@travetto/model-indexed 8.0.0-alpha.10

package/README.md

@@ -0,0 +1,353 @@
+<!-- This file was generated by @travetto/doc and should not be modified directly -->
+<!-- Please modify https://github.com/travetto/travetto/tree/main/module/model-indexed/DOC.tsx and execute "npx trv doc" to rebuild -->
+# Data Model Indexing Support
+
+## Basic indexing support for model sources that support it.
+
+**Install: @travetto/model-indexed**
+```bash
+npm install @travetto/model-indexed
+
+# or
+
+yarn add @travetto/model-indexed
+```
+
+This module provides computed index support for data model sources that support it. It enables efficient lookups and list operations using composite keys extracted from model fields, without requiring a full query engine.
+
+## Overview
+The module allows you to define indexes on your models and use them for fast single-item lookups, uniqueness enforcement, and efficient paginated list operations. Indexes are computed from model field values and act as alternative keys for data access.
+
+### Index Types
+Three types of indexes are supported:
+   *  **Keyed Indexes** — Fast single-item lookups using composite keys
+   *  **Unique Indexes** — Enforce uniqueness constraints on key fields
+   *  **Sorted Indexes** — Enable range queries and paginated listing with sorting
+
+## Defining Indexes
+Indexes are defined using factory functions provided by the module. Each index is registered with the model at decoration time.
+
+### Keyed Indexes
+A [keyedIndex](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/indexes.ts#L29) provides fast lookups by computed key values. It's useful when you want to query records by specific field combinations.
+
+**Code: Creating a Keyed Index**
+```typescript
+import { keyedIndex } from '@travetto/model-indexed';
+import { Model } from '@travetto/model';
+
+@Model()
+export class User {
+  id: string;
+  name: string;
+  email: string;
+}
+
+export const userByName = keyedIndex(User, {
+  name: 'userByName',
+  key: { name: true }
+});
+```
+
+The index definition specifies:
+   *   `name` — The identifier for this index
+   *   `key` — An object where each key path should be included in the index (set to `true`)
+
+### Unique Indexes
+A [uniqueIndex](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/indexes.ts#L47) enforces uniqueness constraints on key fields. This is useful for emails, usernames, or any field that should be globally unique.
+
+**Code: Creating a Unique Index**
+```typescript
+import { uniqueIndex } from '@travetto/model-indexed';
+import { Model } from '@travetto/model';
+
+@Model()
+export class User {
+  id: string;
+  name: string;
+  email: string;
+}
+
+export const emailUnique = uniqueIndex(User, {
+  name: 'uniqueEmail',
+  key: { email: true }
+});
+```
+
+Unique indexes work exactly like keyed indexes, but enforce a uniqueness constraint. A model service will reject writes that violate the uniqueness guarantee.
+
+### Sorted Indexes
+A [sortedIndex](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/indexes.ts#L65) enables range queries and paginated listing. It requires both a `key` for filtering and a `sort` field for ordering.
+
+**Code: Creating a Sorted Index**
+```typescript
+import { sortedIndex } from '@travetto/model-indexed';
+import { Model } from '@travetto/model';
+
+@Model()
+export class User {
+  id: string;
+  name: string;
+  age: number;
+  createdAt: Date;
+}
+
+export const usersByNameAge = sortedIndex(User, {
+  name: 'usersByNameAge',
+  key: { name: true },
+  sort: { age: 1 }  // 1 for ascending, -1 for descending
+});
+
+export const recentUsers = sortedIndex(User, {
+  name: 'recentUsers',
+  key: {},  // No key filtering
+  sort: { createdAt: -1 }  // Most recent first
+});
+```
+
+The `sort` field must be numeric or a `Date` type. The value `1` means ascending order, `-1` means descending.
+
+### Composite Keys
+Indexes can use multiple fields or nested fields in their keys. This allows querying by combinations of values.
+
+**Code: Composite Key Index**
+```typescript
+import { keyedIndex } from '@travetto/model-indexed';
+import { Model } from '@travetto/model';
+
+@Model()
+export class Order {
+  id: string;
+  customerId: string;
+  status: string;
+  productId: string;
+}
+
+// Find orders by customer and status
+export const orders = keyedIndex(Order, {
+  name: 'ordersByCustomerStatus',
+  key: { customerId: true, status: true }
+});
+
+// Find orders by customer, status, and product
+export const specificOrders = keyedIndex(Order, {
+  name: 'ordersByCustomerStatusProduct',
+  key: { customerId: true, status: true, productId: true }
+});
+```
+
+## Using Indexes
+Model services that implement [ModelIndexedSupport](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L23) allow you to query using the indexes you've defined.
+
+### Service Interface
+
+**Code: ModelIndexedSupport Interface**
+```typescript
+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 to search against
+   * @param body The payload of fields needed to search
+   */
+  getByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): 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 to search against
+   * @param body The payload of fields needed to search
+   */
+  deleteByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<void>;
+
+  /**
+   * Upsert by index, allowing the index to act as a primary key
+   * @param cls The type to create for
+   * @param idx The index to use
+   * @param body The document to potentially store
+   */
+  upsertByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: OptionalId<T>): Promise<T>;
+
+  /**
+   * Update by index
+   * @param cls The type to update for
+   * @param idx The index to update by
+   * @param body The document to update
+   */
+  updateByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: T): Promise<T>;
+
+  /**
+   * Update partial by index
+   * @param cls The type to update for
+   * @param idx The index to update by
+   * @param body The partial document to update
+   */
+  updatePartialByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexWithPartialBody<T, K, S>): Promise<T>;
+
+  /**
+   * List entity by ranged index as defined by fields of idx
+   * @param cls The type to search by
+   * @param idx The index to search against
+   * @param body The payload of fields needed to search
+   * @param options The configuration for listing
+   */
+  listByIndex<
+    T extends ModelType,
+    S extends SortedIndexSelection<T>,
+    K extends KeyedIndexSelection<T>
+  >(cls: Class<T>, idx: SortedIndex<T, K, S>, body: KeyedIndexBody<T, K>, options?: ListPageOptions): Promise<ListPageResult<T>>;
+}
+```
+
+The service provides these operations:
+   *  `getByIndex` — Fetch a single item by index
+   *  `deleteByIndex` — Delete a single item by index
+   *  `upsertByIndex` — Insert or update by index
+   *  `updateByIndex` — Update an existing item by index
+   *  `updatePartialByIndex` — Partially update an item by index
+   *  `listByIndex` — List items with pagination and sorting
+
+### Getting Items
+Use `getByIndex` to fetch a single item by providing all required key fields.
+
+**Code: Getting by Keyed Index**
+```typescript
+export async function getExample(modelService: any) {
+  const user = await modelService.getByIndex(User, userByName, {
+    name: 'John Doe'
+  });
+  return user;
+}
+```
+
+For sorted indexes with key fields, you must provide all key values plus the sort value if using it to identify a specific item.
+
+### Deleting Items
+Use `deleteByIndex` to remove an item by index.
+
+**Code: Deleting by Index**
+```typescript
+export async function deleteExample(modelService: any) {
+  await modelService.deleteByIndex(User, userByName, {
+    name: 'John Doe'
+  });
+}
+```
+
+### Upserting Items
+Use `upsertByIndex` to insert a new item or update an existing one. The index acts as a primary key.
+
+**Code: Upserting by Index**
+```typescript
+export async function upsertExample(modelService: any) {
+  const user = await modelService.upsertByIndex(User, userByName, {
+    id: 'user-1',
+    name: 'John Doe',
+    email: 'john@example.com'
+  });
+  return user;
+}
+```
+
+### Updating Items
+Use `updateByIndex` to update an existing item, or `updatePartialByIndex` for partial updates.
+
+**Code: Updating by Index**
+```typescript
+export async function updateExample(modelService: any) {
+  // Full update — all fields required
+  const user = await modelService.updateByIndex(User, userByName, {
+    id: 'user-1',
+    name: 'John Doe',
+    email: 'john.new@example.com',
+    age: 31
+  });
+  return user;
+}
+
+export async function updatePartialExample(modelService: any) {
+  // Partial update — only updated fields required
+  const user = await modelService.updatePartialByIndex(User, userByName, {
+    name: 'John Doe',
+    email: 'john.newer@example.com'
+  });
+  return user;
+}
+```
+
+### Listing Items
+Use `listByIndex` to fetch multiple items from a sorted index with pagination.
+
+**Code: Listing by Sorted Index**
+```typescript
+export async function listExample(modelService: any) {
+  const result = await modelService.listByIndex(User, recentUsers, {}, {
+    limit: 20,
+    offset: '0'
+  });
+
+  console.log(result.items);      // Array of users
+  console.log(result.nextOffset); // Token for next page, if more results exist
+  return result;
+}
+```
+
+You can also provide key values to filter within a sorted index:
+
+**Code: Listing with Key Filter**
+```typescript
+export async function listWithFilterExample(modelService: any) {
+  // Get all users named 'John' sorted by age
+  const result = await modelService.listByIndex(User, usersByNameAge, {
+    name: 'John'
+  }, {
+    limit: 10
+  });
+  return result;
+}
+```
+
+## Integration
+Index registration happens automatically when models are decorated with [@Model](https://github.com/travetto/travetto/tree/main/module/model/src/registry/decorator.ts#L14). Model services like [Memory Model Support](https://github.com/travetto/travetto/tree/main/module/model-memory#readme "Memory backing for the travetto model module."), [MongoDB Model Support](https://github.com/travetto/travetto/tree/main/module/model-mongo#readme "Mongo backing for the travetto model module."), and [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.") implement the [ModelIndexedSupport](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L23) interface to provide indexed access.
+
+### Reading Registry Information
+You can access registered indexes via [ModelRegistryIndex](https://github.com/travetto/travetto/tree/main/module/model/src/registry/registry-index.ts#L12) at runtime:
+
+**Code: Accessing Model Indexes**
+```typescript
+export function registryAccessExample() {
+  const registry = ModelRegistryIndex.get(User);
+  const indexes = registry.indices; // Map of all indexes for the model
+
+  // Access a specific index
+  const userByName = indexes['userByName'];
+  return userByName;
+}
+```
+
+## Best Practices
+
+   *  **Plan indexes strategically** — Define indexes for your common query patterns
+   *  **Use composite keys** — When filtering by multiple fields, include all of them in a single index
+   *  **Leverage sorting** — Use sorted indexes for paginated lists and range queries
+   *  **Enforce uniqueness** — Use [uniqueIndex](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/indexes.ts#L47) for fields that must be globally unique
+   *  **Handle errors gracefully** — Catch [IndexedFieldError](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/indexes.ts#L88) when working with user input

package/__index__.ts

@@ -0,0 +1,5 @@
+export * from './src/types/indexes.ts';
+export * from './src/types/service.ts';
+export * from './src/computed.ts';
+export * from './src/indexes.ts';
+export * from './src/util.ts';

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@travetto/model-indexed",
+  "version": "8.0.0-alpha.10",
+  "type": "module",
+  "description": "Basic indexing support for model sources that support it.",
+  "keywords": [
+    "datastore",
+    "indexing",
+    "typescript",
+    "travetto"
+  ],
+  "homepage": "https://travetto.io",
+  "license": "MIT",
+  "author": {
+    "email": "travetto.framework@gmail.com",
+    "name": "Travetto Framework"
+  },
+  "files": [
+    "__index__.ts",
+    "src",
+    "support"
+  ],
+  "main": "__index__.ts",
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/model-indexed"
+  },
+  "dependencies": {
+    "@travetto/model": "^8.0.0-alpha.10",
+    "@travetto/registry": "^8.0.0-alpha.10",
+    "@travetto/schema": "^8.0.0-alpha.10"
+  },
+  "peerDependencies": {
+    "@travetto/cli": "^8.0.0-alpha.15",
+    "@travetto/test": "^8.0.0-alpha.10"
+  },
+  "peerDependenciesMeta": {
+    "@travetto/cli": {
+      "optional": true
+    },
+    "@travetto/test": {
+      "optional": true
+    }
+  },
+  "travetto": {
+    "displayName": "Data Model Indexing Support"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/computed.ts

@@ -0,0 +1,149 @@
+import type { ModelType } from '@travetto/model';
+import { castTo, type Any } from '@travetto/runtime';
+
+import {
+  type KeyedIndexSelection, type SortedIndexSelection, type AllIndexes, type KeyedIndexBody, IndexedFieldError,
+  type FullKeyedIndexBody, type TemplateValue, type TemplatePart
+} from './types/indexes.ts';
+
+const DEFAULT_SEP = '\u8203';
+
+type IndexPart<T extends TemplateValue = TemplateValue> = {
+  state: 'missing' | 'empty' | 'mismatch' | 'found';
+  value: unknown;
+  path: string[];
+  templateValue: T;
+};
+
+function buildIndexParts<T extends TemplateValue = TemplateValue>(
+  template: TemplatePart<T>[],
+  body: Record<string, unknown> | undefined,
+  checkValueType?: (value: unknown) => boolean,
+): IndexPart<T>[] {
+  const out: IndexPart<T>[] = [];
+  for (const { path, value: templateValue } of template) {
+    let value: unknown = body;
+    let bodyPart: Pick<IndexPart, 'value' | 'state'> | undefined;
+    for (const pathItem of path) {
+      if (typeof value === 'object' && value !== null) {
+        if (value && pathItem in value) {
+          value = castTo<Record<string, unknown>>(value)[pathItem];
+        } else {
+          bodyPart = { value: undefined!, state: 'missing' };
+          break;
+        }
+      } else {
+        bodyPart = { value: undefined!, state: 'mismatch' };
+        break;
+      }
+    }
+    if (bodyPart === undefined) {
+      if (value === null || value === undefined) {
+        bodyPart = { value: null, state: 'empty' };
+      } else if (checkValueType && !checkValueType(value)) {
+        bodyPart = { value, state: 'mismatch' };
+      } else {
+        bodyPart = { value, state: 'found' };
+      }
+    }
+    out.push({ ...bodyPart, path, templateValue });
+  }
+  return out;
+}
+
+function validate<T extends ModelType>(idx: AllIndexes<T>, parts: IndexPart[]): void {
+  for (const { state, path } of parts) {
+    if (state === 'missing') {
+      throw new IndexedFieldError(idx.class, idx, path.join('.'), 'Missing field');
+    } else if (state === 'mismatch') {
+      throw new IndexedFieldError(idx.class, idx, path.join('.'), 'Field type mismatch');
+    }
+  }
+}
+
+type Body<T extends ModelType> = KeyedIndexBody<T, Any> | FullKeyedIndexBody<T, Any, Any> | Partial<T>;
+
+type IndexProcessConfig<T = {}> = T & { keyed?: boolean, sort?: boolean };
+
+export class ModelIndexedComputedIndex<T extends ModelType> {
+  static get<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    idx: AllIndexes<T, K, S>,
+    body: Body<T>,
+  ): ModelIndexedComputedIndex<T> {
+    return new ModelIndexedComputedIndex(idx, body);
+  }
+
+  keyedParts: IndexPart<true>[];
+  sortParts: IndexPart<-1 | 1>[];
+  idx: AllIndexes<T>;
+
+  constructor(
+    idx: AllIndexes<T>,
+    body: Body<T>,
+  ) {
+    this.idx = idx;
+    this.keyedParts = buildIndexParts(idx.keyTemplate, castTo(body));
+    this.sortParts = buildIndexParts(idx.sortTemplate, castTo(body), value => typeof value === 'number' || value instanceof Date);
+  }
+
+  get allParts(): IndexPart[] {
+    return [...this.keyedParts, ...this.sortParts];
+  }
+
+  validate(config: IndexProcessConfig = {}): this {
+    const { keyed = true, sort = false } = config;
+    if (keyed) {
+      validate(this.idx, this.keyedParts);
+    }
+    if (sort) {
+      validate(this.idx, this.sortParts);
+    }
+    return this;
+  }
+
+  getKey(config: IndexProcessConfig<{ sep?: string }> = {}): string {
+    const { keyed = true, sort = false, sep = DEFAULT_SEP } = config;
+    const parts = [keyed ? this.keyedParts : [], sort ? this.sortParts : []].flat();
+    return parts.map(({ value }) => value).map(value => `${value}`).join(sep);
+  }
+
+  getSort(): number {
+    const { value } = this.sortParts[0] ?? {};
+    const direction = (this.sortParts[0]?.templateValue ?? 1);
+    if (value instanceof Date) {
+      return value.getTime() * direction;
+    } else if (typeof value === 'number') {
+      return value * direction;
+    } else {
+      return 0;
+    }
+  }
+
+  project(config: IndexProcessConfig<{ emptyValue?: unknown }> = {}): Record<string, unknown> {
+    const { keyed = true, sort = false, emptyValue = null } = config;
+    const response: Record<string, unknown> = {};
+    if (keyed) {
+      for (const { path, value, state } of this.keyedParts) {
+        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] = state === 'empty' ? emptyValue : value;
+      }
+    }
+    if (sort) {
+      for (const { path, value, state } of this.sortParts) {
+        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] = state === 'empty' ? emptyValue : value;
+      }
+    }
+    return response;
+  }
+}

package/src/indexes.ts

@@ -0,0 +1,83 @@
+import { type ModelType, ModelRegistryIndex } from '@travetto/model';
+import { type Class, type Any, castTo } from '@travetto/runtime';
+
+import {
+  type AllIndexes, type KeyedIndexSelection, type KeyedIndex,
+  type SortedIndexSelection, type SortedIndex, type TemplatePart, type TemplateValue
+} from './types/indexes.ts';
+
+function buildTemplateParts<T extends TemplateValue = TemplateValue>(
+  part: 'key' | 'sort',
+  template: Record<string, unknown>,
+  prefix: string[] = [],
+): TemplatePart<T>[] {
+  const out: TemplatePart<T>[] = [];
+  for (const [key, value] of Object.entries(template)) {
+    const path = prefix.length ? [...prefix, key] : [key];
+    if (typeof value === 'object' && value !== null) {
+      out.push(...buildTemplateParts<T>(part, castTo(value), path));
+    } else {
+      out.push({ path, value: castTo<T>(value), part });
+    }
+  }
+  return out;
+}
+
+/**
+ * Defines a keyed index for a model
+ */
+export function keyedIndex<
+  T extends ModelType,
+  K extends KeyedIndexSelection<T>
+>(cls: Class<T>, config: { name: string, key: K }): KeyedIndex<T, K, {}> {
+  const { name, key } = config;
+  const keyTemplate = buildTemplateParts<true>('key', key);
+  const idx: KeyedIndex<T, K, {}> = {
+    type: 'indexed:keyed',
+    class: cls, name, unique: false,
+    key, keyTemplate, sort: {}, sortTemplate: []
+  };
+  ModelRegistryIndex.getForRegister(cls).register({ indices: { [idx.name]: idx } });
+  return idx;
+}
+
+/**
+ * Defines a unique index for a model
+ */
+export function uniqueIndex<
+  T extends ModelType,
+  K extends KeyedIndexSelection<T>
+>(cls: Class<T>, config: { name: string, key: K }): KeyedIndex<T, K, {}> {
+  const { name, key } = config;
+  const keyTemplate = buildTemplateParts<true>('key', key);
+  const idx: KeyedIndex<T, K, {}> = {
+    type: 'indexed:keyed',
+    class: cls, name, unique: true,
+    key, keyTemplate, sort: {}, sortTemplate: []
+  };
+  ModelRegistryIndex.getForRegister(cls).register({ indices: { [idx.name]: idx } });
+  return idx;
+}
+
+/**
+ * Defines a sorted index for a model
+ */
+export function sortedIndex<
+  T extends ModelType,
+  K extends KeyedIndexSelection<T>,
+  S extends SortedIndexSelection<T>
+>(cls: Class<T>, config: { name: string, key: K, sort: S }): SortedIndex<T, K, S> {
+  const { name, key, sort } = config;
+  const keyTemplate = buildTemplateParts<true>('key', key);
+  const sortTemplate = buildTemplateParts<1 | -1>('sort', sort);
+  const idx: SortedIndex<T, K, S> = {
+    type: 'indexed:sorted',
+    class: cls, name, key, sort,
+    keyTemplate, sortTemplate,
+  };
+  ModelRegistryIndex.getForRegister(cls).register({ indices: { [idx.name]: idx } });
+  return idx;
+}
+
+export const isModelIndexedIndex = <T extends ModelType>(idx: Any): idx is AllIndexes<T> =>
+  typeof idx === 'object' && idx !== null && 'type' in idx && typeof idx.type === 'string' && idx.type.startsWith('indexed:');

package/src/types/indexes.ts

@@ -0,0 +1,94 @@
+import type { ModelType, IndexConfig } from '@travetto/model';
+import { type IntrinsicType, type Any, type DeepPartial, RuntimeError, type Class } from '@travetto/runtime';
+
+type TypeProjection<T, V> = {
+  [P in keyof T]?:
+  (T[P] extends (IntrinsicType | undefined) ? (V | undefined) :
+    (T[P] extends Any[] ?
+      (TypeProjection<T[P][number], V> | null | undefined)[] :
+      TypeProjection<T[P], V>)
+  );
+};
+
+export type KeyedIndexSelection<T> = TypeProjection<T, true>;
+export type SortedIndexSelection<T> = TypeProjection<T, 1 | -1>;
+
+export type KeyedIndexBody<T, K> = {
+  [P in keyof K]: (P extends keyof T ?
+    (K[P] extends true | 1 | -1 ? T[P] :
+      (T[P] extends Any[] | null | undefined ? T[P] :
+        KeyedIndexBody<T[P], NonNullable<K[P]>>))
+    : never);
+};
+
+type Merge<A, B> = {
+  [K in keyof A | keyof B]: (K extends keyof A & keyof B ?
+    A[K] | B[K] : (K extends keyof B ?
+      B[K] : (K extends keyof A ?
+        A[K] : never
+      )
+    )
+  );
+};
+
+export type KeyedIndexWithPartialBody<T, K> = {
+  [P in keyof K]: (P extends keyof T ?
+    (K[P] extends true | 1 | -1 ? T[P] :
+      (T[P] extends Any[] | null | undefined ? T[P] :
+        // Recurse for nested objects
+        KeyedIndexWithPartialBody<T[P], NonNullable<K[P]>>)
+    )
+    : never);
+} &
+  // 2. All other fields in T (not in K) become OPTIONAL
+  DeepPartial<Omit<T, keyof K>>;
+
+
+export type FullKeyedIndexBody<T, K, S> = KeyedIndexBody<T, Merge<K, S>>;
+export type FullKeyedIndexWithPartialBody<T, K, S> = KeyedIndexWithPartialBody<T, Merge<K, S>>;
+
+export type TemplateValue = 1 | -1 | true;
+export type TemplatePart<T extends TemplateValue = TemplateValue> = { path: string[], value: T, part: 'key' | 'sort' };
+
+export interface KeyedIndex<
+  T extends ModelType,
+  K extends KeyedIndexSelection<T>,
+  S extends SortedIndexSelection<T>
+> extends IndexConfig<'indexed:keyed'> {
+  key: K;
+  sort: S;
+  unique: boolean;
+  keyTemplate: TemplatePart<true>[];
+  sortTemplate: TemplatePart<1 | -1>[];
+}
+
+export interface SortedIndex<
+  T extends ModelType,
+  K extends KeyedIndexSelection<T>,
+  S extends SortedIndexSelection<T>
+> extends IndexConfig<'indexed:sorted'> {
+  key: K;
+  sort: S;
+  keyTemplate: TemplatePart<true>[];
+  sortTemplate: TemplatePart<1 | -1>[];
+}
+
+export type SingleItemIndex<
+  T extends ModelType,
+  K extends KeyedIndexSelection<T> = Any,
+  S extends SortedIndexSelection<T> = Any
+> = KeyedIndex<T, K, S> | SortedIndex<T, K, S>;
+
+export type AllIndexes<
+  T extends ModelType,
+  K extends KeyedIndexSelection<T> = Any,
+  S extends SortedIndexSelection<T> = Any
+> = KeyedIndex<T, K, S> | SortedIndex<T, K, S>;
+
+export class IndexedFieldError<T extends ModelType> extends RuntimeError {
+  constructor(cls: Class<T>, idx: AllIndexes<T>, fieldPath: string, message: string) {
+    super(`${message}:  ${idx.name} on ${cls.name} at path ${fieldPath}`, {
+      details: { cls: cls.name, index: idx.name, fieldPath }
+    });
+  }
+}

package/src/types/service.ts

@@ -0,0 +1,96 @@
+import type { ModelType, ModelBasicSupport, OptionalId } from '@travetto/model';
+import type { Class } from '@travetto/runtime';
+import type {
+  KeyedIndexSelection, KeyedIndexBody, SortedIndexSelection, SortedIndex,
+  SingleItemIndex, FullKeyedIndexBody, FullKeyedIndexWithPartialBody
+} from './indexes.ts';
+
+export type ListPageOptions<O = string> = {
+  limit?: number;
+  offset?: O;
+};
+
+export type ListPageResult<T extends ModelType> = {
+  items: T[];
+  nextOffset?: string;
+};
+
+/**
+ * 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 to search against
+   * @param body The payload of fields needed to search
+   */
+  getByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): 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 to search against
+   * @param body The payload of fields needed to search
+   */
+  deleteByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<void>;
+
+  /**
+   * Upsert by index, allowing the index to act as a primary key
+   * @param cls The type to create for
+   * @param idx The index to use
+   * @param body The document to potentially store
+   */
+  upsertByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: OptionalId<T>): Promise<T>;
+
+  /**
+   * Update by index
+   * @param cls The type to update for
+   * @param idx The index to update by
+   * @param body The document to update
+   */
+  updateByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: T): Promise<T>;
+
+  /**
+   * Update partial by index
+   * @param cls The type to update for
+   * @param idx The index to update by
+   * @param body The partial document to update
+   */
+  updatePartialByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexWithPartialBody<T, K, S>): Promise<T>;
+
+  /**
+   * List entity by ranged index as defined by fields of idx
+   * @param cls The type to search by
+   * @param idx The index to search against
+   * @param body The payload of fields needed to search
+   * @param options The configuration for listing
+   */
+  listByIndex<
+    T extends ModelType,
+    S extends SortedIndexSelection<T>,
+    K extends KeyedIndexSelection<T>
+  >(cls: Class<T>, idx: SortedIndex<T, K, S>, body: KeyedIndexBody<T, K>, options?: ListPageOptions): Promise<ListPageResult<T>>;
+}

