@travetto/model 8.0.0-alpha.8 → 8.0.0

package/support/test/polymorphism.ts

@@ -1,17 +1,12 @@
 import assert from 'node:assert';
 import timers from 'node:timers/promises';
 
-import { Suite, Test } from '@travetto/test';
+import { Model, type ModelCrudSupport, NotFoundError, PersistValue, SubTypeNotSupportedError } from '@travetto/model';
 import { castTo } from '@travetto/runtime';
-import { Schema, DiscriminatorField, Text, TypeMismatchError, Discriminated } from '@travetto/schema';
-import {
-  type ModelIndexedSupport, Index, type ModelCrudSupport, Model,
-  NotFoundError, SubTypeNotSupportedError, PersistValue
-} from '@travetto/model';
+import { DiscriminatorField, Schema, Text, TypeMismatchError } from '@travetto/schema';
+import { Suite, Test } from '@travetto/test';
 
-import { ModelIndexedUtil } from '../../src/util/indexed.ts';
 import { ExistsError } from '../../src/error/exists.ts';
-
 import { BaseModelSuite } from './base.ts';
 
 @Schema()
@@ -43,45 +38,8 @@ export class Engineer extends Worker {
   major: string;
 }
 
-@Model()
-@Index({
-  name: 'worker-name',
-  type: 'sorted',
-  fields: [{ name: 1 }, { age: 1 }]
-})
-@Discriminated('type')
-export class IndexedWorker {
-  id: string;
-  type: string;
-  name: string;
-  age?: number;
-}
-@Model()
-export class IndexedDoctor extends IndexedWorker {
-  specialty: string;
-}
-
-@Model()
-export class IndexedFirefighter extends IndexedWorker {
-  firehouse: number;
-}
-
-@Model()
-export class IndexedEngineer extends IndexedWorker {
-  major: string;
-}
-
-async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
-  const out: T[] = [];
-  for await (const el of iterable) {
-    out.push(el);
-  }
-  return out;
-}
-
 @Suite()
 export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSupport> {
-
   @Test('Polymorphic create and find')
   async polymorphicCreateAndFind() {
     const service = await this.service;
@@ -95,9 +53,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     assert(doc instanceof Doctor);
     assert(doc.updatedDate !== undefined);
 
-    await assert.rejects(
-      () => service.get(Engineer, doc.id),
-      NotFoundError);
+    await assert.rejects(() => service.get(Engineer, doc.id), NotFoundError);
 
     assert(doc instanceof Doctor);
     assert(fire instanceof Firefighter);
@@ -108,7 +64,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     const fire2 = await service.get(Worker, fire.id);
     assert(fire2 instanceof Firefighter);
 
-    const all = await collect(service.list(Worker));
+    const all = await this.toArray(service.list(Worker));
     assert(all.length === 3);
 
     const doc3 = all.find(x => x instanceof Doctor);
@@ -126,18 +82,21 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     assert(eng3.major === 'oranges');
     assert(eng3.name === 'cob');
 
-    const engineers = await collect(service.list(Engineer));
+    const engineers = await this.toArray(service.list(Engineer));
     assert(engineers.length === 1);
 
-    await service.create(Engineer, Engineer.from({
-      major: 'foodService',
-      name: 'bob2'
-    }));
+    await service.create(
+      Engineer,
+      Engineer.from({
+        major: 'foodService',
+        name: 'bob2'
+      })
+    );
 
-    const all2 = await collect(service.list(Worker));
+    const all2 = await this.toArray(service.list(Worker));
     assert(all2.length === 4);
 
-    const engineers2 = await collect(service.list(Engineer));
+    const engineers2 = await this.toArray(service.list(Engineer));
     assert(engineers2.length === 2);
   }
 
@@ -152,16 +111,21 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
 
     await this.saveAll(Worker, [doc, fire, eng]);
 
-    assert(await service.get(Worker, doc.id) instanceof Doctor);
-    assert(await service.get(Worker, fire.id) instanceof Firefighter);
+    assert((await service.get(Worker, doc.id)) instanceof Doctor);
+    assert((await service.get(Worker, fire.id)) instanceof Firefighter);
 
     const update = new Date();
 
     await assert.rejects(
       () =>
-        service.upsert(Doctor, Doctor.from({
-          id: fire.id, name: 'gob', specialty: 'eyes'
-        })),
+        service.upsert(
+          Doctor,
+          Doctor.from({
+            id: fire.id,
+            name: 'gob',
+            specialty: 'eyes'
+          })
+        ),
       e => e instanceof SubTypeNotSupportedError || e instanceof ExistsError
     );
 
@@ -172,18 +136,28 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     await timers.setTimeout(15);
 
     try {
-      const result = await service.upsert(Doctor, Doctor.from({
-        id: doc.id, name: 'gob', specialty: 'eyes'
-      }));
+      const result = await service.upsert(
+        Doctor,
+        Doctor.from({
+          id: doc.id,
+          name: 'gob',
+          specialty: 'eyes'
+        })
+      );
 
       assert(result.updatedDate!.getTime() > update.getTime());
     } catch (err) {
       assert(err instanceof SubTypeNotSupportedError);
     }
 
-    const resAlt = await service.upsert(Worker, Doctor.from({
-      id: doc.id, name: 'gob', specialty: 'eyes'
-    }));
+    const resAlt = await service.upsert(
+      Worker,
+      Doctor.from({
+        id: doc.id,
+        name: 'gob',
+        specialty: 'eyes'
+      })
+    );
 
     assert(resAlt.updatedDate!.getTime() > update.getTime());
 
@@ -196,10 +170,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     // Delete by base class
     await service.delete(Worker, fire.id);
 
-    await assert.rejects(
-      () => service.delete(Worker, fire.id),
-      NotFoundError
-    );
+    await assert.rejects(() => service.delete(Worker, fire.id), NotFoundError);
 
     // Delete by any subtype when id is missing
     await assert.rejects(
@@ -207,75 +178,4 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
       e => e instanceof SubTypeNotSupportedError || e instanceof NotFoundError
     );
   }
