RJS-2871: Add relaxed schema

integration-tests/tests/src/tests.ts

@@ -63,6 +63,7 @@ import "./tests/objects";
 import "./tests/observable";
 import "./tests/queries";
 import "./tests/realm-constructor";
+import "./tests/relaxed-schema";
 import "./tests/results";
 import "./tests/schema";
 import "./tests/serialization";

integration-tests/tests/src/tests/relaxed-schema.ts

@@ -0,0 +1,213 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2024 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import { expect } from "chai";
+import { PersonSchema, Person } from "../schemas/person-and-dogs";
+import { openRealmBeforeEach } from "../hooks";
+import { BSON } from "realm";
+
+describe("Relaxed schema", () => {
+ openRealmBeforeEach({ relaxedSchema: true, schema: [PersonSchema] });
+
+ it("can open a Realm with a relaxed schema", function (this: Mocha.Context & RealmContext) {
+ expect(this.realm).not.null;
+ });
+
+ it("can add an object to a Realm with a relaxed schema", function (this: Mocha.Context & RealmContext) {
+ this.realm.write(() => {
+ this.realm.create(PersonSchema.name, {
+ name: "Joe",
+ age: 19,
+ });
+ });
+
+ expect(this.realm.objects(PersonSchema.name).length).equals(1);
+ });
+
+ it("can modify an existing property of an object in a Realm with a relaxed schema", function (this: Mocha.Context &
+ RealmContext) {
+ this.realm.write(() => {
+ this.realm.create(PersonSchema.name, {
+ name: "Joe",
+ age: 19,
+ });
+ });
+
+ this.realm.write(() => {
+ // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+ const joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe")!;
+ expect(joe).not.null;
+ joe.age = 25;
+ });
+
+ // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+ const olderJoe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe")!;
+ expect(olderJoe.age).equals(25n); // TODO: why BigInt and not Number?
+ });
+
+ [
+ ["primitive", 1234],
+ ["data", new ArrayBuffer(10)],
+ ["decimal128", 12n],
+ ["objectId", new BSON.ObjectID()],
+ ["uuid", new BSON.UUID()],
+ // ["linkingObjects", "linkingObjects"],
+ // ["list", ["123", "123", "12"]],
+ // [
+ // "dictionary",
+ // {
+ // dictionary: {
+ // windows: 3,
+ // apples: 3,
+ // },
+ // },
+ // ],
+ ].forEach(([typeName, valueToSet]) => {
+ describe(`with ${typeName}`, () => {
+ let setValue: any;
+
+ beforeEach(function (this: Mocha.Context & RealmContext) {
+ if (valueToSet == "linkingObjects") {
+ this.realm.write(() => {
+ setValue = this.realm.create<Person>(PersonSchema.name, {
+ name: "Different Joe",
+ age: 81,
+ });
+ });
+ } else {
+ setValue = valueToSet;
+ }
+ });
+
+ it("can add a new property", function (this: Mocha.Context & RealmContext) {
+ this.realm.write(() => {
+ this.realm.create(PersonSchema.name, {
+ name: "Joe",
+ age: 19,
+ });
+ });
+
+ this.realm.write(() => {
+ const joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe")!;
+ expect(joe).not.null;
+ joe.customProperty = setValue;
+ });
+ const joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe")!;
+ expect(joe).not.null;
+ expect(joe.name).equals("Joe");
+ expect(joe.customProperty).deep.equals(setValue);
+ });
+
+ it("can add a new property", function (this: Mocha.Context & RealmContext) {
+ this.realm.write(() => {
+ this.realm.create(PersonSchema.name, {
+ name: "Joe",
+ age: 19,
+ });
+ });
+ let joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe")!;
+ expect(() => joe.customProperty).throws("Property 'Person.customProperty' does not exist");
+
+ this.realm.write(() => {
+ joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe")!;
+ expect(joe).not.null;
+ joe.customProperty = setValue;
+ });
+
+ joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe")!;
+ expect(joe).not.null;
+ expect(joe.name).equals("Joe");
+
+ expect(joe.customProperty).deep.equals(setValue);
+ });
+
+ it("can delete a property", function () {
+ let joe: any;
+ this.realm.write(() => {
+ joe = this.realm.create(PersonSchema.name, {
+ name: "Joe",
+ age: 19,
+ });
+ });
+ this.realm.write(() => {
+ joe.customProperty = setValue;
+ });
+ expect(() => joe.customProperty).does.not.throw();
+
+ this.realm.write(() => {
+ delete joe.customProperty;
+ });
+ joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe")!;
+ expect(() => joe.customProperty).throws("Property 'Person.customProperty' does not exist");
+ });
+ });
+ });
+
+ it("Object.keys(), Object.values(), and Object.entries()", function () {
+ this.realm.write(() => {
+ this.realm.create(PersonSchema.name, {
+ name: "Joe",
+ age: 19,
+ });
+ });
+
+ let joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe");
+ let keys = Object.keys(joe);
+ expect(keys.length).equal(3); // 3 (from schema) + 0 (additional property)
+ expect(keys).to.have.deep.members(["age", "friends", "name"]);
+ expect(Object.entries(joe).length).equal(3);
+ expect(Object.values(joe).length).equal(3);
+
+ this.realm.write(() => {
+ const joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe");
+ joe.nickname = "Johannes";
+ });
+
+ joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe");
+ keys = Object.keys(joe);
+ expect(keys.length).equal(4); // 3 (from schema) + 1 (additional property)
+ expect(keys).to.have.deep.members(["age", "friends", "name", "nickname"]);
+ expect(Object.entries(joe).length).equal(4);
+ expect(Object.values(joe).length).equal(4);
+ });
+
+ it("spread operator", function () {
+ this.realm.write(() => {
+ this.realm.create(PersonSchema.name, {
+ name: "Joe",
+ age: 19,
+ });
+ });
+
+ const joe1 = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe");
+ const plainJoe1 = {...joe1};
+ expect(plainJoe1 instanceof Object).to.be.true;
+ expect(Object.keys(plainJoe1)).to.have.deep.members(["age", "friends", "name"]);
+
+ this.realm.write(() => {
+ const joe = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe");
+ joe.nickname = "Johannes";
+ });
+
+ const joe2 = this.realm.objectForPrimaryKey(PersonSchema.name, "Joe");
+ const plainJoe2 = {...joe2};
+ expect(Object.keys(plainJoe2)).to.have.deep.members(["age", "friends", "name", "nickname"]);
+ });
+});

