@dxos/echo-generator 0.3.3-main.1817c8a → 0.3.3-main.22971a3

package/src/data.ts

@@ -0,0 +1,130 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+// 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 { faker } from '@faker-js/faker';
+
+import { Schema, type Space, Text } from '@dxos/client/echo';
+
+import { SpaceObjectGenerator, TestObjectGenerator } from './generator';
+import { type TestGeneratorMap, type TestSchemaMap } from './types';
+
+// TODO(burdon): Handle restricted values.
+export const Status = ['pending', 'active', 'done'];
+export const Priority = [1, 2, 3, 4, 5];
+
+export type TestSchemaType = 'document' | 'organization' | 'person' | 'project';
+
+export const testSchemas = (): TestSchemaMap<TestSchemaType> => {
+  const document = new Schema({
+    props: [
+      {
+        id: 'name',
+        type: Schema.PropType.STRING,
+      },
+      {
+        id: 'content',
+        type: Schema.PropType.STRING, // TODO(burdon): Rich text.
+      },
+    ],
+  });
+
+  const organization = new Schema({
+    props: [
+      // TODO(burdon): Add metadata for default label.
+      {
+        id: 'name',
+        type: Schema.PropType.STRING,
+      },
+      {
+        id: 'website',
+        type: Schema.PropType.STRING,
+      },
+      {
+        id: 'active',
+        type: Schema.PropType.BOOLEAN,
+      },
+    ],
+  });
+
+  const person = new Schema({
+    props: [
+      {
+        id: 'name',
+        type: Schema.PropType.STRING,
+      },
+      {
+        id: 'email',
+        type: Schema.PropType.STRING,
+      },
+      {
+        id: 'org',
+        type: Schema.PropType.REF,
+        ref: organization,
+      },
+    ],
+  });
+
+  const project = new Schema({
+    props: [
+      {
+        id: 'title',
+        type: Schema.PropType.STRING,
+      },
+      {
+        id: 'repo',
+        type: Schema.PropType.STRING,
+      },
+      {
+        id: 'status',
+        type: Schema.PropType.STRING,
+      },
+      {
+        id: 'priority',
+        type: Schema.PropType.NUMBER,
+      },
+    ],
+  });
+
+  return { document, organization, person, project };
+};
+
+export const testObjectGenerators: TestGeneratorMap<TestSchemaType> = {
+  document: () => ({
+    title: faker.lorem.sentence(3),
+    content: faker.lorem.sentences({ min: 1, max: faker.number.int({ min: 1, max: 3 }) }),
+  }),
+
+  organization: () => ({
+    name: faker.company.name(),
+    website: faker.datatype.boolean({ probability: 0.3 }) ? faker.internet.url() : undefined,
+    description: new Text(faker.lorem.sentences()),
+  }),
+
+  person: (provider) => {
+    const organizations = provider?.('organization');
+    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 })
+          ? faker.helpers.arrayElement(organizations)
+          : undefined,
+    };
+  },
+
+  project: () => ({
+    title: faker.commerce.productName(),
+    repo: faker.datatype.boolean({ probability: 0.3 }) ? faker.internet.url() : undefined,
+    status: faker.helpers.arrayElement(Status),
+    priority: faker.helpers.arrayElement(Priority),
+  }),
+};
+
+export const createTestObjectGenerator = () => new TestObjectGenerator(testSchemas(), testObjectGenerators);
+
+export const createSpaceObjectGenerator = (space: Space) =>
+  new SpaceObjectGenerator(space, testSchemas(), testObjectGenerators);

package/src/generator.test.ts

@@ -2,16 +2,43 @@
 // Copyright 2023 DXOS.org
 //
 
+import { faker } from '@faker-js/faker';
 import { expect } from 'chai';
 
+import { Client } from '@dxos/client';
 import { describe, test } from '@dxos/test';
 
-import { TestObjectGenerator } from './generator';
+import { createSpaceObjectGenerator, createTestObjectGenerator } from './data';
 