-
-  @Test('Polymorphic index', { skip: BaseModelSuite.ifNot(ModelIndexedUtil.isSupported) })
-  async polymorphicIndexGet() {
-    const service: ModelIndexedSupport = castTo(await this.service);
-    const now = 30;
-    const [doc, fire, eng] = [
-      IndexedDoctor.from({ name: 'bob', specialty: 'feet', age: now }),
-      IndexedFirefighter.from({ name: 'rob', firehouse: 20, age: now }),
-      IndexedEngineer.from({ name: 'cob', major: 'oranges', age: now })
-    ];
-
-    await this.saveAll(IndexedWorker, [doc, fire, eng]);
-
-    const result = await service.getByIndex(IndexedWorker, 'worker-name', {
-      age: now,
-      name: 'rob'
-    });
-
-    assert(result instanceof IndexedFirefighter);
-
-    try {
-      const res2 = await service.getByIndex(IndexedFirefighter, 'worker-name', {
-        age: now,
-        name: 'rob'
-      });
-      assert(res2 instanceof IndexedFirefighter); // If service allows for get by subtype
-    } catch (err) {
-      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError); // If it does not
-    }
-  }
-
-  @Test('Polymorphic index', { skip: BaseModelSuite.ifNot(ModelIndexedUtil.isSupported) })
-  async polymorphicIndexDelete() {
-    const service: ModelIndexedSupport = castTo(await this.service);
-    const now = 30;
-    const [doc, fire, eng] = [
-      IndexedDoctor.from({ name: 'bob', specialty: 'feet', age: now }),
-      IndexedFirefighter.from({ name: 'rob', firehouse: 20, age: now }),
-      IndexedEngineer.from({ name: 'cob', major: 'oranges', age: now })
-    ];
-
-    await this.saveAll(IndexedWorker, [doc, fire, eng]);
-
-    assert(await this.getSize(IndexedWorker) === 3);
-
-    await service.deleteByIndex(IndexedWorker, 'worker-name', {
-      age: now,
-      name: 'bob'
-    });
-
-    assert(await this.getSize(IndexedWorker) === 2);
-    assert(await this.getSize(IndexedDoctor) === 0);
-
-    try {
-      await service.deleteByIndex(IndexedFirefighter, 'worker-name', {
-        age: now,
-        name: 'rob'
-      });
-    } catch (err) {
-      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError);
-    }
-
-    try {
-      await service.deleteByIndex(IndexedEngineer, 'worker-name', {
-        age: now,
-        name: 'bob'
-      });
-    } catch (err) {
-      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError);
-    }
-  }
-}
+}

package/support/test/suite.ts

@@ -1,16 +1,16 @@
-import { type Class } from '@travetto/runtime';
 import { DependencyRegistryIndex } from '@travetto/di';
 import { Registry } from '@travetto/registry';
-import { SuiteRegistryIndex, TestFixtures, type SuitePhaseHandler } from '@travetto/test';
+import type { Class } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
+import { type SuitePhaseHandler, SuiteRegistryIndex, TestFixtures } from '@travetto/test';
 
+import { ModelRegistryIndex } from '../../src/registry/registry-index.ts';
 import { ModelBlobUtil } from '../../src/util/blob.ts';
 import { ModelStorageUtil } from '../../src/util/storage.ts';
-import { ModelRegistryIndex } from '../../src/registry/registry-index.ts';
 
-type ConfigType = { autoCreate?: boolean, namespace?: string };
+type ConfigType = { autoCreate?: boolean; namespace?: string };
 
