@dxos/echo 0.8.4-main.5ad4a44 → 0.8.4-main.66e292d

package/dist/lib/browser/testing/index.mjs

@@ -1,112 +1,79 @@
 import "@dxos/node-std/globals";
 import {
+  Any,
+  Obj,
+  Ref,
+  Relation,
   Type_exports
-} from "../chunk-ORIE2FMS.mjs";
-import "../chunk-OAZJQHVO.mjs";
+} from "../chunk-E4UTVJNF.mjs";
 import {
-  EchoObject,
-  EchoRelation,
   EchoSchema,
-  Expando,
-  Ref,
-  StoredSchema,
-  TypedObject,
+  PersistentSchema,
   getSchemaTypename,
-  live,
+  makeObject,
   toJsonSchema
-} from "../chunk-MWLA34S5.mjs";
+} from "../chunk-7GH6RXJ3.mjs";
+
+// src/testing/test-data.ts
+import { DatabaseDirectory, ObjectStructure } from "@dxos/echo-protocol";
+import { DXN, ObjectId, PublicKey } from "@dxos/keys";
 
-// src/internal/testing/types.ts
+// src/testing/test-schema.ts
 import * as Schema from "effect/Schema";
-function _define_property(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-(function(Testing3) {
-  const Circle = Schema.Struct({
-    type: Schema.Literal("circle"),
-    radius: Schema.Number
-  });
-  const Square = Schema.Struct({
-    type: Schema.Literal("square"),
-    side: Schema.Number
-  });
-  const Shape = Schema.Union(Circle, Square);
-  const TestNestedSchema = Schema.mutable(Schema.Struct({
+(function(TestSchema2) {
+  const Nested = Schema.Struct({
     field: Schema.String
-  }));
-  Testing3.TestNestedType = TestNestedSchema.pipe(EchoObject({
-    typename: "example.com/type/TestNested",
-    version: "0.1.0"
-  }));
-  class EmptySchemaType extends TypedObject({
-    typename: "example.com/type/Empty",
-    version: "0.1.0"
-  })({}) {
+  }).pipe(Schema.mutable);
+  class TestClass {
+    field = "value";
+    toJSON() {
+      return {
+        field: this.field
+      };
+    }
   }
-  Testing3.EmptySchemaType = EmptySchemaType;
-  const fields = {
+  TestSchema2.TestClass = TestClass;
+  TestSchema2.ExampleSchema = Schema.Struct({
     string: Schema.String,
     number: Schema.Number,
-    nullableShapeArray: Schema.mutable(Schema.Array(Schema.Union(Shape, Schema.Null))),
     boolean: Schema.Boolean,
     null: Schema.Null,
     undefined: Schema.Undefined,
     stringArray: Schema.mutable(Schema.Array(Schema.String)),
     twoDimNumberArray: Schema.mutable(Schema.Array(Schema.mutable(Schema.Array(Schema.Number)))),
-    object: TestNestedSchema,
-    objectArray: Schema.mutable(Schema.Array(TestNestedSchema)),
-    nested: Schema.optional(Ref(Testing3.TestNestedType)),
+    nested: Schema.mutable(Nested),
+    nestedArray: Schema.mutable(Schema.Array(Nested)),
+    nestedNullableArray: Schema.mutable(Schema.Array(Schema.Union(Nested, Schema.Null))),
+    reference: Schema.suspend(() => Ref(TestSchema2.Example)),
+    referenceArray: Schema.mutable(Schema.Array(Schema.suspend(() => Ref(TestSchema2.Example)))),
+    classInstance: Schema.instanceOf(TestClass),
     other: Schema.Any
-  };
-  Testing3.TestSchema = Schema.mutable(Schema.partial(Schema.Struct(fields)));
-  class TestSchemaType extends TypedObject({
-    typename: "example.com/type/Test",
+  }).pipe(Schema.partial, Schema.mutable);
+  TestSchema2.Example = TestSchema2.ExampleSchema.pipe(Obj({
+    typename: "example.com/type/Example",
     version: "0.1.0"
-  })(fields, {
-    partial: true
-  }) {
-  }
-  Testing3.TestSchemaType = TestSchemaType;
-  Testing3.TestType = Testing3.TestSchema.pipe(EchoObject({
-    typename: "example.com/type/Test",
+  }));
+  TestSchema2.MessageStruct = Schema.Struct({
+    // TODO(burdon): Support S.Date; Custom Timestamp (with defaults).
+    // TODO(burdon): Support defaults (update create and create).
+    timestamp: Schema.String.pipe(Schema.propertySignature, Schema.withConstructorDefault(() => (/* @__PURE__ */ new Date()).toISOString()))
+  });
+  TestSchema2.Message = TestSchema2.MessageStruct.pipe(Obj({
+    typename: "example.com/type/Message",
     version: "0.1.0"
   }));
-  class TestClass {
-    toJSON() {
-      return {
-        field: this.field
-      };
-    }
-    constructor() {
-      _define_property(this, "field", "value");
-    }
-  }
-  Testing3.TestClass = TestClass;
-  Testing3.TestSchemaWithClass = Schema.mutable(Schema.extend(Testing3.TestSchema, Schema.mutable(Schema.Struct({
-    classInstance: Schema.optional(Schema.instanceOf(TestClass))
-  }))));
-  class Contact extends TypedObject({
-    typename: "example.com/type/Contact",
+  TestSchema2.Organization = Schema.Struct({
+    name: Schema.String
+  }).pipe(Obj({
+    typename: "example.com/type/Organization",
     version: "0.1.0"
-  })({
+  }));
+  TestSchema2.Person = Schema.Struct({
     name: Schema.String,
     username: Schema.String,
     email: Schema.String,
-    phoneNumbers: Schema.optional(Schema.Array(Schema.Struct({
-      label: Schema.String,
-      number: Schema.String
-    }))),
-    tasks: Schema.suspend(() => Schema.mutable(Schema.Array(Ref(Task)))),
+    tasks: Schema.mutable(Schema.Array(Schema.suspend(() => Ref(TestSchema2.Task)))),
+    employer: Schema.optional(Ref(TestSchema2.Organization)),
     address: Schema.Struct({
       city: Schema.optional(Schema.String),
       state: Schema.optional(Schema.String),
@@ -116,78 +83,206 @@ function _define_property(obj, key, value) {
         lng: Schema.optional(Schema.Number)
       })
     })
-  }, {
-    partial: true
-  }) {
-  }
-  Testing3.Contact = Contact;
-  class Task extends TypedObject({
-    typename: "example.com/type/Task",
+  }).pipe(Schema.partial, Obj({
+    typename: "example.com/type/Person",
     version: "0.1.0"
-  })({
+  }));
+  TestSchema2.Task = Schema.Struct({
     title: Schema.optional(Schema.String),
+    deadline: Schema.optional(Schema.String),
     completed: Schema.optional(Schema.Boolean),
-    assignee: Schema.optional(Ref(Contact)),
-    previous: Schema.optional(Schema.suspend(() => Ref(Task))),
-    subTasks: Schema.optional(Schema.mutable(Schema.Array(Schema.suspend(() => Ref(Task))))),
+    assignee: Schema.optional(Ref(TestSchema2.Person)),
+    previous: Schema.optional(Schema.suspend(() => Ref(TestSchema2.Task))),
+    subTasks: Schema.optional(Schema.mutable(Schema.Array(Schema.suspend(() => Ref(TestSchema2.Task))))),
     description: Schema.optional(Schema.String)
-  }, {
-    partial: true
-  }) {
-  }
-  Testing3.Task = Task;
+  }).pipe(Schema.partial, Obj({
+    typename: "example.com/type/Task",
+    version: "0.1.0"
+  }));
+  TestSchema2.HasManager = Schema.Struct({}).pipe(Relation({
+    typename: "example.com/type/HasManager",
+    version: "0.1.0",
+    source: TestSchema2.Person,
+    target: TestSchema2.Person
+  }));
+  TestSchema2.EmployedBy = Schema.Struct({
+    role: Schema.String,
+    since: Schema.optional(Schema.String)
+  }).pipe(Relation({
+    typename: "example.com/type/EmployedBy",
+    version: "0.1.0",
+    source: TestSchema2.Person,
+    target: TestSchema2.Organization
+  }));
   (function(RecordType) {
     RecordType[RecordType["UNDEFINED"] = 0] = "UNDEFINED";
     RecordType[RecordType["PERSONAL"] = 1] = "PERSONAL";
     RecordType[RecordType["WORK"] = 2] = "WORK";
-  })(Testing3.RecordType || (Testing3.RecordType = {}));
-  class Container extends TypedObject({
-    typename: "example.com/type/Container",
-    version: "0.1.0"
-  })({
-    objects: Schema.mutable(Schema.Array(Ref(Expando))),
+  })(TestSchema2.RecordType || (TestSchema2.RecordType = {}));
+  TestSchema2.Container = Schema.Struct({
+    objects: Schema.mutable(Schema.Array(Ref(Any))),
     records: Schema.mutable(Schema.Array(Schema.partial(Schema.Struct({
       title: Schema.String,
       description: Schema.String,
-      contacts: Schema.mutable(Schema.Array(Ref(Contact))),
-      type: Schema.Enums(Testing3.RecordType)
+      contacts: Schema.mutable(Schema.Array(Ref(TestSchema2.Person))),
+      type: Schema.Enums(TestSchema2.RecordType)
     }))))
-  }, {
-    partial: true
-  }) {
-  }
-  Testing3.Container = Container;
-  Testing3.HasManager = Schema.Struct({
-    since: Schema.optional(Schema.String)
-  }).pipe(EchoRelation({
-    typename: "example.com/type/HasManager",
-    version: "0.1.0",
-    source: Contact,
-    target: Contact
+  }).pipe(Schema.partial, Obj({
+    typename: "example.com/type/Container",
+    version: "0.1.0"
   }));
-})(Testing || (Testing = {}));
-var Testing;
+})(TestSchema || (TestSchema = {}));
+var TestSchema;
 
-// src/internal/testing/utils.ts
+// src/testing/test-data.ts
+var spaceKey = PublicKey.random();
+var PEOPLE = {
+  alice: DatabaseDirectory.make({
+    spaceKey: spaceKey.toHex(),
+    objects: {
+      [ObjectId.random()]: ObjectStructure.makeObject({
+        type: Type_exports.getDXN(TestSchema.Person).toString(),
+        data: {
+          name: "Alice"
+        }
+      })
+    }
+  }),
+  bob: DatabaseDirectory.make({
+    spaceKey: spaceKey.toHex(),
+    objects: {
+      [ObjectId.random()]: ObjectStructure.makeObject({
+        type: Type_exports.getDXN(TestSchema.Person).toString(),
+        data: {
+          name: "Bob"
+        }
+      })
+    }
+  })
+};
+var ORGS = {
+  dxos: DatabaseDirectory.make({
+    spaceKey: spaceKey.toHex(),
+    objects: {
+      [ObjectId.random()]: ObjectStructure.makeObject({
+        type: Type_exports.getDXN(TestSchema.Organization).toString(),
+        data: {
+          name: "DXOS",
+          founded: "2023"
+        }
+      })
+    }
+  }),
+  cyberdyne: DatabaseDirectory.make({
+    spaceKey: spaceKey.toHex(),
+    objects: {
+      [ObjectId.random()]: ObjectStructure.makeObject({
+        type: Type_exports.getDXN(TestSchema.Organization).toString(),
+        data: {
+          name: "Cyberdyne Systems",
+          founded: "1984"
+        }
+      })
+    }
+  })
+};
+var WORKS_FOR = {
+  fredWorksForCyberdyne: DatabaseDirectory.make({
+    spaceKey: spaceKey.toHex(),
+    objects: {
+      [ObjectId.random()]: ObjectStructure.makeRelation({
+        type: Type_exports.getDXN(TestSchema.EmployedBy).toString(),
+        source: {
+          "/": DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects)[0]).toString()
+        },
+        target: {
+          "/": DXN.fromLocalObjectId(Object.keys(ORGS.cyberdyne.objects)[0]).toString()
+        },
+        data: {
+          since: "2020",
+          position: "Engineer"
+        }
+      })
+    }
+  }),
+  aliceWorksForAperture: DatabaseDirectory.make({
+    spaceKey: spaceKey.toHex(),
+    objects: {
+      [ObjectId.random()]: ObjectStructure.makeRelation({
+        type: Type_exports.getDXN(TestSchema.EmployedBy).toString(),
+        source: {
+          "/": DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects)[0]).toString()
+        },
+        target: {
+          "/": DXN.fromLocalObjectId(Object.keys(ORGS.dxos.objects)[0]).toString()
+        },
+        data: {
+          since: "2018",
+          position: "Research Scientist"
+        }
+      })
+    }
+  })
+};
+var TASKS = {
+  task1: DatabaseDirectory.make({
+    spaceKey: spaceKey.toHex(),
+    objects: {
+      [ObjectId.random()]: ObjectStructure.makeObject({
+        type: Type_exports.getDXN(TestSchema.Task).toString(),
+        data: {
+          title: "Complete project documentation",
+          description: "Write comprehensive documentation for the new system",
+          status: "in-progress",
+          dueDate: "2023-12-31",
+          assignee: {
+            "/": DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects)[0]).toString()
+          }
+        }
+      })
+    }
+  }),
+  task2: DatabaseDirectory.make({
+    spaceKey: spaceKey.toHex(),
+    objects: {
+      [ObjectId.random()]: ObjectStructure.makeObject({
+        type: Type_exports.getDXN(TestSchema.Task).toString(),
+        data: {
+          title: "Run experiments",
+          description: "Conduct series of experiments on the portal device",
+          status: "pending",
+          dueDate: "2023-11-15",
+          assignee: {
+            "/": DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects)[0]).toString()
+          }
+        }
+      })
+    }
+  })
+};
+
+// src/testing/util.ts
 import { effect } from "@preact/signals-core";
 import { registerSignalsRuntime } from "@dxos/echo-signals";
