@travetto/model 2.1.5 → 2.2.0

package/README.md

@@ -12,7 +12,7 @@ This module provides a set of contracts/interfaces to data model persistence, mo
 
 ## Contracts
 
-The module is mainly composed of contracts.  The contracts define the expected interface for various model patterns. The primary contracts are [Basic](https://github.com/travetto/travetto/tree/main/module/model/src/service/basic.ts#L9), [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11), [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/service/indexed.ts#L12), [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/service/expiry.ts#L11), [Streaming](https://github.com/travetto/travetto/tree/main/module/model/src/service/stream.ts#L1) and [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/service/bulk.ts#L23).
+The module is mainly composed of contracts.  The contracts define the expected interface for various model patterns. The primary contracts are [Basic](https://github.com/travetto/travetto/tree/main/module/model/src/service/basic.ts#L9), [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11), [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/service/indexed.ts#L12), [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/service/expiry.ts#L11), [Streaming](https://github.com/travetto/travetto/tree/main/module/model/src/service/stream.ts#L3) and [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/service/bulk.ts#L23).
 
 ### [Basic](https://github.com/travetto/travetto/tree/main/module/model/src/service/basic.ts#L9)
 All [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") implementations, must honor the BasicCrud contract to be able to participate in the model ecosystem.  This contract represents the bare minimum for a model service.
@@ -35,7 +35,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>;
 
@@ -115,7 +115,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
@@ -148,7 +148,7 @@ export interface ModelExpirySupport extends ModelCrudSupport {
 }
 ```
 
-### [Streaming](https://github.com/travetto/travetto/tree/main/module/model/src/service/stream.ts#L1)
+### [Streaming](https://github.com/travetto/travetto/tree/main/module/model/src/service/stream.ts#L3)
 
 Some implementations also allow for the ability to read/write binary data as a stream.  Given that all implementations can store [Base64](https://en.wikipedia.org/wiki/Base64) encoded data, the key differentiator here, is native support for streaming data, as well as being able to store binary data of significant sizes.  This pattern is currently used by [Asset](https://github.com/travetto/travetto/tree/main/module/asset#readme "Modular library for storing and retrieving binary assets") for reading and writing asset data.
 
@@ -162,13 +162,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
@@ -235,8 +235,8 @@ All fields are optional, but the `id` and `type` are important as those field ty
 |[Redis Model Support](https://github.com/travetto/travetto/tree/main/module/model-redis#readme "Redis backing for the travetto model module.")|X|X|X|X| ||
 |[S3 Model Support](https://github.com/travetto/travetto/tree/main/module/model-s3#readme "S3 backing for the travetto model module.")|X|X| |X|X| |
 |[SQL Model Service](https://github.com/travetto/travetto/tree/main/module/model-sql#readme "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.")|X|X|X|X| |X|
-|[MemoryModelService](https://github.com/travetto/travetto/tree/main/module/model/src/provider/memory.ts#L50)|X|X|X|X|X|X|
-|[FileModelService](https://github.com/travetto/travetto/tree/main/module/model/src/provider/file.ts#L47)|X|X| |X|X|X|
+|[MemoryModelService](https://github.com/travetto/travetto/tree/main/module/model/src/provider/memory.ts#L54)|X|X|X|X|X|X|
+|[FileModelService](https://github.com/travetto/travetto/tree/main/module/model/src/provider/file.ts#L49)|X|X| |X|X|X|
 
 ## Custom Model Service
 In addition to the provided contracts, the module also provides common utilities and shared test suites.  The common utilities are useful for
@@ -244,6 +244,7 @@ repetitive functionality, that is unable to be shared due to not relying upon in
 
 **Code: Memory Service**
 ```typescript
+import { Readable } from 'stream';
 import { StreamUtil } from '@travetto/boot';
 import { Util, Class, TimeSpan } from '@travetto/base';
 import { DeepPartial } from '@travetto/schema';
@@ -265,19 +266,20 @@ import { ModelStorageUtil } from '../internal/service/storage';
 import { StreamModel, STREAMS } from '../internal/service/stream';
 import { IndexConfig } from '../registry/types';
 const STREAM_META = `${STREAMS}_meta`;
+type StoreType = Map<string, Buffer>;
 @Config('model.memory')
 export class MemoryModelConfig {
   autoCreate?: boolean;
   namespace?: string;
   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];
   }
@@ -291,34 +293,34 @@ export class MemoryModelService implements ModelCrudSupport, ModelStreamSupport,
     sorted: new Map<string, Map<string, Map<string, number>>>(),
     unsorted: new Map<string, Map<string, Set<string>>>()
   };
-  get client() { return this.#store; }
-  async postConstruct() ;
+  get client(): Map<string, StoreType> { return this.#store; }
+  async postConstruct(): Promise<void> ;
   // CRUD Support
-  uuid() ;
-  async get<T extends ModelType>(cls: Class<T>, id: string) ;
-  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) ;
-  async update<T extends ModelType>(cls: Class<T>, item: T) ;
-  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) ;
-  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string) ;
-  async delete<T extends ModelType>(cls: Class<T>, id: string) ;
-  async * list<T extends ModelType>(cls: Class<T>) ;
+  uuid(): string ;
+  async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> ;
+  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> ;
+  async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T> ;
+  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> ;
+  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T> ;
+  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void> ;
+  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> ;
   // Stream Support
