@travetto/model 8.0.0-alpha.2 → 8.0.0-alpha.21

package/src/util/crud.ts

@@ -1,4 +1,4 @@
-import { castTo, type Class, Util, RuntimeError, hasFunction, BinaryUtil, type BinaryArray, JSONUtil } from '@travetto/runtime';
+import { castTo, castKey, type Class, Util, RuntimeError, hasFunction, BinaryUtil, type BinaryArray, JSONUtil } from '@travetto/runtime';
 import { DataUtil, SchemaRegistryIndex, SchemaValidator, type ValidationError, ValidationResultError } from '@travetto/schema';
 
 import { ModelRegistryIndex } from '../registry/registry-index.ts';
@@ -34,6 +34,21 @@ export class ModelCrudUtil {
     return { create, valid };
   }
 
+  static async filterOutNotFound<T extends ModelType>(actions: Promise<T>[] | undefined): Promise<T[]> {
+    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);
+  }
+
   /**
    * Load model
    * @param cls Class to load model for
@@ -96,6 +111,70 @@ export class ModelCrudUtil {
     return castTo(item);
   }
 
+  /**
+   * Recursively deletes or masks transient fields from an object based on its Model config.
+   * If transient fields are present, returns a copy with those fields set to undefined.
+   */
+  static cleanTransientFields<T>(cls: Class<T>, item: T): T {
+    if (!item || typeof item !== 'object') {
+      return item;
+    }
+    if (SchemaRegistryIndex.has(cls)) {
+      const schema = SchemaRegistryIndex.get(cls).get();
+      const transientFields = ModelRegistryIndex.has(cls) ? ModelRegistryIndex.getConfig(cls).transientFields : undefined;
+
+      const isCleanTarget = (key: string): boolean => {
+        return transientFields?.includes(key) ?? false;
+      };
+
+      const hasTargets = Object.keys(schema.fields).some(key => isCleanTarget(key));
+      
+      let res = item;
+      if (hasTargets) {
+        res = { ...item };
+        for (const key of Object.keys(schema.fields)) {
+          if (isCleanTarget(key)) {
+            res[castKey<T>(key)] = undefined!;
+          }
+        }
+      }
+
+      for (const [key, field] of Object.entries(schema.fields)) {
+        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[];
+            let changed = false;
+            const newArr = arr.map(subItem => {
+              const cleaned = this.cleanTransientFields(field.type, subItem);
+              if (cleaned !== subItem) {
+                changed = true;
+              }
+              return cleaned;
+            });
+            if (changed) {
+              if (res === item) {
+                res = { ...item };
+              }
+              res[fieldKey] = newArr as any;
+            }
+          } else {
+            const val = res[fieldKey];
+            const cleaned = this.cleanTransientFields(field.type, val);
+            if (cleaned !== val) {
+              if (res === item) {
+                res = { ...item };
+              }
+              res[fieldKey] = cleaned;
+            }
+          }
+        }
+      }
+      return res;
+    }
+    return item;
+  }
+
   /**
    * Ensure subtype is not supported
    */
@@ -117,10 +196,7 @@ export class ModelCrudUtil {
         item = await handler(item) ?? item;
       }
     }
