@travetto/model 8.0.0-alpha.8 → 8.0.0

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,20 +2,24 @@ 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';
 
 /**
- * Exports model schemas
+ * Export model definitions for a selected provider and model set.
+ *
+ * The command resolves candidate models and delegates to provider-specific
+ * export logic to produce schema/install artifacts.
  */
 @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,16 +2,20 @@ 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';
 
 /**
- * Installing models
+ * Install or update model definitions for a selected provider.
+ *
+ * The command resolves candidate models and applies provider install/upsert
+ * operations so backing stores are prepared for runtime usage.
  */
 @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> {
@@ -19,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,14 +1,14 @@
 /** @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';
 import type { ModelBulkSupport } from '../src/types/bulk.ts';
 import type { ModelCrudSupport } from '../src/types/crud.ts';
 import type { ModelExpirySupport } from '../src/types/expiry.ts';
-import type { ModelIndexedSupport } from '../src/types/indexed.ts';
 
 const toLink = (title: string, target: Function): DocJSXElementByFn<'CodeLink'> =>
   d.codeLink(title, Runtime.getSourceFile(target), new RegExp(`\\binterface\\s+${target.name}`));
@@ -17,9 +17,8 @@ export const Links = {
   Basic: toLink('Basic', toConcrete<ModelBasicSupport>()),
   Crud: toLink('CRUD', toConcrete<ModelCrudSupport>()),
   Expiry: toLink('Expiry', toConcrete<ModelExpirySupport>()),
-  Indexed: toLink('Indexed', toConcrete<ModelIndexedSupport>()),
   Bulk: toLink('Bulk', toConcrete<ModelBulkSupport>()),
-  Blob: toLink('Blob', toConcrete<ModelBlobSupport>()),
+  Blob: toLink('Blob', toConcrete<ModelBlobSupport>())
 };
 
 export const ModelTypes = (fn: Function): DocJSXElement[] => {
@@ -29,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,11 +18,11 @@ 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 __el of svc.list(cls)) {
-        i += 1;
+      for await (const batch of svc.list(cls)) {
+        i += batch.length;
       }
       return i;
     } else {
@@ -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>[] = [];
@@ -52,11 +54,11 @@ export abstract class BaseModelSuite<T> {
     return DependencyRegistryIndex.getInstance(this.serviceClass);
   }
 
-  async toArray<U>(src: AsyncIterable<U> | AsyncGenerator<U>): Promise<U[]> {
-    const out: U[] = [];
+  async toArray<U>(src: AsyncIterable<U | U[]> | AsyncGenerator<U | U[]>): Promise<U[]> {
+    const out: (U | U[])[] = [];
     for await (const el of src) {
       out.push(el);
     }
-    return out;
+    return castTo(out.flat());
   }
-}
+}

package/support/test/basic.ts

@@ -1,10 +1,22 @@
 import assert from 'node:assert';
 
+import { Model, type ModelCrudSupport, ModelCrudUtil, NotFoundError, TransientField } from '@travetto/model';
 import { Suite, Test } from '@travetto/test';
-import { type ModelCrudSupport, Model, NotFoundError } from '@travetto/model';
 
 import { BaseModelSuite } from './base.ts';
 
+@Model('computed_person')
+class ComputedPerson {
+  id: string;
+  name: string;
+  @TransientField()
+  get nameUpper(): string {
+    return this.name.toUpperCase();
+  }
+  @TransientField()
+  ignoredField?: string;
+}
+
 @Model('basic_person')
 class Person {
   id: string;
@@ -15,7 +27,6 @@ class Person {
 
 @Suite()
 export abstract class ModelBasicSuite extends BaseModelSuite<ModelCrudSupport> {
-
   @Test('create, read, delete')
   async create() {
     const service = await this.service;
@@ -59,4 +70,34 @@ export abstract class ModelBasicSuite extends BaseModelSuite<ModelCrudSupport> {
     assert(single !== undefined);
     assert(single.age === 25);
   }
-}
+
+  @Test('Should not persist computed properties')
+  async testComputed() {
+    const service = await this.service;
+    const id = service.idSource.create();
+    await service.create(
+      ComputedPerson,
+      ComputedPerson.from({
+        id,
+        name: 'Bob',
+        ignoredField: 'secret'
+      })
+    );
+
+    const retrieved = await service.get(ComputedPerson, id);
+    assert(retrieved.nameUpper === 'BOB');
+
+    // Verify it wasn't saved in the database holistically:
+    // When we fetch the document, the database driver retrieves a raw object and maps it.
+    // If the database stored 'nameUpper', trying to map it would set it on the retrieved instance.
+    // Since nameUpper is a getter-only property on the instance, we can verify that the persistence
+    // preparation (prePersist) recursively stripped the getter property from the stored object.
+    const instance = ComputedPerson.from({ id, name: 'Bob', ignoredField: 'secret' });
+    assert(Object.hasOwn(instance, 'nameUpper'));
+    assert(instance.ignoredField === 'secret');
+
+    const prepared = await ModelCrudUtil.prePersist(ComputedPerson, instance, 'all');
+    assert(prepared.nameUpper === undefined);
+    assert(prepared.ignoredField === undefined);
+  }
+}

package/support/test/blob.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 
-import { Suite, Test, TestFixtures } from '@travetto/test';
 import { BinaryMetadataUtil, BinaryUtil, Util } from '@travetto/runtime';
+import { Suite, Test, TestFixtures } from '@travetto/test';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
@@ -10,7 +10,6 @@ import { ModelBlobUtil } from '../../src/util/blob.ts';
 
 @Suite()
 export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
-
   fixture = new TestFixtures(['@travetto/model']);
 
   @Test()
@@ -90,7 +89,7 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
     const partialMeta = BinaryMetadataUtil.read(partial)!;
     const subContent = await partial.text();
     const range = BinaryMetadataUtil.enforceRange({ start: 10, end: 20 }, partialMeta);
-    assert(subContent.length === (range.end - range.start) + 1);
+    assert(subContent.length === range.end - range.start + 1);
 
     const og = await this.fixture.readUTF8('/text.txt');
 
@@ -100,7 +99,7 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
     const partialUnboundedMeta = BinaryMetadataUtil.read(partialUnbounded)!;
     const subContent2 = await partialUnbounded.text();
     const range2 = BinaryMetadataUtil.enforceRange({ start: 10 }, partialUnboundedMeta);
-    assert(subContent2.length === (range2.end - range2.start) + 1);
+    assert(subContent2.length === range2.end - range2.start + 1);
     assert(subContent2.startsWith('klm'));
     assert(subContent2.endsWith('xyz'));
 
@@ -156,19 +155,19 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
     const service = await this.service;
 
     const bytes = BinaryUtil.binaryArrayToBuffer(BinaryUtil.makeBinaryArray(1.5 * 10000));
-    for (let i = 0; i < bytes.byteLength; i++) {
+    for (let i = 0; i < bytes.byteLength; i += 1) {
       bytes.writeUInt8(Math.trunc(Math.random() * 255), i);
     }
 
     const writable = await service.getBlobWriteUrl!('largeFile/one', {
-      contentType: 'image/jpeg',
+      contentType: 'image/jpeg'
     });
 
     assert(writable);
 
     const response = await fetch(writable, {
       method: 'PUT',
-      body: new File([bytes], 'gary', { type: 'image/jpeg' }),
+      body: new File([bytes], 'gary', { type: 'image/jpeg' })
     });
 
     console.error(await response.text());
@@ -179,7 +178,7 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
       contentType: 'image/jpeg',
       title: 'orange',
       filename: 'gary',
-      size: bytes.byteLength,
+      size: bytes.byteLength
     });
 
     const found = await service.getBlob('largeFile/one');
@@ -189,4 +188,4 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
     assert(foundMeta.title === 'orange');
     assert(foundMeta.filename === 'gary');
   }
-}
+}

package/support/test/bulk.ts

@@ -14,7 +14,6 @@ class User {
 
 @Suite()
 export abstract class ModelBulkSuite extends BaseModelSuite<ModelBulkSupport> {
-
   @Test()
   async bulkInsert() {
     const service = await this.service;
@@ -48,11 +47,17 @@ export abstract class ModelBulkSuite extends BaseModelSuite<ModelBulkSupport> {
     const service = await this.service;
     const users = [0, 1, 2, 4].map(x => User.from({ name: `name-${x}`, id: service.idSource.create() }));
 
-    const result = await service.processBulk(User, users.map(u => ({ insert: u })));
+    const result = await service.processBulk(
+      User,
+      users.map(u => ({ insert: u }))
+    );
     assert(result.counts.insert === 4);
     assert(result.insertedIds.size === 4);
 
-    const res2 = await service.processBulk(User, users.map(u => ({ update: u })));
+    const res2 = await service.processBulk(
+      User,
+      users.map(u => ({ update: u }))
+    );
     assert(res2.counts.update === 4);
     assert(res2.insertedIds.size === 0);
   }
@@ -62,11 +67,17 @@ export abstract class ModelBulkSuite extends BaseModelSuite<ModelBulkSupport> {
     const service = await this.service;
     const users = [0, 1, 2, 4].map(x => User.from({ name: `name-${x}`, id: service.idSource.create() }));
 
-    const result = await service.processBulk(User, users.map(u => ({ insert: u })));
+    const result = await service.processBulk(
+      User,
+      users.map(u => ({ insert: u }))
+    );
     assert(result.counts.insert === 4);
     assert(result.insertedIds.size === 4);
 
-    const res2 = await service.processBulk(User, users.map(u => ({ delete: u })));
+    const res2 = await service.processBulk(
+      User,
+      users.map(u => ({ delete: u }))
+    );
     assert(res2.counts.delete === 4);
   }
 }