-  async upsertStream(location: string, input: NodeJS.ReadableStream, meta: StreamMeta) ;
-  async getStream(location: string) ;
-  async describeStream(location: string) ;
-  async deleteStream(location: string) ;
+  async upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void> ;
+  async getStream(location: string): Promise<Readable> ;
+  async describeStream(location: string): Promise<StreamMeta> ;
+  async deleteStream(location: string): Promise<void> ;
   // Expiry Support
-  async deleteExpired<T extends ModelType>(cls: Class<T>) ;
+  async deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number> ;
   // Storage Support
-  async createStorage() ;
-  async deleteStorage() ;
-  async createModel<T extends ModelType>(cls: Class<T>) ;
-  async truncateModel<T extends ModelType>(cls: Class<T>) ;
+  async createStorage(): Promise<void> ;
+  async deleteStorage(): Promise<void> ;
+  async createModel<T extends ModelType>(cls: Class<T>): Promise<void> ;
+  async truncateModel<T extends ModelType>(cls: Class<T>): Promise<void> ;
   // Indexed
   async getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<T> ;
-  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> ;
   upsertByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: OptionalId<T>): Promise<T> ;
-  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> ;
 }
 ```
 
@@ -390,7 +392,7 @@ Options:
 
 ## CLI - model:install
 
-The module provides the ability to install all the various [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L12)s within the application given the current configuration being targetted.  This is useful for being able to prepare the datastore manually.
+The module provides the ability to install all the various [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L12)s within the application given the current configuration being targeted.  This is useful for being able to prepare the datastore manually.
 
 **Terminal: Running model install**
 ```bash

package/bin/candidate.ts

@@ -7,7 +7,7 @@ import { ModelCandidateUtil } from './lib/candidate';
 /**
  * Handles direct invocation
  */
