@dxos/echo-generator 0.4.9 → 0.4.10-main.068c3d8

package/src/generator.ts

@@ -2,7 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Expando, type TypedObject, Schema, type Space } from '@dxos/client/echo';
+import { type Space } from '@dxos/client/echo';
+import { type DynamicEchoSchema, Filter, type ReactiveObject } from '@dxos/echo-schema';
+import { create } from '@dxos/echo-schema';
 import { faker } from '@dxos/random';
 
 import { type TestSchemaType } from './data';
@@ -20,30 +22,30 @@ export class TestObjectGenerator<T extends string = TestSchemaType> {
     private readonly _provider?: TestObjectProvider<T>
   ) {}
 
-  get schemas(): Schema[] {
+  get schemas(): DynamicEchoSchema[] {
     return Object.values(this._schemas);
   }
 
-  getSchema(type: T) {
+  getSchema(type: T): DynamicEchoSchema | undefined {
     return this.schemas.find((schema) => schema.typename === type);
   }
 
-  protected setSchema(type: T, schema: Schema) {
+  protected setSchema(type: T, schema: DynamicEchoSchema) {
     this._schemas[type] = schema;
   }
 
   // TODO(burdon): Runtime type check via: https://github.com/Effect-TS/schema (or zod).
-  createObject({ types }: { types?: T[] } = {}): TypedObject {
+  createObject({ types }: { types?: T[] } = {}): ReactiveObject<any> {
     const type = faker.helpers.arrayElement(types ?? (Object.keys(this._schemas) as T[]));
     const data = this._generators[type](this._provider);
     const schema = this.getSchema(type);
-    return new Expando(data, { schema });
+    return schema ? create(schema, data) : create(data);
   }
 
   // TODO(burdon): Create batch.
   // TODO(burdon): Based on dependencies (e.g., organization before contact).
-  createObjects(map: Partial<Record<T, number>>): Expando[] {
-    const objects: Expando[] = [];
+  createObjects(map: Partial<Record<T, number>>): ReactiveObject<any>[] {
+    const objects: ReactiveObject<any>[] = [];
     Object.entries<number>(map as any).forEach(([type, count]) => {
       range(() => objects.push(this.createObject({ types: [type as T] })), count);
     });
@@ -62,36 +64,38 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
     generators: TestGeneratorMap<T>,
   ) {
     super(schemaMap, generators, (type: T) => {
-      const { objects } = this._space.db.query((object: TypedObject) => {
-        return object.__schema?.id === this.getSchema(type)?.id;
-      });
-
-      return objects;
+      const schema = this.getSchema(type);
+      return (schema && this._space.db.query(Filter.schema(schema)).objects) ?? [];
     });
 
     // TODO(burdon): Map initially are objects that have not been added to the space.
     // Merge existing schema in space with defaults.
-    const { objects } = this._space.db.query(Schema.filter());
-    Object.keys(schemaMap).forEach((type) => {
-      const schema = objects.find((object) => object.typename === type);
-      if (schema) {
-        this.setSchema(type as T, schema);
+    const schemas = this._space.db.schemaRegistry.getAll();
+    Object.entries<DynamicEchoSchema>(schemaMap).forEach(([type, dynamicSchema]) => {
+      let schema = schemas.find((object) => object.typename === type);
+      if (schema == null) {
+        schema = this._space.db.schemaRegistry.add(dynamicSchema.schema);
       }
+      this.setSchema(type as T, schema);
     });
   }
 
   addSchemas() {
-    const { objects } = this._space.db.query(Schema.filter());
+    const result: DynamicEchoSchema[] = [];
+    const dbSchemas = this._space.db.schemaRegistry.getAll();
     this.schemas.forEach((schema) => {
-      if (!objects.find((object) => object.typename === schema.typename)) {
-        this._space.db.add(schema);
+      const existing = dbSchemas.find((object) => object.typename === schema.typename);
+      if (existing == null) {
+        result.push(this._space.db.schemaRegistry.add(schema.schema));
+      } else {
+        result.push(existing);
       }
     });
 
-    return this.schemas;
+    return result;
   }
 
-  override createObject({ types }: { types?: T[] } = {}): Expando {
+  override createObject({ types }: { types?: T[] } = {}): ReactiveObject<any> {
     return this._space.db.add(super.createObject({ types }));
   }
 }

package/src/types.ts

@@ -2,12 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Schema, type Expando } from '@dxos/client/echo';
+import { type DynamicEchoSchema, type ReactiveObject } from '@dxos/echo-schema';
 
 export type TestObject = { id: string } & Record<string, any>;
 
-export type TestSchemaMap<T extends string> = Record<T, Schema>;
+export type TestSchemaMap<T extends string> = Record<T, DynamicEchoSchema>;
 
 export type TestGeneratorMap<T extends string> = Record<T, (provider: TestObjectProvider<T> | undefined) => any>;
 
-export type TestObjectProvider<T extends string> = (type: T) => Expando[];
+export type TestObjectProvider<T extends string> = (type: T) => ReactiveObject<any>[];