@dxos/echo-generator 0.4.10-main.0302e13 → 0.4.10-main.05dbd64

package/src/data.ts

@@ -5,7 +5,8 @@
 // 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 { type Space } from '@dxos/client/echo';
+import { S, DynamicEchoSchema, effectToJsonSchema, StoredEchoSchema, create, ref, echoObject } from '@dxos/echo-schema';
 import { faker } from '@dxos/random';
 
 import { SpaceObjectGenerator, TestObjectGenerator } from './generator';
@@ -22,111 +23,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(echoObject(typename, '1.0.0'));
+  return new DynamicEchoSchema(
+    create(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: 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: ref(organization),
   });
 
   return {
@@ -137,20 +73,20 @@ export const testSchemas = (): TestSchemaMap<TestSchemaType> => {
   };
 };
 
-export const testObjectGenerators: TestGeneratorMap<TestSchemaType> = {
-  [TestSchemaType.document]: () => ({
+const testObjectGenerators: TestGeneratorMap<TestSchemaType> = {
+  [TestSchemaType.document]: async () => ({
     title: faker.lorem.sentence(3),
     content: faker.lorem.sentences({ min: 1, max: faker.number.int({ min: 1, max: 3 }) }),
   }),
 
-  [TestSchemaType.organization]: () => ({
+  [TestSchemaType.organization]: async () => ({
     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) => {
-    const organizations = provider?.(TestSchemaType.organization);
+  [TestSchemaType.contact]: async (provider) => {
+    const organizations = await provider?.(TestSchemaType.organization);
     const location = faker.datatype.boolean() ? faker.helpers.arrayElement(locations) : undefined;
     return {
       name: faker.person.fullName(),
@@ -163,7 +99,7 @@ export const testObjectGenerators: TestGeneratorMap<TestSchemaType> = {
     };
   },
 
-  [TestSchemaType.project]: () => ({
+  [TestSchemaType.project]: async () => ({
     name: faker.commerce.productName(),
     repo: faker.datatype.boolean({ probability: 0.3 }) ? faker.internet.url() : undefined,
     status: faker.helpers.arrayElement(Status),

package/src/generator.test.ts

@@ -5,71 +5,67 @@
 import { expect } from 'chai';
 
 import { Client } from '@dxos/client';
-import { debug } from '@dxos/client/echo';
+import { getType } 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';
 
 faker.seed(3);
 
 describe('TestObjectGenerator', () => {
-  test('basic', () => {
+  test('basic', async () => {
     const generator = createTestObjectGenerator();
 
     // Create raw object.
-    const object = generator.createObject({ types: [TestSchemaType.contact] });
+    const object = await generator.createObject({ types: [TestSchemaType.contact] });
     expect(object).to.exist;
   });
 
   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;
+    const organization = await generator.createObject({ types: [TestSchemaType.organization] });
+    expect(getType(organization)).to.exist;
 
     // Expect at least one person object with a linked org reference.
-    const objects = generator.createObjects({ [TestSchemaType.contact]: 10 });
+    const objects = await 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[] = [];
 
     {
       const generator = createSpaceObjectGenerator(space);
       generator.addSchemas();
-      const organization = generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(organization.__schema!.id);
+      const organization = await generator.createObject({ types: [TestSchemaType.organization] });
+      schemaId.push(getType(organization)!.itemId);
     }
 
     {
       const generator = createSpaceObjectGenerator(space);
       generator.addSchemas();
-      const organization = generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(organization.__schema!.id);
+      const organization = await generator.createObject({ types: [TestSchemaType.organization] });
+      schemaId.push(getType(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();
+    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, Filter } from '@dxos/client/echo';
+import { type DynamicEchoSchema, type ReactiveObject } from '@dxos/echo-schema';
+import { create } from '@dxos/echo-schema';
 import { faker } from '@dxos/random';
 
 import { type TestSchemaType } from './data';
@@ -20,35 +22,36 @@ 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 {
+  async createObject({ types }: { types?: T[] } = {}): Promise<ReactiveObject<any>> {
     const type = faker.helpers.arrayElement(types ?? (Object.keys(this._schemas) as T[]));
-    const data = this._generators[type](this._provider);
+    const data = await 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[] = [];
-    Object.entries<number>(map as any).forEach(([type, count]) => {
-      range(() => objects.push(this.createObject({ types: [type as T] })), count);
-    });
+  async createObjects(map: Partial<Record<T, number>>): Promise<ReactiveObject<any>[]> {
+    const tasks = Object.entries<number>(map as any)
+      .map(([type, count]) => {
+        return range(() => this.createObject({ types: [type as T] }), count);
+      })
+      .flatMap((t) => t);
 
-    return objects;
+    return Promise.all(tasks);
   }
 }
 
@@ -61,37 +64,37 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
     schemaMap: TestSchemaMap<T>,
     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;
+    super(schemaMap, generators, async (type: T) => {
+      const schema = this.getSchema(type);
+      return (schema && (await this._space.db.query(Filter.schema(schema)).run()).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);
+    Object.entries<DynamicEchoSchema>(schemaMap).forEach(([type, dynamicSchema]) => {
+      let schema = this._space.db.schemaRegistry.getRegisteredByTypename(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[] = [];
     this.schemas.forEach((schema) => {
-      if (!objects.find((object) => object.typename === schema.typename)) {
-        this._space.db.add(schema);
+      const existing = this._space.db.schemaRegistry.getRegisteredByTypename(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 {
-    return this._space.db.add(super.createObject({ types }));
+  override async createObject({ types }: { types?: T[] } = {}): Promise<ReactiveObject<any>> {
+    return this._space.db.add(await 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) => Promise<ReactiveObject<any>[]>;