@dxos/assistant 0.7.4-df37807

package/src/testing/test-data.ts

@@ -0,0 +1,366 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Schema as S } from '@effect/schema';
+
+import { raise } from '@dxos/debug';
+import { JSON_SCHEMA_ECHO_REF_ID, ObjectId, toJsonSchema, type JsonSchemaType, type Ref } from '@dxos/echo-schema';
+import { invariant } from '@dxos/invariant';
+import { create, makeRef } from '@dxos/live-object';
+
+import {
+  type DataSource,
+  type Node,
+  type Relationship,
+  formatInferredRelationshipLabel,
+  formatNodeLabel,
+} from '../cypher';
+import { Contact, Org, Project, Task } from '../testing';
+import type { EchoDatabase } from '@dxos/echo-db';
+
+export const seedTestData = (db: EchoDatabase) => {
+  const contactRich = db.add(
+    create(Contact, {
+      name: 'Rich',
+    }),
+  );
+  const contactJosiah = db.add(
+    create(Contact, {
+      name: 'Josiah',
+    }),
+  );
+  const contactDima = db.add(
+    create(Contact, {
+      name: 'Dima',
+    }),
+  );
+  const contactFred = db.add(
+    create(Contact, {
+      name: 'Fred',
+    }),
+  );
+
+  const projectComposer = db.add(
+    create(Project, {
+      name: 'Composer',
+    }),
+  );
+  const projectEcho = db.add(
+    create(Project, {
+      name: 'ECHO',
+    }),
+  );
+  const projectDoodles = db.add(
+    create(Project, {
+      name: 'Doodles',
+    }),
+  );
+
+  const _taskComposer1 = db.add(
+    create(Task, {
+      name: 'Optimize startup performance',
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactJosiah),
+    }),
+  );
+  const _taskComposer2 = db.add(
+    create(Task, {
+      name: 'Create form builder',
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactRich),
+    }),
+  );
+  const _taskComposer3 = db.add(
+    create(Task, {
+      name: 'Add support for custom themes',
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactJosiah),
+    }),
+  );
+  const _taskComposer5 = db.add(
+    create(Task, {
+      name: 'Implement community plugin',
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactFred),
+    }),
+  );
+  const _taskComposer4 = db.add(
+    create(Task, {
+      name: 'Implement dark mode',
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactRich),
+    }),
+  );
+  const _taskEcho1 = db.add(
+    create(Task, {
+      name: 'Implement cypher query engine',
+      project: makeRef(projectEcho),
+      assignee: makeRef(contactDima),
+    }),
+  );
+  const _taskEcho2 = db.add(
+    create(Task, {
+      name: 'Add schema editor',
+      project: makeRef(projectEcho),
+      assignee: makeRef(contactRich),
+    }),
+  );
+  const _taskDoodles1 = db.add(
+    create(Task, {
+      name: 'Add support for custom themes',
+      project: makeRef(projectDoodles),
+      assignee: makeRef(contactFred),
+    }),
+  );
+  const _taskDoodles2 = db.add(
+    create(Task, {
+      name: 'Implement dark mode',
+      project: makeRef(projectDoodles),
+      assignee: makeRef(contactJosiah),
+    }),
+  );
+
+  const _orgDxos = db.add(
+    create(Org, {
+      name: 'DXOS',
+      employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
+      projects: [makeRef(projectEcho)],
+    }),
+  );
+  const _orgBraneframe = db.add(
+    create(Org, {
+      name: 'Braneframe',
+      employees: [makeRef(contactJosiah), makeRef(contactRich)],
+      projects: [makeRef(projectComposer)],
+    }),
+  );
+};
+
+// TODO(burdon): Use schema/testing.
+export const createTestData = (): MockDataSource => {
+  const dataSource = new MockDataSource();
+
+  const contactRich = dataSource.add(Contact, {
+    id: ObjectId.random(),
+    name: 'Rich',
+  });
+  const contactJosiah = dataSource.add(Contact, {
+    id: ObjectId.random(),
+    name: 'Josiah',
+  });
+  const contactDima = dataSource.add(Contact, {
+    id: ObjectId.random(),
+    name: 'Dima',
+  });
+  const contactFred = dataSource.add(Contact, {
+    id: ObjectId.random(),
+    name: 'Fred',
+  });
+
+  const projectComposer = dataSource.add(Project, {
+    id: ObjectId.random(),
+    name: 'Composer',
+  });
+  const projectEcho = dataSource.add(Project, {
+    id: ObjectId.random(),
+    name: 'ECHO',
+  });
+  const projectDoodles = dataSource.add(Project, {
+    id: ObjectId.random(),
+    name: 'Doodles',
+  });
+
+  const _taskComposer1 = dataSource.add(Task, {
+    id: ObjectId.random(),
+    name: 'Optimize startup performance',
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactJosiah),
+  });
+  const _taskComposer2 = dataSource.add(Task, {
+    id: ObjectId.random(),
+    name: 'Create form builder',
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactRich),
+  });
+  const _taskComposer3 = dataSource.add(Task, {
+    id: ObjectId.random(),
+    name: 'Add support for custom themes',
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactJosiah),
+  });
+  const _taskComposer5 = dataSource.add(Task, {
+    id: ObjectId.random(),
+    name: 'Implement community plugin',
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactFred),
+  });
+  const _taskComposer4 = dataSource.add(Task, {
+    id: ObjectId.random(),
+    name: 'Implement dark mode',
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactRich),
+  });
+  const _taskEcho1 = dataSource.add(Task, {
+    id: ObjectId.random(),
+    name: 'Implement cypher query engine',
+    project: makeRef(projectEcho),
+    assignee: makeRef(contactDima),
+  });
+  const _taskEcho2 = dataSource.add(Task, {
+    id: ObjectId.random(),
+    name: 'Add schema editor',
+    project: makeRef(projectEcho),
+    assignee: makeRef(contactRich),
+  });
+  const _taskDoodles1 = dataSource.add(Task, {
+    id: ObjectId.random(),
+    name: 'Add support for custom themes',
+    project: makeRef(projectDoodles),
+    assignee: makeRef(contactFred),
+  });
+  const _taskDoodles2 = dataSource.add(Task, {
+    id: ObjectId.random(),
+    name: 'Implement dark mode',
+    project: makeRef(projectDoodles),
+    assignee: makeRef(contactJosiah),
+  });
+
+  const _orgDxos = dataSource.add(Org, {
+    id: ObjectId.random(),
+    name: 'DXOS',
+    employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
+    projects: [makeRef(projectEcho)],
+  });
+  const _orgBraneframe = dataSource.add(Org, {
+    id: ObjectId.random(),
+    name: 'Braneframe',
+    employees: [makeRef(contactJosiah), makeRef(contactRich)],
+    projects: [makeRef(projectComposer)],
+  });
+  dataSource.computeGraph();
+
+  return dataSource;
+};
+
+export class MockDataSource implements DataSource {
+  objects: Record<
+    string,
+    {
+      schema: S.Schema.All;
+      typeDxn: string;
+      id: string;
+      data: unknown;
+    }
+  > = {};
+
+  schema: Record<
+    string,
+    {
+      json: JsonSchemaType;
+      instance: S.Schema.All;
+    }
+  > = {};
+
+  nodes: Node[] = [];
+  relationships: Relationship[] = [];
+
+  async getNodes({ label }: { label?: string }) {
+    return this.nodes.filter((node) => !label || node.label === label);
+  }
+
+  async getRelationships({ label }: { label?: string }) {
+    return this.relationships.filter((relationship) => !label || relationship.label === label);
+  }
+
+  add<S extends S.Schema.All>(schema: S, data: S.Schema.Type<S>) {
+    invariant(typeof data.id === 'string', 'Data must have an id');
+    const jsonSchema = toJsonSchema(schema);
+    if (!this.schema[jsonSchema.$id!]) {
+      this.schema[jsonSchema.$id!] = {
+        json: jsonSchema,
+        instance: schema,
+      };
+    }
+
+    const typenameDxn = jsonSchema.$id ?? raise(new Error('Schema must have $id'));
+
+    this.objects[data.id] = {
+      schema,
+      id: data.id,
+      typeDxn: typenameDxn,
+      data,
+    };
+
+    return data;
+  }
+
+  computeGraph() {
+    this.nodes = [];
+    this.relationships = [];
+
+    for (const object of Object.values(this.objects)) {
+      this.nodes.push({
+        kind: 'node',
+        id: object.id,
+        label: formatNodeLabel(object.typeDxn),
+        properties: object.data as any,
+      });
+    }
+
+    for (const object of Object.values(this.objects)) {
+      const schema = this.schema[object.typeDxn].json;
+      const typenameDxn = schema.$id ?? raise(new Error('Schema must have $id'));
+
+      for (const [name, propSchema] of Object.entries(schema.properties!)) {
+        if (propSchema.$id === JSON_SCHEMA_ECHO_REF_ID) {
+          const label = formatInferredRelationshipLabel(typenameDxn, name);
+
+          const source = this.nodes.find((node) => node.id === object.id);
+          if (!source) {
+            continue;
+          }
+
+          const { id: targetId } = (object.data as any)[name].target;
+
+          const target = this.nodes.find((node) => node.id === targetId);
+          if (!target) {
+            continue;
+          }
+
+          this.relationships.push({
+            kind: 'relationship',
+            id: `${object.id}-${name}-${target.id}`,
+            label,
+            properties: {},
+            source,
+            target,
+          });
+        } else if (propSchema.type === 'array' && propSchema.items?.$id === JSON_SCHEMA_ECHO_REF_ID) {
+          const label = formatInferredRelationshipLabel(typenameDxn, name);
+
+          const source = this.nodes.find((node) => node.id === object.id);
+          if (!source) {
+            continue;
+          }
+
+          for (const { id: targetId } of (object.data as any)[name].map((x: Ref<any>) => x.target)) {
+            const target = this.nodes.find((node) => node.id === targetId);
+            if (!target) {
+              continue;
+            }
+
+            this.relationships.push({
+              kind: 'relationship',
+              id: `${object.id}-${name}-${targetId}`,
+              label,
+              properties: {},
+              source,
+              target,
+            });
+          }
+        }
+      }
+    }
+  }
+}

