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

package/src/generator.ts

@@ -2,13 +2,11 @@
 // 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 { type ReactiveEchoObject } from '@dxos/echo-db';
+import { getTypeAnnotation, EchoSchema, type S } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { live, isLiveObject, type Live } from '@dxos/live-object';
+import { create, getSchema, isReactiveObject, type ReactiveObject } from '@dxos/live-object';
 import { faker } from '@dxos/random';
 import { range } from '@dxos/util';
 
@@ -32,27 +30,27 @@ export class TestObjectGenerator<T extends string = TestSchemaType> {
     private readonly _provider?: TestObjectProvider<T>,
   ) {}
 
-  get schemas(): (EchoSchema | Schema.Schema.AnyNoContext)[] {
+  get schemas(): (EchoSchema | S.Schema.AnyNoContext)[] {
     return Object.values(this._schemas);
   }
 
-  getSchema(type: T): EchoSchema | Schema.Schema.AnyNoContext | undefined {
+  getSchema(type: T): EchoSchema | S.Schema.AnyNoContext | undefined {
     return this.schemas.find((schema) => getTypeAnnotation(schema)!.typename === type);
   }
 
-  protected setSchema(type: T, schema: EchoSchema | Schema.Schema.AnyNoContext) {
+  protected setSchema(type: T, schema: EchoSchema | S.Schema.AnyNoContext) {
     this._schemas[type] = schema;
   }
 
-  async createObject({ types }: { types?: T[] } = {}): Promise<Live<any>> {
+  async createObject({ types }: { types?: T[] } = {}): Promise<ReactiveObject<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 (isReactiveObject(data)) {
       return data;
     }
 
     const schema = this.getSchema(type);
-    return schema ? live(schema, data) : live(data);
+    return schema ? create(schema, data) : create(data);
   }
 
   // TODO(burdon): Based on dependencies (e.g., organization before contact).
@@ -79,14 +77,14 @@ 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.type(schema)).run()).objects) ?? [];
+      return (schema && (await this._space.db.query(Filter.schema(schema)).run()).objects) ?? [];
     });
   }
 
   async addSchemas() {
-    const result: (EchoSchema | Schema.Schema.AnyNoContext)[] = [];
+    const result: (EchoSchema | S.Schema.AnyNoContext)[] = [];
     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 EchoSchema | S.Schema.AnyNoContext);
       this.setSchema(typename as T, echoSchema);
       result.push(echoSchema);
     }
@@ -94,14 +92,14 @@ 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<ReactiveEchoObject<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> {
+    schema: EchoSchema | S.Schema.AnyNoContext,
+  ): Promise<EchoSchema | S.Schema.AnyNoContext> {
     if (schema instanceof EchoSchema) {
       const existingSchema = this._space.db.schemaRegistry.getSchema(typename);
       if (existingSchema != null) {
@@ -119,7 +117,7 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
     }
   }
 
-  async mutateObject(object: AnyLiveObject<any>, params: MutationsProviderParams) {
+  async mutateObject(object: ReactiveEchoObject<any>, params: MutationsProviderParams) {
     invariant(this._mutations, 'Mutations not defined.');
     const type = getTypeAnnotation(getSchema(object)!)!.typename as T;
     invariant(type && this._mutations?.[type], 'Invalid object type.');
@@ -127,7 +125,7 @@ export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<
     await this._mutations![type](object, params);
   }
 
-  async mutateObjects(objects: AnyLiveObject<any>[], params: MutationsProviderParams) {
+  async mutateObjects(objects: ReactiveEchoObject<any>[], params: MutationsProviderParams) {
     for (const object of objects) {
       await this.mutateObject(object, params);
     }

package/src/types.ts

@@ -2,18 +2,16 @@
 // 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 ReactiveEchoObject } from '@dxos/echo-db';
+import { type EchoSchema, type S } from '@dxos/echo-schema';
+import { type ReactiveObject } 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 | Schema.Schema.AnyNoContext>;
+export type TestSchemaMap<T extends string = string> = Record<T, EchoSchema | S.Schema.AnyNoContext>;
 
-export type TestObjectProvider<T extends string = string> = (type: T) => Promise<Live<any>[]>;
+export type TestObjectProvider<T extends string = string> = (type: T) => Promise<ReactiveObject<any>[]>;
 
 export type TestGeneratorMap<T extends string = string> = Record<
   T,
@@ -28,4 +26,4 @@ export type MutationsProviderParams = {
   maxContentLength: number;
 };
 
-export type TestObjectMutators = (object: AnyLiveObject<any>, params: MutationsProviderParams) => Promise<void>;
+export type TestObjectMutators = (object: ReactiveEchoObject<any>, params: MutationsProviderParams) => Promise<void>;