@travetto/model 2.1.5 → 2.2.2

package/src/registry/model.ts

@@ -30,31 +30,32 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
    * by requested store name.  This is the state at the
    * start of the application.
    */
-  intialModelNameMapping = new Map<string, Class[]>();
+  initialModelNameMapping = new Map<string, Class[]>();
 
   constructor() {
     // Listen to schema and dependency
     super(SchemaRegistry, DependencyRegistry);
   }
 
-  getInitialNameMapping() {
-    if (this.intialModelNameMapping.size === 0) {
+  getInitialNameMapping(): Map<string, Class[]> {
+    if (this.initialModelNameMapping.size === 0) {
       for (const cls of this.getClasses()) {
         const store = this.get(cls).store ?? cls.name;
-        if (!this.intialModelNameMapping.has(store)) {
-          this.intialModelNameMapping.set(store, []);
+        if (!this.initialModelNameMapping.has(store)) {
+          this.initialModelNameMapping.set(store, []);
         }
-        this.intialModelNameMapping.get(store)!.push(cls);
+        this.initialModelNameMapping.get(store)!.push(cls);
       }
     }
-    return this.intialModelNameMapping;
+    return this.initialModelNameMapping;
   }
 
   createPending(cls: Class): Partial<ModelOptions<ModelType>> {
     return { class: cls, indices: [], autoCreate: true, baseType: cls.ᚕabstract };
   }
 
-  onInstallFinalize(cls: Class) {
+  onInstallFinalize(cls: Class): ModelOptions<ModelType> {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const config = this.pending.get(cls.ᚕid)! as ModelOptions<ModelType>;
 
     const schema = SchemaRegistry.get(cls);
@@ -68,7 +69,7 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
     return config;
   }
 
-  override onUninstallFinalize(cls: Class) {
+  override onUninstallFinalize(cls: Class): void {
     this.stores.delete(cls);
 
     // Force system to recompute on uninstall
@@ -97,7 +98,7 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
   /**
    * Find all classes by their base types
    */
-  getAllClassesByBaseType() {
+  getAllClassesByBaseType(): Map<Class, Class[]> {
     if (!this.baseModelGrouped.size) {
       const out = new Map<Class, Class[]>();
       for (const el of this.entries.keys()) {
@@ -122,7 +123,7 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
   /**
    * Get all classes for a given base type
    */
-  getClassesByBaseType(base: Class) {
+  getClassesByBaseType(base: Class): Class[] {
     return this.getAllClassesByBaseType().get(base) ?? [];
   }
 
@@ -162,7 +163,7 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
    * Get Index
    */
   getIndex<T extends ModelType, K extends IndexType[]>(cls: Class<T>, name: string, supportedTypes?: K): IndexConfig<T> & { type: K[number] } {
-    const cfg = this.get(cls).indices?.find(x => x.name === name) as IndexConfig<T>;
+    const cfg = this.get(cls).indices?.find((x): x is IndexConfig<T> => x.name === name);
     if (!cfg) {
       throw new NotFoundError(`${cls.name} Index`, `${name}`);
     }
@@ -176,14 +177,14 @@ class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
    * Get Indices
    */
   getIndices<T extends ModelType, K extends IndexType[]>(cls: Class<T>, supportedTypes?: K): (IndexConfig<T> & { type: K[number] })[] {
-    return (this.get(cls).indices ?? []).filter(x => !supportedTypes || supportedTypes.includes(x.type)) as IndexConfig<T>[];
+    return (this.get(cls).indices ?? []).filter((x): x is IndexConfig<T> => !supportedTypes || supportedTypes.includes(x.type));
   }
 
   /**
    * Get expiry field
    * @param cls
    */
-  getExpiry(cls: Class) {
+  getExpiry(cls: Class): string {
     const expiry = this.get(cls).expiresAt;
     if (!expiry) {
       throw new AppError(`${cls.name} is not configured with expiry support, please use @ExpiresAt to declare expiration behavior`, 'general');

package/src/service/basic.ts

@@ -22,7 +22,7 @@ export interface ModelBasicSupport<C = unknown> {
   /**
    * Create new item
    * @param item The document to create
-   * @throws {ExistsError} When an item with the provdided id already exists
+   * @throws {ExistsError} When an item with the provided id already exists
    */
   create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T>;
 

package/src/service/bulk.ts

@@ -20,11 +20,11 @@ export type BulkOp<T extends ModelType> =
 /**
  * Bulk response provides a summary of all the operations
  */
-export interface BulkResponse {
+export interface BulkResponse<E = unknown> {
   /**
    * Errors returned
    */
-  errors: unknown[];
+  errors: E[];
   /**
    * Ids that were added
    */
@@ -45,14 +45,14 @@ export interface BulkResponse {
  * Bulk processing error
  */
 export class BulkProcessError extends AppError {
-  constructor(public errors: { idx: number, error: Error }[]) {
+  constructor(public errors: { idx: number, error: ValidationResultError }[]) {
     super('Bulk processing errors have occurred', 'data', { errors });
   }
 
   /**
    * Provide full results back, with validation errors
    */
-  override toJSON(extra: Record<string, unknown> = {}) {
+  override toJSON(extra: Record<string, unknown> = {}): unknown {
     return {
       ...extra,
       at: new Date(),
@@ -60,7 +60,7 @@ export class BulkProcessError extends AppError {
       category: this.category,
       type: this.type,
       errors: this.errors.map(x => {
-        const { message, type, errors, payload } = x.error as ValidationResultError;
+        const { message, type, errors, payload } = x.error;
         return { message, type, errors: errors ?? payload, idx: x.idx };
       })
     };

package/src/service/indexed.ts

@@ -27,7 +27,7 @@ export interface ModelIndexedSupport extends ModelBasicSupport {
   deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void>;
 
   /**
-   * List entity by rangeable index as defined by fields of idx and the body fields
+   * 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

package/src/service/stream.ts

@@ -1,3 +1,5 @@
+import { Readable } from 'stream';
+
 export interface StreamMeta {
   /**
    * File size
@@ -30,13 +32,13 @@ export interface ModelStreamSupport {
    * @param input The actual stream to write
    * @param meta The stream metadata
    */
-  upsertStream(location: string, input: NodeJS.ReadableStream, meta: StreamMeta): Promise<void>;
+  upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void>;
 
   /**
    * Get stream from asset store
    * @param location The location of the stream
    */
-  getStream(location: string): Promise<NodeJS.ReadableStream>;
+  getStream(location: string): Promise<Readable>;
 
   /**
    * Get metadata for stream

package/test-support/base.ts

@@ -10,14 +10,14 @@ type ServiceClass = { serviceClass: { new(): unknown } };
 @ModelSuite()
 export abstract class BaseModelSuite<T> {
 
-  static ifNot(pred: (svc: unknown) => boolean) {
+  static ifNot(pred: (svc: unknown) => boolean): (x: unknown) => Promise<boolean> {
     return async (x: unknown) => !pred(new (x as ServiceClass).serviceClass());
   }
 
   serviceClass: Class<T>;
   configClass: Class;
 
-  async getSize<U extends ModelType>(cls: Class<U>) {
+  async getSize<U extends ModelType>(cls: Class<U>): Promise<number> {
     const svc = (await this.service);
     if (isCrudSupported(svc)) {
       let i = 0;
@@ -30,7 +30,7 @@ export abstract class BaseModelSuite<T> {
     }
   }
 
-  async saveAll<M extends ModelType>(cls: Class<M>, items: M[]) {
+  async saveAll<M extends ModelType>(cls: Class<M>, items: M[]): Promise<number> {
     const svc = await this.service;
     if (isBulkSupported(svc)) {
       const res = await svc.processBulk(cls, items.map(x => ({ insert: x })));
@@ -47,7 +47,15 @@ export abstract class BaseModelSuite<T> {
     }
   }
 
-  get service() {
-    return DependencyRegistry.getInstance(this.serviceClass) as Promise<T>;
+  get service(): Promise<T> {
+    return DependencyRegistry.getInstance(this.serviceClass);
+  }
+
+  async toArray<U>(src: AsyncIterable<U> | AsyncGenerator<U>): Promise<U[]> {
+    const out: U[] = [];
+    for await (const el of src) {
+      out.push(el);
+    }
+    return out;
   }
 }

package/test-support/crud.ts

@@ -217,7 +217,7 @@ export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
       people.map(el => service.upsert(Person, el))
     );
 
-    const found = (await service.list(Person).toArray()).sort((a, b) => a.age - b.age);
+    const found = (await this.toArray(service.list(Person))).sort((a, b) => a.age - b.age);
 
     assert(found[0].age === people[0].age);
     assert(found[1].age === people[1].age);

package/test-support/indexed.ts

@@ -123,13 +123,13 @@ export abstract class ModelIndexedSuite extends BaseModelSuite<ModelIndexedSuppo
     await service.create(User3, User3.from({ name: 'bob', age: 30, color: 'red' }));
     await service.create(User3, User3.from({ name: 'bob', age: 50, color: 'green' }));
 
-    const arr = await service.listByIndex(User3, 'userAge', { name: 'bob' }).toArray();
+    const arr = await this.toArray(service.listByIndex(User3, 'userAge', { name: 'bob' }));
 
     assert(arr[0].color === 'red' && arr[0].name === 'bob');
     assert(arr[1].color === 'blue' && arr[1].name === 'bob');
     assert(arr[2].color === 'green' && arr[2].name === 'bob');
 
-    await assert.rejects(() => service.listByIndex(User3, 'userAge', {}).toArray(), IndexNotSupported);
+    await assert.rejects(() => this.toArray(service.listByIndex(User3, 'userAge', {})), IndexNotSupported);
   }
 
   @Test()
@@ -140,12 +140,12 @@ export abstract class ModelIndexedSuite extends BaseModelSuite<ModelIndexedSuppo
     await service.create(User4, User4.from({ child: { name: 'bob', age: 30 }, color: 'red' }));
     await service.create(User4, User4.from({ child: { name: 'bob', age: 50 }, color: 'green' }));
 
-    const arr = await service.listByIndex(User4, 'childAge', User4.from({ child: { name: 'bob' } })).toArray();
+    const arr = await this.toArray(service.listByIndex(User4, 'childAge', User4.from({ child: { name: 'bob' } })));
     assert(arr[0].color === 'red' && arr[0].child.name === 'bob' && arr[0].child.age === 30);
     assert(arr[1].color === 'blue' && arr[1].child.name === 'bob' && arr[1].child.age === 40);
     assert(arr[2].color === 'green' && arr[2].child.name === 'bob' && arr[2].child.age === 50);
 
-    await assert.rejects(() => service.listByIndex(User4, 'childAge', {}).toArray(), IndexNotSupported);
+    await assert.rejects(() => this.toArray(service.listByIndex(User4, 'childAge', {})), IndexNotSupported);
   }
 
   @Test()
@@ -156,13 +156,13 @@ export abstract class ModelIndexedSuite extends BaseModelSuite<ModelIndexedSuppo
     await service.create(User4, User4.from({ child: { name: 'bob', age: 30 }, createdDate: Util.timeFromNow('2d'), color: 'red' }));
     await service.create(User4, User4.from({ child: { name: 'bob', age: 50 }, createdDate: Util.timeFromNow('-1d'), color: 'green' }));
 
-    const arr = await service.listByIndex(User4, 'nameCreated', User4.from({ child: { name: 'bob' } })).toArray();
+    const arr = await this.toArray(service.listByIndex(User4, 'nameCreated', User4.from({ child: { name: 'bob' } })));
 
     assert(arr[0].color === 'green' && arr[0].child.name === 'bob' && arr[0].child.age === 50);
     assert(arr[1].color === 'red' && arr[1].child.name === 'bob' && arr[1].child.age === 30);
     assert(arr[2].color === 'blue' && arr[2].child.name === 'bob' && arr[2].child.age === 40);
 
-    await assert.rejects(() => service.listByIndex(User4, 'nameCreated', {}).toArray(), IndexNotSupported);
+    await assert.rejects(() => this.toArray(service.listByIndex(User4, 'nameCreated', {})), IndexNotSupported);
   }
 
   @Test()
@@ -173,7 +173,7 @@ export abstract class ModelIndexedSuite extends BaseModelSuite<ModelIndexedSuppo
     const user2 = await service.upsertByIndex(User4, 'childAge', { child: { name: 'bob', age: 40 }, color: 'green' });
     const user3 = await service.upsertByIndex(User4, 'childAge', { child: { name: 'bob', age: 40 }, color: 'red' });
 
-    const arr = await service.listByIndex(User4, 'childAge', { child: { name: 'bob' } }).toArray();
+    const arr = await this.toArray(service.listByIndex(User4, 'childAge', { child: { name: 'bob' } }));
     assert(arr.length === 1);
 
     assert(user1.id === user2.id);
@@ -182,12 +182,12 @@ export abstract class ModelIndexedSuite extends BaseModelSuite<ModelIndexedSuppo
     assert(user3.color === 'red');
 
     const user4 = await service.upsertByIndex(User4, 'childAge', { child: { name: 'bob', age: 30 }, color: 'red' });
-    const arr2 = await service.listByIndex(User4, 'childAge', { child: { name: 'bob' } }).toArray();
+    const arr2 = await this.toArray(service.listByIndex(User4, 'childAge', { child: { name: 'bob' } }));
     assert(arr2.length === 2);
 
     await service.deleteByIndex(User4, 'childAge', user1);
 
-    const arr3 = await service.listByIndex(User4, 'childAge', { child: { name: 'bob' } }).toArray();
+    const arr3 = await this.toArray(service.listByIndex(User4, 'childAge', { child: { name: 'bob' } }));
     assert(arr3.length === 1);
     assert(arr3[0].id === user4.id);
   }

package/test-support/polymorphism.ts

@@ -153,19 +153,18 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     await assert.rejects(
       () =>
         service.upsert(Doctor, Doctor.from({
-          id: fire.id, name: 'drob', specialty: 'eyes'
+          id: fire.id, name: 'gob', specialty: 'eyes'
         })),
       e => (e instanceof SubTypeNotSupportedError || e instanceof ExistsError) ? undefined : e
     );
 
     await assert.rejects(
-      // @ts-expect-error
-      () => service.update(Engineer, Doctor.from({ ...doc })),
+      () => service.update(Engineer, Doctor.from({ ...doc }) as unknown as Engineer),
       (e: Error) => (e instanceof NotFoundError || e instanceof SubTypeNotSupportedError || e instanceof TypeMismatchError) ? undefined : e);
 
     try {
       const res = await service.upsert(Doctor, Doctor.from({
-        id: doc.id, name: 'drob', specialty: 'eyes'
+        id: doc.id, name: 'gob', specialty: 'eyes'
       }));
 
       assert(res.updatedDate!.getTime() > update.getTime());
@@ -174,7 +173,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     }
 
     const resAlt = await service.upsert(Worker, Doctor.from({
-      id: doc.id, name: 'drob', specialty: 'eyes'
+      id: doc.id, name: 'gob', specialty: 'eyes'
     }));
 
     assert(resAlt.updatedDate!.getTime() > update.getTime());
@@ -225,8 +224,8 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
         name: 'rob'
       });
       assert(res2 instanceof IndexedFirefighter); // If service allows for get by subtype
-    } catch (e) {
-      assert(e instanceof SubTypeNotSupportedError || e instanceof NotFoundError); // If it does not
+    } catch (err) {
+      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError); // If it does not
     }
   }
 
@@ -257,8 +256,8 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
         age: now,
         name: 'rob'
       });
-    } catch (e) {
-      assert(e instanceof SubTypeNotSupportedError || e instanceof NotFoundError);
+    } catch (err) {
+      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError);
     }
 
     try {
@@ -266,8 +265,8 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
         age: now,
         name: 'bob'
       });
-    } catch (e) {
-      assert(e instanceof SubTypeNotSupportedError || e instanceof NotFoundError);
+    } catch (err) {
+      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError);
     }
   }
 }

package/test-support/stream.ts

@@ -2,6 +2,7 @@ import * as assert from 'assert';
 import * as fs from 'fs/promises';
 import { createReadStream } from 'fs';
 import * as crypto from 'crypto';
+import { Readable } from 'stream';
 
 import { PathUtil } from '@travetto/boot';
 import { BeforeAll, Suite, Test } from '@travetto/test';
@@ -13,7 +14,7 @@ import { ModelStreamSupport } from '../src/service/stream';
 @Suite()
 export abstract class ModelStreamSuite extends BaseModelSuite<ModelStreamSupport> {
 
-  async getHash(stream: NodeJS.ReadableStream) {
+  async getHash(stream: Readable) {
     const hash = crypto.createHash('sha1');
     hash.setEncoding('hex');
     await new Promise((res, rej) => {

package/test-support/suite.ts

@@ -11,7 +11,7 @@ import { ModelRegistry } from '../src/registry/model';
 const Loaded = Symbol();
 
 export function ModelSuite<T extends { configClass: Class<{ autoCreate?: boolean, namespace?: string }>, serviceClass: Class }>(qualifier?: symbol) {
-  return (target: Class<T>) => {
+  return (target: Class<T>): void => {
     SuiteRegistry.registerPendingListener(
       target,
       async function (this: T & { [Loaded]?: boolean }) {