@dxos/echo-db 2.31.5-dev.573190a2 → 2.31.6-dev.3f2c3477

package/src/api/schema.test.ts

@@ -1,179 +1,96 @@
 //
-// Copyright 2022 DXOS.org
+// Copyright 2021 DXOS.org
 //
 
-import chalk from 'chalk';
-import columnify from 'columnify';
 import expect from 'expect';
-import faker from 'faker';
+import { it as test } from 'mocha';
 
-import { truncate, truncateKey } from '@dxos/debug';
+import { ModelFactory } from '@dxos/model-factory';
 import { ObjectModel } from '@dxos/object-model';
+import { afterTest } from '@dxos/testutils';
 
-import { createData, createSchemas, log, SchemaDefWithGenerator, setup } from '../testing';
+import { createInMemoryDatabase } from '../database';
 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()}`
-      }
-    ]
-  }
+import { Schema, TYPE_SCHEMA } from './schema';
+
+const SCHEMA = 'example:type/schema/organization';
+const createTestSchema = async (database: Database) => {
+  const schemaItem = await database.createItem({
+    model: ObjectModel,
+    type: TYPE_SCHEMA,
+    props: {
+      schema: SCHEMA
+    }
+  });
+  return new Schema(schemaItem.model);
 };
 
-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]]);
+describe('Schema', () => {
+  const setup = async () => {
+    const modelFactory = new ModelFactory().registerModel(ObjectModel);
+    const backend = await createInMemoryDatabase(modelFactory);
+    afterTest(() => backend.destroy());
+    return backend;
+  };
+
+  test('class creation', async () => {
+    const database = await setup();
+    const schema = await createTestSchema(database);
+    expect(schema).toBeTruthy();
+    expect(schema.schema).toBeTruthy();
+  });
 
-    const newField: SchemaField = {
-      key: 'location',
+  test('add and delete field', async () => {
+    const database = await setup();
+    const key = 'name';
+    const schema = await createTestSchema(database);
+    const newField = {
+      key: key,
       required: true
     };
     await schema.addField(newField);
+    expect(schema.fields.length).toBe(1);
+    expect(schema.getField(key)).toBeTruthy();
+    await schema.deleteField(key);
+    expect(schema.fields.length).toBe(0);
+  });
 
-    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
-      }
+  test('edit field', async () => {
+    const database = await setup();
+    const key = 'name';
+    const schema = await createTestSchema(database);
+    const newField = {
+      key: key,
+      required: true
     };
-    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();
-    });
+    await schema.addField(newField);
+    newField.required = false;
+    await schema.editField(key, newField);
+    expect(schema.getField(key)?.required).toBeFalsy();
+  });
 
-    // Log tables.
-    schemas.forEach(schema => {
-      const type = schema.model.get('schema');
-      const { entities: items } = database.select({ type }).exec();
-      log(renderItems(schema, items, database));
+  test('validate data item', async () => {
+    const database = await setup();
+    const key = 'name';
+    const schema = await createTestSchema(database);
+    const firstField = {
+      key: key,
+      required: true
+    };
+    await schema.addField(firstField);
+    const item = await database.createItem({
+      model: ObjectModel,
+      type: schema.schema
     });
-  }));
-});
-
-/**
- * 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;
-        }
+    expect(schema.validate(item.model)).toBeFalsy();
 
-        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;
-        }
+    firstField.required = false;
+    await schema.editField(key, firstField);
+    expect(schema.validate(item.model)).toBeTruthy();
 
-        default: {
-          row[key] = value;
-        }
-      }
-
-      return row;
-    }, { id: chalk.blue(logKey(item.id)) });
+    firstField.required = true;
+    await schema.editField(key, firstField);
+    await item.model.set(key, 'Test');
+    expect(schema.validate(item.model)).toBeTruthy();
   });
-
-  return columnify(values, { columns: ['id', ...columns] });
-};
+});

package/src/api/schema.ts

@@ -49,7 +49,7 @@ export class Schema {
 
   // TODO(kaplanski): What happens if an item has extra properties?
   validate (model: ObjectModel) {
-    this.fields.forEach(field => {
+    return this.fields.every(field => {
       const value = model.get(field.key);
       if (field.required) {
         if (!value) {
@@ -67,8 +67,8 @@ export class Schema {
         // TODO(kaplanski): Should this class have access to all items in the party to validate?
         // Or maybe possible values should be provided?
       }
+      return true;
     });
-    return true;
   }
 
   // TODO(kaplanski): Should the field be added to each item using the schema in the party? (Empty value?)

package/src/testing/testing.ts

@@ -3,17 +3,12 @@
 //
 
 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';
@@ -84,90 +79,3 @@ 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);
-    }
-  }
-};