-export async function main(op: keyof ModelStorageSupport) {
+export async function main(op: keyof ModelStorageSupport): Promise<void> {
   try {
     EnvInit.init();
     const { PhaseManager } = await import('@travetto/base');

package/bin/cli-model_export.ts

@@ -8,13 +8,17 @@ export class ModelExportPlugin extends BaseModelPlugin {
   name = 'model:export';
   op = 'exportModel' as const;
 
-  async action(provider: string, models: string[]) {
+  async action(provider: string, models: string[]): Promise<void> {
     try {
       await this.validate(provider, models);
       const resolved = await this.resolve(provider, models);
       await ModelExportUtil.run(resolved.provider, resolved.models);
-    } catch (e) {
-      console.error(e.message);
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(err.message);
+      } else {
+        console.error((err && err instanceof Error) ? err.message : err);
+      }
     }
   }
 }

package/bin/cli-model_install.ts

@@ -10,14 +10,14 @@ export class ModelInstallPlugin extends BaseModelPlugin {
   name = 'model:install';
   op = 'createModel' as const;
 
-  async action(provider: string, models: string[]) {
+  async action(provider: string, models: string[]): Promise<void> {
     try {
       await this.validate(provider, models);
       const resolved = await this.resolve(provider, models);
       await ModelInstallUtil.run(resolved.provider, resolved.models);
       console.log(color`${{ success: 'Successfully' }} installed ${{ param: models.length.toString() }} model(s)`);
-    } catch (e) {
-      console.error(e.message);
+    } catch (err) {
+      console.error((err && err instanceof Error) ? err.message : err);
     }
   }
 }

package/bin/lib/base-cli-plugin.ts

@@ -16,11 +16,11 @@ export abstract class BaseModelPlugin extends BasePlugin {
 
   resolve = ModelCandidateUtil.resolve.bind(ModelCandidateUtil);
 
-  envInit() {
+  envInit(): void {
     EnvInit.init();
   }
 
-  override async build() {
+  override async build(): Promise<void> {
     await super.build();
     const { ConsoleManager, PhaseManager } = await import('@travetto/base');
     ConsoleManager.exclude('debug');
@@ -28,17 +28,18 @@ export abstract class BaseModelPlugin extends BasePlugin {
     await PhaseManager.run('init');
   }
 
-  getArgs() {
+  getArgs(): string {
     return '[provider] [models...]';
   }
 
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
   getOptions() {
     return { env: this.option({ desc: 'Application environment' }) };
   }
 
-  async usage({ providers, models }: { providers: string[], models: string[] }, err = '') {
+  async usage({ providers, models }: { providers: string[], models: string[] }, err = ''): Promise<void> {
     await this.showHelp(err, color`   
-${{ title: 'Proivders' }}:
+${{ title: 'Providers' }}:
 ${providers.map(p => color`  * ${{ type: p }}`).join('\n')}
 
 ${{ title: 'Models' }}:
@@ -46,7 +47,7 @@ ${models.map(p => color`  * ${{ param: p }}`).join('\n')}
 `);
   }
 
-  async validate(provider: string, models: string[]) {
+  async validate(provider: string, models: string[]): Promise<void> {
     const candidates = await ModelCandidateUtil.getCandidates(this.op);
     if (!provider) {
       return await this.usage(candidates);

package/bin/lib/candidate.ts

@@ -7,6 +7,8 @@ import type { InjectableConfig } from '@travetto/di';
 import type { ModelStorageSupport } from '../../src/service/storage';
 import type { ModelType } from '../../src/types/model';
 
+type CandidateNames = { providers: string[], models: string[] };
+
 /**
  * Utilities for finding candidates for model operations
  */
@@ -15,7 +17,7 @@ export class ModelCandidateUtil {
   /**
    * Get all models
    */
-  static async #getModels(models?: string[]) {
+  static async #getModels(models?: string[]): Promise<Class<ModelType>[]> {
     const names = new Set(models ?? []);
     const all = names.has('*');
     const { ModelRegistry } = await import('@travetto/model');
@@ -27,7 +29,7 @@ export class ModelCandidateUtil {
   /**
    * Get model names
    */
-  static async getModelNames() {
+  static async getModelNames(): Promise<string[]> {
     const { ModelRegistry } = await import('@travetto/model');
     return (await this.#getModels()).map(x => ModelRegistry.getStore(x)).sort();
   }
@@ -38,6 +40,7 @@ export class ModelCandidateUtil {
   static async getProviders(op?: keyof ModelStorageSupport): Promise<InjectableConfig[]> {
     const { DependencyRegistry } = await import('@travetto/di');
     const { ModelStorageSupportTarget } = await import('@travetto/model/src/internal/service/common');
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const types = DependencyRegistry.getCandidateTypes<ModelStorageSupport>(ModelStorageSupportTarget as unknown as Class<ModelStorageSupport>);
     return types.filter(x => !op || x.class.prototype[op]);
   }
@@ -45,7 +48,7 @@ export class ModelCandidateUtil {
   /**
    * Get list of names of all viable providers
    */
-  static async getProviderNames(op?: keyof ModelStorageSupport) {
+  static async getProviderNames(op?: keyof ModelStorageSupport): Promise<string[]> {
     return (await this.getProviders(op))
       .map(x => x.class.name.replace(/ModelService/, ''))
       .sort();
@@ -54,7 +57,7 @@ export class ModelCandidateUtil {
   /**
    * Get a single provider
    */
-  static async getProvider(provider: string) {
+  static async getProvider(provider: string): Promise<ModelStorageSupport> {
     const { DependencyRegistry } = await import('@travetto/di');
     const config = (await this.getProviders()).find(x => x.class.name === `${provider}ModelService`)!;
     return DependencyRegistry.getInstance<ModelStorageSupport>(config.class, config.qualifier);
@@ -64,9 +67,9 @@ export class ModelCandidateUtil {
    * Get candidates asynchronously
    * @returns
    */
-  static async getCandidates(op: keyof ModelStorageSupport) {
+  static async getCandidates(op: keyof ModelStorageSupport): Promise<CandidateNames> {
     return CliUtil.waiting('Resolving', () =>
-      ExecUtil.workerMain<{ providers: string[], models: string[] }>(require.resolve('../candidate'), [op]).message
+      ExecUtil.workerMain<CandidateNames>(require.resolve('../candidate'), [op]).message
     );
   }
 

package/bin/lib/export.ts

@@ -3,7 +3,7 @@ import type { ModelStorageSupport } from '@travetto/model/src/service/storage';
 import type { ModelType } from '@travetto/model/src/types/model';
 
 export class ModelExportUtil {
-  static async run(provider: ModelStorageSupport, models: Class<ModelType>[]) {
+  static async run(provider: ModelStorageSupport, models: Class<ModelType>[]): Promise<void> {
     for (const model of models) {
       console.log(await provider.exportModel!(model));
     }

package/bin/lib/install.ts

@@ -3,7 +3,7 @@ import type { ModelStorageSupport } from '@travetto/model/src/service/storage';
 import type { ModelType } from '@travetto/model/src/types/model';
 
 export class ModelInstallUtil {
-  static async run(provider: ModelStorageSupport, models: Class<ModelType>[]) {
+  static async run(provider: ModelStorageSupport, models: Class<ModelType>[]): Promise<void> {
     if (!provider.createModel) {
       throw new Error(`${provider} does not support model installation`);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/model",
   "displayName": "Data Modeling Support",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "description": "Datastore abstraction for core operations.",
   "keywords": [
     "datastore",
@@ -28,13 +28,13 @@
     "directory": "module/model"
   },
   "dependencies": {
-    "@travetto/di": "^2.1.5",
-    "@travetto/config": "^2.1.5",
-    "@travetto/registry": "^2.1.5",
-    "@travetto/schema": "^2.1.5"
+    "@travetto/di": "^2.2.0",
+    "@travetto/config": "^2.2.0",
+    "@travetto/registry": "^2.2.0",
+    "@travetto/schema": "^2.2.0"
   },
   "optionalPeerDependencies": {
-    "@travetto/cli": "^2.1.3"
+    "@travetto/cli": "^2.2.0"
   },
   "publishConfig": {
     "access": "public"

package/src/internal/service/bulk.ts

@@ -4,6 +4,14 @@ import { BulkOp } from '../../service/bulk';
 import { ModelType } from '../../types/model';
 import { ModelCrudUtil } from './crud';
 
+export type BulkPreStore<T extends ModelType> = {
+  insertedIds: Map<number, string>;
+  upsertedIds: Map<number, string>;
+  updatedIds: Map<number, string>;
+  existingUpsertedIds: Map<number, string>;
+  operations: BulkOp<T>[];
+};
+
 export class ModelBulkUtil {
   /**
    * Prepares bulk ops for storage
@@ -11,7 +19,7 @@ export class ModelBulkUtil {
    * @param operations
    * @param idSource
    */
-  static async preStore<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[], idSource: { uuid(): string }) {
+  static async preStore<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[], idSource: { uuid(): string }): Promise<BulkPreStore<T>> {
     const insertedIds = new Map<number, string>();
     const upsertedIds = new Map<number, string>();
     const updatedIds = new Map<number, string>();

package/src/internal/service/common.ts

@@ -18,6 +18,7 @@ export class ModelIndexedSupportTarget { }
  * @param o
  */
 export function isBasicSupported(o: unknown): o is ModelBulkSupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['create'];
 }
 
@@ -26,6 +27,7 @@ export function isBasicSupported(o: unknown): o is ModelBulkSupport {
  * @param o
  */
 export function isCrudSupported(o: unknown): o is ModelCrudSupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['upsert'];
 }
 
@@ -34,6 +36,7 @@ export function isCrudSupported(o: unknown): o is ModelCrudSupport {
  * @param o
  */
 export function isExpirySupported(o: unknown): o is ModelExpirySupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['deleteExpired'];
 }
 
@@ -42,6 +45,7 @@ export function isExpirySupported(o: unknown): o is ModelExpirySupport {
  * @param o
  */
 export function isStorageSupported(o: unknown): o is ModelStorageSupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['createStorage'];
 }
 
@@ -50,6 +54,7 @@ export function isStorageSupported(o: unknown): o is ModelStorageSupport {
  * @param o
  */
 export function isStreamSupported(o: unknown): o is ModelStreamSupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['getStream'];
 }
 
@@ -58,6 +63,7 @@ export function isStreamSupported(o: unknown): o is ModelStreamSupport {
  * @param o
  */
 export function isBulkSupported(o: unknown): o is ModelBulkSupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['processBulk'];
 }
 
@@ -66,6 +72,7 @@ export function isBulkSupported(o: unknown): o is ModelBulkSupport {
  * @param o
  */
 export function isIndexedSupported(o: unknown): o is ModelIndexedSupport {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['getByIndex'];
 }
 

package/src/internal/service/crud.ts

@@ -19,7 +19,7 @@ export class ModelCrudUtil {
    * @param value Input value
    * @param length Number of characters to produce
    */
-  static hashValue(value: string, length = 32) {
+  static hashValue(value: string, length = 32): string {
     if (value.length < 32) {
       value = value.padEnd(32, ' ');
     }
@@ -38,6 +38,7 @@ export class ModelCrudUtil {
       input = JSON.parse(input.toString('utf8'));
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const result = ModelRegistry.getBaseModel(cls).from(input as object) as T;
 
     if (!(result instanceof cls || result.constructor.ᚕid === cls.ᚕid)) {
@@ -55,7 +56,7 @@ export class ModelCrudUtil {
   }
 
   /**
-   * Prepares item for storge
+   * Prepares item for storage
    *
    * @param cls Type to store for
    * @param item Item to store
@@ -66,11 +67,13 @@ export class ModelCrudUtil {
     }
 
     if (Util.isPlainObject(item)) {
-      item = cls.from(item as {});
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      item = cls.from(item as object);
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const config = ModelRegistry.get(item.constructor as Class<T>);
-    if (config.subType) { // Subtyping, assign type
+    if (config.subType) { // Sub-typing, assign type
       SchemaRegistry.ensureInstanceTypeField(cls, item);
     }
 
@@ -80,6 +83,7 @@ export class ModelCrudUtil {
       await item.prePersist();
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return item as T;
   }
 
@@ -92,11 +96,13 @@ export class ModelCrudUtil {
    */
   static async naivePartialUpdate<T extends ModelType>(cls: Class<T>, item: Partial<T>, view: undefined | string, getExisting: () => Promise<T>): Promise<T> {
     if (Util.isPlainObject(item)) {
-      item = cls.from(item as {});
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      item = cls.from(item as object);
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const config = ModelRegistry.get(item.constructor as Class<T>);
-    if (config.subType) { // Subtyping, assign type
+    if (config.subType) { // Sub-typing, assign type
       SchemaRegistry.ensureInstanceTypeField(cls, item);
     }
 
@@ -112,13 +118,14 @@ export class ModelCrudUtil {
       await item.prePersist();
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return item as T;
   }
 
   /**
    * Ensure subtype is not supported
    */
-  static ensureNotSubType(cls: Class) {
+  static ensureNotSubType(cls: Class): void {
     if (ModelRegistry.get(cls).subType) {
       throw new SubTypeNotSupportedError(cls);
     }

package/src/internal/service/expiry.ts

@@ -12,23 +12,26 @@ export class ModelExpiryUtil {
   /**
    * Get expiry info for a given item
    */
-  static getExpiryState<T extends ModelType>(cls: Class<T>, item: T) {
+  static getExpiryState<T extends ModelType>(cls: Class<T>, item: T): { expiresAt?: Date, expired?: boolean } {
     const expKey = ModelRegistry.getExpiry(cls);
-    const expiresAt = item[expKey as keyof T] ? item[expKey as keyof T] as unknown as Date : undefined;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const keyAsT = expKey as keyof T;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const expiresAt = item[keyAsT] ? item[keyAsT] as unknown as Date : undefined;
 
     return {
       expiresAt,
       expired: expiresAt ? expiresAt.getTime() < Date.now() : undefined
-    } as const;
+    };
   }
 
   /**
    * Delete all expired on a fixed interval, if supported and needed
    * @param svc
    */
-  static registerCull(svc: ModelExpirySupport & { readonly config?: { cullRate?: number | TimeSpan } }) {
-    const expirable = ModelRegistry.getClasses().filter(cls => !!ModelRegistry.get(cls).expiresAt);
-    if (svc.deleteExpired && expirable.length) {
+  static registerCull(svc: ModelExpirySupport & { readonly config?: { cullRate?: number | TimeSpan } }): void {
+    const cullable = ModelRegistry.getClasses().filter(cls => !!ModelRegistry.get(cls).expiresAt);
+    if (svc.deleteExpired && cullable.length) {
       let running = true;
       const cullInterval = Util.timeToMs(svc.config?.cullRate ?? '10m');
 
@@ -39,11 +42,11 @@ export class ModelExpiryUtil {
         },
         name: 'expiry-culling'
       });
-      (async () => {
+      (async (): Promise<void> => {
         await Util.wait('1s');  // Wait a second to start culling
         while (running) {
           await Util.wait(cullInterval);
-          await Promise.all(expirable.map(cls => svc.deleteExpired(cls)));
+          await Promise.all(cullable.map(cls => svc.deleteExpired(cls)));
         }
       })();
     }