@dxos/echo-db 2.31.1 → 2.31.2-dev.b400b683

package/src/api/schema.test.ts

@@ -0,0 +1,179 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import chalk from 'chalk';
+import columnify from 'columnify';
+import expect from 'expect';
+import faker from 'faker';
+
+import { truncate, truncateKey } from '@dxos/debug';
+import { ObjectModel } from '@dxos/object-model';
+
+import { createData, createSchemas, log, SchemaDefWithGenerator, setup } from '../testing';
+import { Database } from './database';
+import { Item } from './item';
+import { Schema, SchemaField, TYPE_SCHEMA } from './schema';
+
+enum TestType {
+  Org = 'example:type/org',
+  Person = 'example:type/person'
+}
+
+const schemaDefs: { [schema: string]: SchemaDefWithGenerator } = {
+  [TestType.Org]: {
+    schema: 'example:type/schema/organization',
+    fields: [
+      {
+        key: 'title',
+        required: true,
+        generator: () => faker.company.companyName()
+      },
+      {
+        key: 'website',
+        required: false,
+        generator: () => faker.internet.url()
+      },
+      {
+        key: 'collaborators',
+        required: false,
+        generator: () => faker.datatype.number().toString()
+      }
+    ]
+  },
+  [TestType.Person]: {
+    schema: 'example:type/schema/person',
+    fields: [
+      {
+        key: 'title',
+        required: true,
+        generator: () => `${faker.name.firstName()} ${faker.name.lastName()}`
+      }
+    ]
+  }
+};
+
+describe('Schemas', () => {
+  it('creation of Schema', async () => setup(async (database) => {
+    const [schema] = await createSchemas(database, [schemaDefs[TestType.Org]]);
+    expect(schema.schema).toBe(schemaDefs[TestType.Org].schema);
+    expect(schema.fields[0].key).toBe('title');
+  }));
+
+  it('add Schema field', async () => setup(async (database) => {
+    const [schema] = await createSchemas(database, [schemaDefs[TestType.Org]]);
+
+    const newField: SchemaField = {
+      key: 'location',
+      required: true
+    };
+    await schema.addField(newField);
+
+    expect(schema.getField('location')).toBeTruthy();
+  }));
+
+  it('add Schema linked field', async () => setup(async (database) => {
+    const [orgSchema, personSchema] = await createSchemas(database, Object.values(schemaDefs));
+
+    const fieldRef: SchemaField = {
+      key: 'organization',
+      required: false,
+      ref: {
+        schema: orgSchema.schema,
+        field: orgSchema.fields[0].key
+      }
+    };
+    await personSchema.addField(fieldRef);
+
+    await createData(database, Object.values(schemaDefs), {
+      [schemaDefs[TestType.Org].schema]: 8,
+      [schemaDefs[TestType.Person].schema]: 16
+    });
+
+    const items = await database.select().exec().entities;
+
+    [orgSchema, personSchema].forEach(schema => {
+      items.forEach(item => {
+        expect(schema.validate(item.model)).toBeTruthy();
+      });
+    });
+  }));
+
+  it('Use schema to validate the fields of an item', () => setup(async (database) => {
+    await createSchemas(database, Object.values(schemaDefs));
+    await createData(database, Object.values(schemaDefs), {
+      [schemaDefs[TestType.Org].schema]: 8,
+      [schemaDefs[TestType.Person].schema]: 16
+    });
+
+    const { entities: schemas } = database
+      .select({ type: TYPE_SCHEMA })
+      .exec();
+
+    const { entities: orgs } = database
+      .select({ type: TestType.Org })
+      .exec();
+
+    const { entities: people } = database
+      .select({ type: TestType.Person })
+      .exec();
+
+    [...orgs, ...people].forEach(item => {
+      const schemaItem = schemas.find(schema => schema.model.get('schema') === item.type);
+      const schema = new Schema(schemaItem!.model);
+      expect(schema.validate(item.model)).toBeTruthy();
+    });
+
+    // Log tables.
+    schemas.forEach(schema => {
+      const type = schema.model.get('schema');
+      const { entities: items } = database.select({ type }).exec();
+      log(renderItems(schema, items, database));
+    });
+  }));
+});
+
+/**
+ * Log the items for the given schema.
+ * @param schema
+ * @param items
+ * @param [party]
+ */
+const renderItems = (schema: Item<ObjectModel>, items: Item<ObjectModel>[], database?: Database) => {
+  const fields = Object.values(schema.model.get('fields')) as SchemaField[];
+  const columns = fields.map(({ key }) => key);
+
+  const logKey = (id: string) => truncateKey(id, 4);
+  const logString = (value: string) => truncate(value, 24, true);
+
+  const values = items.map(item => {
+    return fields.reduce<{ [key: string]: any }>((row, { key, type, ref }) => {
+      const value = item.model.get(key);
+      switch (type) {
+        case 'string': {
+          row[key] = chalk.green(logString(value));
+          break;
+        }
+
+        case 'ref': {
+          if (database) {
+            const { field } = ref!;
+            const item = database.getItem(value);
+            row[key] = chalk.red(logString(item?.model.get(field)));
+          } else {
+            row[key] = chalk.red(logKey(value));
+          }
+          break;
+        }
+
+        default: {
+          row[key] = value;
+        }
+      }
+
+      return row;
+    }, { id: chalk.blue(logKey(item.id)) });
+  });
+
+  return columnify(values, { columns: ['id', ...columns] });
+};

