@travetto/model-sql 8.0.0-alpha.1 → 8.0.0-alpha.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sql",
-  "version": "8.0.0-alpha.1",
+  "version": "8.0.0-alpha.11",
   "type": "module",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
@@ -28,14 +28,15 @@
     "directory": "module/model-sql"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.1",
-    "@travetto/context": "^8.0.0-alpha.1",
-    "@travetto/model": "^8.0.0-alpha.1",
-    "@travetto/model-query": "^8.0.0-alpha.1"
+    "@travetto/config": "^8.0.0-alpha.10",
+    "@travetto/context": "^8.0.0-alpha.10",
+    "@travetto/model": "^8.0.0-alpha.10",
+    "@travetto/model-indexed": "^8.0.0-alpha.11",
+    "@travetto/model-query": "^8.0.0-alpha.10"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.1",
-    "@travetto/test": "^8.0.0-alpha.1"
+    "@travetto/cli": "^8.0.0-alpha.15",
+    "@travetto/test": "^8.0.0-alpha.10"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/dialect/base.ts

@@ -1,8 +1,9 @@
 /* eslint-disable @stylistic/indent */
 import { DataUtil, type SchemaFieldConfig, SchemaRegistryIndex, type Point } from '@travetto/schema';
 import { type Class, RuntimeError, TypedObject, TimeUtil, castTo, castKey, toConcrete, JSONUtil } from '@travetto/runtime';
-import { type SelectClause, type Query, type SortClause, type WhereClause, type RetainQueryPrimitiveFields, ModelQueryUtil } from '@travetto/model-query';
-import type { BulkResponse, IndexConfig, ModelType } from '@travetto/model';
+import { type SelectClause, type Query, type SortClause, type WhereClause, type RetainQueryPrimitiveFields, ModelQueryUtil, isModelQueryIndex } from '@travetto/model-query';
+import { IndexNotSupported, type BulkResponse, type IndexConfig, type ModelType } from '@travetto/model';
+import { isModelIndexedIndex } from '@travetto/model-indexed';
 
 import { SQLModelUtil } from '../util.ts';
 import type { DeleteWrapper, InsertWrapper, DialectState } from '../internal/types.ts';
@@ -717,14 +718,14 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
   /**
    * Get all create indices need for a given class
    */
