@metaobjectsdev/runtime-ts 0.6.0 → 0.7.0-rc.10

package/src/object-manager.ts

@@ -13,7 +13,10 @@ import {
   resolvePkFields, compileFilter,
   type Filter, type QueryOpts,
 } from "./query-builder.js";
-import { buildNameMap, resolveTableName, type EntityNameMap } from "@metaobjectsdev/metadata";
+import {
+  buildNameMap, resolveTableName, DEFAULT_COLUMN_NAMING_STRATEGY,
+  type ColumnNamingStrategy, type EntityNameMap,
+} from "@metaobjectsdev/metadata";
 import { coerceRowOnRead, coerceRowOnWrite } from "./type-coercer.js";
 import { decodeRef, encodeRef } from "./ref-codec.js";
 import { runValidators } from "./validator-runner.js";
@@ -37,6 +40,12 @@ import { VALID_ENTITY_NAME, DEFAULT_IF_MISSING } from "./constants.js";
 export interface ObjectManagerOptions {
   metadata: MetaData;
   driver: PersistenceDriver;
+  /**
+   * Column-naming strategy for fields with no `@column` override. Defaults to
+   * `"snake_case"`. Must agree with the codegen / migration config that
+   * created the schema (a mismatch yields columns the runtime can't address).
+   */
+  columnNamingStrategy?: ColumnNamingStrategy;
 }
 
 export interface ReadOpts extends QueryOpts {
@@ -54,17 +63,19 @@ export interface WriteOpts {
 export class ObjectManager {
   private readonly metadata: MetaData;
   private readonly driver: PersistenceDriver;
+  private readonly columnNamingStrategy: ColumnNamingStrategy;
   private readonly nameMapCache = new Map<string, EntityNameMap>();
 
   constructor(opts: ObjectManagerOptions) {
     this.metadata = opts.metadata;
     this.driver = opts.driver;
+    this.columnNamingStrategy = opts.columnNamingStrategy ?? DEFAULT_COLUMN_NAMING_STRATEGY;
   }
 
   private nameMap(entity: MetaData): EntityNameMap {
     let m = this.nameMapCache.get(entity.name);
     if (!m) {
-      m = buildNameMap(entity);
+      m = buildNameMap(entity, this.columnNamingStrategy);
       this.nameMapCache.set(entity.name, m);
     }
     return m;
@@ -79,7 +90,7 @@ export class ObjectManager {
   async findFirst(entityName: string, filter: Filter, opts: ReadOpts = {}): Promise<Row | null> {
     const entity = this.requireEntity(entityName);
     const driver = opts.tx ?? this.driver;
-    const spec = buildSelectSpec(entity, filter, { ...opts, limit: 1 });
+    const spec = buildSelectSpec(entity, filter, { ...opts, limit: 1 }, undefined, this.columnNamingStrategy);
     const row = await driver.selectOne(spec);
     if (row === null) return null;
     const jsRow = this.toJsRow(entity, row);
@@ -92,7 +103,7 @@ export class ObjectManager {
   async findMany(entityName: string, filter?: Filter, opts: ReadOpts = {}): Promise<Row[]> {
     const entity = this.requireEntity(entityName);
     const driver = opts.tx ?? this.driver;
-    const spec = buildSelectSpec(entity, filter, opts);
+    const spec = buildSelectSpec(entity, filter, opts, undefined, this.columnNamingStrategy);
     const rows = (await driver.selectMany(spec)).map((r) => this.toJsRow(entity, r));
     if (opts.include && opts.include.length > 0) {
       await this.attachIncludes(entity, rows, opts.include, driver);
@@ -103,7 +114,7 @@ export class ObjectManager {
   async count(entityName: string, filter?: Filter, opts: Pick<ReadOpts, "tx"> = {}): Promise<number> {
     const entity = this.requireEntity(entityName);
     const driver = opts.tx ?? this.driver;
-    return driver.count(buildCountSpec(entity, filter));
+    return driver.count(buildCountSpec(entity, filter, this.columnNamingStrategy));
   }
 
   async load(refString: string): Promise<Row | null> {
@@ -144,7 +155,7 @@ export class ObjectManager {
     }
 
     const coerced = coerceRowOnWrite(entity, merged, driver.dialect);
-    const spec = buildInsertSpec(entity, coerced);
+    const spec = buildInsertSpec(entity, coerced, this.columnNamingStrategy);
     const dbRow = await driver.insert(spec);
     return this.toJsRow(entity, dbRow);
   }
@@ -162,7 +173,7 @@ export class ObjectManager {
     }
 
     const coerced = coerceRowOnWrite(entity, restricted, driver.dialect);
-    const spec = buildUpdateSpec(entity, coerced, id);
+    const spec = buildUpdateSpec(entity, coerced, id, this.columnNamingStrategy);
     const dbRow = await driver.update(spec);
     if (dbRow === null) {
       const mode = opts.ifMissing ?? DEFAULT_IF_MISSING;
@@ -175,7 +186,7 @@ export class ObjectManager {
   async delete(entityName: string, id: unknown, opts: WriteOpts = {}): Promise<boolean> {
     const entity = this.requireEntity(entityName);
     const driver = opts.tx ?? this.driver;
-    const spec = buildDeleteSpec(entity, id);
+    const spec = buildDeleteSpec(entity, id, this.columnNamingStrategy);
     const n = await driver.delete(spec);
     if (n === 0) {
       const mode = opts.ifMissing ?? DEFAULT_IF_MISSING;
@@ -228,7 +239,7 @@ export class ObjectManager {
     const spec: UpdateManySpec = {
       table: resolveTableName(entity),
       values: this.toDbRow(entity, coerced),
-      where: requireNonEmptyFilter(entity, filter, "updateMany"),
+      where: requireNonEmptyFilter(entity, filter, "updateMany", this.columnNamingStrategy),
     };
     return driver.updateMany(spec);
   }
@@ -238,14 +249,16 @@ export class ObjectManager {
     const driver = opts.tx ?? this.driver;
     const spec: DeleteManySpec = {
       table: resolveTableName(entity),
-      where: requireNonEmptyFilter(entity, filter, "deleteMany"),
+      where: requireNonEmptyFilter(entity, filter, "deleteMany", this.columnNamingStrategy),
     };
     return driver.deleteMany(spec);
   }
 
   async transaction<T>(fn: (txOm: ObjectManager) => Promise<T>): Promise<T> {
     return this.driver.transaction(async (txDriver) => {
-      const txOm = new ObjectManager({ metadata: this.metadata, driver: txDriver });
+      const txOm = new ObjectManager({
+        metadata: this.metadata, driver: txDriver, columnNamingStrategy: this.columnNamingStrategy,
+      });
       return fn(txOm);
     });
   }
@@ -258,7 +271,7 @@ export class ObjectManager {
     const n2m = resolveN2mDescriptor(entity, relationName, this.metadata);
     if (n2m !== null) {
       const target = this.requireEntity(n2m.targetEntityName);
-      const { joinSpec, makeTargetSpec } = buildN2mLazySpecs(n2m, record, this.metadata);
+      const { joinSpec, makeTargetSpec } = buildN2mLazySpecs(n2m, record, this.metadata, this.columnNamingStrategy);
       const joinRows = await driver.selectMany(joinSpec);
       const targetSpec = makeTargetSpec(joinRows);
       if (targetSpec === null) return [];
@@ -268,7 +281,7 @@ export class ObjectManager {
 
     const desc = resolveRelationDescriptor(entity, relationName, this.metadata);
     const target = this.requireEntity(desc.targetEntityName);
-    const spec = buildLazyRelateSpec(desc, record, this.metadata);
+    const spec = buildLazyRelateSpec(desc, record, this.metadata, this.columnNamingStrategy);
     if (spec === null) return desc.cardinality === "one" ? null : [];
     if (desc.cardinality === "one") {
       const row = await driver.selectOne(spec);
@@ -311,15 +324,15 @@ export class ObjectManager {
       const n2m = resolveN2mDescriptor(entity, inc, this.metadata);
       if (n2m !== null) {
         const target = this.requireEntity(n2m.targetEntityName);
-        const { joinSpec, makeTargetSpec } = buildN2mBatchSpecs(n2m, records, this.metadata);
+        const { joinSpec, makeTargetSpec } = buildN2mBatchSpecs(n2m, records, this.metadata, this.columnNamingStrategy);
         const joinRows = await driver.selectMany(joinSpec);
         const targetSpec = makeTargetSpec(joinRows);
         const targetRows = targetSpec === null ? [] : (await driver.selectMany(targetSpec)).map((r) => this.toJsRow(target, r));
 
         const sourcePk = resolvePkFields(entity)[0]!;
         const joinEntity = this.requireEntity(n2m.joinEntityName);
-        const sourceJoinDbCol = resolveJoinColumnName(joinEntity, n2m.sourceJoinField);
-        const targetJoinDbCol = resolveJoinColumnName(joinEntity, n2m.targetJoinField);
+        const sourceJoinDbCol = resolveJoinColumnName(joinEntity, n2m.sourceJoinField, this.columnNamingStrategy);
+        const targetJoinDbCol = resolveJoinColumnName(joinEntity, n2m.targetJoinField, this.columnNamingStrategy);
         const targetPk = resolvePkFields(target)[0]!;
         const targetById = new Map(targetRows.map((r) => [r[targetPk], r]));
         const grouped = new Map<unknown, Row[]>();
@@ -336,7 +349,7 @@ export class ObjectManager {
 
       const desc = resolveRelationDescriptor(entity, inc, this.metadata);
       const target = this.requireEntity(desc.targetEntityName);
-      const spec = buildIncludeBatchSpec(desc, records, this.metadata);
+      const spec = buildIncludeBatchSpec(desc, records, this.metadata, this.columnNamingStrategy);
       const targetRows = spec === null ? [] : (await driver.selectMany(spec)).map((r) => this.toJsRow(target, r));
 
       if (desc.cardinality === "one") {
@@ -412,8 +425,10 @@ export class ObjectManager {
 
 // updateMany / deleteMany with an empty filter would silently affect every row.
 // Force callers to be explicit (use $or-style or a tautology if they really mean "all").
-function requireNonEmptyFilter(entity: MetaData, filter: Filter, op: string): WhereClause {
-  const where = compileFilter(entity, filter);
+function requireNonEmptyFilter(
+  entity: MetaData, filter: Filter, op: string, strategy: ColumnNamingStrategy,
+): WhereClause {
+  const where = compileFilter(entity, filter, strategy);
   if (where === null) {
     throw new MetadataError(
       `${op} on '${entity.name}' requires a non-empty filter — pass an explicit condition or use a per-row loop`,

package/src/query-builder.ts

@@ -1,8 +1,9 @@
-import type { MetaData } from "@metaobjectsdev/metadata";
+import type { ColumnNamingStrategy, MetaData } from "@metaobjectsdev/metadata";
 import {
   TYPE_FIELD, TYPE_IDENTITY,
   IDENTITY_SUBTYPE_PRIMARY,
   IDENTITY_ATTR_FIELDS,
+  DEFAULT_COLUMN_NAMING_STRATEGY,
   resolveTableName, resolveColumnName,
 } from "@metaobjectsdev/metadata";
 import { MetadataError } from "./errors.js";
@@ -69,11 +70,11 @@ function getField(entity: MetaData, fieldName: string): MetaData {
   return f;
 }
 
-function rowToColumns(entity: MetaData, data: Row): Row {
+function rowToColumns(entity: MetaData, data: Row, strategy: ColumnNamingStrategy): Row {
   const out: Row = {};
   for (const [k, v] of Object.entries(data)) {
     const field = getField(entity, k);
-    out[resolveColumnName(field)] = v;
+    out[resolveColumnName(field, strategy)] = v;
   }
   return out;
 }
@@ -82,29 +83,37 @@ function rowToColumns(entity: MetaData, data: Row): Row {
  * Returns null when `filter` has no clauses ({} or { $and: [] }) — meaning "match all"
  * (callers should treat null the same as omitting the where clause entirely).
  */
-export function compileFilter(entity: MetaData, filter: Filter): WhereClause | null {
+export function compileFilter(
+  entity: MetaData,
+  filter: Filter,
+  strategy: ColumnNamingStrategy = DEFAULT_COLUMN_NAMING_STRATEGY,
+): WhereClause | null {
   if ("$and" in filter && Array.isArray(filter.$and)) {
     // TS can't narrow $and away from the Record branch, so the runtime check above
     // proves it's a Filter[] but the element type still needs a bridge cast.
     const andFilters = filter.$and as Filter[];
-    const clauses = andFilters.map((f) => compileFilter(entity, f)).filter((c): c is WhereClause => c !== null);
+    const clauses = andFilters
+      .map((f) => compileFilter(entity, f, strategy))
+      .filter((c): c is WhereClause => c !== null);
     if (clauses.length === 0) return null;
     return clauses.length === 1 ? clauses[0]! : { kind: "and", clauses };
   }
   const entries = Object.entries(filter);
   if (entries.length === 0) return null;
   if (entries.length === 1) {
-    return compileEntry(entity, entries[0]![0], entries[0]![1] as FilterValue);
+    return compileEntry(entity, entries[0]![0], entries[0]![1] as FilterValue, strategy);
   }
   return {
     kind: "and",
-    clauses: entries.map(([k, v]) => compileEntry(entity, k, v as FilterValue)),
+    clauses: entries.map(([k, v]) => compileEntry(entity, k, v as FilterValue, strategy)),
   };
 }
 
-function compileEntry(entity: MetaData, fieldName: string, value: FilterValue): WhereClause {
+function compileEntry(
+  entity: MetaData, fieldName: string, value: FilterValue, strategy: ColumnNamingStrategy,
+): WhereClause {
   const field = getField(entity, fieldName);
-  const column = resolveColumnName(field);
+  const column = resolveColumnName(field, strategy);
 
   if (value === null) return { kind: "isNull", column, not: false };
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
@@ -137,12 +146,14 @@ function compileEntry(entity: MetaData, fieldName: string, value: FilterValue):
   throw new MetadataError(`No recognized operator on filter for field '${fieldName}'`);
 }
 
-function normalizeOrderBy(input: QueryOpts["orderBy"], entity: MetaData): OrderBy[] | undefined {
+function normalizeOrderBy(
+  input: QueryOpts["orderBy"], entity: MetaData, strategy: ColumnNamingStrategy,
+): OrderBy[] | undefined {
   if (input === undefined) return undefined;
   const arr = Array.isArray(input[0]) ? (input as [string, "asc" | "desc"][]) : [input as [string, "asc" | "desc"]];
   return arr.map(([fieldName, dir]) => {
     const field = getField(entity, fieldName);
-    return { column: resolveColumnName(field), direction: dir };
+    return { column: resolveColumnName(field, strategy), direction: dir };
   });
 }
 
@@ -152,20 +163,21 @@ export function buildSelectSpec(
   filter: Filter | undefined,
   opts: QueryOpts,
   projectedFields?: string[],
+  strategy: ColumnNamingStrategy = DEFAULT_COLUMN_NAMING_STRATEGY,
 ): SelectSpec {
   const allFields = projectedFields ?? listFieldNames(entity);
   const pkFields = resolvePkFields(entity);
   const fieldSet = new Set<string>(allFields);
   for (const pk of pkFields) fieldSet.add(pk);
 
-  const columns = [...fieldSet].map((f) => resolveColumnName(getField(entity, f)));
-  const orderBy = normalizeOrderBy(opts.orderBy, entity);
+  const columns = [...fieldSet].map((f) => resolveColumnName(getField(entity, f), strategy));
+  const orderBy = normalizeOrderBy(opts.orderBy, entity, strategy);
 
   const spec: SelectSpec = {
     table: resolveTableName(entity),
     columns,
   };
-  const where = filter !== undefined ? compileFilter(entity, filter) : null;
+  const where = filter !== undefined ? compileFilter(entity, filter, strategy) : null;
   if (where !== null) spec.where = where;
   if (orderBy !== undefined) spec.orderBy = orderBy;
   if (opts.limit !== undefined) spec.limit = opts.limit;
@@ -173,25 +185,34 @@ export function buildSelectSpec(
   return spec;
 }
 
-export function buildCountSpec(entity: MetaData, filter: Filter | undefined): CountSpec {
+export function buildCountSpec(
+  entity: MetaData, filter: Filter | undefined,
+  strategy: ColumnNamingStrategy = DEFAULT_COLUMN_NAMING_STRATEGY,
+): CountSpec {
   const spec: CountSpec = { table: resolveTableName(entity) };
-  const where = filter !== undefined ? compileFilter(entity, filter) : null;
+  const where = filter !== undefined ? compileFilter(entity, filter, strategy) : null;
   if (where !== null) spec.where = where;
   return spec;
 }
 
-export function buildInsertSpec(entity: MetaData, data: Row): InsertSpec {
-  const values = rowToColumns(entity, data);
+export function buildInsertSpec(
+  entity: MetaData, data: Row,
+  strategy: ColumnNamingStrategy = DEFAULT_COLUMN_NAMING_STRATEGY,
+): InsertSpec {
+  const values = rowToColumns(entity, data, strategy);
   const allFields = listFieldNames(entity);
   return {
     table: resolveTableName(entity),
     values,
-    returning: allFields.map((f) => resolveColumnName(getField(entity, f))),
+    returning: allFields.map((f) => resolveColumnName(getField(entity, f), strategy)),
   };
 }
 
-export function buildUpdateSpec(entity: MetaData, data: Row, id: unknown): UpdateSpec {
-  const values = rowToColumns(entity, data);
+export function buildUpdateSpec(
+  entity: MetaData, data: Row, id: unknown,
+  strategy: ColumnNamingStrategy = DEFAULT_COLUMN_NAMING_STRATEGY,
+): UpdateSpec {
+  const values = rowToColumns(entity, data, strategy);
   const pkFields = resolvePkFields(entity);
   if (pkFields.length !== 1) {
     throw new MetadataError(
@@ -199,16 +220,19 @@ export function buildUpdateSpec(entity: MetaData, data: Row, id: unknown): Updat
       { entity: entity.name },
     );
   }
-  const pkColumn = resolveColumnName(getField(entity, pkFields[0]!));
+  const pkColumn = resolveColumnName(getField(entity, pkFields[0]!), strategy);
   return {
     table: resolveTableName(entity),
     values,
     where: { kind: "eq", column: pkColumn, value: id as PrimitiveValue },
-    returning: listFieldNames(entity).map((f) => resolveColumnName(getField(entity, f))),
+    returning: listFieldNames(entity).map((f) => resolveColumnName(getField(entity, f), strategy)),
   };
 }
 
-export function buildDeleteSpec(entity: MetaData, id: unknown): DeleteSpec {
+export function buildDeleteSpec(
+  entity: MetaData, id: unknown,
+  strategy: ColumnNamingStrategy = DEFAULT_COLUMN_NAMING_STRATEGY,
+): DeleteSpec {
   const pkFields = resolvePkFields(entity);
   if (pkFields.length !== 1) {
     throw new MetadataError(
@@ -216,7 +240,7 @@ export function buildDeleteSpec(entity: MetaData, id: unknown): DeleteSpec {
       { entity: entity.name },
     );
   }
-  const pkColumn = resolveColumnName(getField(entity, pkFields[0]!));
+  const pkColumn = resolveColumnName(getField(entity, pkFields[0]!), strategy);
   return {
     table: resolveTableName(entity),
     where: { kind: "eq", column: pkColumn, value: id as PrimitiveValue },

package/src/relation-resolver.ts

@@ -1,4 +1,4 @@
-import type { MetaData } from "@metaobjectsdev/metadata";
+import type { ColumnNamingStrategy, MetaData } from "@metaobjectsdev/metadata";
 import {
   TYPE_OBJECT, TYPE_RELATIONSHIP, TYPE_IDENTITY,
   IDENTITY_SUBTYPE_REFERENCE,
@@ -6,6 +6,7 @@ import {
   IDENTITY_REFERENCE_ATTR_REFERENCES,
   RELATIONSHIP_ATTR_CARDINALITY, RELATIONSHIP_ATTR_OBJECT_REF,
   CARDINALITY_ONE, CARDINALITY_MANY,
+  DEFAULT_COLUMN_NAMING_STRATEGY,
 } from "@metaobjectsdev/metadata";
 import { MetadataError } from "./errors.js";
 import {
@@ -140,11 +141,12 @@ export function buildLazyRelateSpec(
   desc: RelationDescriptor,
   sourceRecord: Row,
   root: MetaData,
+  strategy: ColumnNamingStrategy = DEFAULT_COLUMN_NAMING_STRATEGY,
 ): SelectSpec | null {
   const lookup = sourceRecord[desc.sourceField];
   if (lookup === null || lookup === undefined) return null;
   const target = mustGetEntity(root, desc.targetEntityName);
-  return buildSelectSpec(target, { [desc.targetField]: lookup as PrimitiveValue }, {});
+  return buildSelectSpec(target, { [desc.targetField]: lookup as PrimitiveValue }, {}, undefined, strategy);
 }
 
 /** Builds one batched IN(...) lookup. Returns null when there are no non-null source values. */
@@ -152,6 +154,7 @@ export function buildIncludeBatchSpec(
   desc: RelationDescriptor,
   sourceRecords: Row[],
   root: MetaData,
+  strategy: ColumnNamingStrategy = DEFAULT_COLUMN_NAMING_STRATEGY,
 ): SelectSpec | null {
   const seen = new Set<PrimitiveValue>();
   for (const rec of sourceRecords) {
@@ -161,7 +164,7 @@ export function buildIncludeBatchSpec(
   }
   if (seen.size === 0) return null;
   const target = mustGetEntity(root, desc.targetEntityName);
-  return buildSelectSpec(target, { [desc.targetField]: [...seen] as (string | number)[] }, {});
+  return buildSelectSpec(target, { [desc.targetField]: [...seen] as (string | number)[] }, {}, undefined, strategy);
 }
 
 function mustGetEntity(root: MetaData, name: string): MetaData {