packages/realm/bindgen/js_opt_in_spec.yml

@@ -44,6 +44,7 @@ records:
  - schema
  - schema_version
  - schema_mode
+ - flexible_schema
  - disable_format_upgrade
  - sync_config
  - force_sync_history
@@ -298,20 +299,26 @@ classes:
  - get_link_target
  - clear
  - get_primary_key_column
+ - get_column_key
 
  Obj:
  methods:
  - is_valid
  - get_table
  - get_key
  - get_any
+ - get_any_by_name
  - set_any
+ - set_any_by_name
  - set_collection
  - add_int
  - get_linked_object
  - get_backlink_count
  - get_backlink_view
  - create_and_set_linked_object
+ - has_schema_property
+ - erase_additional_prop
+ - get_additional_properties
 
  Timestamp:
  methods:

packages/realm/src/ClassMap.ts

@@ -130,7 +130,7 @@ export class ClassMap {
  properties,
  wrapObject(obj) {
  if (obj.isValid) {
- return RealmObject.createWrapper(obj, constructor);
+ return RealmObject.createWrapper(obj, constructor, realm.internal.config.flexibleSchema);
  } else {
  return null;
  }

packages/realm/src/Configuration.ts

@@ -101,6 +101,12 @@ export type BaseConfiguration = {
  * @since 2.23.0
  */
  fifoFilesFallbackPath?: string;
+ /**
+ * Opening a Realm with relaxed schema means that you can dynamically add, update, and remove properties
+ * at runtime. These additional properties will always have the type Mixed.
+ * @default false
+ */
+ relaxedSchema?: boolean;
  sync?: SyncConfiguration;
  /** @internal */
  openSyncedRealmLocally?: true;
@@ -184,6 +190,7 @@ export function validateConfiguration(config: unknown): asserts config is Config
  path,
  schema,
  schemaVersion,
+ relaxedSchema,
  inMemory,
  readOnly,
  fifoFilesFallbackPath,
@@ -211,6 +218,9 @@ export function validateConfiguration(config: unknown): asserts config is Config
  "'schemaVersion' on realm configuration must be 0 or a positive integer.",
  );
  }
+ if (relaxedSchema !== undefined) {
+ assert.boolean(relaxedSchema, "'relaxedSchema' on realm configuration");
+ }
  if (inMemory !== undefined) {
  assert.boolean(inMemory, "'inMemory' on realm configuration");
  }