@travetto/model 8.0.0-alpha.22 → 8.0.0-alpha.24

package/src/types/bulk.ts

@@ -7,11 +7,7 @@ import type { ModelType, OptionalId } from './model.ts';
 /**
  * Bulk operation. Each operation has a single action and payload
  */
-export type BulkOperation<T extends ModelType> =
-  { delete?: T } &
-  { insert?: OptionalId<T> } &
-  { update?: T } &
-  { upsert?: OptionalId<T> };
+export type BulkOperation<T extends ModelType> = { delete?: T } & { insert?: OptionalId<T> } & { update?: T } & { upsert?: OptionalId<T> };
 
 /**
  * Bulk response provides a summary of all the operations
@@ -37,13 +33,13 @@ export interface BulkResponse<E = unknown> {
   };
 }
 
-type BulkErrorItem = { message: string, type: string, errors?: ValidationError[], idx: number };
+type BulkErrorItem = { message: string; type: string; errors?: ValidationError[]; idx: number };
 
 /**
  * Bulk processing error
  */
 export class BulkProcessError extends RuntimeError<{ errors: BulkErrorItem[] }> {
-  constructor(errors: { idx: number, error: ValidationResultError }[]) {
+  constructor(errors: { idx: number; error: ValidationResultError }[]) {
     super('Bulk processing errors have occurred', {
       category: 'data',
       details: {
@@ -63,4 +59,4 @@ export class BulkProcessError extends RuntimeError<{ errors: BulkErrorItem[] }>
  */
 export interface ModelBulkSupport extends ModelCrudSupport {
   processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOperation<T>[]): Promise<BulkResponse>;
-}
+}

package/src/types/crud.ts

@@ -1,15 +1,13 @@
 import type { Class } from '@travetto/runtime';
 
-import type { ModelListOptions, ModelType, OptionalId } from './model.ts';
-
 import type { ModelBasicSupport } from './basic.ts';
+import type { ModelListOptions, ModelType, OptionalId } from './model.ts';
 
 /**
  * Interface for simple CRUD
  * @concrete
  */
 export interface ModelCrudSupport extends ModelBasicSupport {
-
   /**
    * Update an item
    * @param item The document to update.
@@ -46,4 +44,4 @@ export interface ModelCrudSupport extends ModelBasicSupport {
    * @param options Options for listing
    */
   list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): AsyncIterable<T[]>;
-}
+}

package/src/types/expiry.ts

@@ -1,7 +1,7 @@
 import type { Class } from '@travetto/runtime';
 
-import type { ModelType } from './model.ts';
 import type { ModelCrudSupport } from './crud.ts';
+import type { ModelType } from './model.ts';
 
 /**
  * Support for managing expiration of data
@@ -14,4 +14,4 @@ export interface ModelExpirySupport extends ModelCrudSupport {
    * @returns Returns the number of documents expired
    */
   deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number>;
-}
+}

package/src/types/model.ts

@@ -1,7 +1,7 @@
 /**
  * Model Id Source
  */
-export type ModelIdSource = { create: () => string, valid: (id: string) => boolean };
+export type ModelIdSource = { create: () => string; valid: (id: string) => boolean };
 
 /**
  * Simple model interface
@@ -25,4 +25,4 @@ export interface ModelListOptions {
   abort?: AbortSignal;
   limit?: number;
   batchSizeHint?: number;
-}
+}

package/src/types/storage.ts

@@ -12,7 +12,6 @@ import type { ModelType } from './model.ts';
  * @concrete
  */
 export interface ModelStorageSupport {
-
   /**
    * Should storage modification be allowed
    */
@@ -48,4 +47,4 @@ export interface ModelStorageSupport {
    * Truncate blob storage data
    */
   truncateBlob?(): Promise<void>;
-}
+}

package/src/util/blob.ts

@@ -1,11 +1,11 @@
 import { hasFunction } from '@travetto/runtime';
+
 import type { ModelBlobSupport } from '../types/blob.ts';
 
 /**
  * Utilities for processing blobs
  */
 export class ModelBlobUtil {
-
   /**
    * Type guard for determining if service supports blob operations
    */
@@ -15,4 +15,4 @@ export class ModelBlobUtil {
    * Type guard for determining if service supports blob write urls
    */
   static isWriteUrlSupported = hasFunction<ModelBlobSupport>('getBlobWriteUrl');
-}
+}

package/src/util/bulk.ts

