@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

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

@@ -1,64 +1,102 @@
-import "../chunk-4OIBYSXE.mjs";
-import "../chunk-BNCCGLJN.mjs";
-import "../chunk-YAHXAYOW.mjs";
-import "../chunk-UI6MWK5W.mjs";
-import "../chunk-ANHVGJI4.mjs";
-import "../chunk-WAK4DMFV.mjs";
-import "../chunk-YS6Q3XAD.mjs";
-import "../chunk-GZQTCRJB.mjs";
-import "../chunk-HBUZJNZO.mjs";
-import "../chunk-7RO7CPBZ.mjs";
-import "../chunk-OMUPQMLR.mjs";
-import "../chunk-EAMSSLZC.mjs";
-import "../chunk-TU3GW67D.mjs";
+import "../chunk-UUP46KUQ.mjs";
+import "../chunk-35INCYOE.mjs";
+import "../chunk-QQIYS74I.mjs";
+import "../chunk-5SMDBFVB.mjs";
+import "../chunk-EVK6XBXO.mjs";
+import "../chunk-7LOUAPYZ.mjs";
+import "../chunk-RIVWNMSF.mjs";
+import "../chunk-ZGNNFYHS.mjs";
+import "../chunk-6YDI3J37.mjs";
+import "../chunk-6M2Z6WBH.mjs";
+import "../chunk-LWXVKPPW.mjs";
 import {
-  Type_exports,
-  object,
-  relation
-} from "../chunk-ROG4RXXL.mjs";
-import "../chunk-V36VO5SS.mjs";
+  Service,
+  TypeId
+} from "../chunk-WU3GIANS.mjs";
+import "../chunk-WISOH2XH.mjs";
+import "../chunk-IGK6FN65.mjs";
 import {
   Unknown
-} from "../chunk-B4BASU6W.mjs";
+} from "../chunk-TYGKCRMK.mjs";
 import {
   Ref
-} from "../chunk-BVOFLCVF.mjs";
-import "../chunk-T6W2LEZU.mjs";
+} from "../chunk-MZ7K3MLL.mjs";
+import "../chunk-SBVFRTST.mjs";
+import {
+  Type_exports,
+  makeObject as makeObject2,
+  makeRelation
+} from "../chunk-T6E37YIP.mjs";
 import {
-  EchoSchema,
-  PersistentSchema,
+  TypeSchema,
   makeObject,
   subscribe
-} from "../chunk-MOR5ERFM.mjs";
-import "../chunk-OS35K56T.mjs";
+} from "../chunk-7FPIAJIV.mjs";
+import "../chunk-5SUJPHAE.mjs";
 import {
   toJsonSchema
-} from "../chunk-JUXPFOEI.mjs";
-import "../chunk-DQYLD2RB.mjs";
-import "../chunk-G3IQMKF7.mjs";
-import "../chunk-4P3IXBLT.mjs";
-import "../chunk-PHU22NLC.mjs";
+} from "../chunk-7PI7C4EF.mjs";
+import "../chunk-TFEWTY5A.mjs";
+import "../chunk-3PBP4V4O.mjs";
+import "../chunk-4ZUHOTCG.mjs";
+import "../chunk-WTQJHC75.mjs";
 import {
   getSchemaTypename
-} from "../chunk-2KHZ36F5.mjs";
-import "../chunk-TBKX6JQO.mjs";
-import "../chunk-UBEZSGXY.mjs";
+} from "../chunk-R5W6DXR4.mjs";
+import {
+  getStaticTypeSchema
+} from "../chunk-O6BH7EPN.mjs";
+import "../chunk-BBFJWWAV.mjs";
 import "../chunk-J5LGTIGS.mjs";
 
+// src/testing/registry.ts
+import * as Atom from "@effect-atom/atom/Atom";
+import * as Layer from "effect/Layer";
+import { Event } from "@dxos/async";
+var registryLayerNoop = Layer.succeed(Service, {
+  [TypeId]: TypeId,
+  id: "noop-registry",
+  changed: new Event(),
+  local: [],
+  add: () => {
+  },
+  remove: () => false,
+  clear: () => {
+  },
+  get: () => void 0,
+  getByURI: () => void 0,
+  list: () => [],
+  // QueryFn is an overloaded interface — a single generic function cannot satisfy both overload
+  // signatures without a cast. This is the intentional type-system boundary.
+  query: (_queryOrFilter) => ({
+    results: [],
+    entries: [],
+    run: async () => [],
+    runEntries: async () => [],
+    runSync: () => [],
+    runSyncEntries: () => [],
+    first: async () => {
+      throw new Error("registryLayerNoop: registry is empty");
+    },
+    firstOrUndefined: async () => void 0,
+    subscribe: () => () => {
+    },
+    atom: Atom.make(() => [])
+  })
+});
+
 // src/testing/test-data.ts
