@travetto/model-sql 6.0.0-rc.1 → 6.0.0-rc.3

package/__index__.ts

@@ -1,5 +1,7 @@
-export * from './src/config';
-export * from './src/service';
-export * from './src/connection/base';
-export * from './src/connection/decorator';
-export * from './src/dialect/base';
+export * from './src/config.ts';
+export * from './src/service.ts';
+export * from './src/connection/base.ts';
+export * from './src/connection/decorator.ts';
+export * from './src/dialect/base.ts';
+export * from './src/util.ts';
+export * from './src/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sql",
-  "version": "6.0.0-rc.1",
+  "version": "6.0.0-rc.3",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
     "sql",
@@ -27,14 +27,14 @@
     "directory": "module/model-sql"
   },
   "dependencies": {
-    "@travetto/cli": "^6.0.0-rc.1",
-    "@travetto/config": "^6.0.0-rc.1",
-    "@travetto/context": "^6.0.0-rc.1",
-    "@travetto/model": "^6.0.0-rc.1",
-    "@travetto/model-query": "^6.0.0-rc.1"
+    "@travetto/cli": "^6.0.0-rc.3",
+    "@travetto/config": "^6.0.0-rc.2",
+    "@travetto/context": "^6.0.0-rc.2",
+    "@travetto/model": "^6.0.0-rc.2",
+    "@travetto/model-query": "^6.0.0-rc.2"
   },
   "peerDependencies": {
-    "@travetto/test": "^6.0.0-rc.1"
+    "@travetto/test": "^6.0.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/connection/decorator.ts

@@ -1,5 +1,5 @@
 import { AsyncItrMethodDescriptor, AsyncMethodDescriptor } from '@travetto/runtime';
-import { Connection, TransactionType } from './base';
+import { Connection, TransactionType } from './base.ts';
 
 /**
  * Indicating something is aware of connections

package/src/dialect/base.ts

@@ -1,15 +1,15 @@
 /* eslint-disable @stylistic/indent */
-import { DataUtil, SchemaRegistry, FieldConfig, Schema } from '@travetto/schema';
-import { Class, AppError, TypedObject, TimeUtil, castTo, castKey } from '@travetto/runtime';
-import { SelectClause, Query, SortClause, WhereClause, RetainFields } from '@travetto/model-query';
-import { BulkResponse, IndexConfig } from '@travetto/model';
-import { PointImpl } from '@travetto/model-query/src/internal/model/point';
-import { ModelType } from '@travetto/model/src/types/model';
-import { ModelQueryUtil } from '@travetto/model-query/src/internal/service/query';
-
-import { SQLUtil, VisitStack } from '../internal/util';
-import { DeleteWrapper, InsertWrapper, DialectState } from '../internal/types';
-import { Connection } from '../connection/base';
+import { DataUtil, SchemaRegistry, FieldConfig, Schema, type Point } from '@travetto/schema';
+import { Class, AppError, TypedObject, TimeUtil, castTo, castKey, toConcrete } from '@travetto/runtime';
+import { SelectClause, Query, SortClause, WhereClause, RetainFields, ModelQueryUtil } from '@travetto/model-query';
+import { BulkResponse, IndexConfig, ModelType } from '@travetto/model';
+
+import { SQLModelUtil } from '../util.ts';
+import { DeleteWrapper, InsertWrapper, DialectState } from '../internal/types.ts';
+import { Connection } from '../connection/base.ts';
+import { VisitStack } from '../types.ts';
+
+const PointImpl = toConcrete<Point>();
 
 interface Alias {
   alias: string;
@@ -269,7 +269,7 @@ export abstract class SQLDialect implements DialectState {
    * Delete query and return count removed
    */
   async deleteAndGetCount<T>(cls: Class<T>, query: Query<T>): Promise<number> {
-    const { count } = await this.executeSQL<T>(this.getDeleteSQL(SQLUtil.classToStack(cls), query.where));
+    const { count } = await this.executeSQL<T>(this.getDeleteSQL(SQLModelUtil.classToStack(cls), query.where));
     return count;
   }
 
@@ -307,7 +307,7 @@ export abstract class SQLDialect implements DialectState {
    * Determine table/field namespace for a given stack location
    */
   namespace(stack: VisitStack[]): string {
-    return `${this.ns}${SQLUtil.buildTable(stack)}`;
+    return `${this.ns}${SQLModelUtil.buildTable(stack)}`;
   }
 
   /**
@@ -358,7 +358,7 @@ export abstract class SQLDialect implements DialectState {
     const clauses = new Map<string, Alias>();
     let idx = 0;
 
-    SQLUtil.visitSchemaSync(SchemaRegistry.get(cls), {
+    SQLModelUtil.visitSchemaSync(SchemaRegistry.get(cls), {
       onRoot: ({ descend, path }) => {
         const table = resolve(path);
         clauses.set(table, { alias: this.rootAlias, path });
@@ -396,7 +396,7 @@ export abstract class SQLDialect implements DialectState {
    */
   getWhereFieldSQL(stack: VisitStack[], o: Record<string, unknown>): string {
     const items = [];
-    const { foreignMap, localMap } = SQLUtil.getFieldsByLocation(stack);
+    const { foreignMap, localMap } = SQLModelUtil.getFieldsByLocation(stack);
     const SQL_OPS = this.SQL_OPS;
 
     for (const key of Object.keys(o)) {
@@ -533,7 +533,7 @@ export abstract class SQLDialect implements DialectState {
     } else if (ModelQueryUtil.has$Not(o)) {
       return `${SQL_OPS.$not} (${this.getWhereGroupingSQL<T>(cls, o.$not)})`;
     } else {
-      return this.getWhereFieldSQL(SQLUtil.classToStack(cls), o);
+      return this.getWhereFieldSQL(SQLModelUtil.classToStack(cls), o);
     }
   }
 
@@ -552,7 +552,7 @@ export abstract class SQLDialect implements DialectState {
   getOrderBySQL<T>(cls: Class<T>, sortBy?: SortClause<T>[]): string {
     return !sortBy ?
       '' :
-      `ORDER BY ${SQLUtil.orderBy(cls, sortBy).map((ob) =>
+      `ORDER BY ${SQLModelUtil.orderBy(cls, sortBy).map((ob) =>
         `${this.resolveName(ob.stack)} ${ob.asc ? 'ASC' : 'DESC'}`
       ).join(', ')}`;
   }
@@ -561,8 +561,8 @@ export abstract class SQLDialect implements DialectState {
    * Generate SELECT clause
    */
   getSelectSQL<T>(cls: Class<T>, select?: SelectClause<T>): string {
-    const stack = SQLUtil.classToStack(cls);
-    const columns = select && SQLUtil.select(cls, select).map((sel) => this.resolveName([...stack, sel]));
+    const stack = SQLModelUtil.classToStack(cls);
+    const columns = select && SQLModelUtil.select(cls, select).map((sel) => this.resolveName([...stack, sel]));
     if (columns) {
       columns.unshift(this.alias(this.pathField));
     }
@@ -575,10 +575,10 @@ export abstract class SQLDialect implements DialectState {
    * Generate FROM clause
    */
   getFromSQL<T>(cls: Class<T>): string {
-    const stack = SQLUtil.classToStack(cls);
+    const stack = SQLModelUtil.classToStack(cls);
     const aliases = this.getAliasCache(stack, this.namespace);
-    const tables = [...aliases.keys()].sort((a, b) => a.length - b.length); // Shortest first
-    return `FROM ${tables.map((table, i) => {
+    const tables = [...aliases.keys()].toSorted((a, b) => a.length - b.length); // Shortest first
+    return `FROM ${tables.map((table) => {
       const { alias, path } = aliases.get(table)!;
       let from = `${this.ident(table)} ${alias}`;
       if (path.length > 1) {
@@ -605,25 +605,26 @@ LEFT OUTER JOIN ${from} ON
   /**
    * Generate GROUP BY clause
    */
-  getGroupBySQL<T>(cls: Class<T>, query?: Query<T>): string {
-    return `GROUP BY ${this.alias(this.idField)}`;
+  getGroupBySQL<T>(cls: Class<T>, query: Query<T>): string {
+    const sortFields = !query.sort ?
+      '' :
+      SQLModelUtil.orderBy(cls, query.sort)
+        .map(x => this.resolveName(x.stack))
+        .join(', ');
+
+    // TODO: Really confused on this
+    return `GROUP BY ${this.alias(this.idField)}${sortFields ? `, ${sortFields}` : ''}`;
   }
 
   /**
    * Generate full query
    */
   getQuerySQL<T>(cls: Class<T>, query: Query<T>, where?: WhereClause<T>): string {
-    const sortFields = !query.sort ?
-      '' :
-      SQLUtil.orderBy(cls, query.sort)
-        .map(x => this.resolveName(x.stack))
-        .join(', ');
-
     return `
 ${this.getSelectSQL(cls, query.select)}
 ${this.getFromSQL(cls)}
 ${this.getWhereSQL(cls, where)}
-${this.getGroupBySQL(cls, query)}${sortFields ? `, ${sortFields}` : ''}
+${this.getGroupBySQL(cls, query)}
 ${this.getOrderBySQL(cls, query.sort)}
 ${this.getLimitSQL(cls, query)}`;
   }
@@ -633,7 +634,7 @@ ${this.getLimitSQL(cls, query)}`;
     const parent = stack.length > 1;
     const array = parent && config.array;
     const fields = SchemaRegistry.has(config.type) ?
-      [...SQLUtil.getFieldsByLocation(stack).local] :
+      [...SQLModelUtil.getFieldsByLocation(stack).local] :
       (array ? [castTo<FieldConfig>(config)] : []);
 
     if (!parent) {
@@ -687,7 +688,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
    */
   getCreateAllTablesSQL(cls: Class): string[] {
     const out: string[] = [];
-    SQLUtil.visitSchemaSync(SchemaRegistry.get(cls), {
+    SQLModelUtil.visitSchemaSync(SchemaRegistry.get(cls), {
       onRoot: ({ path, descend }) => { out.push(this.getCreateTableSQL(path)); descend(); },
       onSub: ({ path, descend }) => { out.push(this.getCreateTableSQL(path)); descend(); },
       onSimple: ({ path }) => out.push(this.getCreateTableSQL(path))
@@ -706,7 +707,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
    * Get CREATE INDEX sql
    */
   getCreateIndexSQL<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T>): string {
-    const table = this.namespace(SQLUtil.classToStack(cls));
+    const table = this.namespace(SQLModelUtil.classToStack(cls));
     const fields: [string, boolean][] = idx.fields.map(x => {
       const key = TypedObject.keys(x)[0];
       const val = x[key];
@@ -726,7 +727,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
    */
   getDropAllTablesSQL<T extends ModelType>(cls: Class<T>): string[] {
     const out: string[] = [];
-    SQLUtil.visitSchemaSync(SchemaRegistry.get(cls), {
+    SQLModelUtil.visitSchemaSync(SchemaRegistry.get(cls), {
       onRoot: ({ path, descend }) => { descend(); out.push(this.getDropTableSQL(path)); },
       onSub: ({ path, descend }) => { descend(); out.push(this.getDropTableSQL(path)); },
       onSimple: ({ path }) => out.push(this.getDropTableSQL(path))
@@ -739,7 +740,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
    */
   getTruncateAllTablesSQL<T extends ModelType>(cls: Class<T>): string[] {
     const out: string[] = [];
-    SQLUtil.visitSchemaSync(SchemaRegistry.get(cls), {
+    SQLModelUtil.visitSchemaSync(SchemaRegistry.get(cls), {
       onRoot: ({ path, descend }) => { descend(); out.push(this.getTruncateTableSQL(path)); },
       onSub: ({ path, descend }) => { descend(); out.push(this.getTruncateTableSQL(path)); },
       onSimple: ({ path }) => out.push(this.getTruncateTableSQL(path))
@@ -752,9 +753,9 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
    */
   getInsertSQL(stack: VisitStack[], instances: InsertWrapper['records']): string | undefined {
     const config = stack[stack.length - 1];
-    const columns = SQLUtil.getFieldsByLocation(stack).local
+    const columns = SQLModelUtil.getFieldsByLocation(stack).local
       .filter(x => !SchemaRegistry.has(x.type))
-      .sort((a, b) => a.name.localeCompare(b.name));
+      .toSorted((a, b) => a.name.localeCompare(b.name));
     const columnNames = columns.map(c => c.name);
 
     const hasParent = stack.length > 1;
@@ -801,13 +802,13 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
     for (let i = 0; i < matrix.length; i++) {
       const { stack: elStack } = instances[i];
       if (hasParent) {
-        matrix[i].push(this.hash(`${SQLUtil.buildPath(elStack)}${isArray ? `[${i + idx}]` : ''}`));
-        matrix[i].push(this.hash(SQLUtil.buildPath(elStack.slice(0, elStack.length - 1))));
+        matrix[i].push(this.hash(`${SQLModelUtil.buildPath(elStack)}${isArray ? `[${i + idx}]` : ''}`));
+        matrix[i].push(this.hash(SQLModelUtil.buildPath(elStack.slice(0, elStack.length - 1))));
         if (isArray) {
           matrix[i].push(this.resolveValue(this.idxField, i + idx));
         }
       } else {
-        matrix[i].push(this.hash(SQLUtil.buildPath(elStack)));
+        matrix[i].push(this.hash(SQLModelUtil.buildPath(elStack)));
       }
     }
 
@@ -823,7 +824,7 @@ ${matrix.map(row => `(${row.join(', ')})`).join(',\n')};`;
   getAllInsertSQL<T extends ModelType>(cls: Class<T>, instance: T): string[] {
     const out: string[] = [];
     const add = (text?: string): void => { text && out.push(text); };
-    SQLUtil.visitSchemaInstance(cls, instance, {
+    SQLModelUtil.visitSchemaInstance(cls, instance, {
       onRoot: ({ value, path }) => add(this.getInsertSQL(path, [{ stack: path, value }])),
       onSub: ({ value, path }) => add(this.getInsertSQL(path, [{ stack: path, value }])),
       onSimple: ({ value, path }) => add(this.getInsertSQL(path, [{ stack: path, value }]))
@@ -836,7 +837,7 @@ ${matrix.map(row => `(${row.join(', ')})`).join(',\n')};`;
    */
   getUpdateSQL(stack: VisitStack[], data: Record<string, unknown>, where?: WhereClause<unknown>): string {
     const { type } = stack[stack.length - 1];
-    const { localMap } = SQLUtil.getFieldsByLocation(stack);
+    const { localMap } = SQLModelUtil.getFieldsByLocation(stack);
     return `
 UPDATE ${this.table(stack)} ${this.rootAlias}
 SET
@@ -888,9 +889,9 @@ ${this.getWhereSQL(cls, where!)}`;
     const selectStack: (SelectClause<T> | undefined)[] = [];
 
     const buildSet = (children: unknown[], field?: FieldConfig): Record<string, unknown> =>
-      SQLUtil.collectDependents(this, stack[stack.length - 1], children, field);
+      SQLModelUtil.collectDependents(this, stack[stack.length - 1], children, field);
 
-    await SQLUtil.visitSchema(SchemaRegistry.get(cls), {
+    await SQLModelUtil.visitSchema(SchemaRegistry.get(cls), {
       onRoot: async (config) => {
         const res = buildSet(items); // Already filtered by initial select query
         selectStack.push(select);

package/src/internal/types.ts

@@ -1,5 +1,6 @@
-import { FieldConfig, ClassConfig } from '@travetto/schema';
-import { VisitStack } from './util';
+import type { FieldConfig, ClassConfig } from '@travetto/schema';
+
+import { VisitStack } from '../types.ts';
 
 /**
  * Insertion wrapper

package/src/service.ts

@@ -1,8 +1,8 @@
 import {
   ModelType,
   BulkOp, BulkResponse, ModelCrudSupport, ModelStorageSupport, ModelBulkSupport,
-  NotFoundError, ModelRegistry, ExistsError, OptionalId,
-  ModelIdSource
+  NotFoundError, ModelRegistry, ExistsError, OptionalId, ModelIdSource,
+  ModelExpiryUtil, ModelCrudUtil, ModelStorageUtil, ModelBulkUtil,
 } from '@travetto/model';
 import { castTo, Class } from '@travetto/runtime';
 import { DataUtil, SchemaChange } from '@travetto/schema';
@@ -10,25 +10,18 @@ import { AsyncContext } from '@travetto/context';
 import { Injectable } from '@travetto/di';
 import {
   ModelQuery, ModelQueryCrudSupport, ModelQueryFacetSupport, ModelQuerySupport,
-  PageableModelQuery, ValidStringFields, WhereClauseRaw, QueryVerifier
+  PageableModelQuery, ValidStringFields, WhereClauseRaw, QueryVerifier, ModelQuerySuggestSupport,
+  ModelQueryUtil, ModelQuerySuggestUtil, ModelQueryCrudUtil,
+  ModelQueryFacet,
 } from '@travetto/model-query';
 
-import { ModelQueryUtil } from '@travetto/model-query/src/internal/service/query';
-import { ModelQuerySuggestUtil } from '@travetto/model-query/src/internal/service/suggest';
-import { ModelQueryExpiryUtil } from '@travetto/model-query/src/internal/service/expiry';
-import { ModelExpiryUtil } from '@travetto/model/src/internal/service/expiry';
-import { ModelCrudUtil } from '@travetto/model/src/internal/service/crud';
-import { ModelStorageUtil } from '@travetto/model/src/internal/service/storage';
-import { ModelQuerySuggestSupport } from '@travetto/model-query/src/service/suggest';
-import { ModelBulkUtil } from '@travetto/model/src/internal/service/bulk';
-
-import { SQLModelConfig } from './config';
-import { Connected, ConnectedIterator, Transactional } from './connection/decorator';
-import { SQLUtil } from './internal/util';
-import { SQLDialect } from './dialect/base';
-import { TableManager } from './table-manager';
-import { Connection } from './connection/base';
-import { InsertWrapper } from './internal/types';
+import { SQLModelConfig } from './config.ts';
+import { Connected, ConnectedIterator, Transactional } from './connection/decorator.ts';
+import { SQLModelUtil } from './util.ts';
+import { SQLDialect } from './dialect/base.ts';
+import { TableManager } from './table-manager.ts';
+import { Connection } from './connection/base.ts';
+import { InsertWrapper } from './internal/types.ts';
 
 /**
  * Core for SQL Model Source.  Should not have any direct queries,
@@ -75,7 +68,7 @@ export class SQLModelService implements
     const all = toCheck.size ?
       (await this.#exec<ModelType>(
         this.#dialect.getSelectRowsByIdsSQL(
-          SQLUtil.classToStack(cls), [...toCheck.keys()], [this.#dialect.idField]
+          SQLModelUtil.classToStack(cls), [...toCheck.keys()], [this.#dialect.idField]
         )
       )).records : [];
 
@@ -190,9 +183,9 @@ export class SQLModelService implements
 
   @Connected()
   async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
-    const res = await this.query(cls, { where: castTo({ id }) });
-    if (res.length === 1) {
-      return await ModelCrudUtil.load(cls, res[0]);
+    const result = await this.query(cls, { where: castTo({ id }) });
+    if (result.length === 1) {
+      return await ModelCrudUtil.load(cls, result[0]);
     }
     throw new NotFoundError(cls, id);
   }
@@ -225,9 +218,9 @@ export class SQLModelService implements
       operations.map(x => x[k]).filter((x): x is Required<BulkOp<T>>[K] => !!x);
 
     const getStatements = async (k: keyof BulkOp<T>): Promise<InsertWrapper[]> =>
-      (await SQLUtil.getInserts(cls, get(k))).filter(x => !!x.records.length);
+      (await SQLModelUtil.getInserts(cls, get(k))).filter(x => !!x.records.length);
 
-    const deletes = [{ stack: SQLUtil.classToStack(cls), ids: get('delete').map(x => x.id) }].filter(x => !!x.ids.length);
+    const deletes = [{ stack: SQLModelUtil.classToStack(cls), ids: get('delete').map(x => x.id) }].filter(x => !!x.ids.length);
 
     const [inserts, upserts, updates] = await Promise.all([
       getStatements('insert'),
@@ -235,15 +228,15 @@ export class SQLModelService implements
       getStatements('update')
     ]);
 
-    const ret = await this.#dialect.bulkProcess(deletes, inserts, upserts, updates);
-    ret.insertedIds = addedIds;
-    return ret;
+    const result = await this.#dialect.bulkProcess(deletes, inserts, upserts, updates);
+    result.insertedIds = addedIds;
+    return result;
   }
 
   // Expiry
   @Transactional()
   async deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number> {
-    return ModelQueryExpiryUtil.deleteExpired(this, cls);
+    return ModelQueryCrudUtil.deleteExpired(this, cls);
   }
 
   @Connected()
@@ -254,7 +247,7 @@ export class SQLModelService implements
       await this.#dialect.fetchDependents(cls, res, query && query.select);
     }
 
-    const cleaned = SQLUtil.cleanResults<T>(this.#dialect, res);
+    const cleaned = SQLModelUtil.cleanResults<T>(this.#dialect, res);
     return await Promise.all(cleaned.map(m => ModelCrudUtil.load(cls, m)));
   }
 
@@ -286,7 +279,7 @@ export class SQLModelService implements
   async updatePartialByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, data: Partial<T>): Promise<number> {
     await QueryVerifier.verify(cls, query);
     const item = await ModelCrudUtil.prePartialUpdate(cls, data);
-    const { count } = await this.#exec(this.#dialect.getUpdateSQL(SQLUtil.classToStack(cls), item, ModelQueryUtil.getWhereClause(cls, query.where)));
+    const { count } = await this.#exec(this.#dialect.getUpdateSQL(SQLModelUtil.classToStack(cls), item, ModelQueryUtil.getWhereClause(cls, query.where)));
     return count;
   }
 
@@ -294,7 +287,7 @@ export class SQLModelService implements
   @Transactional()
   async deleteByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
     await QueryVerifier.verify(cls, query);
-    const { count } = await this.#exec(this.#dialect.getDeleteSQL(SQLUtil.classToStack(cls), ModelQueryUtil.getWhereClause(cls, query.where, false)));
+    const { count } = await this.#exec(this.#dialect.getDeleteSQL(SQLModelUtil.classToStack(cls), ModelQueryUtil.getWhereClause(cls, query.where, false)));
     return count;
   }
 
@@ -317,7 +310,7 @@ export class SQLModelService implements
   }
 
   @Connected()
-  async facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<{ key: string, count: number }[]> {
+  async facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]> {
     await QueryVerifier.verify(cls, query);
     const col = this.#dialect.ident(field);
     const ttl = this.#dialect.ident('count');

package/src/table-manager.ts

@@ -4,10 +4,10 @@ import { Class } from '@travetto/runtime';
 import { ChangeEvent } from '@travetto/registry';
 import { SchemaChange } from '@travetto/schema';
 
-import { Connected, Transactional } from './connection/decorator';
-import { SQLDialect } from './dialect/base';
-import { SQLUtil, VisitStack } from './internal/util';
-import { Connection } from './connection/base';
+import { Connected, Transactional } from './connection/decorator.ts';
+import { SQLDialect } from './dialect/base.ts';
+import { SQLModelUtil, VisitStack } from './util.ts';
+import { Connection } from './connection/base.ts';
 
 /**
  * Manage creation/updating of all tables
@@ -109,7 +109,7 @@ export class TableManager {
   @Connected()
   async changeSchema(cls: Class, change: SchemaChange): Promise<void> {
     try {
-      const rootStack = SQLUtil.classToStack(cls);
+      const rootStack = SQLModelUtil.classToStack(cls);
 
       const changes = change.subs.reduce<Record<ChangeEvent<unknown>['type'], VisitStack[][]>>((acc, v) => {
         const path = v.path.map(f => ({ ...f }));

package/src/types.ts

@@ -0,0 +1,11 @@
+import { Class } from '@travetto/runtime';
+
+export const TableSymbol = Symbol.for('@travetto/model-sql:table');
+
+export type VisitStack = {
+  [TableSymbol]?: string;
+  array?: boolean;
+  type: Class;
+  name: string;
+  index?: number;
+};

package/src/{internal/util.ts → util.ts}

@@ -2,19 +2,9 @@ import { castKey, castTo, Class, TypedObject } from '@travetto/runtime';
 import { SelectClause, SortClause } from '@travetto/model-query';
 import { ModelRegistry, ModelType, OptionalId } from '@travetto/model';
 import { SchemaRegistry, ClassConfig, FieldConfig, DataUtil } from '@travetto/schema';
-import { AllViewSymbol } from '@travetto/schema/src/internal/types';
 
-import { DialectState, InsertWrapper, VisitHandler, VisitState, VisitInstanceNode, OrderBy } from './types';
-
-const TableSymbol = Symbol.for('@travetto/model-sql:table');
-
-export type VisitStack = {
-  [TableSymbol]?: string;
-  array?: boolean;
-  type: Class;
-  name: string;
-  index?: number;
-};
+import { DialectState, InsertWrapper, VisitHandler, VisitState, VisitInstanceNode, OrderBy } from './internal/types.ts';
+import { TableSymbol, VisitStack } from './types.ts';
 
 type FieldCacheEntry = {
   local: FieldConfig[];
@@ -26,7 +16,7 @@ type FieldCacheEntry = {
 /**
  * Utilities for dealing with SQL operations
  */
-export class SQLUtil {
+export class SQLModelUtil {
 
   static SCHEMA_FIELDS_CACHE = new Map<Class, FieldCacheEntry>();
 
@@ -79,14 +69,14 @@ export class SQLUtil {
     }
 
     const model = ModelRegistry.get(cls.class)!;
-    const conf = cls.views[AllViewSymbol];
+    const conf = cls.totalView;
     const fields = conf.fields.map(x => ({ ...conf.schema[x] }));
 
     // Polymorphic
     if (model && (model.baseType ?? model.subType)) {
       const fieldMap = new Set(fields.map(f => f.name));
       for (const type of ModelRegistry.getClassesByBaseType(ModelRegistry.getBaseModel(cls.class))) {
-        const typeConf = SchemaRegistry.get(type).views[AllViewSymbol];
+        const typeConf = SchemaRegistry.get(type).totalView;
         for (const f of typeConf.fields) {
           if (!fieldMap.has(f)) {
             fieldMap.add(f);
@@ -232,7 +222,7 @@ export class SQLUtil {
       if (typeof k === 'string' && !DataUtil.isPlainObject(select[k]) && localMap[k]) {
         if (!v) {
           if (toGet.size === 0) {
-            toGet = new Set(SchemaRegistry.get(cls).views[AllViewSymbol].fields);
+            toGet = new Set(SchemaRegistry.get(cls).totalView.fields);
           }
           toGet.delete(k);
         } else {
@@ -254,7 +244,7 @@ export class SQLUtil {
       while (!found) {
         const key = Object.keys(cl)[0];
         const val = cl[key];
-        const field = { ...schema.views[AllViewSymbol].schema[key] };
+        const field = { ...schema.totalView.schema[key] };
         if (DataUtil.isPrimitive(val)) {
           stack.push(field);
           found = { stack, asc: val === 1 };
@@ -315,7 +305,7 @@ export class SQLUtil {
    * Build property path for a table/field given the current stack
    */
   static buildPath(list: VisitStack[]): string {
-    return list.map((el, i) => `${el.name}${el.index ? `[${el.index}]` : ''}`).join('.');
+    return list.map((el) => `${el.name}${el.index ? `[${el.index}]` : ''}`).join('.');
   }
 
   /**
@@ -338,7 +328,7 @@ export class SQLUtil {
 
     await Promise.all(all);
 
-    const ret = [...Object.values(ins)].sort((a, b) => a.stack.length - b.stack.length);
-    return ret;
+    const result = [...Object.values(ins)].toSorted((a, b) => a.stack.length - b.stack.length);
+    return result;
   }
 }

package/support/test/query.ts

@@ -3,10 +3,10 @@ import assert from 'node:assert';
 import { Schema, FieldConfig } from '@travetto/schema';
 import { Suite, Test } from '@travetto/test';
 import { castTo } from '@travetto/runtime';
-import { BaseModelSuite } from '@travetto/model/support/test/base';
+import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
-import { VisitStack } from '../../src/internal/util';
-import { SQLModelService } from '../../src/service';
+import { VisitStack } from '../../src/types.ts';
+import { SQLModelService } from '../../src/service.ts';
 
 @Schema()
 class User {