package/src/util.ts

@@ -0,0 +1,62 @@
+import { castTo, type Class, hasFunction } from '@travetto/runtime';
+import { type ModelType, type ModelCrudSupport, type OptionalId, NotFoundError } from '@travetto/model';
+
+import type { ModelIndexedSupport } from './types/service.ts';
+import type { KeyedIndexSelection, SingleItemIndex, SortedIndexSelection } from './types/indexes.ts';
+
+/**
+ * Utils for working with indexed model services
+ */
+export class ModelIndexedUtil {
+
+  /**
+   * Type guard for determining if service supports indexed operation
+   */
+  static isSupported = hasFunction<ModelIndexedSupport>('getByIndex');
+
+  /**
+   * Naive upsert by index
+   * @param service
+   * @param cls
+   * @param idx
+   * @param body
+   */
+  static async naiveUpsert<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(
+    service: ModelIndexedSupport & ModelCrudSupport,
+    cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: OptionalId<T>
+  ): Promise<T> {
+    try {
+      return await this.naiveUpdate(service, cls, idx, body);
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return await service.create(cls, body);
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  /**
+  * Naive update by index
+  * @param service
+  * @param cls
+  * @param idx
+  * @param body
+  */
+  static async naiveUpdate<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(
+    service: ModelIndexedSupport & ModelCrudSupport,
+    cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: OptionalId<T>
+  ): Promise<T> {
+    const { id } = await service.getByIndex(cls, idx, castTo(body));
+    body.id = id;
+    return await service.update(cls, castTo(body));
+  }
+}

package/support/doc.support.tsx

@@ -0,0 +1,27 @@
+/** @jsxImportSource @travetto/doc/support */
+import { d, type DocJSXElementByFn, type DocJSXElement, DocFileUtil } from '@travetto/doc';
+import { Runtime, toConcrete } from '@travetto/runtime';
+
+import type { ModelIndexedSupport } from '../src/types/service.ts';
+
+const toLink = (title: string, target: Function): DocJSXElementByFn<'CodeLink'> =>
+  d.codeLink(title, Runtime.getSourceFile(target), new RegExp(`\\binterface\\s+${target.name}`));
+
+export const Links = {
+  Indexed: toLink('Indexed', toConcrete<ModelIndexedSupport>()),
+};
+
+export const ModelIndexedTypes = (fn: Function): DocJSXElement[] => {
+  const { content } = DocFileUtil.readSource(fn);
+  const found: DocJSXElementByFn<'CodeLink'>[] = [];
+  const seen = new Set<string>();
+  for (const [, key] of content.matchAll(/Model(Indexed)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];
+      found.push(link);
+    }
+  }
+  return found.map(type => <li>{type}</li>);
+};

package/support/test/indexed.ts

@@ -0,0 +1,323 @@
+import assert from 'node:assert';
+
+import { Suite, Test } from '@travetto/test';
+import { Schema } from '@travetto/schema';
+import { castTo, TimeUtil } from '@travetto/runtime';
+import { Model, NotFoundError } from '@travetto/model';
+import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
+
+import type { ModelIndexedSupport } from '../../src/types/service.ts';
+import { keyedIndex, sortedIndex } from '../../src/indexes.ts';
+import { IndexedFieldError } from '../../__index__.ts';
+
+@Model('index_user')
+class User {
+  id: string;
+  name: string;
+}
+
+const userNameIndex = keyedIndex(User, {
+  name: 'userName',
+  key: { name: true }
+});
+
+@Model('index_user_2')
+class User2 {
+  id: string;
+  name: string;
+}
+
+@Model()
+class User3 {
+  id: string;
+  name: string;
+  age: number;
+  color?: string;
+}
+
+const userAgeIndex = sortedIndex(User3, {
+  name: 'userAge',
+  key: { name: true },
+  sort: { age: 1 }
+});
+const userAgeReversedIndex = sortedIndex(User3, {
+  name: 'userAgeReverse',
+  key: { name: true },
+  sort: { age: -1 }
+});
+const userAgeNoKeyIndex = sortedIndex(User3, {
+  name: 'userAgeNoKey',
+  key: {},
+  sort: { age: 1 }
+});
+
+@Schema()
+class Child {
+  name: string;
+  age: number;
+}
+
+@Model()
+class User4 {
+  id: string;
+  createdDate?: Date = new Date();
+  color: string;
+  child: Child;
+}
+
+const childAgeIndex = sortedIndex(User4, {
+  name: 'childAge',
+  key: { child: { name: true } },
+  sort: { child: { age: 1 } }
+});
+const nameCreatedIndex = sortedIndex(User4, {
+  name: 'nameCreated',
+  key: { child: { name: true } },
+  sort: { createdDate: 1 }
+});
+
+@Suite()
+export abstract class ModelIndexedSuite extends BaseModelSuite<ModelIndexedSupport> {
+
+  indexLimitSkew = 0;
+  supportsDeepIndexes = true;
+
+  @Test()
+  async writeAndRead() {
+    const service = await this.service;
+
+    await service.create(User, User.from({ name: 'bob1' }));
+    await service.create(User, User.from({ name: 'bob2' }));
+
+    const found1 = await service.getByIndex(User, userNameIndex, {
+      name: 'bob1'
+    });
+
+    assert(found1.name === 'bob1');
+
+    const found2 = await service.getByIndex(User, userNameIndex, {
+      name: 'bob2'
+    });
+
+    assert(found2.name === 'bob2');
+  }
+
+  @Test()
+  async readMissingValue() {
+    const service = await this.service;
+    await assert.rejects(() => service.getByIndex(User, userNameIndex, { name: 'jim' }), NotFoundError);
+  }
+
+  @Test()
+  async readDifferentType() {
+    const service = await this.service;
+    await assert.rejects(() => service.getByIndex(User2, userNameIndex, { name: 'jim' }), NotFoundError);
+  }
+
+  @Test()
+  async queryMultiple() {
+    const service = await this.service;
+
+    await service.create(User3, User3.from({ name: 'bob', age: 20 }));
+    await service.create(User3, User3.from({ name: 'bob', age: 30, color: 'green' }));
+
+    const found = await service.getByIndex(User3, userAgeIndex, { name: 'bob', age: 30 });
+
+    assert(found.color === 'green');
+
+    const found2 = await service.getByIndex(User3, userAgeIndex, { name: 'bob', age: 20 });
+
+    assert(!found2.color);
+
+    // @ts-expect-error
+    await assert.rejects(() => service.getByIndex(User3, userAgeIndex, { name: 'bob' }), IndexedFieldError);
+  }
+
+  @Test()
+  async queryList() {
+    const service = await this.service;
+
+    await service.create(User3, User3.from({ name: 'bob', age: 40, color: 'blue' }));
+    await service.create(User3, User3.from({ name: 'bob', age: 30, color: 'red' }));
+    await service.create(User3, User3.from({ name: 'bob', age: 50, color: 'green' }));
+
+    const { items: arr } = await service.listByIndex(User3, userAgeIndex, { name: 'bob' });
+
+    console.error(arr);
+
+    assert(arr[0].color === 'red');
+    assert(arr[0].name === 'bob');
+    assert(arr[1].color === 'blue');
+    assert(arr[1].name === 'bob');
+    assert(arr[2].color === 'green');
+    assert(arr[2].name === 'bob');
+
+    // @ts-expect-error
+    await assert.rejects(() => service.listByIndex(User3, userAgeIndex, {}), IndexedFieldError);
+  }
+
+  @Test()
+  async queryListNoSelectedKeys() {
+    const service = await this.service;
+
+    await service.create(User3, User3.from({ name: 'charlie', age: 40, color: 'blue' }));
+    await service.create(User3, User3.from({ name: 'alice', age: 30, color: 'red' }));
+    await service.create(User3, User3.from({ name: 'bob', age: 50, color: 'green' }));
+
+    const { items: arr } = await service.listByIndex(User3, userAgeNoKeyIndex, {});
+
+    assert(arr[0].name === 'alice' && arr[0].age === 30);
+    assert(arr[1].name === 'charlie' && arr[1].age === 40);
+    assert(arr[2].name === 'bob' && arr[2].age === 50);
+
+    const found = await service.getByIndex(User3, userAgeNoKeyIndex, { age: 40 });
+    assert(found.name === 'charlie');
+
+    // @ts-expect-error
+    await assert.rejects(() => service.getByIndex(User3, userAgeNoKeyIndex, {}), IndexedFieldError);
+  }
+
+  @Test({ skip: (self) => !castTo<ModelIndexedSuite>(self).supportsDeepIndexes })
+  async queryDeepList() {
+    const service = await this.service;
+
+    await service.create(User4, User4.from({ child: { name: 'bob', age: 40 }, color: 'blue' }));
+    await service.create(User4, User4.from({ child: { name: 'bob', age: 30 }, color: 'red' }));
+    await service.create(User4, User4.from({ child: { name: 'bob', age: 50 }, color: 'green' }));
+
+    const { items: arr } = await service.listByIndex(User4, childAgeIndex, { child: { name: 'bob' } });
+    assert(arr[0].color === 'red' && arr[0].child.name === 'bob' && arr[0].child.age === 30);
+    assert(arr[1].color === 'blue' && arr[1].child.name === 'bob' && arr[1].child.age === 40);
+    assert(arr[2].color === 'green' && arr[2].child.name === 'bob' && arr[2].child.age === 50);
+
+    // @ts-expect-error
+    await assert.rejects(() => service.listByIndex(User4, childAgeIndex, {}), IndexedFieldError);
+  }
+
+  @Test({ skip: (self) => !castTo<ModelIndexedSuite>(self).supportsDeepIndexes })
+  async queryComplexDateList() {
+    const service = await this.service;
+
+    await service.create(User4, User4.from({ child: { name: 'bob', age: 40 }, createdDate: TimeUtil.fromNow('3d'), color: 'blue' }));
+    await service.create(User4, User4.from({ child: { name: 'bob', age: 30 }, createdDate: TimeUtil.fromNow('2d'), color: 'red' }));
+    await service.create(User4, User4.from({ child: { name: 'bob', age: 50 }, createdDate: TimeUtil.fromNow('-1d'), color: 'green' }));
+
+    const { items: arr } = await service.listByIndex(User4, nameCreatedIndex, { child: { name: 'bob' } });
+
+    assert(arr[0].color === 'green' && arr[0].child.name === 'bob' && arr[0].child.age === 50);
+    assert(arr[1].color === 'red' && arr[1].child.name === 'bob' && arr[1].child.age === 30);
+    assert(arr[2].color === 'blue' && arr[2].child.name === 'bob' && arr[2].child.age === 40);
+
+    // @ts-expect-error
+    await assert.rejects(() => service.listByIndex(User4, nameCreatedIndex, {}), IndexedFieldError);
+  }
+
+  @Test()
+  async upsertByIndex() {
+    const service = await this.service;
+
+    const user1 = await service.upsertByIndex(User3, userAgeIndex, { name: 'bob', age: 40, color: 'blue' });
+    const user2 = await service.upsertByIndex(User3, userAgeIndex, { name: 'bob', age: 40, color: 'green' });
+    const user3 = await service.upsertByIndex(User3, userAgeIndex, { name: 'bob', age: 40, color: 'red' });
+
+    const { items: arr } = await service.listByIndex(User3, userAgeIndex, { name: 'bob' });
+    assert(arr.length === 1);
+
+    assert(user1.id === user2.id);
+    assert(user2.id === user3.id);
+    assert(user1.color === 'blue');
+    assert(user3.color === 'red');
+
+    const user4 = await service.upsertByIndex(User3, userAgeIndex, { name: 'bob', age: 30, color: 'red' });
+    const { items: arr2 } = await service.listByIndex(User3, userAgeIndex, { name: 'bob' });
+    assert(arr2.length === 2);
+
+    await service.deleteByIndex(User3, userAgeIndex, user1);
+
+    const { items: arr3 } = await service.listByIndex(User3, userAgeIndex, { name: 'bob' });
+    assert(arr3.length === 1);
+    assert(arr3[0].id === user4.id);
+  }
+
+  @Test()
+  async updateByIndex() {
+    const service = await this.service;
+
+    const created = await service.create(User3, User3.from({ name: 'alice', age: 25, color: 'blue' }));
+
+    const updated = await service.updateByIndex(User3, userAgeIndex, { ...created, color: 'red' });
+
+    assert(updated.id === created.id);
+    assert(updated.name === 'alice');
+    assert(updated.age === 25);
+    assert(updated.color === 'red');
+
+    const found = await service.getByIndex(User3, userAgeIndex, { name: 'alice', age: 25 });
+    assert(found.color === 'red');
+  }
+
+  @Test()
+  async updatePartialByIndex() {
+    const service = await this.service;
+
+    const created = await service.create(User3, User3.from({ name: 'carol', age: 35, color: 'green' }));
+
+    const updated = await service.updatePartialByIndex(User3, userAgeIndex, { name: 'carol', age: 35, color: 'yellow' });
+
+    assert(updated.id === created.id);
+    assert(updated.name === 'carol');
+    assert(updated.age === 35);
+    assert(updated.color === 'yellow');
+
+    const found = await service.getByIndex(User3, userAgeIndex, { name: 'carol', age: 35 });
+    assert(found.color === 'yellow');
+  }
+
+  @Test()
+  async paginateByIndex() {
+    const service = await this.service;
+
+    const allColors = 'abcdefghijklmnopqrstuvwxyzABCDEFGHJIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_=+,<.>/?;:\'"[{]}|`~'.repeat(2).split('');
+
+    for (const [i, color] of allColors.entries()) {
+      await service.create(User3, User3.from({ name: 'page', age: (i + 1) * 10, color }));
+    }
+
+    const limit = 7;
+    const items: string[] = [];
+    let offset: string | undefined;
+
+    do {
+      const page = await service.listByIndex(User3, userAgeIndex, { name: 'page' }, { limit, offset });
+      items.push(...page.items.map(u => u.color!));
+      offset = page.nextOffset;
+    } while (offset);
+
+    assert(items.length === allColors.length);
+    assert.deepEqual(items, allColors);
+  }
+
+  @Test()
+  async paginateByIndexReverse() {
+    const service = await this.service;
+
+    const allColors = 'abcdefghijklmnopqrstuvwxyzABCDEFGHJIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_=+,<.>/?;:\'"[{]}|`~'.repeat(2).split('');
+
+    for (const [i, color] of allColors.entries()) {
+      await service.create(User3, User3.from({ name: 'page', age: (i + 1) * 10, color }));
+    }
+
+    const limit = 7;
+    const items: string[] = [];
+    let offset: string | undefined;
+
+    do {
+      const page = await service.listByIndex(User3, userAgeReversedIndex, { name: 'page' }, { limit, offset });
+      items.push(...page.items.map(u => u.color!));
+      offset = page.nextOffset;
+    } while (offset);
+
+    assert(items.length === allColors.length);
+    assert.deepEqual(items, allColors.toReversed());
+  }
+}

package/support/test/polymorphism.ts

@@ -0,0 +1,116 @@
+import assert from 'node:assert';
+
+import { Suite, Test } from '@travetto/test';
+import { castTo } from '@travetto/runtime';
+import { Discriminated } from '@travetto/schema';
+import { Model, NotFoundError, SubTypeNotSupportedError } from '@travetto/model';
+
+import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
+
+import type { ModelIndexedSupport } from '../../src/types/service.ts';
+import { ModelIndexedUtil } from '../../src/util.ts';
+import { keyedIndex } from '../../src/indexes.ts';
+
+@Model()
+@Discriminated('type')
+export class IndexedWorker {
+  id: string;
+  type: string;
+  name: string;
+  age?: number;
+}
+
+const workerNameIndex = keyedIndex(IndexedWorker, {
+  name: 'worker-name',
+  key: { name: true, age: true }
+});
+
+@Model()
+export class IndexedDoctor extends IndexedWorker {
+  specialty: string;
+}
+
+@Model()
+export class IndexedFirefighter extends IndexedWorker {
+  firehouse: number;
+}
+
+@Model()
+export class IndexedEngineer extends IndexedWorker {
+  major: string;
+}
+
+@Suite()
+export abstract class ModelIndexedPolymorphismSuite extends BaseModelSuite<ModelIndexedSupport> {
+
+  @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, workerNameIndex, {
+      age: now,
+      name: 'rob'
+    });
+
+    assert(result instanceof IndexedFirefighter);
+
+    try {
+      const res2 = await service.getByIndex(IndexedFirefighter, workerNameIndex, {
+        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, workerNameIndex, {
+      age: now,
+      name: 'bob'
+    });
+
+    assert(await this.getSize(IndexedWorker) === 2);
+    assert(await this.getSize(IndexedDoctor) === 0);
+
+    try {
+      await service.deleteByIndex(IndexedFirefighter, workerNameIndex, {
+        age: now,
+        name: 'rob'
+      });
+    } catch (err) {
+      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError);
+    }
+
+    try {
+      await service.deleteByIndex(IndexedEngineer, workerNameIndex, {
+        age: now,
+        name: 'bob'
+      });
+    } catch (err) {
+      assert(err instanceof SubTypeNotSupportedError || err instanceof NotFoundError);
+    }
+  }
+}