@dxos/echo-generator 0.8.2-staging.7ac8446 → 0.8.2

package/src/data.ts

@@ -2,10 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { next as A } from '@dxos/automerge/automerge';
+import { next as A } from '@automerge/automerge';
+import { Schema } from 'effect';
+
 import { createDocAccessor, type Space } from '@dxos/client/echo';
-import { Ref, S } from '@dxos/echo-schema';
-import { createEchoSchema, makeRef } from '@dxos/live-object';
+import { EchoObject, Ref } from '@dxos/echo-schema';
 import { faker } from '@dxos/random';
 
 import { SpaceObjectGenerator, TestObjectGenerator } from './generator';
@@ -19,67 +20,49 @@ import { randomText } from './util';
 export const Status = ['pending', 'active', 'done'];
 export const Priority = [1, 2, 3, 4, 5];
 
+/**
+ * @deprecated
+ */
 export enum TestSchemaType {
-  document = 'example.com/type/document',
-  organization = 'example.com/type/organization',
-  contact = 'example.com/type/contact',
-  project = 'example.com/type/project',
+  document = 'example.com/type/Document',
+  organization = 'example.com/type/Organization',
+  contact = 'example.com/type/Contact',
+  project = 'example.com/type/Project',
 }
 
+/**
+ * @deprecated
+ */
 const testSchemas = (): TestSchemaMap<TestSchemaType> => {
-  const document = createEchoSchema(
-    {
-      typename: TestSchemaType.document,
-      version: '0.1.0',
-    },
-    {
-      title: S.String.annotations({ description: 'title of the document' }),
-      content: S.String,
-    },
-  );
-
-  const organization = createEchoSchema(
-    {
-      typename: TestSchemaType.organization,
-      version: '0.1.0',
-    },
-    {
-      name: S.String.annotations({ description: 'name of the company or organization' }),
-      website: S.String.annotations({ description: 'public website URL' }),
-      description: S.String.annotations({ description: 'short summary of the company' }),
-    },
-  );
-
-  const contact = createEchoSchema(
-    {
-      typename: TestSchemaType.contact,
-      version: '0.1.0',
-    },
-    {
-      name: S.String.annotations({ description: 'name of the person' }),
-      email: S.String,
-      org: Ref(organization),
-      lat: S.Number,
-      lng: S.Number,
-    },
-  );
-
-  const project = createEchoSchema(
-    {
-      typename: TestSchemaType.project,
-      version: '0.1.0',
-    },
-    {
-      name: S.String.annotations({ 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),
-    },
-  );
+  const document = Schema.Struct({
+    title: Schema.String.annotations({ description: 'title of the document' }),
+    content: Schema.String,
+  }).pipe(EchoObject({ typename: TestSchemaType.document, version: '0.1.0' }));
+
+  const organization = Schema.Struct({
+    name: Schema.String.annotations({ description: 'name of the company or organization' }),
+    website: Schema.optional(Schema.String.annotations({ description: 'public website URL' })),
+    description: Schema.String.annotations({ description: 'short summary of the company' }),
+  }).pipe(EchoObject({ typename: TestSchemaType.organization, version: '0.1.0' }));
+
+  const contact = Schema.Struct({
+    name: Schema.String.annotations({ description: 'name of the person' }),
+    email: Schema.optional(Schema.String),
+    org: Schema.optional(Ref(organization)),
+    lat: Schema.optional(Schema.Number),
+    lng: Schema.optional(Schema.Number),
+  }).pipe(EchoObject({ typename: TestSchemaType.contact, version: '0.1.0' }));
+
+  const project = Schema.Struct({
+    name: Schema.String.annotations({ description: 'name of the project' }),
+    description: Schema.String,
+    website: Schema.String,
+    repo: Schema.String,
+    status: Schema.String,
+    priority: Schema.Number,
+    active: Schema.Boolean,
+    org: Schema.optional(Ref(organization)),
+  }).pipe(EchoObject({ typename: TestSchemaType.project, version: '0.1.0' }));
 
   return {
     [TestSchemaType.document]: document,
@@ -103,13 +86,14 @@ const testObjectGenerators: TestGeneratorMap<TestSchemaType> = {
 
   [TestSchemaType.contact]: async (provider) => {
     const organizations = await provider?.(TestSchemaType.organization);
-    const { location } = faker.datatype.boolean() ? faker.geo.airport() : {};
+    const location = faker.datatype.boolean() ? faker.geo.airport() : {};
+
     return {
       name: faker.person.fullName(),
       email: faker.datatype.boolean({ probability: 0.5 }) ? faker.internet.email() : undefined,
       org:
-        organizations?.length && faker.datatype.boolean({ probability: 0.3 })
-          ? makeRef(faker.helpers.arrayElement(organizations))
+        organizations?.length && faker.datatype.boolean({ probability: 0.8 })
+          ? Ref.make(faker.helpers.arrayElement(organizations))
           : undefined,
       ...location,
     };
@@ -117,8 +101,10 @@ const testObjectGenerators: TestGeneratorMap<TestSchemaType> = {
 
   [TestSchemaType.project]: async () => ({
     name: faker.commerce.productName(),
-    repo: faker.datatype.boolean({ probability: 0.3 }) ? faker.internet.url() : undefined,
+    repo: faker.internet.url(),
     status: faker.helpers.arrayElement(Status),
+    description: faker.lorem.sentences(),
+    website: faker.internet.url(),
     priority: faker.helpers.arrayElement(Priority),
     active: faker.datatype.boolean(),
   }),
@@ -151,7 +137,13 @@ const testObjectMutators: TestMutationsMap<TestSchemaType> = {
   },
 };
 
+/**
+ * @deprecated Use generators in schema package.
+ */
 export const createTestObjectGenerator = () => new TestObjectGenerator(testSchemas(), testObjectGenerators);
 
+/**
+ * @deprecated Use generators in schema package.
+ */
 export const createSpaceObjectGenerator = (space: Space) =>
   new SpaceObjectGenerator(space, testSchemas(), testObjectGenerators, testObjectMutators);

package/src/generator.test.ts

@@ -2,12 +2,13 @@
 // Copyright 2023 DXOS.org
 //
 
+import { next as A } from '@automerge/automerge';
+import { Schema } from 'effect';
 import { describe, expect, onTestFinished, test } from 'vitest';
 
-import { next as A } from '@dxos/automerge/automerge';
 import { Client } from '@dxos/client';
 import { getObjectCore } from '@dxos/echo-db';
-import { S, TypedObject } from '@dxos/echo-schema';
+import { TypedObject } from '@dxos/echo-schema';
 import { getType } from '@dxos/live-object';
 import { faker } from '@dxos/random';
 
@@ -59,14 +60,14 @@ describe('TestObjectGenerator', () => {
       const generator = createSpaceObjectGenerator(space);
       await generator.addSchemas();
       const organization = await generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(getType(organization)!.objectId);
+      schemaId.push(getType(organization)!.toString());
     }
 
     {
       const generator = createSpaceObjectGenerator(space);
       await generator.addSchemas();
       const organization = await generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(getType(organization)!.objectId);
+      schemaId.push(getType(organization)!.toString());
     }
 
     expect(schemaId[0]).not.to.be.undefined;
@@ -80,14 +81,14 @@ describe('TestObjectGenerator', () => {
     const document = await generator.createObject({ types: [TestSchemaType.document] });
     expect(getType(document)).to.exist;
 
-    const beforeChangesCount = A.getAllChanges(getObjectCore(document).docHandle!.docSync()).length;
+    const beforeChangesCount = A.getAllChanges(getObjectCore(document).docHandle!.doc()).length;
 
     // Mutate the document.
     const mutationsCount = 10;
     await generator.mutateObject(document, { count: mutationsCount, maxContentLength: 1000, mutationSize: 10 });
     await space.db.flush();
 
-    const changesCount = A.getAllChanges(getObjectCore(document).docHandle!.docSync()).length;
+    const changesCount = A.getAllChanges(getObjectCore(document).docHandle!.doc()).length;
     expect(changesCount - beforeChangesCount).to.be.eq(mutationsCount);
   });
 
@@ -96,7 +97,7 @@ describe('TestObjectGenerator', () => {
       typename: 'example.org/type/Task',
       version: '0.1.0',
     })({
-      name: S.optional(S.String),
+      name: Schema.optional(Schema.String),
     }) {}
 
     enum Types {
@@ -123,4 +124,31 @@ describe('TestObjectGenerator', () => {
     const todo = await generator.createObject({ types: [Types.task] });
     expect(getType(todo)).to.exist;
   });
+
+  test('references', async () => {
+    const { space } = await setupTest();
+    const generator = createSpaceObjectGenerator(space);
+    await generator.addSchemas();
+
+    // Create raw object.
+    const objects = await generator.createObjects({
+      [TestSchemaType.organization]: 1,
+      [TestSchemaType.contact]: 1,
+    });
+    expect(objects).to.exist;
+    expect(objects.length).to.be.eq(2);
+  });
+
+  test('create project', async () => {
+    const generator = createTestObjectGenerator();
+    const project = await generator.createObject({ types: [TestSchemaType.project] });
+    expect(getType(project)).to.exist;
+  });
+
+  test('create object with not type', async () => {
+    // TODO(burdon): Create Client/spaces.
+    const generator = createTestObjectGenerator();
+
+    await generator.createObject();
+  });
 });

package/src/generator.ts

@@ -2,13 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
+import { type Schema } from 'effect';
+
 import { Filter, type Space } from '@dxos/client/echo';
-import { type ReactiveEchoObject } from '@dxos/echo-db';
-import { getTypeAnnotation, EchoSchema, type S } from '@dxos/echo-schema';
+import { type AnyLiveObject } from '@dxos/echo-db';
+import { getTypeAnnotation, EchoSchema, getSchema } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { create, getSchema, isReactiveObject, type ReactiveObject } from '@dxos/live-object';
+import { live, isLiveObject, type Live } from '@dxos/live-object';
 import { faker } from '@dxos/random';
-import { range } from '@dxos/util';
+import { entries, range } from '@dxos/util';
 
 import { type TestSchemaType } from './data';
 import {
@@ -21,6 +23,7 @@ import {
 
 /**
  * Typed object generator.
+ * @deprecated
  */
 export class TestObjectGenerator<T extends string = TestSchemaType> {
   // prettier-ignore
@@ -30,31 +33,36 @@ export class TestObjectGenerator<T extends string = TestSchemaType> {
     private readonly _provider?: TestObjectProvider<T>,
   ) {}
 
-  get schemas(): (EchoSchema | S.Schema.AnyNoContext)[] {
+  get schemas(): (EchoSchema | Schema.Schema.AnyNoContext)[] {
     return Object.values(this._schemas);
   }
 
-  getSchema(type: T): EchoSchema | S.Schema.AnyNoContext | undefined {
+  getSchema(type: T): EchoSchema | Schema.Schema.AnyNoContext | undefined {
     return this.schemas.find((schema) => getTypeAnnotation(schema)!.typename === type);
   }
 
-  protected setSchema(type: T, schema: EchoSchema | S.Schema.AnyNoContext) {
+  protected setSchema(type: T, schema: EchoSchema | Schema.Schema.AnyNoContext): void {
     this._schemas[type] = schema;
   }
 
-  async createObject({ types }: { types?: T[] } = {}): Promise<ReactiveObject<any>> {
+  async createObject({ types }: { types?: T[] } = {}): Promise<Live<any>> {
     const type = faker.helpers.arrayElement(types ?? (Object.keys(this._schemas) as T[]));
     const data = await this._generators[type](this._provider);
-    if (isReactiveObject(data)) {
+    if (isLiveObject(data)) {
       return data;
     }
 
     const schema = this.getSchema(type);
-    return schema ? create(schema, data) : create(data);
+    return schema ? live(schema, data) : live(data);
   }
 
   // TODO(burdon): Based on dependencies (e.g., organization before contact).
   async createObjects(map: Partial<Record<T, number>>) {
+    const results: Live<any>[] = [];
+    for (const [type, count] of entries(map)) {
+      results.push(...(await Promise.all(range(count ?? 0, () => this.createObject({ types: [type as T] })))));
+    }
+
     const tasks = Object.entries<number>(map as any)
       .map(([type, count]) => {
         return range(count, () => this.createObject({ types: [type as T] }));
@@ -77,14 +85,15 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
   ) {
     super(schemaMap, generators, async (type: T) => {
       const schema = this.getSchema(type);
-      return (schema && (await this._space.db.query(Filter.schema(schema)).run()).objects) ?? [];
+      const { objects } = await this._space.db.query(schema ? Filter.type(schema) : Filter.nothing()).run();
+      return objects;
     });
   }
 
   async addSchemas() {
-    const result: (EchoSchema | S.Schema.AnyNoContext)[] = [];
+    const result: (EchoSchema | Schema.Schema.AnyNoContext)[] = [];
     for (const [typename, schema] of Object.entries(this._schemas)) {
-      const echoSchema = await this._maybeRegisterSchema(typename, schema as EchoSchema | S.Schema.AnyNoContext);
+      const echoSchema = await this._maybeRegisterSchema(typename, schema as EchoSchema | Schema.Schema.AnyNoContext);
       this.setSchema(typename as T, echoSchema);
       result.push(echoSchema);
     }
@@ -92,14 +101,14 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
     return result;
   }
 
-  override async createObject({ types }: { types?: T[] } = {}): Promise<ReactiveEchoObject<any>> {
+  override async createObject({ types }: { types?: T[] } = {}): Promise<AnyLiveObject<any>> {
     return this._space.db.add(await super.createObject({ types }));
   }
 
   private async _maybeRegisterSchema(
     typename: string,
-    schema: EchoSchema | S.Schema.AnyNoContext,
-  ): Promise<EchoSchema | S.Schema.AnyNoContext> {
+    schema: EchoSchema | Schema.Schema.AnyNoContext,
+  ): Promise<EchoSchema | Schema.Schema.AnyNoContext> {
     if (schema instanceof EchoSchema) {
       const existingSchema = this._space.db.schemaRegistry.getSchema(typename);
       if (existingSchema != null) {
@@ -117,7 +126,7 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
     }
   }
 
-  async mutateObject(object: ReactiveEchoObject<any>, params: MutationsProviderParams) {
+  async mutateObject(object: AnyLiveObject<any>, params: MutationsProviderParams): Promise<void> {
     invariant(this._mutations, 'Mutations not defined.');
     const type = getTypeAnnotation(getSchema(object)!)!.typename as T;
     invariant(type && this._mutations?.[type], 'Invalid object type.');
@@ -125,7 +134,7 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
     await this._mutations![type](object, params);
   }
 
-  async mutateObjects(objects: ReactiveEchoObject<any>[], params: MutationsProviderParams) {
+  async mutateObjects(objects: AnyLiveObject<any>[], params: MutationsProviderParams): Promise<void> {
     for (const object of objects) {
       await this.mutateObject(object, params);
     }

package/src/types.ts

@@ -2,16 +2,18 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type ReactiveEchoObject } from '@dxos/echo-db';
-import { type EchoSchema, type S } from '@dxos/echo-schema';
-import { type ReactiveObject } from '@dxos/live-object';
+import { type Schema } from 'effect';
+
+import { type AnyLiveObject } from '@dxos/echo-db';
+import { type EchoSchema } from '@dxos/echo-schema';
+import { type Live } from '@dxos/live-object';
 
 // TODO(burdon): Use echo-schema types.
 export type TestObject = { id: string } & Record<string, any>;
 
-export type TestSchemaMap<T extends string = string> = Record<T, EchoSchema | S.Schema.AnyNoContext>;
+export type TestSchemaMap<T extends string = string> = Record<T, EchoSchema | Schema.Schema.AnyNoContext>;
 
-export type TestObjectProvider<T extends string = string> = (type: T) => Promise<ReactiveObject<any>[]>;
+export type TestObjectProvider<T extends string = string> = (type: T) => Promise<Live<any>[]>;
 
 export type TestGeneratorMap<T extends string = string> = Record<
   T,
@@ -26,4 +28,4 @@ export type MutationsProviderParams = {
   maxContentLength: number;
 };
 
-export type TestObjectMutators = (object: ReactiveEchoObject<any>, params: MutationsProviderParams) => Promise<void>;
+export type TestObjectMutators = (object: AnyLiveObject<any>, params: MutationsProviderParams) => Promise<void>;