package/src/testing/test-schema.ts

@@ -0,0 +1,80 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Schema as S } from '@effect/schema';
+
+import { EntityKind, ObjectAnnotationId, Ref } from '@dxos/echo-schema';
+
+// TODO(burdon): Reconcile with sdk/schema/testing.
+// TODO(burdon): Convert interface to type.
+
+// TODO(dmaretskyi): Extract.
+export const ObjectId = S.String.annotations({ description: 'The unique object identifier.' });
+
+export const Contact = S.Struct({
+  id: ObjectId,
+  name: S.String.annotations({ description: 'The name of the person.' }),
+  email: S.optional(S.String).annotations({ description: 'Email address.' }),
+})
+  .pipe(S.mutable)
+  .annotations({
+    [ObjectAnnotationId]: {
+      kind: EntityKind.Object,
+      typename: 'example.com/type/Contact',
+      version: '0.1.0',
+    },
+    description: 'Contact information.',
+  });
+export interface Contact extends S.Schema.Type<typeof Contact> {}
+
+export const Project = S.Struct({
+  id: ObjectId,
+  name: S.String.annotations({ description: 'The name of the project.' }),
+  description: S.optional(S.String).annotations({ description: 'The description of the project.' }),
+})
+  .pipe(S.mutable)
+  .annotations({
+    [ObjectAnnotationId]: {
+      kind: EntityKind.Object,
+      typename: 'example.com/type/Project',
+      version: '0.1.0',
+    },
+    description: 'Contact information.',
+  });
+export interface Project extends S.Schema.Type<typeof Project> {}
+
+export const Task = S.Struct({
+  id: ObjectId,
+  name: S.String.annotations({ description: 'The name of the task.' }),
+  description: S.optional(S.String).annotations({ description: 'The description of the task.' }),
+  project: Ref(Project),
+  assignee: Ref(Contact),
+})
+  .pipe(S.mutable)
+  .annotations({
+    [ObjectAnnotationId]: {
+      kind: EntityKind.Object,
+      typename: 'example.com/type/Task',
+      version: '0.1.0',
+    },
+    description: 'Contact information.',
+  });
+export interface Task extends S.Schema.Type<typeof Task> {}
+
+export const Org = S.Struct({
+  id: ObjectId,
+  name: S.String.annotations({ description: 'The name of the organization.' }),
+  projects: S.Array(Ref(Project)),
+  employees: S.Array(Ref(Contact)),
+})
+  .pipe(S.mutable)
+  .annotations({
+    [ObjectAnnotationId]: {
+      kind: EntityKind.Object,
+      typename: 'example.com/type/Org',
+      version: '0.1.0',
+    },
+    description: 'Contact information.',
+  });
+export interface Org extends S.Schema.Type<typeof Org> {}

package/src/util/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './trim';

package/src/util/trim.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+/**
+ * Trims multiline strings.
+ */
+// TODO(burdon): Move to util.
+export const trim = (strings: TemplateStringsArray, ...values: any[]) => {
+  const combined = strings.reduce((acc, str, i) => {
+    return acc + str + (values[i] || '');
+  }, '');
+
+  return combined.replace('/^\n/', '').replace(/\n$/, '');
+};