@dxos/echo-generator 0.4.10-main.b39148d → 0.4.10-main.c32f430

package/src/data.ts

@@ -5,7 +5,11 @@
 // TODO(burdon): Reconcile with @dxos/plugin-debug, @dxos/aurora/testing.
 // TODO(burdon): Bug when adding stale objects to space (e.g., static objects already added in previous story invocation).
 
-import { Schema, type Space, TextObject } from '@dxos/client/echo';
+import * as S from '@effect/schema/Schema';
+
+import { type Space } from '@dxos/client/echo';
+import * as E from '@dxos/echo-schema';
+import { DynamicEchoSchema, effectToJsonSchema, StoredEchoSchema } from '@dxos/echo-schema';
 import { faker } from '@dxos/random';
 
 import { SpaceObjectGenerator, TestObjectGenerator } from './generator';
@@ -22,111 +26,46 @@ export enum TestSchemaType {
   project = 'example.com/schema/project',
 }
 
-export const testSchemas = (): TestSchemaMap<TestSchemaType> => {
-  const document = new Schema({
-    typename: TestSchemaType.document,
-    props: [
-      {
-        id: 'title',
-        type: Schema.PropType.STRING,
-        description: 'title of the document',
-      },
-      {
-        id: 'content',
-        type: Schema.PropType.STRING, // TODO(burdon): Rich text.
-      },
-    ],
+const createDynamicSchema = (typename: string, fields: S.Struct.Fields): DynamicEchoSchema => {
+  const typeSchema = S.partial(S.struct(fields)).pipe(E.echoObject(typename, '1.0.0'));
+  return new DynamicEchoSchema(
+    E.object(StoredEchoSchema, {
+      typename,
+      version: '1.0.0',
+      jsonSchema: effectToJsonSchema(typeSchema),
+    }),
+  );
+};
+
+const testSchemas = (): TestSchemaMap<TestSchemaType> => {
+  const document = createDynamicSchema(TestSchemaType.document, {
+    title: S.string.pipe(S.description('title of the document')),
+    content: S.string,
   });
 
-  const organization = new Schema({
-    typename: TestSchemaType.organization,
-    props: [
-      {
-        id: 'name',
-        type: Schema.PropType.STRING,
-        description: 'name of the company or organization',
-      },
-      {
-        id: 'website',
-        type: Schema.PropType.STRING,
-        description: 'public website URL',
-      },
-      {
-        id: 'description',
-        type: Schema.PropType.STRING,
-        description: 'short summary of the company',
-      },
-    ],
+  const organization = createDynamicSchema(TestSchemaType.organization, {
+    name: S.string.pipe(S.description('name of the company or organization')),
+    website: S.string.pipe(S.description('public website URL')),
+    description: S.string.pipe(S.description('short summary of the company')),
   });
 
-  const contact = new Schema({
-    typename: TestSchemaType.contact,
-    props: [
-      {
-        id: 'name',
-        type: Schema.PropType.STRING,
-        description: 'name of the person',
-      },
-      // TODO(burdon): Support multiple tagged properties.
-      {
-        id: 'email',
-        type: Schema.PropType.STRING,
-      },
-      {
-        id: 'org',
-        type: Schema.PropType.REF,
-        ref: organization,
-      },
-      // TODO(burdon): Convert to object with nested props.
-      {
-        id: 'lat',
-        type: Schema.PropType.NUMBER,
-      },
-      {
-        id: 'lng',
-        type: Schema.PropType.NUMBER,
-      },
-    ],
+  const contact = createDynamicSchema(TestSchemaType.contact, {
+    name: S.string.pipe(S.description('name of the person')),
+    email: S.string,
+    org: E.ref(organization),
+    lat: S.number,
+    lng: S.number,
   });
 
-  const project = new Schema({
-    typename: TestSchemaType.project,
-    props: [
-      {
-        id: 'name',
-        type: Schema.PropType.STRING,
-        description: 'name of the project',
-      },
-      {
-        id: 'description',
-        type: Schema.PropType.STRING, // TODO(burdon): Text.
-      },
-      {
-        id: 'website',
-        type: Schema.PropType.STRING,
-      },
-      {
-        id: 'repo',
-        type: Schema.PropType.STRING,
-      },
-      {
-        id: 'status',
-        type: Schema.PropType.STRING,
-      },
-      {
-        id: 'priority',
-        type: Schema.PropType.NUMBER,
-      },
-      {
-        id: 'active',
-        type: Schema.PropType.BOOLEAN,
-      },
-      {
-        id: 'org',
-        type: Schema.PropType.REF,
-        ref: organization,
-      },
-    ],
+  const project = createDynamicSchema(TestSchemaType.project, {
+    name: S.string.pipe(S.description('name of the project')),
+    description: S.string,
+    website: S.string,
+    repo: S.string,
+    status: S.string,
+    priority: S.number,
+    active: S.boolean,
+    org: E.ref(organization),
   });
 
   return {
@@ -137,7 +76,7 @@ export const testSchemas = (): TestSchemaMap<TestSchemaType> => {
   };
 };
 
-export const testObjectGenerators: TestGeneratorMap<TestSchemaType> = {
+const testObjectGenerators: TestGeneratorMap<TestSchemaType> = {
   [TestSchemaType.document]: () => ({
     title: faker.lorem.sentence(3),
     content: faker.lorem.sentences({ min: 1, max: faker.number.int({ min: 1, max: 3 }) }),
@@ -146,7 +85,7 @@ export const testObjectGenerators: TestGeneratorMap<TestSchemaType> = {
   [TestSchemaType.organization]: () => ({
     name: faker.company.name(),
     website: faker.datatype.boolean({ probability: 0.3 }) ? faker.internet.url() : undefined,
-    description: new TextObject(faker.lorem.sentences()),
+    description: faker.lorem.sentences(),
   }),
 
   [TestSchemaType.contact]: (provider) => {

package/src/generator.test.ts

@@ -4,10 +4,11 @@
 
 import { expect } from 'chai';
 
-import { Client } from '@dxos/client';
+import { Client, Config } from '@dxos/client';
 import { debug } from '@dxos/client/echo';
+import * as E from '@dxos/echo-schema';
 import { faker } from '@dxos/random';
-import { describe, test } from '@dxos/test';
+import { afterTest, describe, test } from '@dxos/test';
 
 import { createSpaceObjectGenerator, createTestObjectGenerator, TestSchemaType } from './data';
 
@@ -23,30 +24,22 @@ describe('TestObjectGenerator', () => {
   });
 
   test('with space', async () => {
-    const client = new Client();
-    await client.initialize();
-    await client.halo.createIdentity();
-    const space = await client.spaces.create();
+    const { space } = await setupTest();
 
     const generator = createSpaceObjectGenerator(space);
     generator.addSchemas();
 
     // Create org object.
     const organization = generator.createObject({ types: [TestSchemaType.organization] });
-    expect(organization.__schema).to.exist;
+    expect(E.typeOf(organization)).to.exist;
 
     // Expect at least one person object with a linked org reference.
     const objects = generator.createObjects({ [TestSchemaType.contact]: 10 });
     expect(objects.some((object) => object.org === organization)).to.be.true;
-
-    await client.destroy();
   });
 
-  test.only('idempotence', async () => {
-    const client = new Client();
-    await client.initialize();
-    await client.halo.createIdentity();
-    const space = await client.spaces.create();
+  test('idempotence', async () => {
+    const { space } = await setupTest();
 
     const schemaId: string[] = [];
 
@@ -54,22 +47,30 @@ describe('TestObjectGenerator', () => {
       const generator = createSpaceObjectGenerator(space);
       generator.addSchemas();
       const organization = generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(organization.__schema!.id);
+      schemaId.push(E.typeOf(organization)!.itemId);
     }
 
     {
       const generator = createSpaceObjectGenerator(space);
       generator.addSchemas();
       const organization = generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(organization.__schema!.id);
+      schemaId.push(E.typeOf(organization)!.itemId);
     }
 
+    expect(schemaId[0]).not.to.be.undefined;
     expect(schemaId[0]).to.eq(schemaId[1]);
 
     {
       console.log(space.db.objects.map((object) => object[debug]));
     }
-
-    await client.destroy();
   });
+
+  const setupTest = async () => {
+    const client = new Client({ config: new Config({ runtime: { client: { useReactiveObjectApi: true } } }) });
+    await client.initialize();
+    afterTest(async () => await client.destroy());
+    await client.halo.createIdentity();
+    const space = await client.spaces.create();
+    return { client, space };
+  };
 });

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 * as E 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 ? E.object(schema, data) : E.object(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>[];