@dxos/echo-generator 0.8.4-main.ef1bc66f44 → 0.8.4-main.effb148878

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-generator",
-  "version": "0.8.4-main.ef1bc66f44",
+  "version": "0.8.4-main.effb148878",
   "description": "ECHO data generator for testing.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/dxos/dxos"
   },
-  "license": "MIT",
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
   "sideEffects": false,
   "type": "module",
@@ -20,30 +20,28 @@
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {}
-  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@automerge/automerge": "3.2.3",
-    "effect": "3.19.16",
-    "@dxos/client": "0.8.4-main.ef1bc66f44",
-    "@dxos/echo": "0.8.4-main.ef1bc66f44",
-    "@dxos/invariant": "0.8.4-main.ef1bc66f44",
-    "@dxos/echo-db": "0.8.4-main.ef1bc66f44",
-    "@dxos/node-std": "0.8.4-main.ef1bc66f44",
-    "@dxos/util": "0.8.4-main.ef1bc66f44",
-    "@dxos/log": "0.8.4-main.ef1bc66f44"
+    "@automerge/automerge": "3.2.6",
+    "effect": "3.20.0",
+    "@dxos/client": "0.8.4-main.effb148878",
+    "@dxos/context": "0.8.4-main.effb148878",
+    "@dxos/echo": "0.8.4-main.effb148878",
+    "@dxos/echo-db": "0.8.4-main.effb148878",
+    "@dxos/invariant": "0.8.4-main.effb148878",
+    "@dxos/node-std": "0.8.4-main.effb148878",
+    "@dxos/util": "0.8.4-main.effb148878",
+    "@dxos/log": "0.8.4-main.effb148878"
   },
   "devDependencies": {
-    "@dxos/random": "0.8.4-main.ef1bc66f44"
+    "@dxos/random": "0.8.4-main.effb148878"
   },
   "peerDependencies": {
-    "effect": "3.19.16",
-    "@dxos/random": "0.8.4-main.ef1bc66f44"
+    "effect": "3.20.0",
+    "@dxos/random": "0.8.4-main.effb148878"
   },
   "publishConfig": {
     "access": "public"

package/src/data.ts

@@ -6,9 +6,9 @@ import { next as A } from '@automerge/automerge';
 import * as Schema from 'effect/Schema';
 
 import { type Space } from '@dxos/client/echo';
-import { Ref, Type } from '@dxos/echo';
+import { DXN, Ref, Type } from '@dxos/echo';
 import { createDocAccessor } from '@dxos/echo-db';
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 
 import { SpaceObjectGenerator, TestObjectGenerator } from './generator';
 import { type TestGeneratorMap, type TestMutationsMap, type TestSchemaMap } from './types';
@@ -25,10 +25,10 @@ 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/Person',
-  project = 'example.com/type/Project',
+  document = 'com.example.type.document',
+  organization = 'com.example.type.organization',
+  contact = 'com.example.type.person',
+  project = 'com.example.type.project',
 }
 
 /**
@@ -38,21 +38,21 @@ const testSchemas = (): TestSchemaMap<TestSchemaType> => {
   const document = Schema.Struct({
     title: Schema.String.annotations({ description: 'title of the document' }),
     content: Schema.String,
-  }).pipe(Type.object({ typename: TestSchemaType.document, version: '0.1.0' }));
+  }).pipe(Type.makeObject(DXN.make(TestSchemaType.document, '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(Type.object({ typename: TestSchemaType.organization, version: '0.1.0' }));
+  }).pipe(Type.makeObject(DXN.make(TestSchemaType.organization, '0.1.0')));
 
   const contact = Schema.Struct({
     name: Schema.String.annotations({ description: 'name of the person' }),
     email: Schema.optional(Schema.String),
-    org: Schema.optional(Type.Ref(organization)),
+    org: Schema.optional(Ref.Ref(organization)),
     lat: Schema.optional(Schema.Number),
     lng: Schema.optional(Schema.Number),
-  }).pipe(Type.object({ typename: TestSchemaType.contact, version: '0.1.0' }));
+  }).pipe(Type.makeObject(DXN.make(TestSchemaType.contact, '0.1.0')));
 
   const project = Schema.Struct({
     name: Schema.String.annotations({ description: 'name of the project' }),
@@ -62,8 +62,8 @@ const testSchemas = (): TestSchemaMap<TestSchemaType> => {
     status: Schema.String,
     priority: Schema.Number,
     active: Schema.Boolean,
-    org: Schema.optional(Type.Ref(organization)),
-  }).pipe(Type.object({ typename: TestSchemaType.project, version: '0.1.0' }));
+    org: Schema.optional(Ref.Ref(organization)),
+  }).pipe(Type.makeObject(DXN.make(TestSchemaType.project, '0.1.0')));
 
   return {
     [TestSchemaType.document]: document,
@@ -75,39 +75,39 @@ const testSchemas = (): TestSchemaMap<TestSchemaType> => {
 
 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 }) }),
+    title: random.lorem.sentence(3),
+    content: random.lorem.sentences({ min: 1, max: random.number.int({ min: 1, max: 3 }) }),
   }),
 
   [TestSchemaType.organization]: async () => ({
-    name: faker.company.name(),
-    website: faker.datatype.boolean({ probability: 0.3 }) ? faker.internet.url() : undefined,
-    description: faker.lorem.sentences(),
+    name: random.company.name(),
+    website: random.datatype.boolean({ probability: 0.3 }) ? random.internet.url() : undefined,
+    description: random.lorem.sentences(),
   }),
 
   [TestSchemaType.contact]: async (provider) => {
     const organizations = await provider?.(TestSchemaType.organization);
-    const location = faker.datatype.boolean() ? faker.geo.airport() : {};
+    const location = random.datatype.boolean() ? random.geo.airport() : {};
 
     return {
-      name: faker.person.fullName(),
-      email: faker.datatype.boolean({ probability: 0.5 }) ? faker.internet.email() : undefined,
+      name: random.person.fullName(),
+      email: random.datatype.boolean({ probability: 0.5 }) ? random.internet.email() : undefined,
       org:
-        organizations?.length && faker.datatype.boolean({ probability: 0.8 })
-          ? Ref.make(faker.helpers.arrayElement(organizations))
+        organizations?.length && random.datatype.boolean({ probability: 0.8 })
+          ? Ref.make(random.helpers.arrayElement(organizations))
           : undefined,
       ...location,
     };
   },
 
   [TestSchemaType.project]: async () => ({
-    name: faker.commerce.productName(),
-    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(),
+    name: random.commerce.productName(),
+    repo: random.internet.url(),
+    status: random.helpers.arrayElement(Status),
+    description: random.lorem.sentences(),
+    website: random.internet.url(),
+    priority: random.helpers.arrayElement(Priority),
+    active: random.datatype.boolean(),
   }),
 };
 

package/src/generator.test.ts

@@ -7,14 +7,14 @@ 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 { DXN, Obj, Type } from '@dxos/echo';
 import { getObjectCore } from '@dxos/echo-db';
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 
 import { TestSchemaType, createSpaceObjectGenerator, createTestObjectGenerator } from './data';
 import { SpaceObjectGenerator } from './generator';
 
-faker.seed(3);
+random.seed(3);
 
 describe('TestObjectGenerator', () => {
   // TODO(burdon): Use TestBuilder.
@@ -43,7 +43,7 @@ describe('TestObjectGenerator', () => {
 
     // Create org object.
     const organization = await generator.createObject({ types: [TestSchemaType.organization] });
-    expect(Obj.getTypeDXN(organization)).to.exist;
+    expect(Obj.getTypeURI(organization)).to.exist;
 
     // Expect at least one person object with a linked org reference.
     const objects = await generator.createObjects({ [TestSchemaType.contact]: 10 });
@@ -59,26 +59,27 @@ describe('TestObjectGenerator', () => {
       const generator = createSpaceObjectGenerator(space);
       await generator.addSchemas();
       const organization = await generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(Obj.getTypeDXN(organization)!.toString());
+      schemaId.push(Obj.getTypeURI(organization)!.toString());
     }
 
     {
       const generator = createSpaceObjectGenerator(space);
       await generator.addSchemas();
       const organization = await generator.createObject({ types: [TestSchemaType.organization] });
-      schemaId.push(Obj.getTypeDXN(organization)!.toString());
+      schemaId.push(Obj.getTypeURI(organization)!.toString());
     }
 
     expect(schemaId[0]).not.to.be.undefined;
     expect(schemaId[0]).to.eq(schemaId[1]);
   });
 
-  test('mutations', async () => {
+  // flaky
+  test.skip('mutations', async () => {
     const { space } = await setupTest();
     const generator = createSpaceObjectGenerator(space);
     await generator.addSchemas();
     const document = await generator.createObject({ types: [TestSchemaType.document] });
-    expect(Obj.getTypeDXN(document)).to.exist;
+    expect(Obj.getTypeURI(document)).to.exist;
 
     const beforeChangesCount = A.getAllChanges(getObjectCore(document).docHandle!.doc()).length;
 
@@ -94,15 +95,10 @@ describe('TestObjectGenerator', () => {
   test('create object with in memory schema', async () => {
     const Task = Schema.Struct({
       name: Schema.optional(Schema.String),
-    }).pipe(
-      Type.object({
-        typename: 'example.org/type/Task',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.task', '0.1.0')));
 
     enum Types {
-      task = 'example.org/type/Task',
+      task = 'com.example.type.task',
     }
 
     const { space } = await setupTest();
@@ -117,7 +113,7 @@ describe('TestObjectGenerator', () => {
       {
         [Types.task]: async (task, params) => {
           for (const _ in Array.from({ length: params.count })) {
-            task.name = faker.lorem.sentence();
+            task.name = random.lorem.sentence();
           }
         },
       },
@@ -125,7 +121,7 @@ describe('TestObjectGenerator', () => {
     await generator.addSchemas();
 
     const todo = await generator.createObject({ types: [Types.task] });
-    expect(Obj.getTypeDXN(todo)).to.exist;
+    expect(Obj.getTypeURI(todo)).to.exist;
   });
 
   test('references', async () => {
@@ -145,7 +141,7 @@ describe('TestObjectGenerator', () => {
   test('create project', async () => {
     const generator = createTestObjectGenerator();
     const project = await generator.createObject({ types: [TestSchemaType.project] });
-    expect(Obj.getTypeDXN(project)).to.exist;
+    expect(Obj.getTypeURI(project)).to.exist;
   });
 
   test('create object with not type', async () => {

package/src/generator.ts

@@ -2,12 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Filter, type Space } from '@dxos/client/echo';
-import { Obj, type Type } from '@dxos/echo';
-import { EchoSchema, getTypeAnnotation } from '@dxos/echo/internal';
+import { type Space } from '@dxos/client/echo';
+import { Filter, Obj, Type } from '@dxos/echo';
 import { isProxy } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 import { entries, range } from '@dxos/util';
 
 import { type TestSchemaType } from './data';
@@ -31,20 +30,20 @@ export class TestObjectGenerator<T extends string = TestSchemaType> {
 		private readonly _provider?: TestObjectProvider<T>,
 	) {}
 
-  get schemas(): Type.Obj.Any[] {
+  get schemas(): Type.AnyObj[] {
     return Object.values(this._schemas);
   }
 
-  getSchema(type: T): Type.Obj.Any | undefined {
-    return this.schemas.find((schema) => getTypeAnnotation(schema)!.typename === type);
+  getSchema(type: T): Type.AnyObj | undefined {
+    return this.schemas.find((schema) => Type.getTypename(schema) === type);
   }
 
-  protected setSchema(type: T, schema: Type.Obj.Any): void {
+  protected setSchema(type: T, schema: Type.AnyEntity): void {
     this._schemas[type] = schema;
   }
 
   async createObject({ types }: { types?: T[] } = {}): Promise<any> {
-    const type = faker.helpers.arrayElement(types ?? (Object.keys(this._schemas) as T[]));
+    const type = random.helpers.arrayElement(types ?? (Object.keys(this._schemas) as T[]));
     const data = await this._generators[type](this._provider);
     if (isProxy(data)) {
       return data;
@@ -90,9 +89,9 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
   }
 
   async addSchemas() {
-    const result: Type.Obj.Any[] = [];
+    const result: Type.AnyEntity[] = [];
     for (const [typename, schema] of Object.entries(this._schemas)) {
-      const echoSchema = await this._maybeRegisterSchema(typename, schema as Type.Obj.Any);
+      const echoSchema = await this._maybeRegisterSchema(typename, schema as Type.AnyObj);
       this.setSchema(typename as T, echoSchema);
       result.push(echoSchema);
     }
@@ -108,8 +107,8 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
     return this._space.db.add(await super.createObject({ types }));
   }
 
-  private async _maybeRegisterSchema(typename: string, schema: Type.Obj.Any): Promise<Type.Obj.Any> {
-    if (schema instanceof EchoSchema) {
+  private async _maybeRegisterSchema(typename: string, schema: Type.AnyEntity): Promise<Type.AnyEntity> {
+    if (Type.getDatabase(schema) != null) {
       const existingSchema = this._space.internal.db.schemaRegistry.getSchema(typename);
       if (existingSchema != null) {
         return existingSchema;
@@ -128,7 +127,7 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
 
   async mutateObject(object: Obj.Any, params: MutationsProviderProps): Promise<void> {
     invariant(this._mutations, 'Mutations not defined.');
-    const type = getTypeAnnotation(Obj.getSchema(object)!)!.typename as T;
+    const type = Type.getTypename(Obj.getType(object)!) as T;
     invariant(type && this._mutations?.[type], 'Invalid object type.');
 
     await this._mutations![type](object, params);

package/src/types.ts

@@ -7,7 +7,7 @@ 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, Type.Obj.Any>;
+export type TestSchemaMap<T extends string = string> = Record<T, Type.AnyEntity>;
 
 export type TestObjectProvider<T extends string = string> = (type: T) => Promise<any[]>;