+import { assertArgument } from "@dxos/invariant";
 import { deepMapValues } from "@dxos/util";
 registerSignalsRuntime();
-var updateCounter = (touch) => {
-  let updateCount = -1;
-  const unsubscribe = effect(() => {
-    touch();
-    updateCount++;
+var createEchoSchema = (schema, version = "0.1.0") => {
+  const jsonSchema = toJsonSchema(schema);
+  const typename = getSchemaTypename(schema);
+  assertArgument(typename, "typename", "Schema does not have a typename.");
+  const echoSchema = new EchoSchema(makeObject(PersistentSchema, {
+    typename,
+    version,
+    jsonSchema
+  }));
+  effect(() => {
+    const _ = echoSchema.jsonSchema;
+    echoSchema._invalidate();
   });
-  return {
-    // https://github.com/tc39/proposal-explicit-resource-management
-    [Symbol.dispose]: unsubscribe,
-    get count() {
-      return updateCount;
-    }
-  };
+  return echoSchema;
 };
-var prepareAstForCompare = (obj) => deepMapValues(obj, (value, recurse, key) => {
+var prepareAstForCompare = (obj) => deepMapValues(obj, (value, recurse) => {
   if (typeof value === "function") {
     return null;
   }
@@ -206,91 +301,26 @@ var prepareAstForCompare = (obj) => deepMapValues(obj, (value, recurse, key) =>
   }
   return recurse(value);
 });
-
-// src/testing/types.ts
-import * as Schema2 from "effect/Schema";
-(function(Testing3) {
-  const _Contact = Schema2.Struct({
-    name: Schema2.String,
-    username: Schema2.String,
-    email: Schema2.String,
-    tasks: Schema2.mutable(Schema2.Array(Schema2.suspend(() => Type_exports.Ref(Testing3.Task)))),
-    address: Schema2.Struct({
-      city: Schema2.optional(Schema2.String),
-      state: Schema2.optional(Schema2.String),
-      zip: Schema2.optional(Schema2.String),
-      coordinates: Schema2.Struct({
-        lat: Schema2.optional(Schema2.Number),
-        lng: Schema2.optional(Schema2.Number)
-      })
-    })
-  }).pipe(Schema2.partial, Type_exports.Obj({
-    typename: "example.com/type/Contact",
-    version: "0.1.0"
-  }));
-  Testing3.Contact = _Contact;
-  const _Task = Schema2.Struct({
-    title: Schema2.optional(Schema2.String),
-    completed: Schema2.optional(Schema2.Boolean),
-    assignee: Schema2.optional(Type_exports.Ref(Testing3.Contact)),
-    previous: Schema2.optional(Schema2.suspend(() => Type_exports.Ref(Testing3.Task))),
-    subTasks: Schema2.optional(Schema2.mutable(Schema2.Array(Schema2.suspend(() => Type_exports.Ref(Testing3.Task))))),
-    description: Schema2.optional(Schema2.String)
-  }).pipe(Schema2.partial, Type_exports.Obj({
-    typename: "example.com/type/Task",
-    version: "0.1.0"
-  }));
-  Testing3.Task = _Task;
-  (function(RecordType) {
-    RecordType[RecordType["UNDEFINED"] = 0] = "UNDEFINED";
-    RecordType[RecordType["PERSONAL"] = 1] = "PERSONAL";
-    RecordType[RecordType["WORK"] = 2] = "WORK";
-  })(Testing3.RecordType || (Testing3.RecordType = {}));
-  Testing3.Container = Schema2.Struct({
-    objects: Schema2.mutable(Schema2.Array(Type_exports.Ref(Type_exports.Expando))),
-    records: Schema2.mutable(Schema2.Array(Schema2.partial(Schema2.Struct({
-      title: Schema2.String,
-      description: Schema2.String,
-      contacts: Schema2.mutable(Schema2.Array(Type_exports.Ref(Testing3.Contact))),
-      type: Schema2.Enums(Testing3.RecordType)
-    }))))
-  }).pipe(Schema2.partial, Type_exports.Obj({
-    typename: "example.com/type/Container",
-    version: "0.1.0"
-  }));
-  Testing3.WorksFor = Schema2.Struct({
-    since: Schema2.optional(Schema2.String)
-  }).pipe(Type_exports.Relation({
-    typename: "example.com/type/WorksFor",
-    version: "0.1.0",
-    source: Testing3.Contact,
-    target: Testing3.Contact
-  }));
-})(Testing2 || (Testing2 = {}));
-var Testing2;
-
-// src/testing/echo-schema.ts
-import { effect as effect2 } from "@preact/signals-core";
-import { registerSignalsRuntime as registerSignalsRuntime2 } from "@dxos/echo-signals";
-import { assertArgument } from "@dxos/invariant";
-registerSignalsRuntime2();
-var createEchoSchema = (schema) => {
-  const typename = getSchemaTypename(schema);
-  assertArgument(typename, "typename", "Schema does not have a typename.");
-  const echoSchema = new EchoSchema(live(StoredSchema, {
-    typename,
-    version: "0.1.0",
-    jsonSchema: toJsonSchema(schema)
-  }));
-  effect2(() => {
-    const _ = echoSchema.jsonSchema;
-    echoSchema._invalidate();
+var updateCounter = (touch) => {
+  let updateCount = -1;
+  const unsubscribe = effect(() => {
+    touch();
+    updateCount++;
   });
-  return echoSchema;
+  return {
+    // https://github.com/tc39/proposal-explicit-resource-management
+    [Symbol.dispose]: unsubscribe,
+    get count() {
+      return updateCount;
+    }
+  };
 };
 export {
-  Testing2 as Testing,
-  Testing as TestingDeprecated,
+  ORGS,
+  PEOPLE,
+  TASKS,
+  TestSchema,
+  WORKS_FOR,
   createEchoSchema,
   prepareAstForCompare,
   updateCounter