@travetto/model 2.1.3 → 2.2.0

package/src/internal/service/indexed.ts

@@ -15,6 +15,9 @@ type ComputeConfig = {
   emptySortValue?: unknown;
 };
 
+type IndexFieldPart = { path: string[], value: (string | boolean | Date | number) };
+type IndexSortPart = { path: string[], dir: number, value: number | Date };
+
 /**
  * Utils for working with indexed model services
  */
@@ -26,34 +29,41 @@ export class ModelIndexedUtil {
    * @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 = {}) {
+  static computeIndexParts<T extends ModelType>(
+    cls: Class<T>, idx: IndexConfig<T> | string, item: DeepPartial<T>, opts: ComputeConfig = {}
+  ): { fields: IndexFieldPart[], sorted: IndexSortPart | undefined } {
     const cfg = typeof idx === 'string' ? ModelRegistry.getIndex(cls, idx) : idx;
     const sortField = cfg.type === 'sorted' ? cfg.fields[cfg.fields.length - 1] : undefined;
 
-    const fields: { path: string[], value: (string | boolean | Date | number) }[] = [];
+    const fields: IndexFieldPart[] = [];
     let sortDir: number = 0;
-    let sorted: { path: string[], dir: number, value: number | Date } | undefined;
+    let sorted: IndexSortPart | undefined;
 
     for (const field of cfg.fields) {
-      let f = field as Record<string, unknown>;
-      let o = item as Record<string, unknown>;
+      let f: Record<string, unknown> = field;
+      let o: Record<string, unknown> = item;
       const parts = [];
 
       while (o !== undefined && o !== null) {
         const k = Object.keys(f)[0];
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         o = (o[k] as Record<string, unknown>);
         parts.push(k);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const fk = k as (keyof typeof f);
         if (typeof f[fk] === 'boolean' || typeof f[fk] === 'number') {
           if (cfg.type === 'sorted') {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             sortDir = f[fk] === true ? 1 : f[fk] as number;
           }
           break; // At the bottom
         } else {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           f = f[fk] as Record<string, unknown>;
         }
       }
       if (field === sortField) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         sorted = { path: parts, dir: sortDir, value: o as unknown as number | Date };
       }
       if (o === undefined || o === null) {
@@ -61,9 +71,11 @@ export class ModelIndexedUtil {
         if (empty === undefined || empty === Error) {
           throw new IndexNotSupported(cls, cfg, `Missing field value for ${parts.join('.')}`);
         }
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         o = empty as Record<string, unknown>;
       } else {
         if (field !== sortField || (opts.includeSortInFields ?? true)) {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           fields.push({ path: parts, value: o as unknown as string | boolean | Date | number });
         }
       }
@@ -78,13 +90,14 @@ export class ModelIndexedUtil {
    * @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>, cfg?: ComputeConfig) {
-    const res = {} as Record<string, unknown>;
+  static projectIndex<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string, item?: DeepPartial<T>, cfg?: ComputeConfig): Record<string, unknown> {
+    const res: Record<string, unknown> = {};
     for (const { path, value } of this.computeIndexParts(cls, idx, item ?? {}, cfg).fields) {
       let sub = res;
       const all = path.slice(0);
       const last = all.pop()!;
       for (const k of all) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         sub = (sub[k] ??= {}) as typeof res;
       }
       sub[last] = value;
@@ -98,7 +111,12 @@ export class ModelIndexedUtil {
    * @param idx Index config
    * @param item item to process
    */
-  static computeIndexKey<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string, item: DeepPartial<T> = {}, opts?: ComputeConfig & { sep?: string }) {
+  static computeIndexKey<T extends ModelType>(
+    cls: Class<T>,
+    idx: IndexConfig<T> | string,
+    item: DeepPartial<T> = {},
+    opts?: ComputeConfig & { sep?: string }
+  ): { type: string, key: string, sort?: number | Date } {
     const { fields, sorted } = this.computeIndexParts(cls, idx, item, { ...(opts ?? {}), includeSortInFields: false });
     const key = fields.map(({ value }) => value).map(x => `${x}`).join(opts?.sep ?? 'ᚕ');
     const cfg = typeof idx === 'string' ? ModelRegistry.getIndex(cls, idx) : idx;
@@ -117,8 +135,10 @@ export class ModelIndexedUtil {
     cls: Class<T>, idx: string, body: OptionalId<T>
   ): Promise<T> {
     try {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const { id } = await service.getByIndex(cls, idx, body as DeepPartial<T>);
       body.id = id;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return await service.update(cls, body as T);
     } catch (err) {
       if (err instanceof NotFoundError) {

package/src/internal/service/storage.ts

@@ -13,15 +13,16 @@ export class ModelStorageUtil {
   /**
    * Register change listener on startup
    */
-  static async registerModelChangeListener(storage: ModelStorageSupport, target?: Class) {
+  static async registerModelChangeListener(storage: ModelStorageSupport, target?: Class): Promise<void> {
     if (!EnvUtil.isDynamic() || !(storage?.config?.autoCreate ?? !AppManifest.prod)) {
       return;
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     target = target ?? storage.constructor as Class<ModelStorageSupport>;
 
 
-    const checkType = (cls: Class, enforceBase = true) => {
+    const checkType = (cls: Class, enforceBase = true): boolean => {
       if (enforceBase && ModelRegistry.getBaseModel(cls) !== cls) {
         return false;
       }

package/src/provider/file.ts

@@ -2,6 +2,7 @@ import * as fs from 'fs/promises';
 import { createReadStream } from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { Readable } from 'stream';
 
 import { FsUtil, PathUtil, StreamUtil } from '@travetto/boot';
 import { Class, Util, TimeSpan } from '@travetto/base';
@@ -34,7 +35,7 @@ export class FileModelConfig {
   autoCreate?: boolean;
   cullRate?: number | TimeSpan;
 
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     if (!this.folder) {
       this.folder = PathUtil.resolveUnix(os.tmpdir(), Util.uuid().substring(0, 10));
     }
@@ -47,17 +48,17 @@ export class FileModelConfig {
 @Injectable()
 export class FileModelService implements ModelCrudSupport, ModelStreamSupport, ModelExpirySupport, ModelStorageSupport {
 
-  private static async * scanFolder(folder: string, suffix: string) {
+  private static async * scanFolder(folder: string, suffix: string): AsyncGenerator<[id: string, field: string]> {
     for (const sub of await fs.readdir(folder)) {
       for (const file of await fs.readdir(PathUtil.resolveUnix(folder, sub))) {
         if (file.endsWith(suffix)) {
-          yield [file.replace(suffix, ''), PathUtil.resolveUnix(folder, sub, file)] as [id: string, file: string];
+          yield [file.replace(suffix, ''), PathUtil.resolveUnix(folder, sub, file)];
         }
       }
     }
   }
 
-  get client() {
+  get client(): string {
     return this.config.folder;
   }
 
@@ -68,7 +69,7 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
    */
   constructor(public readonly config: FileModelConfig) { }
 
-  async #resolveName<T extends ModelType>(cls: Class<T> | string, suffix?: Suffix, id?: string) {
+  async #resolveName<T extends ModelType>(cls: Class<T> | string, suffix?: Suffix, id?: string): Promise<string> {
     const name = typeof cls === 'string' ? cls : ModelRegistry.getStore(cls);
     let resolved = PathUtil.resolveUnix(this.config.folder, this.config.namespace, name);
     if (id) {
@@ -85,7 +86,7 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
     return resolved;
   }
 
-  async #find<T extends ModelType>(cls: Class<T> | string, suffix: Suffix, id?: string) {
+  async #find<T extends ModelType>(cls: Class<T> | string, suffix: Suffix, id?: string): Promise<string> {
     const file = await this.#resolveName(cls, suffix, id);
     if (id && !(await FsUtil.exists(file))) {
       throw new NotFoundError(cls, id);
@@ -93,11 +94,11 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
     return file;
   }
 
-  postConstruct() {
+  postConstruct(): void {
     ModelExpiryUtil.registerCull(this);
   }
 
-  checkExpiry<T extends ModelType>(cls: Class<T>, item: T) {
+  checkExpiry<T extends ModelType>(cls: Class<T>, item: T): T {
     const { expiresAt } = ModelRegistry.get(cls);
     if (expiresAt && ModelExpiryUtil.getExpiryState(cls, item).expired) {
       throw new NotFoundError(cls, item.id);
@@ -105,11 +106,11 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
     return item;
   }
 
-  uuid() {
+  uuid(): string {
     return Util.uuid(32);
   }
 
-  async get<T extends ModelType>(cls: Class<T>, id: string) {
+  async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
     await this.#find(cls, '.json', id);
 
     const file = await this.#resolveName(cls, '.json', id);
@@ -122,7 +123,7 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
     throw new NotFoundError(cls, id);
   }
 
-  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     if (!item.id) {
       item.id = this.uuid();
     }
@@ -136,12 +137,12 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
     return await this.upsert(cls, item);
   }
 
-  async update<T extends ModelType>(cls: Class<T>, item: T) {
+  async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T> {
     await this.get(cls, item.id);
     return await this.upsert(cls, item);
   }
 
-  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
     const prepped = await ModelCrudUtil.preStore(cls, item, this);
 
@@ -151,35 +152,36 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
     return prepped;
   }
 
-  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string) {
+  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
     const id = item.id;
     item = await ModelCrudUtil.naivePartialUpdate(cls, item, view, () => this.get(cls, id));
     const file = await this.#resolveName(cls, '.json', item.id);
     await fs.writeFile(file, JSON.stringify(item), { encoding: 'utf8' });
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return item as T;
   }
 
-  async delete<T extends ModelType>(cls: Class<T>, id: string) {
+  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void> {
     const file = await this.#find(cls, '.json', id);
     await fs.unlink(file);
   }
 
-  async * list<T extends ModelType>(cls: Class<T>) {
+  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
     for await (const [id] of FileModelService.scanFolder(await this.#resolveName(cls, '.json'), '.json')) {
       try {
         yield await this.get(cls, id);
-      } catch (e) {
-        if (!(e instanceof NotFoundError)) {
-          throw e;
+      } catch (err) {
+        if (!(err instanceof NotFoundError)) {
+          throw err;
         }
       }
     }
   }
 
   // Stream
-  async upsertStream(location: string, input: NodeJS.ReadableStream, meta: StreamMeta) {
+  async upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void> {
     const file = await this.#resolveName(STREAMS, BIN, location);
     await Promise.all([
       StreamUtil.writeToFile(input, file),
@@ -187,19 +189,19 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
     ]);
   }
 
-  async getStream(location: string) {
+  async getStream(location: string): Promise<Readable> {
     const file = await this.#find(STREAMS, BIN, location);
     return createReadStream(file);
   }
 
-  async describeStream(location: string) {
+  async describeStream(location: string): Promise<StreamMeta> {
     const file = await this.#find(STREAMS, META, location);
     const content = await StreamUtil.streamToBuffer(createReadStream(file));
-    const text = JSON.parse(content.toString('utf8'));
-    return text as StreamMeta;
+    const text: StreamMeta = JSON.parse(content.toString('utf8'));
+    return text;
   }
 
-  async deleteStream(location: string) {
+  async deleteStream(location: string): Promise<void> {
     const file = await this.#resolveName(STREAMS, BIN, location);
     if (await FsUtil.exists(file)) {
       await Promise.all([
@@ -212,7 +214,7 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
   }
 
   // Expiry
-  async deleteExpired<T extends ModelType>(cls: Class<T>) {
+  async deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number> {
     const deleted = [];
     for await (const el of this.list(cls)) {
       if (ModelExpiryUtil.getExpiryState(cls, el).expired) {
@@ -222,17 +224,17 @@ export class FileModelService implements ModelCrudSupport, ModelStreamSupport, M
     return (await Promise.all(deleted)).length;
   }
 
-  // Storage mgmt
-  async createStorage() {
+  // Storage management
+  async createStorage(): Promise<void> {
     const dir = PathUtil.resolveUnix(this.config.folder, this.config.namespace);
     await fs.mkdir(dir, { recursive: true });
   }
 
-  async deleteStorage() {
+  async deleteStorage(): Promise<void> {
     await FsUtil.unlinkRecursive(PathUtil.resolveUnix(this.config.folder, this.config.namespace));
   }
 
-  async truncateModel(cls: Class<ModelType>) {
+  async truncateModel(cls: Class<ModelType>): Promise<void> {
     await FsUtil.unlinkRecursive(await this.#resolveName(cls === StreamModel ? STREAMS : cls));
   }
 }

package/src/provider/memory.ts

@@ -1,3 +1,5 @@
+import { Readable } from 'stream';
+
 import { StreamUtil } from '@travetto/boot';
 import { Util, Class, TimeSpan } from '@travetto/base';
 import { DeepPartial } from '@travetto/schema';
@@ -22,6 +24,8 @@ import { IndexConfig } from '../registry/types';
 
 const STREAM_META = `${STREAMS}_meta`;
 
+type StoreType = Map<string, Buffer>;
+
 @Config('model.memory')
 export class MemoryModelConfig {
   autoCreate?: boolean;
@@ -29,14 +33,14 @@ export class MemoryModelConfig {
   cullRate?: number | TimeSpan;
 }
 
-function indexName<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string, suffix?: string) {
+function indexName<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string, suffix?: string): string {
   return [cls.ᚕid, typeof idx === 'string' ? idx : idx.name, suffix].filter(x => !!x).join(':');
 }
 
-function getFirstId(data: Map<string, unknown> | Set<string>, value?: string | number) {
+function getFirstId(data: Map<string, unknown> | Set<string>, value?: string | number): string | undefined {
   let id: string | undefined;
   if (data instanceof Set) {
-    id = data.values().next().value as string;
+    id = data.values().next().value;
   } else {
     id = [...data.entries()].find(([k, v]) => value === undefined || v === value)?.[0];
   }
@@ -49,16 +53,16 @@ function getFirstId(data: Map<string, unknown> | Set<string>, value?: string | n
 @Injectable()
 export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport, ModelExpirySupport, ModelStorageSupport, ModelIndexedSupport {
 
-  #store = new Map<string, Map<string, Buffer>>();
+  #store = new Map<string, StoreType>();
   #indices = {
     sorted: new Map<string, Map<string, Map<string, number>>>(),
     unsorted: new Map<string, Map<string, Set<string>>>()
   };
-  get client() { return this.#store; }
+  get client(): Map<string, StoreType> { return this.#store; }
 
   constructor(public readonly config: MemoryModelConfig) { }
 
-  #getStore<T extends ModelType>(cls: Class<T> | string): Map<string, Buffer> {
+  #getStore<T extends ModelType>(cls: Class<T> | string): StoreType {
     const key = typeof cls === 'string' ? cls : ModelRegistry.getStore(cls);
     if (!this.#store.has(key)) {
       this.#store.set(key, new Map());
@@ -66,7 +70,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     return this.#store.get(key)!;
   }
 
-  #find<T extends ModelType>(cls: Class<T> | string, id?: string, errorState?: 'data' | 'notfound') {
+  #find<T extends ModelType>(cls: Class<T> | string, id?: string, errorState?: 'data' | 'notfound'): StoreType {
     const store = this.#getStore(cls);
 
     if (id && errorState && (errorState === 'notfound' ? !store.has(id) : store.has(id))) {
@@ -76,24 +80,26 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     return store;
   }
 
-  async #removeIndices<T extends ModelType>(cls: Class<T>, id: string) {
+  async #removeIndices<T extends ModelType>(cls: Class<T>, id: string): Promise<void> {
     try {
       const item = await this.get(cls, id);
       for (const idx of ModelRegistry.getIndices(cls, ['sorted', 'unsorted'])) {
         const idxName = indexName(cls, idx);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const { key } = ModelIndexedUtil.computeIndexKey(cls, idx, item as DeepPartial<T>);
         this.#indices[idx.type].get(idxName)?.get(key)?.delete(id);
       }
-    } catch (e) {
-      if (!(e instanceof NotFoundError)) {
-        throw e;
+    } catch (err) {
+      if (!(err instanceof NotFoundError)) {
+        throw err;
       }
     }
   }
 
-  async #writeIndices<T extends ModelType>(cls: Class<T>, item: T) {
+  async #writeIndices<T extends ModelType>(cls: Class<T>, item: T): Promise<void> {
     for (const idx of ModelRegistry.getIndices(cls, ['sorted', 'unsorted'])) {
       const idxName = indexName(cls, idx);
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const { key, sort } = ModelIndexedUtil.computeIndexKey(cls, idx, item as DeepPartial<T>);
       let index = this.#indices[idx.type].get(idxName)?.get(key);
 
@@ -115,7 +121,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
 
   async #write<T extends ModelType>(cls: Class<T>, item: T, action: 'remove'): Promise<void>;
   async #write<T extends ModelType>(cls: Class<T>, item: T, action: 'write'): Promise<T>;
-  async #write<T extends ModelType>(cls: Class<T>, item: T, action: 'write' | 'remove') {
+  async #write<T extends ModelType>(cls: Class<T>, item: T, action: 'write' | 'remove'): Promise<T | void> {
     const store = this.#getStore(cls);
     await this.#removeIndices(cls, item.id);
     if (action === 'write') {
@@ -145,7 +151,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     throw new NotFoundError(cls, key);
   }
 
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     await ModelStorageUtil.registerModelChangeListener(this);
     ModelExpiryUtil.registerCull(this);
 
@@ -153,7 +159,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
       for (const idx of ModelRegistry.get(el).indices ?? []) {
         switch (idx.type) {
           case 'unique': {
-            console.error('Unique inidices are not supported for', { cls: el.ᚕid, idx: idx.name });
+            console.error('Unique indices are not supported for', { cls: el.ᚕid, idx: idx.name });
             break;
           }
         }
@@ -162,11 +168,11 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
   }
 
   // CRUD Support
-  uuid() {
+  uuid(): string {
     return Util.uuid(32);
   }
 
-  async get<T extends ModelType>(cls: Class<T>, id: string) {
+  async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
     const store = this.#getStore(cls);
     if (store.has(id)) {
       const res = await ModelCrudUtil.load(cls, store.get(id)!);
@@ -183,7 +189,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     throw new NotFoundError(cls, id);
   }
 
-  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     if (!item.id) {
       item.id = this.uuid();
     }
@@ -191,12 +197,12 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     return await this.upsert(cls, item);
   }
 
-  async update<T extends ModelType>(cls: Class<T>, item: T) {
+  async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T> {
     await this.get(cls, item.id);
     return await this.upsert(cls, item);
   }
 
-  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     const store = this.#getStore(cls);
     if (item.id && store.has(item.id)) {
       await ModelCrudUtil.load(cls, store.get(item.id)!, 'exists');
@@ -205,64 +211,66 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     return await this.#write(cls, prepped, 'write');
   }
 
-  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string) {
+  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T> {
     const id = item.id;
     const clean = await ModelCrudUtil.naivePartialUpdate(cls, item, view, () => this.get(cls, id));
     return await this.#write(cls, clean, 'write');
   }
 
-  async delete<T extends ModelType>(cls: Class<T>, id: string) {
+  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void> {
     const store = this.#getStore(cls);
     if (!store.has(id)) {
       throw new NotFoundError(cls, id);
     }
     await ModelCrudUtil.load(cls, store.get(id)!);
-    await this.#write(cls, { id } as T, 'remove');
+    const where: ModelType = { id };
+    await this.#write(cls, where, 'remove');
   }
 
-  async * list<T extends ModelType>(cls: Class<T>) {
+  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
     for (const id of this.#getStore(cls).keys()) {
       try {
         yield await this.get(cls, id);
-      } catch (e) {
-        if (!(e instanceof NotFoundError)) {
-          throw e;
+      } catch (err) {
+        if (!(err instanceof NotFoundError)) {
+          throw err;
         }
       }
     }
   }
 
   // Stream Support
-  async upsertStream(location: string, input: NodeJS.ReadableStream, meta: StreamMeta) {
+  async upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void> {
     const streams = this.#getStore(STREAMS);
-    const metas = this.#getStore(STREAM_META);
-    metas.set(location, Buffer.from(JSON.stringify(meta)));
+    const metaContent = this.#getStore(STREAM_META);
+    metaContent.set(location, Buffer.from(JSON.stringify(meta)));
     streams.set(location, await StreamUtil.streamToBuffer(input));
   }
 
-  async getStream(location: string) {
+  async getStream(location: string): Promise<Readable> {
     const streams = this.#find(STREAMS, location, 'notfound');
     return StreamUtil.bufferToStream(streams.get(location)!);
   }
 
-  async describeStream(location: string) {
-    const metas = this.#find(STREAM_META, location, 'notfound');
-    return JSON.parse(metas.get(location)!.toString('utf8')) as StreamMeta;
+  async describeStream(location: string): Promise<StreamMeta> {
+    const metaContent = this.#find(STREAM_META, location, 'notfound');
+    const meta: StreamMeta = JSON.parse(metaContent.get(location)!.toString('utf8'));
+    return meta;
   }
 
-  async deleteStream(location: string) {
+  async deleteStream(location: string): Promise<void> {
     const streams = this.#getStore(STREAMS);
-    const metas = this.#getStore(STREAM_META);
+    const metaContent = this.#getStore(STREAM_META);
     if (streams.has(location)) {
       streams.delete(location);
-      metas.delete(location);
+      metaContent.delete(location);
     } else {
       throw new NotFoundError('Stream', location);
     }
   }
 
   // Expiry Support
-  async deleteExpired<T extends ModelType>(cls: Class<T>) {
+  async deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number> {
     const deleting = [];
     const store = this.#getStore(cls);
     for (const id of [...store.keys()]) {
@@ -274,17 +282,17 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
   }
 
   // Storage Support
-  async createStorage() {
+  async createStorage(): Promise<void> {
   }
 
-  async deleteStorage() {
+  async deleteStorage(): Promise<void> {
     this.#store.clear();
     this.#indices.sorted.clear();
     this.#indices.unsorted.clear();
   }
 
 
-  async createModel<T extends ModelType>(cls: Class<T>) {
+  async createModel<T extends ModelType>(cls: Class<T>): Promise<void> {
     for (const idx of ModelRegistry.get(cls).indices ?? []) {
       if (idx.type === 'sorted' || idx.type === 'unsorted') {
         this.#indices[idx.type].set(indexName(cls, idx), new Map());
@@ -292,7 +300,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     }
   }
 
-  async truncateModel<T extends ModelType>(cls: Class<T>) {
+  async truncateModel<T extends ModelType>(cls: Class<T>): Promise<void> {
     if (cls === StreamModel) {
       this.#getStore(STREAMS).clear();
       this.#getStore(STREAM_META).clear();
@@ -306,7 +314,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     return this.get(cls, await this.#getIdByIndex(cls, idx, body));
   }
 
-  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void> {
     await this.delete(cls, await this.#getIdByIndex(cls, idx, body));
   }
 
@@ -314,7 +322,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     return ModelIndexedUtil.naiveUpsert(this, cls, idx, body);
   }
 
-  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncGenerator<T> {
+  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T> {
     const config = ModelRegistry.getIndex(cls, idx, ['sorted', 'unsorted']);
     const { key } = ModelIndexedUtil.computeIndexKey(cls, idx, body, { emptySortValue: null });
     const index = this.#indices[config.type].get(indexName(cls, idx))?.get(key);

package/src/registry/decorator.ts

@@ -24,7 +24,7 @@ export function Model(conf: Partial<ModelOptions<ModelType>> | string = {}) {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function Index<T>(...indices: IndexConfig<any>[]) {
-  return function (target: Class<T>) {
+  return function (target: Class<T>): void {
     ModelRegistry.getOrCreatePending(target).indices!.push(...indices);
   };
 }
@@ -34,7 +34,8 @@ export function Index<T>(...indices: IndexConfig<any>[]) {
  * @augments `@trv:schema/Field`
  */
 export function ExpiresAt() {
-  return <K extends string, T extends Partial<Record<K, Date>>>(tgt: T, prop: K) => {
+  return <K extends string, T extends Partial<Record<K, Date>>>(tgt: T, prop: K): void => {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     ModelRegistry.register(tgt.constructor as Class<T>, { expiresAt: prop });
   };
 }