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

package/src/expected-schema.ts

@@ -1,10 +1,11 @@
-import type { MetaData, MetaObject, MetaRoot } from "@metaobjectsdev/metadata";
+import type { ColumnNamingStrategy, MetaData, MetaObject, MetaRoot } from "@metaobjectsdev/metadata";
 import {
   TYPE_OBJECT,
   MetaSource,
   IDENTITY_ATTR_GENERATION,
   IDENTITY_ATTR_UNIQUE,
   FIELD_ATTR_DEFAULT,
+  FIELD_ATTR_MAX_LENGTH,
   FIELD_ATTR_UNIQUE,
   FIELD_SUBTYPE_STRING,
   FIELD_SUBTYPE_INT,
@@ -25,12 +26,14 @@ import {
   FIELD_ATTR_STORAGE,
   STORAGE_FLATTENED,
   DOC_ATTR_DESCRIPTION,
+  applyColumnNamingStrategy, DEFAULT_COLUMN_NAMING_STRATEGY,
   resolveTableName, resolveColumnName, resolveTableSchema,
 } from "@metaobjectsdev/metadata";
 import type { SqlType } from "./sql-type.js";
 import type {
   Dialect, SchemaSnapshot, TableDescriptor, ColumnDescriptor, IndexDescriptor, FkDescriptor,
 } from "./types.js";
+import { buildExpectedViews } from "./expected-views.js";
 import {
   resolveReferentialActions,
   validateSetNullNullability,
@@ -49,6 +52,12 @@ export interface BuildExpectedSchemaOptions {
    * patterns produce INTEGER / TEXT in the actual DB.
    */
   dialect?: Dialect;
+  /**
+   * Column-naming strategy for fields with no `@column` override. Defaults to
+   * `"snake_case"`. Must match the runtime's `ObjectManager` strategy — a
+   * mismatch yields a schema whose columns the runtime can't address.
+   */
+  columnNamingStrategy?: ColumnNamingStrategy;
 }
 
 export function buildExpectedSchema(
@@ -58,6 +67,7 @@ export function buildExpectedSchema(
   // D1 is SQLite at the SQL level; normalize it so downstream dialect checks
   // don't need to handle "d1" separately.
   const dialect = opts?.dialect === "d1" ? "sqlite" : opts?.dialect;
+  const strategy: ColumnNamingStrategy = opts?.columnNamingStrategy ?? DEFAULT_COLUMN_NAMING_STRATEGY;
 
   // Pass 1: collect entities + their resolved table names.
   // Skip:
@@ -87,7 +97,7 @@ export function buildExpectedSchema(
   // Schema is resolved here (not stored in Pass 1) to avoid exactOptionalPropertyTypes
   // issues with `string | undefined` vs `schema?: string`.
   const tables: TableDescriptor[] = entities.map(({ entity, tableName }) => {
-    const t = buildTable(entity, tableName, resolveTargetTable, root as MetaRoot);
+    const t = buildTable(entity, tableName, resolveTargetTable, root as MetaRoot, strategy);
     const schema = resolveTableSchema(entity);
     if (schema !== undefined) t.schema = schema;
     return t;
@@ -113,7 +123,12 @@ export function buildExpectedSchema(
     }
   }
 
-  return { tables, views: [] };
+  // Pass 4: views from read-only projections. Built regardless of dialect so
+  // the diff produces correct create-view changes; emit() refuses them for
+  // sqlite/d1 with a clear error ("view migration not implemented for ...").
+  const views = buildExpectedViews(root as MetaRoot, strategy);
+
+  return { tables, views };
 }
 
 /**
@@ -143,6 +158,7 @@ function buildTable(
   tableName: string,
   resolveTargetTable: (entityName: string) => string | undefined,
   root: MetaRoot,
+  strategy: ColumnNamingStrategy,
 ): TableDescriptor {
   // Use effective accessors so inherited fields/identities (from `extends:` /
   // abstract bases like BaseEntity) are included.
@@ -155,7 +171,7 @@ function buildTable(
 
   const primaryKey = pkJsNames.map((jsName) => {
     const field = findField(entity, jsName);
-    return field ? resolveColumnName(field) : toSnake(jsName);
+    return field ? resolveColumnName(field, strategy) : applyColumnNamingStrategy(jsName, strategy);
   });
 
   const columns: ColumnDescriptor[] = [];
@@ -167,17 +183,17 @@ function buildTable(
     ) {
       // Flattened storage: expand nested value-object fields as prefixed columns.
       // The parent field.object itself does NOT produce its own column.
-      columns.push(...flattenObjectField(field, root));
+      columns.push(...flattenObjectField(field, root, strategy));
     } else {
-      columns.push(buildColumn(field, isPk, isPk ? pkGeneration : undefined));
+      columns.push(buildColumn(field, isPk, isPk ? pkGeneration : undefined, strategy));
     }
   }
 
   const descriptor: TableDescriptor = {
     name: tableName,
     columns,
-    indexes: buildSecondaryIndexes(entity, tableName),
-    foreignKeys: buildForeignKeys(entity, tableName, resolveTargetTable, root),
+    indexes: buildSecondaryIndexes(entity, tableName, strategy),
+    foreignKeys: buildForeignKeys(entity, tableName, resolveTargetTable, root, strategy),
     primaryKey,
   };
   const entityDesc = readDescription(entity);
@@ -196,7 +212,9 @@ function readDescription(node: { attr: (n: string) => unknown }): string | undef
   return typeof v === "string" && v.length > 0 ? v : undefined;
 }
 
-function buildSecondaryIndexes(entity: MetaObject, tableName: string): IndexDescriptor[] {
+function buildSecondaryIndexes(
+  entity: MetaObject, tableName: string, strategy: ColumnNamingStrategy,
+): IndexDescriptor[] {
   const indexes: IndexDescriptor[] = [];
 
   // (a) Implicit unique indexes from @unique fields. Drizzle auto-creates these
@@ -205,7 +223,7 @@ function buildSecondaryIndexes(entity: MetaObject, tableName: string): IndexDesc
   // doesn't see them as drop-only on the actual side.
   for (const field of entity.fields()) {
     if (field.ownAttr(FIELD_ATTR_UNIQUE) !== true) continue;
-    const colName = resolveColumnName(field);
+    const colName = resolveColumnName(field, strategy);
     indexes.push({
       name: `${tableName}_${colName}_unique`,
       columns: [colName],
@@ -221,7 +239,7 @@ function buildSecondaryIndexes(entity: MetaObject, tableName: string): IndexDesc
     if (fieldNames.length === 0) continue;
     const cols = fieldNames.map((jsName) => {
       const field = findField(entity, jsName);
-      return field ? resolveColumnName(field) : toSnake(jsName);
+      return field ? resolveColumnName(field, strategy) : applyColumnNamingStrategy(jsName, strategy);
     });
     const uniqueAttr = identity.ownAttr(IDENTITY_ATTR_UNIQUE);
     indexes.push({
@@ -238,6 +256,7 @@ function buildForeignKeys(
   tableName: string,
   resolveTargetTable: (entityName: string) => string | undefined,
   root: MetaRoot,
+  strategy: ColumnNamingStrategy,
 ): FkDescriptor[] {
   const fks: FkDescriptor[] = [];
   for (const refChild of entity.referenceIdentities()) {
@@ -253,7 +272,7 @@ function buildForeignKeys(
 
     const fkCols = fkFieldJsNames.map((jsName) => {
       const fkField = findField(entity, jsName);
-      return fkField ? resolveColumnName(fkField) : toSnake(jsName);
+      return fkField ? resolveColumnName(fkField, strategy) : applyColumnNamingStrategy(jsName, strategy);
     });
 
     // Target columns: prefer explicit multi-field dotted form, else delegate
@@ -261,8 +280,8 @@ function buildForeignKeys(
     // primary identity → "id" fallback).
     const explicitTargetFields = refChild.targetFields;
     const refColumns = explicitTargetFields.length > 1
-      ? explicitTargetFields.map(toSnake)
-      : [toSnake(refChild.resolvedTargetPkField(root) ?? "id")];
+      ? explicitTargetFields.map((n) => applyColumnNamingStrategy(n, strategy))
+      : [applyColumnNamingStrategy(refChild.resolvedTargetPkField(root) ?? "id", strategy)];
 
     const { onDelete, onUpdate } = resolveReferentialActions(entity, refChild);
     const constraintName = `${tableName}_${fkCols[0]}_fk`;
@@ -291,15 +310,17 @@ function buildForeignKeys(
  * EF OwnsOne pattern: no JSON column for the parent itself; each nested field
  * becomes `<parent_col>_<nested_col>` in the owning entity's table.
  */
-function flattenObjectField(field: MetaData, root: MetaRoot): ColumnDescriptor[] {
+function flattenObjectField(
+  field: MetaData, root: MetaRoot, strategy: ColumnNamingStrategy,
+): ColumnDescriptor[] {
   const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
   if (typeof ref !== "string" || ref.length === 0) return [];
   const targetObject = root.findObject(ref);
   if (targetObject === undefined) return [];
-  const prefix = resolveColumnName(field) + "_";
+  const prefix = resolveColumnName(field, strategy) + "_";
   const cols: ColumnDescriptor[] = [];
   for (const nested of targetObject.fields()) {
-    const inner = buildColumn(nested, /* isPk */ false, /* pkGeneration */ undefined);
+    const inner = buildColumn(nested, /* isPk */ false, /* pkGeneration */ undefined, strategy);
     cols.push({ ...inner, name: prefix + inner.name });
   }
   return cols;
@@ -317,14 +338,15 @@ function buildColumn(
   field: MetaData,
   isPk: boolean,
   pkGeneration: string | undefined,
+  strategy: ColumnNamingStrategy,
 ): ColumnDescriptor {
   // Both the @required attr and the validator.required child signal NOT NULL.
   const fieldIsRequired = isRequired(field);
   const defaultRaw = field.ownAttr(FIELD_ATTR_DEFAULT);
 
   const col: ColumnDescriptor = {
-    name: resolveColumnName(field),
-    sqlType: subtypeToSqlType(field.subType),
+    name: resolveColumnName(field, strategy),
+    sqlType: subtypeToSqlType(field),
     nullable: !isPk && !fieldIsRequired,
   };
 
@@ -345,9 +367,14 @@ function buildColumn(
   return col;
 }
 
-function subtypeToSqlType(subType: string): SqlType {
+function subtypeToSqlType(field: MetaData): SqlType {
+  const subType = field.subType;
   switch (subType) {
-    case FIELD_SUBTYPE_STRING:    return { kind: "text" };
+    case FIELD_SUBTYPE_STRING:    {
+      // @maxLength is declared as ATTR_SUBTYPE_INT so the loader coerces it to a number.
+      const m = field.ownAttr(FIELD_ATTR_MAX_LENGTH);
+      return typeof m === "number" ? { kind: "text", maxLength: m } : { kind: "text" };
+    }
     case FIELD_SUBTYPE_INT:
     case FIELD_SUBTYPE_SHORT:
     case FIELD_SUBTYPE_BYTE:      return { kind: "integer", bits: 32 };
@@ -366,9 +393,3 @@ function subtypeToSqlType(subType: string): SqlType {
   }
 }
 
-function toSnake(s: string): string {
-  return s
-    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
-    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-    .toLowerCase();
-}

package/src/expected-views.ts

@@ -0,0 +1,175 @@
+// expected-views.ts — derive ViewDescriptor[] from projection metadata.
+//
+// Ports the shape of csharp/MetaObjects.Codegen/Schema/PostgresSchema.cs's
+// CreateView. v1 supports:
+//
+//   * passthrough origin (no @via)  → plain column from the single base entity
+//   * aggregate origin (@agg/@of/@via) → correlated subquery over a to-many
+//
+// Deferred to v2 (returns a "-- TODO" view that the runner skips applying):
+//
+//   * passthrough origin WITH @via  → to-one correlated subquery
+//   * collection origin              → json_agg over a to-many
+//   * multi-base projections         → blocked
+//
+// Identifiers are quoted throughout so mixed-case column names (e.g.
+// "programId") survive PG's case-folding pass.
+
+import type { MetaObject, MetaRoot } from "@metaobjectsdev/metadata";
+import {
+  type ColumnNamingStrategy,
+  MetaPassthroughOrigin,
+  MetaAggregateOrigin,
+  MetaCollectionOrigin,
+  MetaSource,
+  SOURCE_ROLE_PRIMARY,
+  TYPE_OBJECT,
+  TYPE_ORIGIN,
+  resolveColumnName,
+  resolveTableName,
+  stripPackage,
+} from "@metaobjectsdev/metadata";
+import type { ViewDescriptor } from "./types.js";
+
+export function buildExpectedViews(root: MetaRoot, strategy: ColumnNamingStrategy): ViewDescriptor[] {
+  const out: ViewDescriptor[] = [];
+  for (const child of root.ownChildren()) {
+    if (child.type !== TYPE_OBJECT) continue;
+    const proj = child as MetaObject;
+    if (proj.isAbstract) continue;
+    if (!isReadOnlyProjection(proj)) continue;
+    const view = buildView(proj, root, strategy);
+    if (view !== null) out.push(view);
+  }
+  return out;
+}
+
+function isReadOnlyProjection(entity: MetaObject): boolean {
+  const sources = entity.ownChildren().filter((c): c is MetaSource => c instanceof MetaSource);
+  if (sources.length === 0) return false;
+  const hasReadOnly = sources.some((s) => s.isReadOnly());
+  const hasWritable = sources.some((s) => !s.isReadOnly());
+  return hasReadOnly && !hasWritable;
+}
+
+function buildView(
+  projection: MetaObject, root: MetaRoot, strategy: ColumnNamingStrategy,
+): ViewDescriptor | null {
+  const primarySource = projection.ownChildren().find(
+    (c): c is MetaSource => c instanceof MetaSource && c.role === SOURCE_ROLE_PRIMARY,
+  );
+  if (primarySource?.tableName === undefined) return null;
+  const viewName = primarySource.tableName;
+
+  const cols: string[] = [];
+  let baseEntity: string | undefined;
+  let blocked: string | undefined;
+  const T = "t"; // target alias in correlated subqueries
+
+  const baseTable = () => {
+    if (baseEntity === undefined) return undefined;
+    const found = root.findObject(baseEntity);
+    return found ? resolveTableName(found) : baseEntity;
+  };
+
+  for (const f of projection.fields()) {
+    const origin = f.ownChildren().find((c) => c.type === TYPE_ORIGIN);
+    const fieldCol = resolveColumnName(f, strategy);
+
+    if (origin instanceof MetaPassthroughOrigin && origin.via === undefined &&
+        origin.from !== undefined && origin.from.includes(".")) {
+      const [ent, field] = splitDot(origin.from);
+      const bare = stripPackage(ent);
+      baseEntity ??= bare;
+      if (bare !== baseEntity) { blocked = "passthrough from multiple base entities"; break; }
+      const srcEntity = root.findObject(baseEntity);
+      const srcCol = resolveColumnByName(srcEntity, field, strategy);
+      cols.push(`  "${srcCol}" AS "${fieldCol}"`);
+    } else if (origin instanceof MetaAggregateOrigin && origin.agg !== undefined &&
+               origin.of !== undefined && origin.via !== undefined &&
+               origin.of.includes(".") && origin.via.includes(".")) {
+      const [baseEnt, relName] = splitDot(origin.via);
+      const bareBase = stripPackage(baseEnt);
+      baseEntity ??= bareBase;
+      if (bareBase !== baseEntity) { blocked = "aggregate over a different base entity"; break; }
+      const fk = resolveToManyFk(root, baseEntity, relName, strategy);
+      if (fk === null) {
+        blocked = `unresolved to-many FK for @via "${origin.via}" (target needs an identity.reference back to ${baseEntity})`;
+        break;
+      }
+      const ofCol = resolveColumnByName(fk.target, splitDot(origin.of)[1], strategy);
+      cols.push(
+        `  (SELECT ${origin.agg}(${T}."${ofCol}") ` +
+        `FROM "${fk.targetTable}" ${T} ` +
+        `WHERE ${T}."${fk.fkCol}" = "${baseTable()}"."${fk.parentCol}") AS "${fieldCol}"`,
+      );
+    } else if (origin instanceof MetaPassthroughOrigin || origin instanceof MetaCollectionOrigin) {
+      blocked = `field "${f.name}" uses an origin shape not yet supported by TS migrate-ts (passthrough-via / collection — deferred)`;
+      break;
+    } else {
+      blocked = `field "${f.name}" has no resolvable origin`;
+      break;
+    }
+  }
+
+  if (blocked !== undefined || baseEntity === undefined || cols.length === 0) {
+    // Caller decides what to do with a null result. For v1 the runner just
+    // omits it from expected.views — diff sees no expected view, no
+    // create-view change, and an actual leftover view (if any) gets dropped.
+    return null;
+  }
+
+  const sql = `SELECT\n${cols.join(",\n")}\nFROM "${baseTable()}"`;
+  const view: ViewDescriptor = { name: viewName, sql };
+  return view;
+}
+
+function splitDot(s: string): [string, string] {
+  const i = s.indexOf(".");
+  return [s.slice(0, i), s.slice(i + 1)];
+}
+
+function resolveColumnByName(
+  owner: MetaObject | undefined, fieldName: string, strategy: ColumnNamingStrategy,
+): string {
+  if (owner === undefined) return fieldName;
+  const field = owner.fields().find((f) => f.name === fieldName);
+  return field ? resolveColumnName(field, strategy) : fieldName;
+}
+
+interface ToManyFk {
+  target: MetaObject;
+  targetTable: string;
+  /** Column on the target entity holding the FK back to the base. */
+  fkCol: string;
+  /** Column on the base entity the FK references (usually the base's PK). */
+  parentCol: string;
+}
+
+function resolveToManyFk(
+  root: MetaRoot, baseEntityName: string, relName: string, strategy: ColumnNamingStrategy,
+): ToManyFk | null {
+  const baseObj = root.findObject(baseEntityName);
+  if (baseObj === undefined) return null;
+  const rel = baseObj.relationships().find((r) => r.name === relName);
+  if (rel === undefined || rel.objectRef === undefined) return null;
+  const target = root.findObject(stripPackage(rel.objectRef));
+  if (target === undefined) return null;
+
+  const fkRef = target.referenceIdentities().find(
+    (r) => r.targetEntity !== undefined && stripPackage(r.targetEntity) === baseEntityName,
+  );
+  if (fkRef === undefined) return null;
+  const fkFields = fkRef.fields;
+  if (fkFields.length === 0) return null;
+  const fkCol = resolveColumnByName(target, fkFields[0]!, strategy);
+
+  const parentFieldName = fkRef.targetFields.length > 0
+    ? fkRef.targetFields[0]!
+    : baseObj.primaryIdentity()?.fields[0];
+  if (parentFieldName === undefined) return null;
+  const parentCol = resolveColumnByName(baseObj, parentFieldName, strategy);
+
+  return { target, targetTable: resolveTableName(target), fkCol, parentCol };
+}
+

package/src/introspect/d1.ts

@@ -33,10 +33,20 @@ export async function introspectD1(opts: IntrospectD1Options): Promise<SchemaSna
     return parseEnvelope(stdout);
   };
 
-  const versionRows = await exec("SELECT sqlite_version() AS v");
-  const meta: SnapshotMeta = {
-    sqliteVersion: String(versionRows[0]?.v ?? "0.0.0"),
-  };
+  // sqlite_version() is blocked by workerd's local D1 sandbox, so we fall back
+  // to a known-good static version (Cloudflare D1 ships a recent SQLite). Remote
+  // wrangler executions answer the function, so we try once and only fall back
+  // on failure. Keep this string ≥ any version-gated downstream feature checks
+  // (see emit/sqlite.ts → parseVersion).
+  let sqliteVersion = "3.44.0";
+  try {
+    const versionRows = await exec("SELECT sqlite_version() AS v");
+    const v = versionRows[0]?.v;
+    if (v !== undefined && v !== null) sqliteVersion = String(v);
+  } catch {
+    // Fall through to the static default — workerd local sandbox path.
+  }
+  const meta: SnapshotMeta = { sqliteVersion };
 
   const tableRows = await exec(
     "SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__new_%' ORDER BY name",

package/src/types.ts

@@ -82,7 +82,14 @@ export interface ViewDescriptor {
   name: string;
   /** Same semantics as TableDescriptor.schema. */
   schema?: string;
-  // structural fields deferred to v0.3
+  /**
+   * View body: everything between `CREATE VIEW <name> AS` and the trailing `;`
+   * (the SELECT clause through the FROM/WHERE/GROUP-BY tail). Populated by
+   * `buildExpectedSchema` from projection metadata; omitted by introspect
+   * (body-level comparison isn't implemented yet — diff matches by name only,
+   * so a body change does NOT trigger replace-view today).
+   */
+  sql?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -118,9 +125,9 @@ export type Change =
   | { kind: "add-fk"; table: string; schema?: string; fk: FkDescriptor; status: ChangeStatus }
   | { kind: "drop-fk"; table: string; schema?: string; fk: string; status: ChangeStatus }
   // Declared for v0.3, never produced in v0.1:
-  | { kind: "create-view"; view: ViewDescriptor; status: ChangeStatus }
-  | { kind: "drop-view"; view: string; status: ChangeStatus }
-  | { kind: "replace-view"; view: ViewDescriptor; status: ChangeStatus };
+  | { kind: "create-view"; view: ViewDescriptor; schema?: string; status: ChangeStatus }
+  | { kind: "drop-view"; view: string; schema?: string; status: ChangeStatus }
+  | { kind: "replace-view"; view: ViewDescriptor; schema?: string; status: ChangeStatus };
 
 export type ChangeKind = Change["kind"];