-    if (typeof item === 'object' && item && 'prePersist' in item && typeof item['prePersist'] === 'function') {
-      item = await item.prePersist() ?? item;
-    }
-    return item;
+    return this.cleanTransientFields(cls, item);
   }
 
   /**
@@ -131,9 +207,6 @@ export class ModelCrudUtil {
     for (const handler of castTo<DataHandler<T>[]>(config.postLoad ?? [])) {
       item = await handler(item) ?? item;
     }
-    if (typeof item === 'object' && item && 'postLoad' in item && typeof item['postLoad'] === 'function') {
-      item = await item.postLoad() ?? item;
-    }
     return item;
   }
 

package/support/cli.model_export.ts

@@ -6,7 +6,10 @@ import { ModelExportUtil } from './bin/export.ts';
 import { ModelCandidateUtil } from './bin/candidate.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 {

package/support/cli.model_install.ts

@@ -6,7 +6,10 @@ import { ModelInstallUtil } from './bin/install.ts';
 import { ModelCandidateUtil } from './bin/candidate.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 {

package/support/doc.support.tsx

@@ -8,7 +8,6 @@ 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,7 +16,6 @@ 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>()),
 };

package/support/test/base.ts

@@ -22,8 +22,8 @@ export abstract class BaseModelSuite<T> {
     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 {
@@ -52,11 +52,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 { Suite, Test } from '@travetto/test';
-import { type ModelCrudSupport, Model, NotFoundError } from '@travetto/model';
+import { type ModelCrudSupport, Model, NotFoundError, ModelCrudUtil, TransientField } 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;
@@ -59,4 +71,31 @@ 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

@@ -92,7 +92,7 @@ export abstract class ModelBlobSuite extends BaseModelSuite<ModelBlobSupport> {
     const range = BinaryMetadataUtil.enforceRange({ start: 10, end: 20 }, partialMeta);
     assert(subContent.length === (range.end - range.start) + 1);
 
-    const og = await this.fixture.readText('/text.txt');
+    const og = await this.fixture.readUTF8('/text.txt');
 
     assert(subContent === og.substring(10, 21));
 

package/support/test/crud.ts

@@ -3,7 +3,7 @@ import timers from 'node:timers/promises';
 
 import { Suite, Test } from '@travetto/test';
 import { Schema, Text, Precision, Required, } from '@travetto/schema';
-import { type ModelCrudSupport, Model, NotFoundError, PersistValue } from '@travetto/model';
+import { type ModelCrudSupport, Model, NotFoundError, PersistValue, PrePersist } from '@travetto/model';
 
 import { BaseModelSuite } from './base.ts';
 
@@ -42,14 +42,13 @@ class SimpleList {
 }
 
 @Model()
+@PrePersist((item) => {
+  item.name = `${item.name}-suffix`;
+})
 class User2 {
   id: string;
   address?: Address;
   name: string;
-
-  prePersist() {
-    this.name = `${this.name}-suffix`;
-  }
 }
 
 @Model()
@@ -77,6 +76,8 @@ class BigIntModel {
 @Suite()
 export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
 
+  indexLimitSkew = 0;
+
   @Test('save it')
   async save() {
     const service = await this.service;
@@ -268,6 +269,39 @@ export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
     assert(found[2].age === people[2].age);
   }
 
+  @Test('verify list abort signal')
+  async listAbortSignal() {
+    const service = await this.service;
+
+    await Promise.all(
+      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => service.upsert(Person, Person.from({
+        id: service.idSource.create(),
+        name: 'Bob',
+        age: 20 + x,
+        gender: 'm',
+        address: {
+          street1: 'a',
+          ...(x === 1 ? { street2: 'b' } : {})
+        }
+      })))
+    );
+
+    const controller = new AbortController();
+    const found: Person[] = [];
+
+    for await (const items of service.list(Person, { abort: controller.signal, batchSizeHint: 1 })) {
+      found.push(...items);
+      controller.abort();
+      await timers.setTimeout(10);
+    }
+
+    if (this.indexLimitSkew) {
+      assert(found.length > 0 && found.length < this.indexLimitSkew);
+    } else {
+      assert(found.length === 1);
+    }
+  }
+
   @Test('save it')
   async verifyRaw() {
     const service = await this.service;

package/support/test/polymorphism.ts

@@ -3,13 +3,12 @@ import timers from 'node:timers/promises';
 
 import { Suite, Test } from '@travetto/test';
 import { castTo } from '@travetto/runtime';
-import { Schema, DiscriminatorField, Text, TypeMismatchError, Discriminated } from '@travetto/schema';
+import { Schema, DiscriminatorField, Text, TypeMismatchError } from '@travetto/schema';
 import {
-  type ModelIndexedSupport, Index, type ModelCrudSupport, Model,
+  type ModelCrudSupport, Model,
   NotFoundError, SubTypeNotSupportedError, PersistValue
 } from '@travetto/model';
 
-import { ModelIndexedUtil } from '../../src/util/indexed.ts';
 import { ExistsError } from '../../src/error/exists.ts';
 
 import { BaseModelSuite } from './base.ts';
@@ -43,42 +42,6 @@ export class Engineer extends Worker {
   major: string;
 }
 
-@Model()
-@Index({
-  name: 'worker-name',
-  type: 'sorted',
-  fields: [{ name: 1 }, { age: 1 }]
-})
-@Discriminated('type')
-export class IndexedWorker {
-  id: string;
-  type: string;
-  name: string;
-  age?: number;
-}
-@Model()
-export class IndexedDoctor extends IndexedWorker {
-  specialty: string;
-}
-
-@Model()
-export class IndexedFirefighter extends IndexedWorker {
-  firehouse: number;
-}
-
-@Model()
-export class IndexedEngineer extends IndexedWorker {
-  major: string;
-}
-
-async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
-  const out: T[] = [];
-  for await (const el of iterable) {
-    out.push(el);
-  }
-  return out;
-}
-
 @Suite()
 export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSupport> {
 
@@ -108,7 +71,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     const fire2 = await service.get(Worker, fire.id);
     assert(fire2 instanceof Firefighter);
 
-    const all = await collect(service.list(Worker));
+    const all = await this.toArray(service.list(Worker));
     assert(all.length === 3);
 
     const doc3 = all.find(x => x instanceof Doctor);
@@ -126,7 +89,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     assert(eng3.major === 'oranges');
     assert(eng3.name === 'cob');
 
-    const engineers = await collect(service.list(Engineer));
+    const engineers = await this.toArray(service.list(Engineer));
     assert(engineers.length === 1);
 
     await service.create(Engineer, Engineer.from({
@@ -134,10 +97,10 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
       name: 'bob2'
     }));
 
-    const all2 = await collect(service.list(Worker));
+    const all2 = await this.toArray(service.list(Worker));
     assert(all2.length === 4);
 
-    const engineers2 = await collect(service.list(Engineer));
+    const engineers2 = await this.toArray(service.list(Engineer));
     assert(engineers2.length === 2);
   }
 
@@ -207,75 +170,4 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
       e => e instanceof SubTypeNotSupportedError || e instanceof NotFoundError
     );
   }
-
-  @Test('Polymorphic index', { skip: BaseModelSuite.ifNot(ModelIndexedUtil.isSupported) })
-  async polymorphicIndexGet() {
-    const service: ModelIndexedSupport = castTo(await this.service);
-    const now = 30;
-    const [doc, fire, eng] = [
-      IndexedDoctor.from({ name: 'bob', specialty: 'feet', age: now }),
-      IndexedFirefighter.from({ name: 'rob', firehouse: 20, age: now }),
-      IndexedEngineer.from({ name: 'cob', major: 'oranges', age: now })
-    ];
-
-    await this.saveAll(IndexedWorker, [doc, fire, eng]);
-
-    const result = await service.getByIndex(IndexedWorker, 'worker-name', {
-      age: now,
-      name: 'rob'
-    });
-
-    assert(result instanceof IndexedFirefighter);
-
-    try {
-      const res2 = await service.getByIndex(IndexedFirefighter, 'worker-name', {
-        age: now,
-        name: 'rob'
-      });
-      assert(res2 instanceof IndexedFirefighter); // If service allows for get by subtype
-    } catch (err) {
-      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError); // If it does not
-    }
-  }
-
-  @Test('Polymorphic index', { skip: BaseModelSuite.ifNot(ModelIndexedUtil.isSupported) })
-  async polymorphicIndexDelete() {
-    const service: ModelIndexedSupport = castTo(await this.service);
-    const now = 30;
-    const [doc, fire, eng] = [
-      IndexedDoctor.from({ name: 'bob', specialty: 'feet', age: now }),
-      IndexedFirefighter.from({ name: 'rob', firehouse: 20, age: now }),
-      IndexedEngineer.from({ name: 'cob', major: 'oranges', age: now })
-    ];
-
-    await this.saveAll(IndexedWorker, [doc, fire, eng]);
-
-    assert(await this.getSize(IndexedWorker) === 3);
-
-    await service.deleteByIndex(IndexedWorker, 'worker-name', {
-      age: now,
-      name: 'bob'
-    });
-
-    assert(await this.getSize(IndexedWorker) === 2);
-    assert(await this.getSize(IndexedDoctor) === 0);
-
-    try {
-      await service.deleteByIndex(IndexedFirefighter, 'worker-name', {
-        age: now,
-        name: 'rob'
-      });
-    } catch (err) {
-      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError);
-    }
-
-    try {
-      await service.deleteByIndex(IndexedEngineer, 'worker-name', {
-        age: now,
-        name: 'bob'
-      });
-    } catch (err) {
-      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError);
-    }
-  }
 }

package/src/types/indexed.ts

@@ -1,43 +0,0 @@
-import type { Class, DeepPartial } from '@travetto/runtime';
-
-import type { ModelType, OptionalId } from '../types/model.ts';
-import type { ModelBasicSupport } from './basic.ts';
-
-/**
- * Support for simple indexed activity
- *
- * @concrete
- */
-export interface ModelIndexedSupport extends ModelBasicSupport {
-  /**
-   * Get entity by 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
-   */
-  getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<T>;
-
-  /**
-   * Delete entity by 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
-   */
-  deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void>;
-
-  /**
-   * 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
-   */
-  listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T>;
-
-  /**
-   * Upsert by index, allowing the index to act as a primary key
-   * @param cls The type to create for
-   * @param idx The index name to use
-   * @param body The document to potentially store
-   */
-  upsertByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: OptionalId<T>): Promise<T>;
-}

