@travetto/model-sql 6.0.1 → 7.0.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sql",
-  "version": "6.0.1",
+  "version": "7.0.0-rc.0",
   "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.1",
-    "@travetto/config": "^6.0.1",
-    "@travetto/context": "^6.0.1",
-    "@travetto/model": "^6.0.1",
-    "@travetto/model-query": "^6.0.1"
+    "@travetto/cli": "^7.0.0-rc.0",
+    "@travetto/config": "^7.0.0-rc.0",
+    "@travetto/context": "^7.0.0-rc.0",
+    "@travetto/model": "^7.0.0-rc.0",
+    "@travetto/model-query": "^7.0.0-rc.0"
   },
   "peerDependencies": {
-    "@travetto/test": "^6.0.2"
+    "@travetto/test": "^7.0.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/connection/decorator.ts

@@ -10,6 +10,7 @@ export interface ConnectionAware<C = unknown> {
 
 /**
  * Decorator to ensure a method runs with a valid connection
+ * @kind decorator
  */
 export function Connected() {
   return function <T extends { conn?: Connection }>(
@@ -24,6 +25,7 @@ export function Connected() {
 
 /**
  * Decorator to ensure a method runs with a valid connection
+ * @kind decorator
  */
 export function ConnectedIterator() {
   return function <T extends { conn?: Connection }>(
@@ -38,6 +40,7 @@ export function ConnectedIterator() {
 
 /**
  * Decorator to ensure a method runs with a valid transaction
+ * @kind decorator
  */
 export function Transactional(mode: TransactionType = 'required') {
   return function <T extends { conn?: Connection }>(

package/src/dialect/base.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @stylistic/indent */
-import { DataUtil, SchemaRegistry, FieldConfig, Schema, type Point } from '@travetto/schema';
+import { DataUtil, SchemaFieldConfig, Schema, SchemaRegistryIndex, 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 { SelectClause, Query, SortClause, WhereClause, RetainQueryPrimitiveFields, ModelQueryUtil } from '@travetto/model-query';
 import { BulkResponse, IndexConfig, ModelType } from '@travetto/model';
 
 import { SQLModelUtil } from '../util.ts';
@@ -21,9 +21,10 @@ class Total {
   total: number;
 }
 
-function makeField(name: string, type: Class, required: boolean, extra: Partial<FieldConfig>): FieldConfig {
+function makeField(name: string, type: Class, required: boolean, extra: Partial<SchemaFieldConfig>): SchemaFieldConfig {
   return {
     name,
+    owner: null!,
     type,
     array: false,
     ...(required ? { required: { active: true } } : {}),
@@ -98,6 +99,8 @@ export abstract class SQLDialect implements DialectState {
     DECIMAL: (d, p) => `DECIMAL(${d},${p})`
   };
 
+  ID_AFFIX = '`';
+
   /**
    * Generate an id field
    */
@@ -160,7 +163,14 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Identify a name or field (escape it)
    */
-  abstract ident(name: string | FieldConfig): string;
+  ident(field: SchemaFieldConfig | string | symbol): string {
+    if (field === '*') {
+      return field;
+    } else {
+      const name = (typeof field === 'symbol' || typeof field === 'string') ? field : field.name;
+      return `${this.ID_AFFIX}${name.toString()}${this.ID_AFFIX}`;
+    }
+  }
 
   quote(text: string): string {
     return `'${text.replace(/[']/g, "''")}'`;
@@ -179,7 +189,7 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Convert value to SQL valid representation
    */
-  resolveValue(conf: FieldConfig, value: unknown): string {
+  resolveValue(conf: SchemaFieldConfig, value: unknown): string {
     if (value === undefined || value === null) {
       return 'NULL';
     } else if (conf.type === String) {
@@ -204,13 +214,13 @@ export abstract class SQLDialect implements DialectState {
     } else if (conf.type === Object) {
       return this.quote(JSON.stringify(value).replace(/[']/g, "''"));
     }
-    throw new AppError(`Unknown value type for field ${conf.name}, ${value}`, { category: 'data' });
+    throw new AppError(`Unknown value type for field ${conf.name.toString()}, ${value}`, { category: 'data' });
   }
 
   /**
    * Get column type from field config
    */
-  getColumnType(conf: FieldConfig): string {
+  getColumnType(conf: SchemaFieldConfig): string {
     let type: string = '';
 
     if (conf.type === Number) {
@@ -257,12 +267,12 @@ export abstract class SQLDialect implements DialectState {
   /**
    * FieldConfig to Column definition
    */
-  getColumnDefinition(conf: FieldConfig): string | undefined {
+  getColumnDefinition(conf: SchemaFieldConfig): string | undefined {
     const type = this.getColumnType(conf);
     if (!type) {
       return;
     }
-    return `${this.ident(conf)} ${type} ${(conf.required && conf.required.active) ? 'NOT NULL' : 'DEFAULT NULL'}`;
+    return `${this.ident(conf)} ${type} ${(conf.required?.active !== false) ? 'NOT NULL' : 'DEFAULT NULL'}`;
   }
 
   /**
@@ -294,7 +304,7 @@ export abstract class SQLDialect implements DialectState {
    * Add a sql column
    */
   getAddColumnSQL(stack: VisitStack[]): string {
-    const field: FieldConfig = castTo(stack.at(-1));
+    const field: SchemaFieldConfig = castTo(stack.at(-1));
     return `ALTER TABLE ${this.parentTable(stack)} ADD COLUMN ${this.getColumnDefinition(field)};`;
   }
 
@@ -341,7 +351,7 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Alias a field for usage
    */
-  alias(field: string | FieldConfig, alias: string = this.rootAlias): string {
+  alias(field: string | symbol | SchemaFieldConfig, alias: string = this.rootAlias): string {
     return `${alias}.${this.ident(field)}`;
   }
 
@@ -358,7 +368,7 @@ export abstract class SQLDialect implements DialectState {
     const clauses = new Map<string, Alias>();
     let idx = 0;
 
-    SQLModelUtil.visitSchemaSync(SchemaRegistry.get(cls), {
+    SQLModelUtil.visitSchemaSync(SchemaRegistryIndex.getConfig(cls), {
       onRoot: ({ descend, path }) => {
         const table = resolve(path);
         clauses.set(table, { alias: this.rootAlias, path });
@@ -366,12 +376,12 @@ export abstract class SQLDialect implements DialectState {
       },
       onSub: ({ descend, config, path }) => {
         const table = resolve(path);
-        clauses.set(table, { alias: `${config.name.charAt(0)}${idx++}`, path });
+        clauses.set(table, { alias: `${config.name.toString().charAt(0)}${idx++}`, path });
         return descend();
       },
       onSimple: ({ config, path }) => {
         const table = resolve(path);
-        clauses.set(table, { alias: `${config.name.charAt(0)}${idx++}`, path });
+        clauses.set(table, { alias: `${config.name.toString().charAt(0)}${idx++}`, path });
       }
     });
 
@@ -406,10 +416,11 @@ export abstract class SQLDialect implements DialectState {
         throw new Error(`Unknown field: ${key}`);
       }
       const sStack = [...stack, field];
-      if (key in foreignMap && field.array && !SchemaRegistry.has(field.type)) {
+      if (key in foreignMap && field.array && !SchemaRegistryIndex.has(field.type)) {
         // If dealing with simple external
         sStack.push({
           name: field.name,
+          owner: null!,
           type: field.type
         });
       }
@@ -633,9 +644,9 @@ ${this.getLimitSQL(cls, query)}`;
     const config = stack.at(-1)!;
     const parent = stack.length > 1;
     const array = parent && config.array;
-    const fields = SchemaRegistry.has(config.type) ?
+    const fields = SchemaRegistryIndex.has(config.type) ?
       [...SQLModelUtil.getFieldsByLocation(stack).local] :
-      (array ? [castTo<FieldConfig>(config)] : []);
+      (array ? [castTo<SchemaFieldConfig>(config)] : []);
 
     if (!parent) {
       let idField = fields.find(x => x.name === this.idField.name);
@@ -688,7 +699,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
    */
   getCreateAllTablesSQL(cls: Class): string[] {
     const out: string[] = [];
-    SQLModelUtil.visitSchemaSync(SchemaRegistry.get(cls), {
+    SQLModelUtil.visitSchemaSync(SchemaRegistryIndex.getConfig(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))
@@ -727,7 +738,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
    */
   getDropAllTablesSQL<T extends ModelType>(cls: Class<T>): string[] {
     const out: string[] = [];
-    SQLModelUtil.visitSchemaSync(SchemaRegistry.get(cls), {
+    SQLModelUtil.visitSchemaSync(SchemaRegistryIndex.getConfig(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))
@@ -740,7 +751,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
    */
   getTruncateAllTablesSQL<T extends ModelType>(cls: Class<T>): string[] {
     const out: string[] = [];
-    SQLModelUtil.visitSchemaSync(SchemaRegistry.get(cls), {
+    SQLModelUtil.visitSchemaSync(SchemaRegistryIndex.getConfig(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))
@@ -754,8 +765,8 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
   getInsertSQL(stack: VisitStack[], instances: InsertWrapper['records']): string | undefined {
     const config = stack.at(-1)!;
     const columns = SQLModelUtil.getFieldsByLocation(stack).local
-      .filter(x => !SchemaRegistry.has(x.type))
-      .toSorted((a, b) => a.name.localeCompare(b.name));
+      .filter(x => !SchemaRegistryIndex.has(x.type))
+      .toSorted((a, b) => a.name.toString().localeCompare(b.name.toString()));
     const columnNames = columns.map(c => c.name);
 
     const hasParent = stack.length > 1;
@@ -787,7 +798,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
       return;
     }
 
-    const matrix = instances.map(inst => columns.map(c => this.resolveValue(c, castTo<Record<string, unknown>>(inst.value)[c.name])));
+    const matrix = instances.map(inst => columns.map(c => this.resolveValue(c, castTo<Record<string | symbol, unknown>>(inst.value)[c.name])));
 
     columnNames.push(this.pathField.name);
     if (hasParent) {
@@ -859,11 +870,11 @@ ${this.getWhereSQL(type, where)};`;
   /**
   * Get elements by ids
   */
-  getSelectRowsByIdsSQL(stack: VisitStack[], ids: string[], select: FieldConfig[] = []): string {
+  getSelectRowsByIdsSQL(stack: VisitStack[], ids: string[], select: SchemaFieldConfig[] = []): string {
     const config = stack.at(-1)!;
     const orderBy = !config.array ?
       '' :
-      `ORDER BY ${this.rootAlias}.${this.idxField.name} ASC`;
+      `ORDER BY ${this.rootAlias}.${this.idxField.name.toString()} ASC`;
 
     const idField = (stack.length > 1 ? this.parentPathField : this.idField);
 
@@ -888,10 +899,10 @@ ${this.getWhereSQL(cls, where!)}`;
     const stack: Record<string, unknown>[] = [];
     const selectStack: (SelectClause<T> | undefined)[] = [];
 
-    const buildSet = (children: unknown[], field?: FieldConfig): Record<string, unknown> =>
+    const buildSet = (children: unknown[], field?: SchemaFieldConfig): Record<string, unknown> =>
       SQLModelUtil.collectDependents(this, stack.at(-1)!, children, field);
 
-    await SQLModelUtil.visitSchema(SchemaRegistry.get(cls), {
+    await SQLModelUtil.visitSchema(SchemaRegistryIndex.getConfig(cls), {
       onRoot: async (config) => {
         const res = buildSet(items); // Already filtered by initial select query
         selectStack.push(select);
@@ -902,11 +913,11 @@ ${this.getWhereSQL(cls, where!)}`;
         const top = stack.at(-1)!;
         const ids = Object.keys(top);
         const selectTop = selectStack.at(-1)!;
-        const fieldKey = castKey<RetainFields<T>>(config.name);
+        const fieldKey = castKey<RetainQueryPrimitiveFields<T>>(config.name);
         const subSelectTop: SelectClause<T> | undefined = castTo(selectTop?.[fieldKey]);
 
         // See if a selection exists at all
-        const sel: FieldConfig[] = subSelectTop ? fields
+        const sel: SchemaFieldConfig[] = subSelectTop ? fields
           .filter(f => typeof subSelectTop === 'object' && subSelectTop[castTo<typeof fieldKey>(f.name)] === 1)
           : [];
 
@@ -990,10 +1001,10 @@ ${this.getWhereSQL(cls, where!)}`;
 
       await Promise.all([
         ...upserts.filter(x => x.stack.length === 1).map(i =>
-          this.deleteByIds(i.stack, i.records.map(v => castTo<Record<string, string>>(v.value)[idx]))
+          this.deleteByIds(i.stack, i.records.map(v => castTo<Record<string | symbol, string>>(v.value)[idx]))
         ),
         ...updates.filter(x => x.stack.length === 1).map(i =>
-          this.deleteByIds(i.stack, i.records.map(v => castTo<Record<string, string>>(v.value)[idx]))
+          this.deleteByIds(i.stack, i.records.map(v => castTo<Record<string | symbol, string>>(v.value)[idx]))
         ),
       ]);
     }

package/src/internal/types.ts

@@ -1,4 +1,4 @@
-import type { FieldConfig, ClassConfig } from '@travetto/schema';
+import type { SchemaFieldConfig, SchemaClassConfig } from '@travetto/schema';
 
 import { VisitStack } from '../types.ts';
 
@@ -22,10 +22,10 @@ export interface DeleteWrapper {
  * Dialect state
  */
 export interface DialectState {
-  pathField: FieldConfig;
-  parentPathField: FieldConfig;
-  idField: FieldConfig;
-  idxField: FieldConfig;
+  pathField: SchemaFieldConfig;
+  parentPathField: SchemaFieldConfig;
+  idField: SchemaFieldConfig;
+  idxField: SchemaFieldConfig;
 }
 
 export type VisitState = { path: VisitStack[] };
@@ -35,7 +35,7 @@ export type VisitState = { path: VisitStack[] };
  */
 export interface VisitNode<R> {
   path: VisitStack[];
-  fields: FieldConfig[];
+  fields: SchemaFieldConfig[];
   descend: () => R;
 }
 
@@ -58,7 +58,7 @@ export interface VisitInstanceNode<R> extends VisitNode<R> {
  * Visit handler
  */
 export interface VisitHandler<R, U extends VisitNode<R> = VisitNode<R>> {
-  onRoot(config: U & { config: ClassConfig }): R;
-  onSub(config: U & { config: FieldConfig }): R;
-  onSimple(config: Omit<U, 'descend'> & { config: FieldConfig }): R;
+  onRoot(config: U & { config: SchemaClassConfig }): R;
+  onSub(config: U & { config: SchemaFieldConfig }): R;
+  onSimple(config: Omit<U, 'descend'> & { config: SchemaFieldConfig }): R;
 }

package/src/service.ts

@@ -1,7 +1,7 @@
 import {
   ModelType,
   BulkOp, BulkResponse, ModelCrudSupport, ModelStorageSupport, ModelBulkSupport,
-  NotFoundError, ModelRegistry, ExistsError, OptionalId, ModelIdSource,
+  NotFoundError, ModelRegistryIndex, ExistsError, OptionalId, ModelIdSource,
   ModelExpiryUtil, ModelCrudUtil, ModelStorageUtil, ModelBulkUtil,
 } from '@travetto/model';
 import { castTo, Class } from '@travetto/runtime';
@@ -243,7 +243,7 @@ export class SQLModelService implements
   async query<T extends ModelType>(cls: Class<T>, query: PageableModelQuery<T>): Promise<T[]> {
     await QueryVerifier.verify(cls, query);
     const { records: res } = await this.#exec<T>(this.#dialect.getQuerySQL(cls, query, ModelQueryUtil.getWhereClause(cls, query.where)));
-    if (ModelRegistry.has(cls)) {
+    if (ModelRegistryIndex.has(cls)) {
       await this.#dialect.fetchDependents(cls, res, query && query.select);
     }
 

package/src/table-manager.ts

@@ -1,13 +1,14 @@
 import { AsyncContext, WithAsyncContext } from '@travetto/context';
-import { ModelRegistry } from '@travetto/model';
+import { ModelRegistryIndex } from '@travetto/model';
 import { Class } from '@travetto/runtime';
 import { ChangeEvent } from '@travetto/registry';
 import { SchemaChange } from '@travetto/schema';
 
 import { Connected, Transactional } from './connection/decorator.ts';
 import { SQLDialect } from './dialect/base.ts';
-import { SQLModelUtil, VisitStack } from './util.ts';
+import { SQLModelUtil } from './util.ts';
 import { Connection } from './connection/base.ts';
+import { VisitStack } from './types.ts';
 
 /**
  * Manage creation/updating of all tables
@@ -34,7 +35,7 @@ export class TableManager {
     for (const op of this.#dialect.getCreateAllTablesSQL(cls)) {
       out.push(op);
     }
-    const indices = ModelRegistry.get(cls).indices;
+    const indices = ModelRegistryIndex.getConfig(cls).indices;
     if (indices) {
       for (const op of this.#dialect.getCreateAllIndicesSQL(cls, indices)) {
         out.push(op);
@@ -53,7 +54,7 @@ export class TableManager {
     for (const op of this.#dialect.getCreateAllTablesSQL(cls)) {
       await this.#exec(op);
     }
-    const indices = ModelRegistry.get(cls).indices;
+    const indices = ModelRegistryIndex.getConfig(cls).indices;
     if (indices) {
       for (const op of this.#dialect.getCreateAllIndicesSQL(cls, indices)) {
         try {

package/src/types.ts

@@ -6,6 +6,6 @@ export type VisitStack = {
   [TableSymbol]?: string;
   array?: boolean;
   type: Class;
-  name: string;
+  name: string | symbol;
   index?: number;
 };

package/src/util.ts

@@ -1,16 +1,16 @@
 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 { ModelRegistryIndex, ModelType, OptionalId } from '@travetto/model';
+import { SchemaClassConfig, SchemaFieldConfig, DataUtil, SchemaRegistryIndex } from '@travetto/schema';
 
 import { DialectState, InsertWrapper, VisitHandler, VisitState, VisitInstanceNode, OrderBy } from './internal/types.ts';
 import { TableSymbol, VisitStack } from './types.ts';
 
 type FieldCacheEntry = {
-  local: FieldConfig[];
-  localMap: Record<string, FieldConfig>;
-  foreign: FieldConfig[];
-  foreignMap: Record<string, FieldConfig>;
+  local: SchemaFieldConfig[];
+  localMap: Record<string | symbol, SchemaFieldConfig>;
+  foreign: SchemaFieldConfig[];
+  foreignMap: Record<string | symbol, SchemaFieldConfig>;
 };
 
 /**
@@ -54,33 +54,32 @@ export class SQLModelUtil {
    */
   static getFieldsByLocation(stack: VisitStack[]): FieldCacheEntry {
     const top = stack.at(-1)!;
-    const cls = SchemaRegistry.get(top.type);
+    const conf = SchemaRegistryIndex.has(top.type) ? SchemaRegistryIndex.getConfig(top.type) : undefined;
 
-    if (cls && this.#schemaFieldsCache.has(cls.class)) {
-      return this.#schemaFieldsCache.get(cls.class)!;
+    if (conf && this.#schemaFieldsCache.has(conf.class)) {
+      return this.#schemaFieldsCache.get(conf.class)!;
     }
 
-    if (!cls) { // If a simple type, it is it's own field
-      const field: FieldConfig = castTo({ ...top });
+    if (!conf) { // If a simple type, it is it's own field
+      const field: SchemaFieldConfig = castTo({ ...top });
       return {
         local: [field], localMap: { [field.name]: field },
         foreign: [], foreignMap: {}
       };
     }
 
-    const model = ModelRegistry.get(cls.class)!;
-    const conf = cls.totalView;
-    const fields = conf.fields.map(x => ({ ...conf.schema[x] }));
+    const hasModel = ModelRegistryIndex.has(conf.class)!;
+    const fields = Object.values(conf.fields).map(field => ({ ...field }));
 
     // Polymorphic
-    if (model && (model.baseType ?? model.subType)) {
+    if (hasModel && conf.discriminatedBase) {
       const fieldMap = new Set(fields.map(f => f.name));
-      for (const type of ModelRegistry.getClassesByBaseType(ModelRegistry.getBaseModel(cls.class))) {
-        const typeConf = SchemaRegistry.get(type).totalView;
-        for (const f of typeConf.fields) {
-          if (!fieldMap.has(f)) {
-            fieldMap.add(f);
-            fields.push({ ...typeConf.schema[f], required: { active: false } });
+      for (const type of SchemaRegistryIndex.getDiscriminatedClasses(conf.class)) {
+        const typeConf = SchemaRegistryIndex.getConfig(type);
+        for (const [fieldName, field] of Object.entries<SchemaFieldConfig>(typeConf.fields)) {
+          if (!fieldMap.has(fieldName)) {
+            fieldMap.add(fieldName);
+            fields.push({ ...field, required: { active: false } });
           }
         }
       }
@@ -89,14 +88,14 @@ export class SQLModelUtil {
     const ret: FieldCacheEntry = {
       localMap: {},
       foreignMap: {},
-      local: fields.filter(x => !SchemaRegistry.has(x.type) && !x.array),
-      foreign: fields.filter(x => SchemaRegistry.has(x.type) || x.array)
+      local: fields.filter(x => !SchemaRegistryIndex.has(x.type) && !x.array),
+      foreign: fields.filter(x => SchemaRegistryIndex.has(x.type) || x.array)
     };
 
     ret.local.reduce((acc, f) => (acc[f.name] = f) && acc, ret.localMap);
     ret.foreign.reduce((acc, f) => (acc[f.name] = f) && acc, ret.foreignMap);
 
-    this.#schemaFieldsCache.set(cls.class, ret);
+    this.#schemaFieldsCache.set(conf.class, ret);
 
     return ret;
   }
@@ -104,13 +103,13 @@ export class SQLModelUtil {
   /**
    * Process a schema structure, synchronously
    */
-  static visitSchemaSync(config: ClassConfig | FieldConfig, handler: VisitHandler<void>, state: VisitState = { path: [] }): void {
+  static visitSchemaSync(config: SchemaClassConfig | SchemaFieldConfig, handler: VisitHandler<void>, state: VisitState = { path: [] }): void {
     const path = 'class' in config ? this.classToStack(config.class) : [...state.path, config];
     const { local: fields, foreign } = this.getFieldsByLocation(path);
 
     const descend = (): void => {
       for (const field of foreign) {
-        if (SchemaRegistry.has(field.type)) {
+        if (SchemaRegistryIndex.has(field.type)) {
           this.visitSchemaSync(field, handler, { path });
         } else {
           handler.onSimple({
@@ -132,13 +131,13 @@ export class SQLModelUtil {
   /**
    * Visit a Schema structure
    */
-  static async visitSchema(config: ClassConfig | FieldConfig, handler: VisitHandler<Promise<void>>, state: VisitState = { path: [] }): Promise<void> {
+  static async visitSchema(config: SchemaClassConfig | SchemaFieldConfig, handler: VisitHandler<Promise<void>>, state: VisitState = { path: [] }): Promise<void> {
     const path = 'class' in config ? this.classToStack(config.class) : [...state.path, config];
     const { local: fields, foreign } = this.getFieldsByLocation(path);
 
     const descend = async (): Promise<void> => {
       for (const field of foreign) {
-        if (SchemaRegistry.has(field.type)) {
+        if (SchemaRegistryIndex.has(field.type)) {
           await this.visitSchema(field, handler, { path });
         } else {
           await handler.onSimple({
@@ -162,7 +161,7 @@ export class SQLModelUtil {
    */
   static visitSchemaInstance<T extends ModelType>(cls: Class<T>, instance: T | OptionalId<T>, handler: VisitHandler<unknown, VisitInstanceNode<unknown>>): void {
     const pathObj: unknown[] = [instance];
-    this.visitSchemaSync(SchemaRegistry.get(cls), {
+    this.visitSchemaSync(SchemaRegistryIndex.getConfig(cls), {
       onRoot: (config) => {
         const { path } = config;
         path[0].name = instance.id!;
@@ -171,7 +170,7 @@ export class SQLModelUtil {
       },
       onSub: (config) => {
         const { config: field } = config;
-        const topObj: Record<string, unknown> = castTo(pathObj.at(-1));
+        const topObj: Record<string | symbol, unknown> = castTo(pathObj.at(-1));
         const top = config.path.at(-1)!;
 
         if (field.name in topObj) {
@@ -199,7 +198,7 @@ export class SQLModelUtil {
       },
       onSimple: (config) => {
         const { config: field } = config;
-        const topObj: Record<string, unknown> = castTo(pathObj.at(-1));
+        const topObj: Record<string | symbol, unknown> = castTo(pathObj.at(-1));
         const value = topObj[field.name];
         return handler.onSimple({ ...config, value });
       }
@@ -209,7 +208,7 @@ export class SQLModelUtil {
   /**
    * Get list of selected fields
    */
-  static select<T>(cls: Class<T>, select?: SelectClause<T>): FieldConfig[] {
+  static select<T>(cls: Class<T>, select?: SelectClause<T>): SchemaFieldConfig[] {
     if (!select || Object.keys(select).length === 0) {
       return [{ type: cls, name: '*', owner: cls, array: false }];
     }
@@ -222,7 +221,7 @@ export class SQLModelUtil {
       if (typeof k === 'string' && !DataUtil.isPlainObject(select[k]) && localMap[k]) {
         if (!v) {
           if (toGet.size === 0) {
-            toGet = new Set(SchemaRegistry.get(cls).totalView.fields);
+            toGet = new Set(Object.keys(SchemaRegistryIndex.getConfig(cls).fields));
           }
           toGet.delete(k);
         } else {
@@ -238,19 +237,19 @@ export class SQLModelUtil {
    */
   static orderBy<T>(cls: Class<T>, sort: SortClause<T>[]): OrderBy[] {
     return sort.map((cl: Record<string, unknown>) => {
-      let schema: ClassConfig = SchemaRegistry.get(cls);
+      let schema: SchemaClassConfig = SchemaRegistryIndex.getConfig(cls);
       const stack = this.classToStack(cls);
       let found: OrderBy | undefined;
       while (!found) {
         const key = Object.keys(cl)[0];
         const val = cl[key];
-        const field = { ...schema.totalView.schema[key] };
+        const field = { ...schema.fields[key] };
         if (DataUtil.isPrimitive(val)) {
           stack.push(field);
           found = { stack, asc: val === 1 };
         } else {
           stack.push(field);
-          schema = SchemaRegistry.get(field.type);
+          schema = SchemaRegistryIndex.getConfig(field.type);
           cl = castTo(val);
         }
       }
@@ -261,9 +260,9 @@ export class SQLModelUtil {
   /**
    * Find all dependent fields via child tables
    */
-  static collectDependents<T>(dct: DialectState, parent: unknown, v: T[], field?: FieldConfig): Record<string, T> {
+  static collectDependents<T>(dct: DialectState, parent: unknown, v: T[], field?: SchemaFieldConfig): Record<string, T> {
     if (field) {
-      const isSimple = SchemaRegistry.has(field.type);
+      const isSimple = SchemaRegistryIndex.has(field.type);
       for (const el of v) {
         const parentKey: string = castTo(el[castKey<T>(dct.parentPathField.name)]);
         const root = castTo<Record<string, Record<string, unknown>>>(parent)[parentKey];
@@ -296,7 +295,7 @@ export class SQLModelUtil {
   static buildTable(list: VisitStack[]): string {
     const top = list.at(-1)!;
     if (!top[TableSymbol]) {
-      top[TableSymbol] = list.map((el, i) => i === 0 ? ModelRegistry.getStore(el.type) : el.name).join('_');
+      top[TableSymbol] = list.map((el, i) => i === 0 ? ModelRegistryIndex.getStoreName(el.type) : el.name).join('_');
     }
     return top[TableSymbol]!;
   }
@@ -305,7 +304,7 @@ export class SQLModelUtil {
    * Build property path for a table/field given the current stack
    */
   static buildPath(list: VisitStack[]): string {
-    return list.map((el) => `${el.name}${el.index ? `[${el.index}]` : ''}`).join('.');
+    return list.map((el) => `${el.name.toString()}${el.index ? `[${el.index}]` : ''}`).join('.');
   }
 
   /**

package/support/test/query.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 
-import { Schema, FieldConfig } from '@travetto/schema';
+import { Schema, SchemaFieldConfig } from '@travetto/schema';
 import { Suite, Test } from '@travetto/test';
 import { castTo } from '@travetto/runtime';
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
@@ -67,9 +67,9 @@ export abstract class BaseSQLTest extends BaseModelSuite<SQLModelService> {
 
     const dct = await this.dialect;
     dct.resolveName = (stack: VisitStack[]) => {
-      const field: FieldConfig = castTo(stack.at(-1));
-      const parent: FieldConfig = castTo(stack.at(-2));
-      return `${field.owner ? field.owner.name : parent.name}.${field.name}`;
+      const field: SchemaFieldConfig = castTo(stack.at(-1));
+      const parent: SchemaFieldConfig = castTo(stack.at(-2));
+      return `${field.owner ? field.owner.name.toString() : parent.name.toString()}.${field.name.toString()}`;
     };
 
     const qryStr = dct.getWhereGroupingSQL(WhereType, qry);
@@ -80,8 +80,8 @@ export abstract class BaseSQLTest extends BaseModelSuite<SQLModelService> {
   async testRegEx() {
     const dct = await this.dialect;
     dct.resolveName = (stack: VisitStack[]) => {
-      const field: FieldConfig = castTo(stack.at(-1));
-      return `${field.owner?.name}.${field.name}`;
+      const field: SchemaFieldConfig = castTo(stack.at(-1));
+      return `${field.owner?.name}.${field.name.toString()}`;
     };
 
     const out = dct.getWhereGroupingSQL(User, {