-import { DatabaseDirectory, ObjectStructure } from "@dxos/echo-protocol";
-import { DXN, ObjectId, PublicKey } from "@dxos/keys";
+import { DatabaseDirectory, EntityStructure } from "@dxos/echo-protocol";
+import { EID, EntityId, PublicKey } from "@dxos/keys";
 
 // src/testing/test-schema.ts
 import * as Schema from "effect/Schema";
+import { DXN } from "@dxos/keys";
 (function(TestSchema2) {
   TestSchema2.Expando = Schema.Struct({}, {
     key: Schema.String,
     value: Schema.Any
-  }).pipe(object({
-    typename: "com.example.type.expando",
-    version: "0.1.0"
-  }));
+  }).pipe(makeObject2(DXN.make("com.example.type.expando", "0.1.0")));
   const Nested = Schema.Struct({
     field: Schema.String
   });
@@ -87,29 +125,20 @@ import * as Schema from "effect/Schema";
     classInstance: Schema.instanceOf(TestClass),
     other: Schema.Any
   }).pipe(Schema.partial);
-  TestSchema2.Example = TestSchema2.ExampleSchema.pipe(object({
-    typename: "com.example.type.example",
-    version: "0.1.0"
-  }));
+  TestSchema2.Example = TestSchema2.ExampleSchema.pipe(makeObject2(DXN.make("com.example.type.example", "0.1.0")));
   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(object({
-    typename: "com.example.type.message",
-    version: "0.1.0"
-  }));
+  TestSchema2.Message = TestSchema2.MessageStruct.pipe(makeObject2(DXN.make("com.example.type.message", "0.1.0")));
   TestSchema2.Organization = Schema.Struct({
     name: Schema.String,
     properties: Schema.optional(Schema.Record({
       key: Schema.String,
       value: Schema.String
     }))
-  }).pipe(object({
-    typename: "com.example.type.organization",
-    version: "0.1.0"
-  }));
+  }).pipe(makeObject2(DXN.make("com.example.type.organization", "0.1.0")));
   TestSchema2.Person = Schema.Struct({
     name: Schema.String,
     username: Schema.String,
@@ -130,10 +159,7 @@ import * as Schema from "effect/Schema";
       label: Schema.String,
       value: Schema.String
     }).pipe(Schema.Array, Schema.optional)
-  }).pipe(Schema.partial, object({
-    typename: "com.example.type.person",
-    version: "0.1.0"
-  }));
+  }).pipe(Schema.partial, makeObject2(DXN.make("com.example.type.person", "0.1.0")));
   TestSchema2.Task = Schema.Struct({
     title: Schema.optional(Schema.String),
     deadline: Schema.optional(Schema.String),
@@ -142,22 +168,17 @@ import * as Schema from "effect/Schema";
     previous: Schema.optional(Schema.suspend(() => Ref(TestSchema2.Task))),
     subTasks: Schema.optional(Schema.Array(Schema.suspend(() => Ref(TestSchema2.Task)))),
     description: Schema.optional(Schema.String)
-  }).pipe(Schema.partial, object({
-    typename: "com.example.type.task",
-    version: "0.1.0"
-  }));
-  TestSchema2.HasManager = Schema.Struct({}).pipe(relation({
-    typename: "com.example.type.has-manager",
-    version: "0.1.0",
+  }).pipe(Schema.partial, makeObject2(DXN.make("com.example.type.task", "0.1.0")));
+  TestSchema2.HasManager = Schema.Struct({}).pipe(makeRelation({
+    dxn: DXN.make("com.example.type.hasManager", "0.1.0"),
     source: TestSchema2.Person,
     target: TestSchema2.Person
   }));
   TestSchema2.EmployedBy = Schema.Struct({
     role: Schema.String,
     since: Schema.optional(Schema.String)
-  }).pipe(relation({
-    typename: "com.example.type.employed-by",
-    version: "0.1.0",
+  }).pipe(makeRelation({
+    dxn: DXN.make("com.example.type.employedBy", "0.1.0"),
     source: TestSchema2.Person,
     target: TestSchema2.Organization
   }));
@@ -174,138 +195,201 @@ import * as Schema from "effect/Schema";
       contacts: Schema.Array(Ref(TestSchema2.Person)),
       type: Schema.Enums(TestSchema2.RecordType)
     })))
-  }).pipe(Schema.partial, object({
-    typename: "com.example.type.container",
-    version: "0.1.0"
-  }));
+  }).pipe(Schema.partial, makeObject2(DXN.make("com.example.type.container", "0.1.0")));
 })(TestSchema || (TestSchema = {}));
 var TestSchema;
 
 // src/testing/test-data.ts