package/src/api/schema.ts

@@ -0,0 +1,100 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { ObjectModel } from '@dxos/object-model';
+
+export const TYPE_SCHEMA = 'dxos:type/schema';
+
+export type FieldType = 'string' | 'number' | 'boolean' | 'ref'
+
+// TODO(burdon): Protobuf definitions.
+
+export type SchemaRef = {
+  schema: string
+  field: string
+}
+
+export type SchemaField = {
+  key: string
+  type?: FieldType
+  required: boolean
+  ref?: SchemaRef
+}
+
+export type SchemaDef = {
+  schema: string
+  fields: SchemaField[]
+}
+
+/**
+ * Wrapper for ECHO Item that represents an `ObjectModel` schema.
+ */
+export class Schema {
+  constructor (
+    private readonly _schema: ObjectModel
+  ) {}
+
+  get schema (): string {
+    return this._schema.get('schema');
+  }
+
+  get fields (): SchemaField[] {
+    return Object.values(this._schema.get('fields') ?? {});
+  }
+
+  getField (key: string): SchemaField | undefined {
+    return this.fields.find(field => field.key === key);
+  }
+
+  // TODO(kaplanski): What happens if an item has extra properties?
+  validate (model: ObjectModel) {
+    this.fields.forEach(field => {
+      const value = model.get(field.key);
+      if (field.required) {
+        if (!value) {
+          return false;
+        }
+      }
+
+      if (field.type) {
+        if (typeof value !== field.type) {
+          return false;
+        }
+      }
+
+      if (field.ref) {
+        // TODO(kaplanski): Should this class have access to all items in the party to validate?
+        // Or maybe possible values should be provided?
+      }
+    });
+    return true;
+  }
+
+  // TODO(kaplanski): Should the field be added to each item using the schema in the party? (Empty value?)
+  // TODO(kaplanski): Should the type be infered from the first value added?
+  async addField (newField: SchemaField) {
+    const newFields = [
+      ...this.fields,
+      newField
+    ];
+    // TODO(kaplanski): Create a SET mutation to just modify the field (not all fields).
+    await this._schema.set('fields', newFields);
+  }
+
+  // TODO(kaplanski): Should editing a field modify all existing items using this schema?
+  async editField (currentKey: string, editedField: SchemaField) {
+    const newFields = this.fields.map(field => {
+      if (field.key === currentKey) {
+        return editedField;
+      }
+      return field;
+    });
+    await this._schema.set('fields', newFields);
+  }
+
+  async deleteField (key: string) {
+    const newFields = this.fields.filter(field => field.key !== key);
+    await this._schema.set('fields', newFields);
+  }
+}

