@dxos/echo-generator 0.8.4-main.b97322e → 0.8.4-main.bc674ce

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "@dxos/echo-generator",
-  "version": "0.8.4-main.b97322e",
+  "version": "0.8.4-main.bc674ce",
   "description": "ECHO data generator for testing.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "info@dxos.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
@@ -24,24 +29,22 @@
     "src"
   ],
   "dependencies": {
-    "@automerge/automerge": "3.0.0",
-    "effect": "3.17.0",
-    "@dxos/client": "0.8.4-main.b97322e",
-    "@dxos/echo-db": "0.8.4-main.b97322e",
-    "@dxos/echo-schema": "0.8.4-main.b97322e",
-    "@dxos/live-object": "0.8.4-main.b97322e",
-    "@dxos/invariant": "0.8.4-main.b97322e",
-    "@dxos/log": "0.8.4-main.b97322e",
-    "@dxos/node-std": "0.8.4-main.b97322e",
-    "@dxos/schema": "0.8.4-main.b97322e",
-    "@dxos/util": "0.8.4-main.b97322e"
+    "@automerge/automerge": "3.2.3",
+    "effect": "3.19.11",
+    "@dxos/client": "0.8.4-main.bc674ce",
+    "@dxos/echo": "0.8.4-main.bc674ce",
+    "@dxos/echo-db": "0.8.4-main.bc674ce",
+    "@dxos/invariant": "0.8.4-main.bc674ce",
+    "@dxos/log": "0.8.4-main.bc674ce",
+    "@dxos/node-std": "0.8.4-main.bc674ce",
+    "@dxos/util": "0.8.4-main.bc674ce"
   },
   "devDependencies": {
-    "@dxos/random": "0.8.4-main.b97322e"
+    "@dxos/random": "0.8.4-main.bc674ce"
   },
   "peerDependencies": {
-    "effect": "^3.13.3",
-    "@dxos/random": "0.8.4-main.b97322e"
+    "effect": "3.19.11",
+    "@dxos/random": "0.8.4-main.bc674ce"
   },
   "publishConfig": {
     "access": "public"

package/src/data.ts

@@ -3,10 +3,11 @@
 //
 
 import { next as A } from '@automerge/automerge';
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-import { createDocAccessor, type Space } from '@dxos/client/echo';
-import { EchoObject, Ref } from '@dxos/echo-schema';
+import { type Space } from '@dxos/client/echo';
+import { Ref, Type } from '@dxos/echo';
+import { createDocAccessor } from '@dxos/echo-db';
 import { faker } from '@dxos/random';
 
 import { SpaceObjectGenerator, TestObjectGenerator } from './generator';
@@ -26,7 +27,7 @@ export const Priority = [1, 2, 3, 4, 5];
 export enum TestSchemaType {
   document = 'example.com/type/Document',
   organization = 'example.com/type/Organization',
-  contact = 'example.com/type/Contact',
+  contact = 'example.com/type/Person',
   project = 'example.com/type/Project',
 }
 
@@ -37,21 +38,21 @@ const testSchemas = (): TestSchemaMap<TestSchemaType> => {
   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' }));
+  }).pipe(Type.object({ 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' }));
+  }).pipe(Type.object({ 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)),
+    org: Schema.optional(Type.Ref(organization)),
     lat: Schema.optional(Schema.Number),
     lng: Schema.optional(Schema.Number),
-  }).pipe(EchoObject({ typename: TestSchemaType.contact, version: '0.1.0' }));
+  }).pipe(Type.object({ typename: TestSchemaType.contact, version: '0.1.0' }));
 
   const project = Schema.Struct({
     name: Schema.String.annotations({ description: 'name of the project' }),
@@ -61,8 +62,8 @@ const testSchemas = (): TestSchemaMap<TestSchemaType> => {
     status: Schema.String,
     priority: Schema.Number,
     active: Schema.Boolean,
-    org: Schema.optional(Ref(organization)),
-  }).pipe(EchoObject({ typename: TestSchemaType.project, version: '0.1.0' }));
+    org: Schema.optional(Type.Ref(organization)),
+  }).pipe(Type.object({ typename: TestSchemaType.project, version: '0.1.0' }));
 
   return {
     [TestSchemaType.document]: document,

package/src/generator.test.ts

@@ -3,15 +3,15 @@
 //
 
 import { next as A } from '@automerge/automerge';
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Client } from '@dxos/client';
+import { Obj, Type } from '@dxos/echo';
 import { getObjectCore } from '@dxos/echo-db';