-  getCreateAllIndicesSQL<T extends ModelType>(cls: Class<T>, indices: IndexConfig<T>[]): string[] {
-    return indices.map(idx => this.getCreateIndexSQL(cls, idx));
+  getCreateAllIndicesSQL<T extends ModelType>(cls: Class<T>, indices: IndexConfig[]): string[] {
+    return indices.map(idx => this.getCreateIndexSQL(cls, idx)).filter((sql): sql is string => !!sql);
   }
 
   /**
    * Get index name
    */
-  getIndexName<T extends ModelType>(cls: Class<T>, idx: IndexConfig<ModelType>): string {
+  getIndexName<T extends ModelType>(cls: Class<T>, idx: IndexConfig): string {
     const table = this.namespace(SQLModelUtil.classToStack(cls));
     return ['idx', table, idx.name.toLowerCase().replaceAll('-', '_')].join('_');
   }
@@ -732,26 +733,43 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
   /**
    * Get CREATE INDEX sql
    */
-  getCreateIndexSQL<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T>): string {
+  getCreateIndexSQL<T extends ModelType>(cls: Class<T>, idx: IndexConfig): string | undefined {
+    const constraint = this.getIndexName(cls, idx);
     const table = this.namespace(SQLModelUtil.classToStack(cls));
-    const fields: [string, boolean][] = idx.fields.map(field => {
-      const key = TypedObject.keys(field)[0];
-      const value = field[key];
-      if (DataUtil.isPlainObject(value)) {
-        throw new Error('Unable to supported nested fields for indices');
+
+    if (isModelQueryIndex(idx)) {
+      const fields: [string, boolean][] = idx.fields.map(field => {
+        const key = TypedObject.keys(field)[0];
+        const value = field[key];
+        if (DataUtil.isPlainObject(value)) {
+          throw new IndexNotSupported(cls, idx, 'Only indexed and query indices are supported in SQL');
+        }
+        return [castTo(key), typeof value === 'number' ? value === 1 : (!!value)];
+      });
+      return `CREATE ${idx.type === 'query:unique' ? 'UNIQUE ' : ''}INDEX ${constraint} ON ${this.identifier(table)} (${fields
+        .map(([name, sel]) => `${this.identifier(name)} ${sel ? 'ASC' : 'DESC'}`)
+        .join(', ')});`;
+    } else if (isModelIndexedIndex(idx)) {
+      if ([...idx.sortTemplate, ...idx.keyTemplate].find(field => field.path.length > 1)) {
+        console.debug('Nested fields are not supported in ModelIndexed indices SQL', { index: idx.name });
+        return;
       }
-      return [castTo(key), typeof value === 'number' ? value === 1 : (!!value)];
-    });
-    const constraint = this.getIndexName(cls, idx);
-    return `CREATE ${idx.type === 'unique' ? 'UNIQUE ' : ''}INDEX ${constraint} ON ${this.identifier(table)} (${fields
-      .map(([name, sel]) => `${this.identifier(name)} ${sel ? 'ASC' : 'DESC'}`)
-      .join(', ')});`;
+      const fields = [...idx.sortTemplate, ...idx.keyTemplate]
+        .map(({ path, value }) => `${this.identifier(path.join('_'))} ${value === -1 ? 'DESC' : 'ASC'}`)
+        .join(', ');
+      switch (idx.type) {
+        case 'indexed:keyed': return `CREATE ${idx.unique ? 'UNIQUE ' : ''}INDEX ${constraint} ON ${this.identifier(table)} (${fields});`;
+        case 'indexed:sorted': return `CREATE INDEX ${constraint} ON ${this.identifier(table)} (${fields});`;
+      }
+    } else {
+      throw new IndexNotSupported(cls, idx, 'Only indexed and query indices are supported in SQL');
+    }
   }
 
   /**
    * Get DROP INDEX sql
    */
-  getDropIndexSQL<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string): string {
+  getDropIndexSQL<T extends ModelType>(cls: Class<T>, idx: IndexConfig | string): string {
     const constraint = typeof idx === 'string' ? idx : this.getIndexName(cls, idx);
     return `DROP INDEX ${this.identifier(constraint)} ;`;
   }
@@ -1074,18 +1092,25 @@ ${this.getWhereSQL(cls, where!)}`;
   /**
    * Determine if an index has changed
    */
-  isIndexChanged(requested: IndexConfig<ModelType>, existing: SQLTableDescription['indices'][number]): boolean {
-    let result =
-      (existing.is_unique && requested.type !== 'unique')
-      || requested.fields.length !== existing.columns.length;
-
-    for (let i = 0; i < requested.fields.length && !result; i++) {
-      const [[key, value]] = Object.entries(requested.fields[i]);
-      const desc = value === -1;
-      result ||= key !== existing.columns[i].name && desc !== existing.columns[i].desc;
-    }
+  isIndexChanged(requested: IndexConfig, existing: SQLTableDescription['indices'][number]): boolean {
+    if (isModelQueryIndex(requested)) {
+      let result =
+        (existing.is_unique && requested.type !== 'query:unique')
+        || requested.fields.length !== existing.columns.length;
+
+      for (let i = 0; i < requested.fields.length && !result; i++) {
+        const [[key, value]] = Object.entries(requested.fields[i]);
+        const desc = value === -1;
+        result ||= key !== existing.columns[i].name && desc !== existing.columns[i].desc;
+      }
 
-    return result;
+      return result;
+    } else if (isModelIndexedIndex(requested)) {
+      // TODO: Fill this out
+      return false;
+    } else {
+      throw new IndexNotSupported(requested.class, requested, 'Only indexed and query indices are supported in SQL');
+    }
   }
 
   /**

package/src/service.ts

@@ -1,10 +1,14 @@
 import {
   type ModelType,
-  type BulkOperation, type BulkResponse, type ModelCrudSupport, type ModelStorageSupport, type ModelBulkSupport,
-  NotFoundError, ModelRegistryIndex, ExistsError, type OptionalId, type ModelIdSource,
-  ModelExpiryUtil, ModelCrudUtil, ModelStorageUtil, ModelBulkUtil,
+  type BulkOperation, type BulkResponse, type ModelCrudSupport, type ModelStorageSupport, type ModelBulkSupport, NotFoundError,
+  ModelRegistryIndex, ExistsError, type OptionalId, type ModelIdSource, ModelExpiryUtil, ModelCrudUtil, ModelStorageUtil, ModelBulkUtil,
 } from '@travetto/model';
-import { castTo, type Class } from '@travetto/runtime';
+import {
+  type ModelIndexedSupport, type KeyedIndexSelection, type KeyedIndexBody, type ListPageOptions, ModelIndexedUtil,
+  type SingleItemIndex, type SortedIndexSelection, type ListPageResult, type SortedIndex, type FullKeyedIndexBody,
+  type FullKeyedIndexWithPartialBody, ModelIndexedComputedIndex
+} from '@travetto/model-indexed';
+import { castTo, type Class, JSONUtil } from '@travetto/runtime';
 import { DataUtil } from '@travetto/schema';
 import type { AsyncContext } from '@travetto/context';
 import { Injectable, PostConstruct } from '@travetto/di';
@@ -33,6 +37,7 @@ export class SQLModelService implements
   ModelCrudSupport, ModelStorageSupport,
   ModelBulkSupport, ModelQuerySupport,
   ModelQueryCrudSupport, ModelQueryFacetSupport,
+  ModelIndexedSupport,
   ModelQuerySuggestSupport {
 
   #manager: TableManager;
@@ -326,4 +331,114 @@ export class SQLModelService implements
       return result;
     });
   }
+
+  // Indexed support
+  @Connected()
+  async 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> {
+    const computed = ModelIndexedComputedIndex.get(idx, body).validate({ sort: true });
+    const results = await this.query(cls, castTo({ where: computed.project({ sort: true, includeId: true }) }));
+    if (results.length !== 1) {
+      throw new NotFoundError(`${cls.name}: ${idx}`, computed.getKey({ sort: true }));
+    }
+    return results[0];
+  }
+
+  @Connected()
+  @Transactional()
+  async 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> {
+    const computed = ModelIndexedComputedIndex.get(idx, body).validate({ sort: true });
+    const count = await this.deleteByQuery(cls, castTo({ where: computed.project({ sort: true, includeId: true }) }));
+    if (count === 0) {
+      throw new NotFoundError(`${cls.name}: ${idx}`, computed.getKey({ sort: true }));
+    }
+  }
+
+  @Connected()
+  @Transactional()
+  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> {
+    return ModelIndexedUtil.naiveUpsert(this, cls, idx, body);
+  }
+
+  @Connected()
+  @Transactional()
+  updateByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: T): Promise<T> {
+    return ModelIndexedUtil.naiveUpdate(this, cls, idx, body);
+  }
+
+  @Connected()
+  @Transactional()
+  async 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> {
+    const item = await ModelCrudUtil.naivePartialUpdate(cls, () => this.getByIndex(cls, idx, castTo(body)), castTo(body));
+    return this.update(cls, item);
+  }
+
+  @Connected()
+  async pageByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(
+    cls: Class<T>,
+    idx: SortedIndex<T, K, S>,
+    body: KeyedIndexBody<T, K>,
+    options?: ListPageOptions
+  ): Promise<ListPageResult<T>> {
+    const offset = options?.offset ? JSONUtil.fromBase64<number>(options.offset) : 0;
+    const limit = options?.limit ?? 100;
+    const computed = ModelIndexedComputedIndex.get(idx, body).validate();
+
+    const items = await this.query(cls, castTo({
+      where: computed.project(),
+      sort: idx.sortTemplate.map(part => ({ [part.path.join('.')]: part.value })),
+      limit, offset
+    }));
+    return { items, nextOffset: items.length ? JSONUtil.toBase64(offset + items.length) : undefined };
+  }
+
+  @ConnectedIterator()
+  async * listByIndex<
+    T extends ModelType,
+    K extends KeyedIndexSelection<T>,
+    S extends SortedIndexSelection<T>
+  >(
+    cls: Class<T>,
+    idx: SortedIndex<T, K, S>,
+    body: KeyedIndexBody<T, K>,
+  ): AsyncIterable<T> {
+    const computed = ModelIndexedComputedIndex.get(idx, body).validate();
+    let offset = 0;
+    while (offset >= 0) {
+      const items = await this.query(cls, castTo({
+        where: computed.project(),
+        sort: idx.sortTemplate.map(part => ({ [part.path.join('.')]: part.value })),
+        limit: 100, offset
+      }));
+      if (items.length === 0) {
+        offset = -1;
+      } else {
+        offset += items.length;
+        yield* items;
+      }
+    }
+  }
 }

package/src/table-manager.ts

@@ -45,7 +45,7 @@ export class TableManager {
     for (const command of this.#dialect.getCreateAllTablesSQL(cls)) {
       out.push(command);
     }
-    const indices = ModelRegistryIndex.getConfig(cls).indices;
+    const indices = ModelRegistryIndex.getIndices(cls);
     if (indices) {
       for (const command of this.#dialect.getCreateAllIndicesSQL(cls, indices)) {
         out.push(command);
@@ -64,7 +64,8 @@ export class TableManager {
       const existingFields = new Map(found?.columns.map(column => [column.name, column]) ?? []);
       const existingIndices = new Map(found?.indices.map(index => [index.name, index]) ?? []);
       const model = path.length === 1 ? ModelRegistryIndex.getConfig(type) : undefined;
-      const requestedIndices = new Map((model?.indices ?? []).map(index => [this.#dialect.getIndexName(type, index), index]) ?? []);
+      const indices = model ? ModelRegistryIndex.getIndices(type) : undefined;
+      const requestedIndices = new Map((indices ?? []).map(index => [this.#dialect.getIndexName(type, index), index]) ?? []);
 
       // Manage fields
       if (!existingFields.size) {
@@ -98,10 +99,16 @@ export class TableManager {
       // Manage indices
       for (const index of requestedIndices.keys()) {
         if (!existingIndices.has(index)) {
-          sqlCommands.createIndex.push(this.#dialect.getCreateIndexSQL(type, requestedIndices.get(index)!));
+          const sql = this.#dialect.getCreateIndexSQL(type, requestedIndices.get(index)!);
+          if (sql) {
+            sqlCommands.createIndex.push(sql);
+          }
         } else if (this.#dialect.isIndexChanged(requestedIndices.get(index)!, existingIndices.get(index)!)) {
           sqlCommands.dropIndex.push(this.#dialect.getDropIndexSQL(type, existingIndices.get(index)!.name));
-          sqlCommands.createIndex.push(this.#dialect.getCreateIndexSQL(type, requestedIndices.get(index)!));
+          const sql = this.#dialect.getCreateIndexSQL(type, requestedIndices.get(index)!);
+          if (sql) {
+            sqlCommands.createIndex.push(sql);
+          }
         }
       }