package/src/util/indexed.ts

@@ -1,144 +0,0 @@
-import { castTo, type Class, type DeepPartial, hasFunction, TypedObject } from '@travetto/runtime';
-
-import { IndexNotSupported } from '../error/invalid-index.ts';
-import { NotFoundError } from '../error/not-found.ts';
-import type { IndexConfig } from '../registry/types.ts';
-import type { ModelCrudSupport } from '../types/crud.ts';
-import type { ModelIndexedSupport } from '../types/indexed.ts';
-import type { ModelType, OptionalId } from '../types/model.ts';
-import { ModelRegistryIndex } from '../registry/registry-index.ts';
-
-type ComputeConfig = {
-  includeSortInFields?: boolean;
-  emptyValue?: unknown;
-  emptySortValue?: unknown;
-};
-
-type IndexFieldPart = { path: string[], value: (string | boolean | Date | number) };
-type IndexSortPart = { path: string[], dir: number, value: number | Date };
-
-const DEFAULT_SEP = '\u8203';
-
-/**
- * Utils for working with indexed model services
- */
-export class ModelIndexedUtil {
-
-  /**
-   * Type guard for determining if service supports indexed operation
-   */
-  static isSupported = hasFunction<ModelIndexedSupport>('getByIndex');
-
-  /**
-   * Compute flattened field to value mappings
-   * @param cls Class to get info for
-   * @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 = {}
-  ): { fields: IndexFieldPart[], sorted: IndexSortPart | undefined } {
-    const config = typeof idx === 'string' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
-    const sortField = config.type === 'sorted' ? config.fields.at(-1) : undefined;
-
-    const fields: IndexFieldPart[] = [];
-    let sortDirection: number = 0;
-    let sorted: IndexSortPart | undefined;
-
-    for (const field of config.fields) {
-      let fieldRef: Record<string, unknown> = field;
-      let itemRef: Record<string, unknown> = item;
-      const parts = [];
-
-      while (itemRef !== undefined && itemRef !== null) {
-        const key = TypedObject.keys(fieldRef)[0];
-        itemRef = castTo(itemRef[key]);
-        parts.push(key);
-        if (typeof fieldRef[key] === 'boolean' || typeof fieldRef[key] === 'number') {
-          if (config.type === 'sorted') {
-            sortDirection = fieldRef[key] === true ? 1 : fieldRef[key] === false ? 0 : fieldRef[key];
-          }
-          break; // At the bottom
-        } else {
-          fieldRef = castTo(fieldRef[key]);
-        }
-      }
-      if (field === sortField) {
-        sorted = { path: parts, dir: sortDirection, value: castTo(itemRef) };
-      }
-      if (itemRef === undefined || itemRef === null) {
-        const empty = field === sortField ? opts.emptySortValue : opts.emptyValue;
-        if (empty === undefined || empty === Error) {
-          throw new IndexNotSupported(cls, config, `Missing field value for ${parts.join('.')}`);
-        }
-      } else {
-        if (field !== sortField || (opts.includeSortInFields ?? true)) {
-          fields.push({ path: parts, value: castTo(itemRef) });
-        }
-      }
-    }
-
-    return { fields, sorted };
-  }
-
-  /**
-   * Project item via index
-   * @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>, config?: ComputeConfig): Record<string, unknown> {
-    const response: Record<string, unknown> = {};
-    for (const { path, value } of this.computeIndexParts(cls, idx, item ?? {}, config).fields) {
-      let sub: Record<string, unknown> = response;
-      const all = path.slice(0);
-      const last = all.pop()!;
-      for (const part of all) {
-        sub = castTo(sub[part] ??= {});
-      }
-      sub[last] = value;
-    }
-    return response;
-  }
-
-  /**
-   * Compute index key as a single value
-   * @param cls Class to get index for
-   * @param idx Index config
-   * @param item item to process
-   */
-  static computeIndexKey<T extends ModelType>(
-    cls: Class<T>,
-    idx: IndexConfig<T> | string,
-    item: DeepPartial<T> = {},
-    config?: ComputeConfig & { separator?: string }
-  ): { type: string, key: string, sort?: number | Date } {
-    const { fields, sorted } = this.computeIndexParts(cls, idx, item, { ...(config ?? {}), includeSortInFields: false });
-    const key = fields.map(({ value }) => value).map(value => `${value}`).join(config?.separator ?? DEFAULT_SEP);
-    const indexConfig = typeof idx === 'string' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
-    return !sorted ? { type: indexConfig.type, key } : { type: indexConfig.type, key, sort: sorted.value };
-  }
-
-  /**
-   * Naive upsert by index
-   * @param service
-   * @param cls
-   * @param idx
-   * @param body
-   */
-  static async naiveUpsert<T extends ModelType>(
-    service: ModelIndexedSupport & ModelCrudSupport,
-    cls: Class<T>, idx: string, body: OptionalId<T>
-  ): Promise<T> {
-    try {
-      const { id } = await service.getByIndex(cls, idx, castTo(body));
-      body.id = id;
-      return await service.update(cls, castTo(body));
-    } catch (error) {
-      if (error instanceof NotFoundError) {
-        return await service.create(cls, body);
-      } else {
-        throw error;
-      }
-    }
-  }
-}