-import { TypedObject, getType } from '@dxos/echo-schema';
 import { faker } from '@dxos/random';
 
-import { createSpaceObjectGenerator, createTestObjectGenerator, TestSchemaType } from './data';
+import { TestSchemaType, createSpaceObjectGenerator, createTestObjectGenerator } from './data';
 import { SpaceObjectGenerator } from './generator';
 
 faker.seed(3);
@@ -43,7 +43,7 @@ describe('TestObjectGenerator', () => {
 
     // Create org object.
     const organization = await generator.createObject({ types: [TestSchemaType.organization] });
-    expect(getType(organization)).to.exist;
+    expect(Obj.getTypeDXN(organization)).to.exist;
 
     // Expect at least one person object with a linked org reference.
     const objects = await generator.createObjects({ [TestSchemaType.contact]: 10 });
@@ -59,14 +59,14 @@ describe('TestObjectGenerator', () => {
       const generator = createSpaceObjectGenerator(space);
       await generator.addSchemas();
       const organization = await generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(getType(organization)!.toString());
+      schemaId.push(Obj.getTypeDXN(organization)!.toString());
     }
 
     {
       const generator = createSpaceObjectGenerator(space);
       await generator.addSchemas();
       const organization = await generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(getType(organization)!.toString());
+      schemaId.push(Obj.getTypeDXN(organization)!.toString());
     }
 
     expect(schemaId[0]).not.to.be.undefined;
@@ -78,7 +78,7 @@ describe('TestObjectGenerator', () => {
     const generator = createSpaceObjectGenerator(space);
     await generator.addSchemas();
     const document = await generator.createObject({ types: [TestSchemaType.document] });
-    expect(getType(document)).to.exist;
+    expect(Obj.getTypeDXN(document)).to.exist;
 
     const beforeChangesCount = A.getAllChanges(getObjectCore(document).docHandle!.doc()).length;
 
@@ -92,12 +92,14 @@ describe('TestObjectGenerator', () => {
   });
 
   test('create object with in memory schema', async () => {
-    class Task extends TypedObject({
-      typename: 'example.org/type/Task',
-      version: '0.1.0',
-    })({
+    const Task = Schema.Struct({
       name: Schema.optional(Schema.String),
-    }) {}
+    }).pipe(
+      Type.object({
+        typename: 'example.org/type/Task',
+        version: '0.1.0',
+      }),
+    );
 
     enum Types {
       task = 'example.org/type/Task',
@@ -106,7 +108,9 @@ describe('TestObjectGenerator', () => {
     const { space } = await setupTest();
     const generator = new SpaceObjectGenerator<Types>(
       space,
-      { [Types.task]: Task },
+      {
+        [Types.task]: Task,
+      },
       {
         [Types.task]: () => ({ name: 'Default' }),
       },
@@ -121,7 +125,7 @@ describe('TestObjectGenerator', () => {
     await generator.addSchemas();
 
     const todo = await generator.createObject({ types: [Types.task] });
-    expect(getType(todo)).to.exist;
+    expect(Obj.getTypeDXN(todo)).to.exist;
   });
 
   test('references', async () => {
@@ -141,7 +145,7 @@ describe('TestObjectGenerator', () => {
   test('create project', async () => {
     const generator = createTestObjectGenerator();
     const project = await generator.createObject({ types: [TestSchemaType.project] });
-    expect(getType(project)).to.exist;
+    expect(Obj.getTypeDXN(project)).to.exist;
   });
 
   test('create object with not type', async () => {

package/src/generator.ts

@@ -2,19 +2,17 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Schema } from 'effect';
-
 import { Filter, type Space } from '@dxos/client/echo';
-import { type AnyLiveObject } from '@dxos/echo-db';
-import { getTypeAnnotation, EchoSchema, getSchema } from '@dxos/echo-schema';
+import { Obj, type Type } from '@dxos/echo';
+import { EchoSchema, getTypeAnnotation } from '@dxos/echo/internal';
+import { isProxy } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
-import { live, isLiveObject, type Live } from '@dxos/live-object';
 import { faker } from '@dxos/random';
 import { entries, range } from '@dxos/util';
 
 import { type TestSchemaType } from './data';
 import {
-  type MutationsProviderParams,
+  type MutationsProviderProps,
   type TestGeneratorMap,
   type TestMutationsMap,
   type TestObjectProvider,
@@ -28,37 +26,38 @@ import {
 export class TestObjectGenerator<T extends string = TestSchemaType> {
   // prettier-ignore
   constructor(
-    protected readonly _schemas: TestSchemaMap<T>,
-    private readonly _generators: TestGeneratorMap<T>,
-    private readonly _provider?: TestObjectProvider<T>,
-  ) {}
+		protected readonly _schemas: TestSchemaMap<T>,
+		private readonly _generators: TestGeneratorMap<T>,
+		private readonly _provider?: TestObjectProvider<T>,
+	) {}
 
-  get schemas(): (EchoSchema | Schema.Schema.AnyNoContext)[] {
+  get schemas(): Type.Obj.Any[] {
     return Object.values(this._schemas);
   }
 
-  getSchema(type: T): EchoSchema | Schema.Schema.AnyNoContext | undefined {
+  getSchema(type: T): Type.Obj.Any | undefined {
     return this.schemas.find((schema) => getTypeAnnotation(schema)!.typename === type);
   }
 
-  protected setSchema(type: T, schema: EchoSchema | Schema.Schema.AnyNoContext): void {
+  protected setSchema(type: T, schema: Type.Obj.Any): void {
     this._schemas[type] = schema;
   }
 
-  async createObject({ types }: { types?: T[] } = {}): Promise<Live<any>> {
+  async createObject({ types }: { types?: T[] } = {}): Promise<any> {
     const type = faker.helpers.arrayElement(types ?? (Object.keys(this._schemas) as T[]));
     const data = await this._generators[type](this._provider);
-    if (isLiveObject(data)) {
+    if (isProxy(data)) {
       return data;
     }
 
     const schema = this.getSchema(type);
-    return schema ? live(schema, data) : live(data);
+    invariant(schema, `Schema is required for type: ${type}. Register a schema for this type.`);
+    return Obj.make(schema, data);
   }
 
   // TODO(burdon): Based on dependencies (e.g., organization before contact).
   async createObjects(map: Partial<Record<T, number>>) {
-    const results: Live<any>[] = [];
+    const results: any[] = [];
     for (const [type, count] of entries(map)) {
       results.push(...(await Promise.all(range(count ?? 0, () => this.createObject({ types: [type as T] })))));
     }
@@ -85,15 +84,15 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
   ) {
     super(schemaMap, generators, async (type: T) => {
       const schema = this.getSchema(type);
-      const { objects } = await this._space.db.query(schema ? Filter.type(schema) : Filter.nothing()).run();
+      const objects = await this._space.db.query(schema ? Filter.type(schema) : Filter.nothing()).run();
       return objects;
     });
   }
 
   async addSchemas() {
-    const result: (EchoSchema | Schema.Schema.AnyNoContext)[] = [];
+    const result: Type.Obj.Any[] = [];
     for (const [typename, schema] of Object.entries(this._schemas)) {
-      const echoSchema = await this._maybeRegisterSchema(typename, schema as EchoSchema | Schema.Schema.AnyNoContext);
+      const echoSchema = await this._maybeRegisterSchema(typename, schema as Type.Obj.Any);
       this.setSchema(typename as T, echoSchema);
       result.push(echoSchema);
     }
@@ -101,40 +100,41 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
     return result;
   }
 
-  override async createObject({ types }: { types?: T[] } = {}): Promise<AnyLiveObject<any>> {
+  override async createObject({
+    types,
+  }: {
+    types?: T[];
+  } = {}): Promise<Obj.Any> {
     return this._space.db.add(await super.createObject({ types }));
   }
 
-  private async _maybeRegisterSchema(
-    typename: string,
-    schema: EchoSchema | Schema.Schema.AnyNoContext,
-  ): Promise<EchoSchema | Schema.Schema.AnyNoContext> {
+  private async _maybeRegisterSchema(typename: string, schema: Type.Obj.Any): Promise<Type.Obj.Any> {
     if (schema instanceof EchoSchema) {
-      const existingSchema = this._space.db.schemaRegistry.getSchema(typename);
+      const existingSchema = this._space.internal.db.schemaRegistry.getSchema(typename);
       if (existingSchema != null) {
         return existingSchema;
       }
-      const [registeredSchema] = await this._space.db.schemaRegistry.register([schema]);
+      const [registeredSchema] = await this._space.internal.db.schemaRegistry.register([schema]);
       return registeredSchema;
     } else {
-      const existingSchema = this._space.db.graph.schemaRegistry.getSchema(typename);
+      const existingSchema = this._space.internal.db.graph.schemaRegistry.getSchema(typename);
       if (existingSchema != null) {
         return existingSchema;
       }
-      this._space.db.graph.schemaRegistry.addSchema([schema]);
+      await this._space.internal.db.graph.schemaRegistry.register([schema]);
       return schema;
     }
   }
 
-  async mutateObject(object: AnyLiveObject<any>, params: MutationsProviderParams): Promise<void> {
+  async mutateObject(object: Obj.Any, params: MutationsProviderProps): Promise<void> {
     invariant(this._mutations, 'Mutations not defined.');
-    const type = getTypeAnnotation(getSchema(object)!)!.typename as T;
+    const type = getTypeAnnotation(Obj.getSchema(object)!)!.typename as T;
     invariant(type && this._mutations?.[type], 'Invalid object type.');
 
     await this._mutations![type](object, params);
   }
 
-  async mutateObjects(objects: AnyLiveObject<any>[], params: MutationsProviderParams): Promise<void> {
+  async mutateObjects(objects: Obj.Any[], params: MutationsProviderProps): Promise<void> {
     for (const object of objects) {
       await this.mutateObject(object, params);
     }

package/src/types.ts

@@ -2,18 +2,14 @@
 // Copyright 2023 DXOS.org
 //
 
-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';
+import { type Obj, type Type } from '@dxos/echo';
 
 // TODO(burdon): Use echo-schema types.
 export type TestObject = { id: string } & Record<string, any>;
 
-export type TestSchemaMap<T extends string = string> = Record<T, EchoSchema | Schema.Schema.AnyNoContext>;
+export type TestSchemaMap<T extends string = string> = Record<T, Type.Obj.Any>;
 
-export type TestObjectProvider<T extends string = string> = (type: T) => Promise<Live<any>[]>;
+export type TestObjectProvider<T extends string = string> = (type: T) => Promise<any[]>;
 
 export type TestGeneratorMap<T extends string = string> = Record<
   T,
@@ -22,10 +18,10 @@ export type TestGeneratorMap<T extends string = string> = Record<
 
 export type TestMutationsMap<T extends string = string> = Record<T, TestObjectMutators>;
 
-export type MutationsProviderParams = {
+export type MutationsProviderProps = {
   count: number;
   mutationSize: number;
   maxContentLength: number;
 };
 
-export type TestObjectMutators = (object: AnyLiveObject<any>, params: MutationsProviderParams) => Promise<void>;
+export type TestObjectMutators = (object: Obj.Any, params: MutationsProviderProps) => Promise<void>;