-var spaceKey = PublicKey.random();
+var cachedSpaceKeyHex;
+var getSpaceKeyHex = () => {
+  if (cachedSpaceKeyHex === void 0) {
+    cachedSpaceKeyHex = PublicKey.random().toHex();
+  }
+  return cachedSpaceKeyHex;
+};
+var cachedPeopleAlice;
+var cachedPeopleBob;
+var cachedOrgsDxos;
+var cachedOrgsCyberdyne;
+var cachedWorksFredCyberdyne;
+var cachedWorksAliceAperture;
+var cachedTasksTask1;
+var cachedTasksTask2;
 var PEOPLE = {
-  alice: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type_exports.getDXN(TestSchema.Person).toString(),
-        data: {
-          name: "Alice"
+  get alice() {
+    if (cachedPeopleAlice === void 0) {
+      cachedPeopleAlice = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type_exports.getURI(TestSchema.Person),
+            data: {
+              name: "Alice"
+            }
+          })
         }
-      })
+      });
     }
-  }),
-  bob: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type_exports.getDXN(TestSchema.Person).toString(),
-        data: {
-          name: "Bob"
+    return cachedPeopleAlice;
+  },
+  get bob() {
+    if (cachedPeopleBob === void 0) {
+      cachedPeopleBob = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type_exports.getURI(TestSchema.Person),
+            data: {
+              name: "Bob"
+            }
+          })
         }
-      })
+      });
     }
-  })
+    return cachedPeopleBob;
+  }
 };
 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"
+  get dxos() {
+    if (cachedOrgsDxos === void 0) {
+      cachedOrgsDxos = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type_exports.getURI(TestSchema.Organization),
+            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"
+    return cachedOrgsDxos;
+  },
+  get cyberdyne() {
+    if (cachedOrgsCyberdyne === void 0) {
+      cachedOrgsCyberdyne = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type_exports.getURI(TestSchema.Organization),
+            data: {
+              name: "Cyberdyne Systems",
+              founded: "1984"
+            }
+          })
         }
-      })
+      });
     }
-  })
+    return cachedOrgsCyberdyne;
+  }
 };
 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"
+  get fredWorksForCyberdyne() {
+    if (cachedWorksFredCyberdyne === void 0) {
+      cachedWorksFredCyberdyne = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeRelation({
+            type: Type_exports.getURI(TestSchema.EmployedBy),
+            source: {
+              "/": EID.make({
+                entityId: Object.keys(PEOPLE.bob.objects)[0]
+              })
+            },
+            target: {
+              "/": EID.make({
+                entityId: Object.keys(ORGS.cyberdyne.objects)[0]
+              })
+            },
+            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"
+    return cachedWorksFredCyberdyne;
+  },
+  get aliceWorksForAperture() {
+    if (cachedWorksAliceAperture === void 0) {
+      cachedWorksAliceAperture = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeRelation({
+            type: Type_exports.getURI(TestSchema.EmployedBy),
+            source: {
+              "/": EID.make({
+                entityId: Object.keys(PEOPLE.alice.objects)[0]
+              })
+            },
+            target: {
+              "/": EID.make({
+                entityId: Object.keys(ORGS.dxos.objects)[0]
+              })
+            },
+            data: {
+              since: "2018",
+              position: "Research Scientist"
+            }
+          })
         }
-      })
+      });
     }
-  })
+    return cachedWorksAliceAperture;
+  }
 };
 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()
-          }
+  get task1() {
+    if (cachedTasksTask1 === void 0) {
+      cachedTasksTask1 = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type_exports.getURI(TestSchema.Task),
+            data: {
+              title: "Complete project documentation",
+              description: "Write comprehensive documentation for the new system",
+              status: "in-progress",
+              dueDate: "2023-12-31",
+              assignee: {
+                "/": EID.make({
+                  entityId: Object.keys(PEOPLE.bob.objects)[0]
+                })
+              }
+            }
+          })
         }
-      })
+      });
     }
-  }),
-  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()
-          }
+    return cachedTasksTask1;
+  },
+  get task2() {
+    if (cachedTasksTask2 === void 0) {
+      cachedTasksTask2 = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type_exports.getURI(TestSchema.Task),
+            data: {
+              title: "Run experiments",
+              description: "Conduct series of experiments on the portal device",
+              status: "pending",
+              dueDate: "2023-11-15",
+              assignee: {
+                "/": EID.make({
+                  entityId: Object.keys(PEOPLE.alice.objects)[0]
+                })
+              }
+            }
+          })
         }
-      })
+      });
     }
-  })
+    return cachedTasksTask2;
+  }
 };
 
 // src/testing/util.ts
@@ -315,15 +399,13 @@ 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,
+  return makeObject(getStaticTypeSchema(TypeSchema), {
     jsonSchema
-  }));
-  subscribe(echoSchema.persistentSchema, () => {
-    echoSchema._invalidate();
-  });
-  return echoSchema;
+  }, {
+    keys: [],
+    key: typename,
+    version
+  }, TypeSchema);
 };
 var prepareAstForCompare = (obj) => deepMapValues(obj, (value, recurse) => {
   if (typeof value === "function") {
@@ -370,6 +452,7 @@ export {
   WORKS_FOR,
   createEchoSchema,
   prepareAstForCompare,
+  registryLayerNoop,
   updateCounter
 };
 //# sourceMappingURL=index.mjs.map