@@ -13,7 +13,6 @@ export type BulkPreStore<T extends ModelType> = {
 };
 
 export class ModelBulkUtil {
-
   /**
    * Type guard for determining if service supports bulk operation
    */
@@ -25,7 +24,11 @@ export class ModelBulkUtil {
    * @param operations
    * @param provider
    */
-  static async preStore<T extends ModelType>(cls: Class<T>, operations: BulkOperation<T>[], provider: ModelCrudProvider): Promise<BulkPreStore<T>> {
+  static async preStore<T extends ModelType>(
+    cls: Class<T>,
+    operations: BulkOperation<T>[],
+    provider: ModelCrudProvider
+  ): Promise<BulkPreStore<T>> {
     const insertedIds = new Map<number, string>();
     const upsertedIds = new Map<number, string>();
     const updatedIds = new Map<number, string>();
@@ -53,4 +56,4 @@ export class ModelBulkUtil {
     }
     return { insertedIds, upsertedIds, updatedIds, existingUpsertedIds, operations };
   }
-}
+}

package/src/util/crud.ts

@@ -1,13 +1,13 @@
-import { castTo, castKey, type Class, Util, RuntimeError, hasFunction, BinaryUtil, type BinaryArray, JSONUtil } from '@travetto/runtime';
+import { type BinaryArray, BinaryUtil, type Class, castKey, castTo, hasFunction, JSONUtil, RuntimeError, Util } from '@travetto/runtime';
 import { DataUtil, SchemaRegistryIndex, SchemaValidator, type ValidationError, ValidationResultError } from '@travetto/schema';
 
-import { ModelRegistryIndex } from '../registry/registry-index.ts';
-import type { ModelIdSource, ModelType, OptionalId } from '../types/model.ts';
-import { NotFoundError } from '../error/not-found.ts';
 import { ExistsError } from '../error/exists.ts';
 import { SubTypeNotSupportedError } from '../error/invalid-sub-type.ts';
+import { NotFoundError } from '../error/not-found.ts';
+import { ModelRegistryIndex } from '../registry/registry-index.ts';
 import type { DataHandler, PrePersistScope } from '../registry/types.ts';
 import type { ModelCrudSupport } from '../types/crud.ts';
+import type { ModelIdSource, ModelType, OptionalId } from '../types/model.ts';
 
 type ModelLoadInput = string | BinaryArray | object;
 
@@ -19,7 +19,6 @@ export type ModelCrudProvider = {
  * Crud utilities
  */
 export class ModelCrudUtil {
-
   /**
    * Type guard for determining if service supports crud operations
    */
@@ -38,15 +37,17 @@ export class ModelCrudUtil {
     if (!actions) {
       return [];
     }
-    return (await Promise.allSettled(actions)).map(p => {
-      if (p.status === 'fulfilled') {
-        return p.value;
-      } else if (p.reason instanceof NotFoundError) {
-        return undefined!;
-      } else {
-        throw p.reason;
-      }
-    }).filter(item => !!item);
+    return (await Promise.allSettled(actions))
+      .map(p => {
+        if (p.status === 'fulfilled') {
+          return p.value;
+        } else if (p.reason instanceof NotFoundError) {
+          return undefined!;
+        } else {
+          throw p.reason;
+        }
+      })
+      .filter(item => !!item);
   }
 
   /**
@@ -54,11 +55,13 @@ export class ModelCrudUtil {
    * @param cls Class to load model for
    * @param input Input as string or plain object
    */
-  static async load<T extends ModelType>(cls: Class<T>, input: ModelLoadInput, onTypeMismatch: 'notfound' | 'exists' = 'notfound'): Promise<T> {
+  static async load<T extends ModelType>(
+    cls: Class<T>,
+    input: ModelLoadInput,
+    onTypeMismatch: 'notfound' | 'exists' = 'notfound'
+  ): Promise<T> {
     const resolvedInput: object =
-      typeof input === 'string' ? JSONUtil.fromUTF8(input) :
-        BinaryUtil.isBinaryArray(input) ? JSONUtil.fromBinaryArray(input) :
-          input;
+      typeof input === 'string' ? JSONUtil.fromUTF8(input) : BinaryUtil.isBinaryArray(input) ? JSONUtil.fromBinaryArray(input) : input;
 
     const result = SchemaRegistryIndex.getBaseClass(cls).from(resolvedInput);
 
@@ -79,7 +82,12 @@ export class ModelCrudUtil {
    * @param cls Type to store for
    * @param item Item to store
    */
-  static async preStore<T extends ModelType>(cls: Class<T>, item: Partial<OptionalId<T>>, provider: ModelCrudProvider, scope: PrePersistScope = 'all'): Promise<T> {
+  static async preStore<T extends ModelType>(
+    cls: Class<T>,
+    item: Partial<OptionalId<T>>,
+    provider: ModelCrudProvider,
+    scope: PrePersistScope = 'all'
+  ): Promise<T> {
     if (!item.id) {
       item.id = provider.idSource.create();
     }
@@ -128,7 +136,7 @@ export class ModelCrudUtil {
       };
 
       const hasTargets = Object.keys(schema.fields).some(key => isCleanTarget(key));
-      
+
       let res = item;
       if (hasTargets) {
         res = { ...item };
@@ -143,9 +151,9 @@ export class ModelCrudUtil {
         const fieldKey = castKey<typeof res>(key);
         if (!isCleanTarget(key) && res[fieldKey] !== undefined && res[fieldKey] !== null) {
           if (field.array && Array.isArray(res[fieldKey])) {
-            const arr = res[fieldKey] as any[];
+            const arr = res[fieldKey];
             let changed = false;
-            const newArr = arr.map(subItem => {
+            const newArray = arr.map(subItem => {
               const cleaned = this.cleanTransientFields(field.type, subItem);
               if (cleaned !== subItem) {
                 changed = true;
@@ -156,7 +164,7 @@ export class ModelCrudUtil {
               if (res === item) {
                 res = { ...item };
               }
-              res[fieldKey] = newArr as any;
+              res[fieldKey] = castTo(newArray);
             }
           } else {
             const val = res[fieldKey];
@@ -190,10 +198,10 @@ export class ModelCrudUtil {
    */
   static async prePersist<T>(cls: Class<T>, item: T, scope: PrePersistScope): Promise<T> {
     const config = ModelRegistryIndex.getConfig(cls);
-    for (const state of (config.prePersist ?? [])) {
+    for (const state of config.prePersist ?? []) {
       if (state.scope === scope || scope === 'all' || state.scope === 'all') {
         const handler: DataHandler<T> = castTo(state.handler);
-        item = await handler(item) ?? item;
+        item = (await handler(item)) ?? item;
       }
     }
     return this.cleanTransientFields(cls, item);
@@ -205,7 +213,7 @@ export class ModelCrudUtil {
   static async postLoad<T>(cls: Class<T>, item: T): Promise<T> {
     const config = ModelRegistryIndex.getConfig(cls);
     for (const handler of castTo<DataHandler<T>[]>(config.postLoad ?? [])) {
-      item = await handler(item) ?? item;
+      item = (await handler(item)) ?? item;
     }
     return item;
   }
@@ -215,7 +223,9 @@ export class ModelCrudUtil {
    */
   static async prePartialUpdate<T extends ModelType>(cls: Class<T>, item: Partial<T>, view?: string): Promise<Partial<T>> {
     if (!DataUtil.isPlainObject(item)) {
-      throw new RuntimeError(`A partial update requires a plain object, not an instance of ${castTo<Function>(item).constructor.name}`, { category: 'data' });
+      throw new RuntimeError(`A partial update requires a plain object, not an instance of ${castTo<Function>(item).constructor.name}`, {
+        category: 'data'
+      });
     }
     const keys = Object.keys(item);
     if ((keys.length === 1 && item.id) || keys.length === 0) {
@@ -237,4 +247,4 @@ export class ModelCrudUtil {
     const full = await get();
     return cls.from(castTo({ ...full, ...prepared }));
   }
-}
+}

package/src/util/expiry.ts

@@ -1,14 +1,13 @@
-import { ShutdownManager, type Class, type TimeSpan, TimeUtil, Util, castTo, hasFunction } from '@travetto/runtime';
+import { type Class, castTo, hasFunction, ShutdownManager, type TimeSpan, TimeUtil, Util } from '@travetto/runtime';
 
+import { ModelRegistryIndex } from '../registry/registry-index.ts';
 import type { ModelExpirySupport } from '../types/expiry.ts';
 import type { ModelType } from '../types/model.ts';
-import { ModelRegistryIndex } from '../registry/registry-index.ts';
 
 /**
  * Utils for model expiry
  */
 export class ModelExpiryUtil {
-
   /**
    * Type guard for determining if model supports expiry
    */
@@ -17,7 +16,7 @@ export class ModelExpiryUtil {
   /**
    * Get expiry info for a given item
    */
-  static getExpiryState<T extends ModelType>(cls: Class<T>, item: T): { expiresAt?: Date, expired?: boolean } {
+  static getExpiryState<T extends ModelType>(cls: Class<T>, item: T): { expiresAt?: Date; expired?: boolean } {
     const expKey = ModelRegistryIndex.getExpiryFieldName(cls);
     const expiresAt: Date = castTo(item[expKey]);
 
@@ -45,4 +44,4 @@ export class ModelExpiryUtil {
       })();
     }
   }
-}
+}

package/src/util/storage.ts

@@ -1,14 +1,13 @@
 import { type Class, hasFunction, Runtime } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
-import type { ModelStorageSupport } from '../types/storage.ts';
 import { ModelRegistryIndex } from '../registry/registry-index.ts';
+import type { ModelStorageSupport } from '../types/storage.ts';
 
 /**
  * Model storage util
  */
 export class ModelStorageUtil {
-
   /**
    * Type guard for determining if service supports storage operation
    */
@@ -33,7 +32,7 @@ export class ModelStorageUtil {
         return false;
       }
 
-      return (autoCreate === 'production' || !Runtime.production);
+      return autoCreate === 'production' || !Runtime.production;
     };
 
     // Initialize on startup (test manages)
@@ -47,4 +46,4 @@ export class ModelStorageUtil {
       }
     }
   }
-}
+}

package/support/base-command.ts

@@ -1,10 +1,9 @@
-import { Env } from '@travetto/runtime';
-import { type CliCommandShape, cliTpl, CliModuleFlag, CliProfilesFlag } from '@travetto/cli';
+import { type CliCommandShape, CliModuleFlag, CliProfilesFlag, cliTpl } from '@travetto/cli';
 import { Registry } from '@travetto/registry';
+import { Env } from '@travetto/runtime';
 import { Schema, type ValidationError } from '@travetto/schema';
 
 import type { ModelStorageSupport } from '../src/types/storage.ts';
-
 import { ModelCandidateUtil } from './bin/candidate.ts';
 
 /**
@@ -12,7 +11,6 @@ import { ModelCandidateUtil } from './bin/candidate.ts';
  */
 @Schema()
 export abstract class BaseModelCommand implements CliCommandShape {
-
   static async validate(operation: keyof ModelStorageSupport, provider: string, models: string[]): Promise<ValidationError | undefined> {
     const candidates = await ModelCandidateUtil.export(operation);
     if (provider && !candidates.providers.includes(provider)) {
@@ -52,4 +50,4 @@ export abstract class BaseModelCommand implements CliCommandShape {
   }
 
   abstract main(...args: unknown[]): ReturnType<CliCommandShape['main']>;
-}
+}

package/support/bin/candidate.ts

@@ -1,17 +1,16 @@
-import { toConcrete, type Class } from '@travetto/runtime';
-import { type InjectableCandidate, DependencyRegistryIndex } from '@travetto/di';
+import { DependencyRegistryIndex, type InjectableCandidate } from '@travetto/di';
+import { type Class, toConcrete } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
-import type { ModelStorageSupport } from '../../src/types/storage.ts';
-import type { ModelType } from '../../src/types/model.ts';
 import { ModelRegistryIndex } from '../../src/registry/registry-index.ts';
+import type { ModelType } from '../../src/types/model.ts';
+import type { ModelStorageSupport } from '../../src/types/storage.ts';
 
 /**
  * Utilities for finding candidates for model operations
  */
 export class ModelCandidateUtil {
-
-  static async export(operation: keyof ModelStorageSupport): Promise<{ models: string[], providers: string[] }> {
+  static async export(operation: keyof ModelStorageSupport): Promise<{ models: string[]; providers: string[] }> {
     return {
       models: await this.getModelNames(),
       providers: await this.getProviderNames(operation)
@@ -48,9 +47,7 @@ export class ModelCandidateUtil {
    * Get list of names of all viable providers
    */
   static async getProviderNames(operation?: keyof ModelStorageSupport): Promise<string[]> {
-    return (await this.getProviders(operation))
-      .map(x => x.class.name.replace(/ModelService/, ''))
-      .toSorted();
+    return (await this.getProviders(operation)).map(x => x.class.name.replace(/ModelService/, '')).toSorted();
   }
 
   /**
@@ -67,10 +64,10 @@ export class ModelCandidateUtil {
    * @param models
    * @returns
    */
-  static async resolve(provider: string, models: string[]): Promise<{ provider: ModelStorageSupport, models: Class<ModelType>[] }> {
+  static async resolve(provider: string, models: string[]): Promise<{ provider: ModelStorageSupport; models: Class<ModelType>[] }> {
     return {
       provider: await this.getProvider(provider),
       models: await this.#getModels(models)
     };
   }
-}
+}

package/support/bin/export.ts

@@ -1,5 +1,5 @@
-import type { Class } from '@travetto/runtime';
 import type { ModelStorageSupport, ModelType } from '@travetto/model';
+import type { Class } from '@travetto/runtime';
 
 export class ModelExportUtil {
   static async run(provider: ModelStorageSupport, models: Class<ModelType>[]): Promise<void> {
@@ -7,4 +7,4 @@ export class ModelExportUtil {
       console.log(await provider.exportModel!(model));
     }
   }
-}
+}

package/support/bin/install.ts

@@ -1,5 +1,5 @@
-import type { Class } from '@travetto/runtime';
 import type { ModelStorageSupport, ModelType } from '@travetto/model';
+import type { Class } from '@travetto/runtime';
 
 export class ModelInstallUtil {
   static async run(provider: ModelStorageSupport, models: Class<ModelType>[]): Promise<void> {
@@ -11,4 +11,4 @@ export class ModelInstallUtil {
       await provider.upsertModel(cls);
     }
   }
-}
+}

package/support/cli.model_export.ts

@@ -2,8 +2,8 @@ import { CliCommand } from '@travetto/cli';
 import { MethodValidator } from '@travetto/schema';
 
 import { BaseModelCommand } from './base-command.ts';
-import { ModelExportUtil } from './bin/export.ts';
 import { ModelCandidateUtil } from './bin/candidate.ts';
+import { ModelExportUtil } from './bin/export.ts';
 
 /**
  * Export model definitions for a selected provider and model set.
@@ -13,12 +13,13 @@ import { ModelCandidateUtil } from './bin/candidate.ts';
  */
 @CliCommand()
 export class ModelExportCommand extends BaseModelCommand {
-
-  getOperation(): 'exportModel' { return 'exportModel'; }
+  getOperation(): 'exportModel' {
+    return 'exportModel';
+  }
 
   @MethodValidator(BaseModelCommand.validate.bind(null, 'exportModel'))
   async main(provider: string, models: string[]): Promise<void> {
     const resolved = await ModelCandidateUtil.resolve(provider, models);
     await ModelExportUtil.run(resolved.provider, resolved.models);
   }
-}
+}

package/support/cli.model_install.ts

@@ -2,8 +2,8 @@ import { CliCommand, cliTpl } from '@travetto/cli';
 import { MethodValidator } from '@travetto/schema';
 
 import { BaseModelCommand } from './base-command.ts';
-import { ModelInstallUtil } from './bin/install.ts';
 import { ModelCandidateUtil } from './bin/candidate.ts';
+import { ModelInstallUtil } from './bin/install.ts';
 
 /**
  * Install or update model definitions for a selected provider.
@@ -13,8 +13,9 @@ import { ModelCandidateUtil } from './bin/candidate.ts';
  */
 @CliCommand()
 export class ModelInstallCommand extends BaseModelCommand {
-
-  getOperation(): 'upsertModel' { return 'upsertModel'; }
+  getOperation(): 'upsertModel' {
+    return 'upsertModel';
+  }
 
   @MethodValidator(BaseModelCommand.validate.bind(null, 'upsertModel'))
   async main(provider: string, models: string[]): Promise<void> {
@@ -22,4 +23,4 @@ export class ModelInstallCommand extends BaseModelCommand {
     await ModelInstallUtil.run(resolved.provider, resolved.models);
     console.log(cliTpl`${{ success: 'Successfully' }} installed ${{ param: models.length.toString() }} model(s)`);
   }
-}
+}

package/support/doc.support.tsx

@@ -1,7 +1,8 @@
 /** @jsxImportSource @travetto/doc/support */
-import { d, c, type DocJSXElementByFn, type DocJSXElement, DocFileUtil } from '@travetto/doc';
+
 import { Config } from '@travetto/config';
-import { Runtime, toConcrete } from '@travetto/runtime';
+import { c, DocFileUtil, type DocJSXElement, type DocJSXElementByFn, d } from '@travetto/doc';
+import { castKey, Runtime, toConcrete } from '@travetto/runtime';
 
 import type { ModelBasicSupport } from '../src/types/basic.ts';
 import type { ModelBlobSupport } from '../src/types/blob.ts';
@@ -17,7 +18,7 @@ export const Links = {
   Crud: toLink('CRUD', toConcrete<ModelCrudSupport>()),
   Expiry: toLink('Expiry', toConcrete<ModelExpirySupport>()),
   Bulk: toLink('Bulk', toConcrete<ModelBulkSupport>()),
-  Blob: toLink('Blob', toConcrete<ModelBlobSupport>()),
+  Blob: toLink('Blob', toConcrete<ModelBlobSupport>())
 };
 
 export const ModelTypes = (fn: Function): DocJSXElement[] => {
@@ -27,24 +28,21 @@ export const ModelTypes = (fn: Function): DocJSXElement[] => {
   for (const [, key] of content.matchAll(/Model([A-Za-z]+)Support/g)) {
     if (!seen.has(key) && key in Links) {
       seen.add(key);
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const link = Links[key as keyof typeof Links];
+      const link = Links[castKey(key)];
       found.push(link);
     }
   }
   return found.map(type => <li>{type}</li>);
 };
 
-export const ModelCustomConfig = ({ config }: { config: Function }): DocJSXElement => <>
-  Out of the box, by installing the module, everything should be wired up by default.If you need to customize any aspect of the source
-  or config, you can override and register it with the {d.module('Di')} module.
-
-  <c.Code title='Wiring up a custom Model Source' src='doc/custom-service.ts' />
-
-  where the {config} is defined by:
-
-  <c.Code title={`Structure of ${config.name}`} src={config} startRe={/@Config/} />
-
-  Additionally, you can see that the class is registered with the {Config} annotation, and so these values can be overridden using the
-  standard {d.module('Config')}resolution paths.
-</>;
+export const ModelCustomConfig = ({ config }: { config: Function }): DocJSXElement => (
+  <>
+    Out of the box, by installing the module, everything should be wired up by default.If you need to customize any aspect of the source or
+    config, you can override and register it with the {d.module('Di')} module.
+    <c.Code title="Wiring up a custom Model Source" src="doc/custom-service.ts" />
+    where the {config} is defined by:
+    <c.Code title={`Structure of ${config.name}`} src={config} startRe={/@Config/} />
+    Additionally, you can see that the class is registered with the {Config} annotation, and so these values can be overridden using the
+    standard {d.module('Config')}resolution paths.
+  </>
+);

package/support/test/base.ts

@@ -1,16 +1,15 @@
 import { DependencyRegistryIndex } from '@travetto/di';
-import { RuntimeError, castTo, type Class, classConstruct } from '@travetto/runtime';
+import { type Class, castTo, classConstruct, RuntimeError } from '@travetto/runtime';
 
+import type { ModelType } from '../../src/types/model.ts';
 import { ModelBulkUtil } from '../../src/util/bulk.ts';
 import { ModelCrudUtil } from '../../src/util/crud.ts';
-import type { ModelType } from '../../src/types/model.ts';
 import { ModelSuite } from './suite.ts';
 
-type ServiceClass = { serviceClass: { new(): unknown } };
+type ServiceClass = { serviceClass: { new (): unknown } };
 
 @ModelSuite()
 export abstract class BaseModelSuite<T> {
-
   static ifNot(pred: (svc: unknown) => boolean): (x: unknown) => Promise<boolean> {
     return async (x: unknown) => !pred(classConstruct(castTo<ServiceClass>(x).serviceClass));
   }
@@ -19,7 +18,7 @@ export abstract class BaseModelSuite<T> {
   configClass: Class;
 
   async getSize<U extends ModelType>(cls: Class<U>): Promise<number> {
-    const svc = (await this.service);
+    const svc = await this.service;
     if (ModelCrudUtil.isSupported(svc)) {
       let i = 0;
       for await (const batch of svc.list(cls)) {
@@ -34,7 +33,10 @@ export abstract class BaseModelSuite<T> {
   async saveAll<M extends ModelType>(cls: Class<M>, items: M[]): Promise<number> {
     const svc = await this.service;
     if (ModelBulkUtil.isSupported(svc)) {
-      const result = await svc.processBulk(cls, items.map(x => ({ insert: x })));
+      const result = await svc.processBulk(
+        cls,
+        items.map(x => ({ insert: x }))
+      );
       return result.counts.insert;
     } else if (ModelCrudUtil.isSupported(svc)) {
       const out: Promise<M>[] = [];
@@ -59,4 +61,4 @@ export abstract class BaseModelSuite<T> {
     }
     return castTo(out.flat());
   }
-}
+}