-describe('sanity', () => {
+faker.seed(3);
+
+describe('TestObjectGenerator', () => {
   test('basic', () => {
-    const generator = new TestObjectGenerator();
-    const object = generator.createObject();
+    const generator = createTestObjectGenerator();
+
+    // Create raw object.
+    const object = generator.createObject({ types: ['person'] });
     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 generator = createSpaceObjectGenerator(space);
+
+    // Add schemas.
+    generator.addSchemas();
+
+    // Create org object.
+    const organization = generator.createObject({ types: ['organization'] });
+    expect(organization.__schema).to.exist;
+
+    // Expect at least one person object with a linked org reference.
+    const objects = generator.createObjects({ types: ['person'], count: 10 });
+    expect(objects.some((object) => object.org === organization)).to.be.true;
+
+    await client.destroy();
+  });
 });

package/src/generator.ts

@@ -7,140 +7,59 @@
 
 import { faker } from '@faker-js/faker';
 
-import { Expando, type TypedObject, Schema as SchemaType } from '@dxos/client/echo';
+import { Expando, type Schema, type Space } from '@dxos/client/echo';
 
-// TODO(burdon): Util.
-export const range = <T>(fn: (i: number) => T | undefined, length: number): T[] =>
-  Array.from({ length })
-    .map((_, i) => fn(i))
-    .filter(Boolean) as T[];
-
-// TODO(burdon): Commit to using ECHO to generate all test data? Or convert from raw data?
-export type TestItem = { id: string; type: string } & Record<string, any>;
-
-type ObjectDataGenerator = {
-  createSchema?: () => SchemaType;
-  createData: () => any;
-};
-
-type ObjectFactory<T extends TypedObject> = {
-  schema?: SchemaType; // TODO(burdon): Support both typed and expando schema.
-  createObject: () => T;
-};
-
-type ObjectFactoryMap = { [type: string]: ObjectFactory<any> };
-
-const createFactory = ({ createSchema, createData }: ObjectDataGenerator) => {
-  const schema = createSchema?.();
-  return {
-    schema,
-    createObject: () => new Expando(createData(), { schema }),
-  };
-};
-
-// TODO(burdon): Handle restricted values.
-export const Status = ['pending', 'active', 'done'];
-export const Priority = [1, 2, 3, 4, 5];
-
-export const defaultGenerators: { [type: string]: ObjectDataGenerator } = {
-  document: {
-    createSchema: () =>
-      new SchemaType({
-        props: [
-          {
-            id: 'title',
-            type: SchemaType.PropType.STRING,
-          },
-          {
-            id: 'body',
-            type: SchemaType.PropType.STRING,
-          },
-        ],
-      }),
-    createData: () => ({
-      title: faker.lorem.sentence(3),
-      body: faker.lorem.sentences({ min: 1, max: faker.number.int({ min: 1, max: 3 }) }),
-    }),
-  },
-
-  // TODO(burdon): Configure images.
-  image: {
-    createSchema: () =>
-      new SchemaType({
-        props: [
-          {
-            id: 'title',
-            type: SchemaType.PropType.STRING,
-          },
-          {
-            id: 'body',
-            type: SchemaType.PropType.STRING,
-          },
-        ],
-      }),
-    createData: () => ({
-      title: faker.lorem.sentence(3),
-      body: faker.datatype.boolean() ? faker.lorem.sentences() : undefined,
-    }),
-  },
-
-  project: {
-    createSchema: () =>
-      new SchemaType({
-        props: [
-          {
-            id: 'title',
-            type: SchemaType.PropType.STRING,
-          },
-          {
-            id: 'repo',
-            type: SchemaType.PropType.STRING,
-          },
-          {
-            id: 'status',
-            type: SchemaType.PropType.STRING,
-          },
-          {
-            id: 'priority',
-            type: SchemaType.PropType.NUMBER,
-          },
-        ],
-      }),
-    createData: () => ({
-      title: faker.commerce.productName(),
-      repo: faker.datatype.boolean({ probability: 0.3 }) ? faker.internet.url() : undefined,
-      status: faker.helpers.arrayElement(Status),
-      priority: faker.helpers.arrayElement(Priority),
-    }),
-  },
-};
+import { type TestGeneratorMap, type TestObjectProvider, type TestSchemaMap } from './types';
+import { range } from './util';
 
 /**
  * Typed object generator.
  */
-export class TestObjectGenerator {
-  public readonly factories: ObjectFactoryMap;
+export class TestObjectGenerator<T extends string> {
+  // prettier-ignore
+  constructor(
+    public readonly schema: TestSchemaMap<T>,
+    private readonly _generators: TestGeneratorMap<T>,
+    private readonly _provider?: TestObjectProvider<T>
+  ) {}
+
+  get schemas(): Schema[] {
+    return Object.values(this.schema);
+  }
 
-  constructor({ types, factories }: { types?: string[]; factories?: ObjectFactoryMap } = {}) {
-    this.factories =
-      factories ??
-      (types ?? Object.keys(defaultGenerators)).reduce<ObjectFactoryMap>((acc, type) => {
-        acc[type] = createFactory(defaultGenerators[type]);
-        return acc;
-      }, {});
+  createObject({ types }: { types?: T[] } = {}): Expando {
+    const type = faker.helpers.arrayElement(types ?? (Object.keys(this.schema) as T[]));
+    const factory = this._generators[type];
+    const data = factory(this._provider);
+    return new Expando(data, { schema: this.schema[type] });
   }
 
-  get schema(): SchemaType[] {
-    return Object.values(this.factories).map((f) => f.schema!);
+  // TODO(burdon): Create batch.
+  createObjects({ types, count }: { types?: T[]; count: number }): Expando[] {
+    return range(() => this.createObject({ types }), count);
+  }
+}
+
+/**
+ * Typed object generator for a space.
+ */
+export class SpaceObjectGenerator<T extends string> extends TestObjectGenerator<T> {
+  constructor(private readonly _space: Space, schema: TestSchemaMap<T>, generators: TestGeneratorMap<T>) {
+    super(schema, generators, (type: T) => {
+      // TODO(burdon): Query by schema.
+      const { objects } = this._space.db.query((object) => {
+        return object.__schema === schema[type];
+      });
+
+      return objects;
+    });
   }
 
-  createObject({ types }: { types?: string[] } = {}) {
-    const type = faker.helpers.arrayElement(types ?? Object.keys(this.factories));
-    const factory = this.factories[type];
-    return factory?.createObject();
+  addSchemas() {
+    this.schemas.forEach((schema) => this._space.db.add(schema));
   }
 
-  createObjects({ types, length }: { types?: string[]; length: number }) {
-    return range(() => this.createObject({ types }), length);
+  override createObject({ types }: { types?: T[] } = {}): Expando {
+    return this._space.db.add(super.createObject({ types }));
   }
 }

package/src/index.ts

@@ -2,4 +2,6 @@
 // Copyright 2023 DXOS.org
 //
 
+export * from './data';
 export * from './generator';
+export * from './util';

package/src/types.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Schema, type Expando } from '@dxos/client/echo';
+
+export type TestObject = { id: string } & Record<string, any>;
+
+export type TestSchemaMap<T extends string> = Record<T, Schema>;
+
+export type TestObjectProvider<T extends string> = (type: T) => Expando[];
+
+export type TestGeneratorMap<T extends string> = Record<T, (provider: TestObjectProvider<T> | undefined) => any>;

package/src/util.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+// TODO(burdon): Util.
+export const range = <T>(fn: (i: number) => T | undefined, length: number): T[] =>
+  Array.from({ length })
+    .map((_, i) => fn(i))
+    .filter(Boolean) as T[];