-class ModelSuiteHandler<T extends { configClass: Class<ConfigType>, serviceClass: Class }> implements SuitePhaseHandler<T> {
+class ModelSuiteHandler<T extends { configClass: Class<ConfigType>; serviceClass: Class }> implements SuitePhaseHandler<T> {
   qualifier?: symbol;
   target: Class<T>;
   constructor(target: Class<T>, qualifier?: symbol) {
@@ -35,9 +35,11 @@ class ModelSuiteHandler<T extends { configClass: Class<ConfigType>, serviceClass
     if (ModelStorageUtil.isSupported(service)) {
       await service.createStorage();
       if (service.upsertModel) {
-        await Promise.all(ModelRegistryIndex.getClasses()
-          .filter(cls => cls === SchemaRegistryIndex.getBaseClass(cls))
-          .map(modelCls => service.upsertModel!(modelCls)));
+        await Promise.all(
+          ModelRegistryIndex.getClasses()
+            .filter(cls => cls === SchemaRegistryIndex.getBaseClass(cls))
+            .map(modelCls => service.upsertModel!(modelCls))
+        );
       }
     }
   }
@@ -45,8 +47,7 @@ class ModelSuiteHandler<T extends { configClass: Class<ConfigType>, serviceClass
   async afterEach(instance: T) {
     const service = await DependencyRegistryIndex.getInstance<T>(instance.serviceClass, this.qualifier);
     if (ModelStorageUtil.isSupported(service)) {
-      const models = ModelRegistryIndex.getClasses()
-        .filter(model => model === SchemaRegistryIndex.getBaseClass(model));
+      const models = ModelRegistryIndex.getClasses().filter(model => model === SchemaRegistryIndex.getBaseClass(model));
 
       if (ModelBlobUtil.isSupported(service) && service.truncateBlob) {
         await service.truncateBlob();
@@ -83,7 +84,9 @@ class ModelSuiteHandler<T extends { configClass: Class<ConfigType>, serviceClass
  * @example opt-in
  * @kind decorator
  */
-export function ModelSuite<T extends { configClass: Class<{ autoCreate?: boolean, namespace?: string }>, serviceClass: Class }>(qualifier?: symbol) {
+export function ModelSuite<T extends { configClass: Class<{ autoCreate?: boolean; namespace?: string }>; serviceClass: Class }>(
+  qualifier?: symbol
+) {
   const fixtures = new TestFixtures(['@travetto/model']);
   return (target: Class<T>): void => {
     target.prototype.fixtures = fixtures;
@@ -91,4 +94,4 @@ export function ModelSuite<T extends { configClass: Class<{ autoCreate?: boolean
       phaseHandlers: [new ModelSuiteHandler(target, qualifier)]
     });
   };
-}
+}

package/src/types/indexed.ts

@@ -1,43 +0,0 @@
-import type { Class, DeepPartial } from '@travetto/runtime';
-
-import type { ModelType, OptionalId } from '../types/model.ts';
-import type { ModelBasicSupport } from './basic.ts';
-
-/**
- * Support for simple indexed activity
- *
- * @concrete
- */
-export interface ModelIndexedSupport extends ModelBasicSupport {
-  /**
-   * Get entity by index as defined by fields of idx and the body fields
-   * @param cls The type to search by
-   * @param idx The index name to search against
-   * @param body The payload of fields needed to search
-   */
-  getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<T>;
-
-  /**
-   * Delete entity by index as defined by fields of idx and the body fields
-   * @param cls The type to search by
-   * @param idx The index name to search against
-   * @param body The payload of fields needed to search
-   */
-  deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void>;
-
-  /**
-   * List entity by ranged index as defined by fields of idx and the body fields
-   * @param cls The type to search by
-   * @param idx The index name to search against
-   * @param body The payload of fields needed to search
-   */
-  listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T>;
-
-  /**
-   * Upsert by index, allowing the index to act as a primary key
-   * @param cls The type to create for
-   * @param idx The index name to use
-   * @param body The document to potentially store
-   */
-  upsertByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: OptionalId<T>): Promise<T>;
-}

package/src/util/indexed.ts

@@ -1,144 +0,0 @@
-import { castTo, type Class, type DeepPartial, hasFunction, TypedObject } from '@travetto/runtime';
-
-import { IndexNotSupported } from '../error/invalid-index.ts';
-import { NotFoundError } from '../error/not-found.ts';
-import type { IndexConfig } from '../registry/types.ts';
-import type { ModelCrudSupport } from '../types/crud.ts';
-import type { ModelIndexedSupport } from '../types/indexed.ts';
-import type { ModelType, OptionalId } from '../types/model.ts';
-import { ModelRegistryIndex } from '../registry/registry-index.ts';
-
-type ComputeConfig = {
-  includeSortInFields?: boolean;
-  emptyValue?: unknown;
-  emptySortValue?: unknown;
-};
-
-type IndexFieldPart = { path: string[], value: (string | boolean | Date | number) };
-type IndexSortPart = { path: string[], dir: number, value: number | Date };
-
-const DEFAULT_SEP = '\u8203';
-
-/**
- * Utils for working with indexed model services
- */
-export class ModelIndexedUtil {
-
-  /**
-   * Type guard for determining if service supports indexed operation
-   */
-  static isSupported = hasFunction<ModelIndexedSupport>('getByIndex');
-
-  /**
-   * Compute flattened field to value mappings
-   * @param cls Class to get info for
-   * @param idx Index config
-   * @param item Item to read values from
-   */
-  static computeIndexParts<T extends ModelType>(
-    cls: Class<T>, idx: IndexConfig<T> | string, item: DeepPartial<T>, opts: ComputeConfig = {}
-  ): { fields: IndexFieldPart[], sorted: IndexSortPart | undefined } {
-    const config = typeof idx === 'string' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
-    const sortField = config.type === 'sorted' ? config.fields.at(-1) : undefined;
-
-    const fields: IndexFieldPart[] = [];
-    let sortDirection: number = 0;
-    let sorted: IndexSortPart | undefined;
-
-    for (const field of config.fields) {
-      let fieldRef: Record<string, unknown> = field;
-      let itemRef: Record<string, unknown> = item;
-      const parts = [];
-
-      while (itemRef !== undefined && itemRef !== null) {
-        const key = TypedObject.keys(fieldRef)[0];
-        itemRef = castTo(itemRef[key]);
-        parts.push(key);
-        if (typeof fieldRef[key] === 'boolean' || typeof fieldRef[key] === 'number') {
-          if (config.type === 'sorted') {
-            sortDirection = fieldRef[key] === true ? 1 : fieldRef[key] === false ? 0 : fieldRef[key];
-          }
-          break; // At the bottom
-        } else {
-          fieldRef = castTo(fieldRef[key]);
-        }
-      }
-      if (field === sortField) {
-        sorted = { path: parts, dir: sortDirection, value: castTo(itemRef) };
-      }
-      if (itemRef === undefined || itemRef === null) {
-        const empty = field === sortField ? opts.emptySortValue : opts.emptyValue;
-        if (empty === undefined || empty === Error) {
-          throw new IndexNotSupported(cls, config, `Missing field value for ${parts.join('.')}`);
-        }
-      } else {
-        if (field !== sortField || (opts.includeSortInFields ?? true)) {
-          fields.push({ path: parts, value: castTo(itemRef) });
-        }
-      }
-    }
-
-    return { fields, sorted };
-  }
-
-  /**
-   * Project item via index
-   * @param cls Type to get index for
-   * @param idx Index config
-   */
-  static projectIndex<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string, item?: DeepPartial<T>, config?: ComputeConfig): Record<string, unknown> {
-    const response: Record<string, unknown> = {};
-    for (const { path, value } of this.computeIndexParts(cls, idx, item ?? {}, config).fields) {
-      let sub: Record<string, unknown> = response;
-      const all = path.slice(0);
-      const last = all.pop()!;
-      for (const part of all) {
-        sub = castTo(sub[part] ??= {});
-      }
-      sub[last] = value;
-    }
-    return response;
-  }
-
-  /**
-   * Compute index key as a single value
-   * @param cls Class to get index for
-   * @param idx Index config
-   * @param item item to process
-   */
-  static computeIndexKey<T extends ModelType>(
-    cls: Class<T>,
-    idx: IndexConfig<T> | string,
-    item: DeepPartial<T> = {},
-    config?: ComputeConfig & { separator?: string }
-  ): { type: string, key: string, sort?: number | Date } {
-    const { fields, sorted } = this.computeIndexParts(cls, idx, item, { ...(config ?? {}), includeSortInFields: false });
-    const key = fields.map(({ value }) => value).map(value => `${value}`).join(config?.separator ?? DEFAULT_SEP);
-    const indexConfig = typeof idx === 'string' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
-    return !sorted ? { type: indexConfig.type, key } : { type: indexConfig.type, key, sort: sorted.value };
-  }
-
-  /**
-   * Naive upsert by index
-   * @param service
-   * @param cls
-   * @param idx
-   * @param body
-   */
-  static async naiveUpsert<T extends ModelType>(
-    service: ModelIndexedSupport & ModelCrudSupport,
-    cls: Class<T>, idx: string, body: OptionalId<T>
-  ): Promise<T> {
-    try {
-      const { id } = await service.getByIndex(cls, idx, castTo(body));
-      body.id = id;
-      return await service.update(cls, castTo(body));
-    } catch (error) {
-      if (error instanceof NotFoundError) {
-        return await service.create(cls, body);
-      } else {
-        throw error;
-      }
-    }
-  }
-}