package/src/testing/testing.ts

@@ -3,17 +3,22 @@
 //
 
 import debug from 'debug';
+import faker from 'faker';
 
 import { createKeyPair } from '@dxos/crypto';
+import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManagerOptions } from '@dxos/network-manager';
+import { ObjectModel } from '@dxos/object-model';
 import { IStorage } from '@dxos/random-access-multi-storage';
 import { jsonReplacer } from '@dxos/util';
 
+import { Database, Schema, SchemaDef, SchemaField, TYPE_SCHEMA } from '../api';
+import { createInMemoryDatabase } from '../database';
 import { ECHO } from '../echo';
 import { PartyInternal } from '../parties';
 import { createRamStorage } from '../util';
 
-const log = debug('dxos:echo-db:testing');
+export const log = debug('dxos:echo-db:testing');
 
 export const messageLogger = (tag: string) => (message: any) => {
   log(tag, JSON.stringify(message, jsonReplacer, 2));
@@ -79,3 +84,90 @@ export const inviteTestPeer = async (party: PartyInternal, peer: ECHO): Promise<
 
   return peer.joinParty(invitation, async () => Buffer.from('0000'));
 };
+
+export type SchemaFieldWithGenerator = SchemaField & { generator: () => string }
+export type SchemaDefWithGenerator = Omit<SchemaDef, 'fields'> & { fields: SchemaFieldWithGenerator[] };
+
+type Callback = (party: Database) => Promise<void>
+
+export const setup = async (callback: Callback) => {
+  const modelFactory = new ModelFactory().registerModel(ObjectModel);
+  const database = await createInMemoryDatabase(modelFactory);
+  try {
+    await callback(database);
+  } finally {
+    await database.destroy();
+  }
+};
+
+/**
+ * Create schema items.
+ */
+export const createSchemas = async (database: Database, schemas: SchemaDefWithGenerator[]) => {
+  log(`Creating schemas: [${schemas.map(({ schema }) => schema).join()}]`);
+
+  const schemaItems = await Promise.all(schemas.map(({ schema, fields }) => {
+    const schemaFields = fields.map(fieldWithGenerator => {
+      // eslint-disable-next-line unused-imports/no-unused-vars
+      const { generator, ...field } = fieldWithGenerator;
+      return field;
+    }).flat();
+
+    return database.createItem({
+      model: ObjectModel,
+      type: TYPE_SCHEMA,
+      props: {
+        schema,
+        fields: schemaFields
+      }
+    });
+  }));
+
+  return schemaItems.map(item => new Schema(item.model));
+};
+
+/**
+ * Create items for a given schema.
+ * NOTE: Assumes that referenced items have already been constructed.
+ */
+export const createItems = async (database: Database, { schema, fields }: SchemaDefWithGenerator, numItems: number) => {
+  log(`Creating items for: ${schema}`);
+
+  return await Promise.all(Array.from({ length: numItems }).map(async () => {
+    const values = fields.map(field => {
+      if (field.ref) {
+        // Look-up item.
+        const { entities: items } = database.select().filter({ type: field.ref.schema }).exec();
+        if (items.length) {
+          return {
+            [field.key]: faker.random.arrayElement(items).id
+          };
+        }
+      } else {
+        return {
+          [field.key]: field.generator()
+        };
+      }
+
+      return undefined;
+    }).filter(Boolean);
+
+    return await database.createItem({
+      type: schema,
+      props: Object.assign({}, ...values)
+    });
+  }));
+};
+
+/**
+ * Create data for all schemas.
+ */
+export const createData = async (database: Database, schemas: SchemaDefWithGenerator[], options: { [key: string]: number } = {}) => {
+  // Synchronous loop.
+  for (const schema of schemas) {
+    const count = options[schema.schema] ?? 0;
+    if (count) {
+      await createItems(database, schema, count);
+    }
+  }
+};