nextly 0.0.2-alpha.7 → 0.0.2-alpha.9

package/dist/{chunk-66ZNVKTF.mjs → chunk-HSIAXEYF.mjs}

@@ -5,16 +5,16 @@ import {
   countRows,
   diffSnapshots,
   introspectLiveSnapshot
-} from "./chunk-J4KHGYOM.mjs";
+} from "./chunk-JCQMC6HH.mjs";
 import {
   ComponentSchemaService
-} from "./chunk-JXZITQPZ.mjs";
+} from "./chunk-4HUQNXVM.mjs";
 import {
   generateRuntimeSchema
-} from "./chunk-UB4CALU5.mjs";
+} from "./chunk-2QSGNGOB.mjs";
 import {
   getDialectTables
-} from "./chunk-TS7GHTG2.mjs";
+} from "./chunk-YXZH65YV.mjs";
 
 // src/domains/schema/pipeline/errors.ts
 import { UnsupportedDialectVersionError } from "@nextlyhq/adapter-drizzle/version-check";
@@ -285,9 +285,6 @@ var RealPreCleanupExecutor = class {
   }
 };
 
-// src/domains/schema/pipeline/pushschema-pipeline.ts
-import { dequal } from "dequal";
-
 // src/init/schema-snapshot-cache.ts
 var g = globalThis;
 function getCachedSnapshot() {
@@ -296,6 +293,27 @@ function getCachedSnapshot() {
 function setCachedSnapshot(snapshot) {
   g.__nextly_prevSchemaSnapshot = snapshot;
 }
+function keyOf(tableNames) {
+  return [...tableNames].sort().join(" ");
+}
+function bag() {
+  return globalThis;
+}
+function getLiveSnapshot(managedTableNames) {
+  return bag().__nextly_liveSnapshots?.get(keyOf(managedTableNames));
+}
+function setLiveSnapshot(managedTableNames, snapshot) {
+  const b = bag();
+  if (!b.__nextly_liveSnapshots) b.__nextly_liveSnapshots = /* @__PURE__ */ new Map();
+  b.__nextly_liveSnapshots.set(keyOf(managedTableNames), snapshot);
+}
+function clearLiveSnapshots() {
+  const b = bag();
+  if (b.__nextly_liveSnapshots) b.__nextly_liveSnapshots.clear();
+}
+
+// src/domains/schema/pipeline/pushschema-pipeline.ts
+import { dequal } from "dequal";
 
 // src/runtime/notifications/build-event.ts
 function buildNotificationEvent(args) {
@@ -323,6 +341,96 @@ function buildNotificationEvent(args) {
   };
 }
 
+// src/domains/schema/pipeline/ddl-emitter/identifiers.ts
+function quoteIdent(identifier) {
+  if (identifier.includes("\0")) {
+    throw new Error(
+      `Invalid identifier (contains NUL byte): ${JSON.stringify(identifier)}`
+    );
+  }
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+// src/domains/schema/pipeline/ddl-emitter/postgres.ts
+function columnTail(col) {
+  let s = col.type;
+  if (col.nullable === false) s += " NOT NULL";
+  if (col.default !== void 0) s += ` DEFAULT ${col.default}`;
+  return s;
+}
+function createTableColumn(col) {
+  if (col.name === "id") {
+    return `${quoteIdent(col.name)} ${col.type} PRIMARY KEY NOT NULL`;
+  }
+  return `${quoteIdent(col.name)} ${columnTail(col)}`;
+}
+function createTableCanonicalIndexes(spec) {
+  const colNames = new Set(spec.columns.map((c) => c.name));
+  const stmts = [];
+  if (colNames.has("slug")) {
+    stmts.push(
+      `CREATE UNIQUE INDEX ${quoteIdent(`idx_${spec.name}_slug`)} ON ${quoteIdent(spec.name)} USING btree (${quoteIdent("slug")})`
+    );
+  }
+  if (colNames.has("created_at")) {
+    stmts.push(
+      `CREATE INDEX ${quoteIdent(`idx_${spec.name}_created_at`)} ON ${quoteIdent(spec.name)} USING btree (${quoteIdent("created_at")} DESC)`
+    );
+  }
+  return stmts;
+}
+function emitPostgresDdl(op) {
+  switch (op.type) {
+    case "rename_table":
+    case "rename_column":
+    case "drop_column":
+    case "drop_table":
+      return [];
+    case "add_column":
+      return [
+        `ALTER TABLE ${quoteIdent(op.tableName)} ADD COLUMN ${quoteIdent(op.column.name)} ${columnTail(op.column)}`
+      ];
+    case "add_table": {
+      const cols = op.table.columns.map(createTableColumn);
+      const createTable = `CREATE TABLE ${quoteIdent(op.table.name)} (
+  ${cols.join(",\n  ")}
+)`;
+      return [createTable, ...createTableCanonicalIndexes(op.table)];
+    }
+    case "change_column_type":
+    case "change_column_nullable":
+    case "change_column_default":
+      throw new Error(
+        `emitPostgresDdl: op type "${op.type}" not yet implemented \u2014 canEmitWithoutDrizzleKit should not have routed it here`
+      );
+    default: {
+      const exhaustive = op;
+      throw new Error(
+        `emitPostgresDdl: unknown op ${JSON.stringify(exhaustive)}`
+      );
+    }
+  }
+}
+
+// src/domains/schema/pipeline/ddl-emitter/index.ts
+var FAST_PATH_OP_TYPES = /* @__PURE__ */ new Set([
+  "add_column",
+  "add_table"
+]);
+function canEmitWithoutDrizzleKit(ops, dialect) {
+  if (dialect !== "postgresql") return false;
+  if (ops.length === 0) return false;
+  return ops.every((op) => FAST_PATH_OP_TYPES.has(op.type));
+}
+function emitDdl(ops, dialect) {
+  if (dialect !== "postgresql") {
+    throw new Error(
+      `emitDdl: unsupported dialect "${dialect}" (fast path is PostgreSQL-only)`
+    );
+  }
+  return ops.flatMap((op) => emitPostgresDdl(op));
+}
+
 // src/domains/schema/pipeline/managed-tables.ts
 var MANAGED_TABLE_PREFIXES_REGEX = /^(dc_|single_|comp_)/;
 function isManagedTable(name) {
@@ -393,7 +501,7 @@ function isPreResolutionOp(op) {
 }
 
 // src/domains/schema/pipeline/sql-templates/identifier-quoting.ts
-function quoteIdent(name, dialect) {
+function quoteIdent2(name, dialect) {
   const q4 = dialect === "mysql" ? "`" : '"';
   if (name.includes(q4)) {
     throw new Error(
@@ -404,7 +512,7 @@ function quoteIdent(name, dialect) {
 }
 
 // src/domains/schema/pipeline/sql-templates/mysql.ts
-var q = (n) => quoteIdent(n, "mysql");
+var q = (n) => quoteIdent2(n, "mysql");
 function columnDef(c) {
   const nullable = c.nullable ? "" : " NOT NULL";
   const def = c.default !== void 0 ? ` DEFAULT ${c.default}` : "";
@@ -480,7 +588,7 @@ var MysqlUnsupportedOperationError = class extends Error {
 };
 
 // src/domains/schema/pipeline/sql-templates/postgres.ts
-var q2 = (n) => quoteIdent(n, "postgresql");
+var q2 = (n) => quoteIdent2(n, "postgresql");
 function columnDef2(c) {
   const nullable = c.nullable ? "" : " NOT NULL";
   const def = c.default !== void 0 ? ` DEFAULT ${c.default}` : "";
@@ -547,7 +655,7 @@ function generateChangeColumnDefault2(op) {
 }
 
 // src/domains/schema/pipeline/sql-templates/sqlite.ts
-var q3 = (n) => quoteIdent(n, "sqlite");
+var q3 = (n) => quoteIdent2(n, "sqlite");
 function columnDef3(c) {
   const nullable = c.nullable ? "" : " NOT NULL";
   const def = c.default !== void 0 ? ` DEFAULT ${c.default}` : "";
@@ -777,6 +885,29 @@ var DdlExecutionError = class extends Error {
     this.name = "DdlExecutionError";
   }
 };
+var ORPHAN_DROP_PATTERNS = [
+  {
+    kind: "SEQUENCE",
+    re: /^DROP\s+SEQUENCE\s+(?:IF\s+EXISTS\s+)?(?:["`]?\w+["`]?\.)?["`]?(\w+)["`]?/i
+  },
+  {
+    kind: "INDEX",
+    re: /^DROP\s+INDEX\s+(?:IF\s+EXISTS\s+)?(?:["`]?\w+["`]?\.)?["`]?(\w+)["`]?/i
+  }
+];
+function logApplyRoute(useFastPath, ops) {
+  if (process.env.DEBUG_SCHEMA !== "1") return;
+  if (useFastPath) {
+    console.debug(
+      `[nextly] schema apply: fast-path DDL emitter (${ops.length} op(s))`
+    );
+    return;
+  }
+  const nonAdditive = ops.filter((o) => o.type !== "add_column" && o.type !== "add_table").map((o) => o.type);
+  console.debug(
+    `[nextly] schema apply: drizzle-kit fallback (${ops.length} op(s); non-additive: ${nonAdditive.length === 0 ? "<none>" : nonAdditive.join(",")})`
+  );
+}
 function computeJournalSummaryFromOperations(operations) {
   let added = 0;
   let removed = 0;
@@ -864,11 +995,17 @@ var PushSchemaPipeline = class {
         ...Object.values(desired.singles).map((s) => s.tableName),
         ...Object.values(desired.components).map((c) => c.tableName)
       ];
-      const liveSnapshot = this.testHooks._introspectSnapshotOverride ? await this.testHooks._introspectSnapshotOverride(
-        db,
-        dialect,
-        managedTableNames
-      ) : await introspectLiveSnapshot(db, dialect, managedTableNames);
+      let liveSnapshot;
+      if (this.testHooks._introspectSnapshotOverride) {
+        liveSnapshot = await this.testHooks._introspectSnapshotOverride(
+          db,
+          dialect,
+          managedTableNames
+        );
+      } else {
+        const cached2 = getLiveSnapshot(managedTableNames);
+        liveSnapshot = cached2 !== void 0 ? cached2 : await introspectLiveSnapshot(db, dialect, managedTableNames);
+      }
       const desiredSnapshot = {
         tables: [
           ...Object.values(desired.collections).map(
@@ -910,9 +1047,17 @@ var PushSchemaPipeline = class {
         countRows: (table) => countRows(db, dialect, table),
         dialect
       });
-      const dispatchResult = candidates.length > 0 || classificationResult.level !== "safe" ? await this.deps.promptDispatcher.dispatch({
+      const dropsCoveredByCandidates = /* @__PURE__ */ new Set();
+      for (const c of candidates) {
+        dropsCoveredByCandidates.add(`${c.tableName}::${c.fromColumn}`);
+      }
+      const dispatchEvents = classificationResult.events.filter(
+        (e) => e.kind !== "destructive_drop" || !dropsCoveredByCandidates.has(`${e.tableName}::${e.columnName}`)
+      );
+      const needsPrompt = candidates.length > 0 || dispatchEvents.length > 0;
+      const dispatchResult = needsPrompt ? await this.deps.promptDispatcher.dispatch({
         candidates,
-        events: classificationResult.events,
+        events: dispatchEvents,
         classification: classificationResult.level,
         channel: promptChannel
       }) : {
@@ -928,11 +1073,43 @@ var PushSchemaPipeline = class {
         dispatchResult.resolutions,
         classificationResult.events
       );
-      const resolvedOps = applyResolutionsToOperations(
+      const resolvedOps = this.testHooks._resolvedOpsOverride ?? applyResolutionsToOperations(
         operations,
         toRenameResolutions(dispatchResult.confirmedRenames, candidates)
       );
       const drizzleSchema = this.testHooks._buildDrizzleSchemaOverride ? this.testHooks._buildDrizzleSchemaOverride(patchedDesired, dialect) : this.buildDrizzleSchema(patchedDesired, dialect);
+      const affectedTableNames = /* @__PURE__ */ new Set();
+      for (const op of resolvedOps) {
+        switch (op.type) {
+          case "add_table":
+            affectedTableNames.add(op.table.name);
+            break;
+          case "rename_table":
+            affectedTableNames.add(op.toName);
+            break;
+          case "drop_table":
+            break;
+          case "add_column":
+          case "drop_column":
+          case "rename_column":
+          case "change_column_type":
+          case "change_column_nullable":
+          case "change_column_default":
+            affectedTableNames.add(op.tableName);
+            break;
+          default: {
+            const _exhaustive = op;
+            void _exhaustive;
+          }
+        }
+      }
+      const scopedSchema = {};
+      for (const [tableName, tableObj] of Object.entries(drizzleSchema)) {
+        if (affectedTableNames.has(tableName)) {
+          scopedSchema[tableName] = tableObj;
+        }
+      }
+      const effectiveDrizzleSchema = Object.keys(scopedSchema).length > 0 ? scopedSchema : drizzleSchema;
       const kit = this.testHooks._kitOverride ? this.testHooks._kitOverride : await this.importDrizzleKit(dialect, databaseName);
       const isSqlite = dialect === "sqlite";
       const runApply = async (tx) => {
@@ -970,22 +1147,30 @@ var PushSchemaPipeline = class {
             err
           );
         }
-        const desiredTableNames = Object.keys(drizzleSchema);
-        let pushResult;
-        try {
-          pushResult = await withCapturedStdout(
-            () => kit.pushSchema(drizzleSchema, tx, desiredTableNames),
-            // eslint-disable-next-line turbo/no-undeclared-env-vars
-            process.env.DEBUG_SCHEMA === "1" ? { debug: (msg) => console.debug(msg) } : void 0
-          );
-        } catch (err) {
-          throw new PushSchemaError(
-            err instanceof Error ? err.message : String(err),
-            err
-          );
+        const desiredTableNames = Object.keys(effectiveDrizzleSchema);
+        const useFastPath = canEmitWithoutDrizzleKit(resolvedOps, dialect);
+        logApplyRoute(useFastPath, resolvedOps);
+        let emittedStatements;
+        if (useFastPath) {
+          emittedStatements = emitDdl(resolvedOps, dialect);
+        } else {
+          let pushResult;
+          try {
+            pushResult = await withCapturedStdout(
+              () => kit.pushSchema(effectiveDrizzleSchema, tx, desiredTableNames),
+              // eslint-disable-next-line turbo/no-undeclared-env-vars
+              process.env.DEBUG_SCHEMA === "1" ? { debug: (msg) => console.debug(msg) } : void 0
+            );
+          } catch (err) {
+            throw new PushSchemaError(
+              err instanceof Error ? err.message : String(err),
+              err
+            );
+          }
+          emittedStatements = pushResult.statementsToExecute;
         }
         const safe = this.filterUnsafeStatements(
-          pushResult.statementsToExecute,
+          emittedStatements,
           desiredTableNames
         );
         try {
@@ -1066,25 +1251,67 @@ var PushSchemaPipeline = class {
     }
   }
   filterUnsafeStatements(statements, desiredTableNames) {
-    const desiredSet = new Set(
-      desiredTableNames.map((t) => t.toLowerCase())
-    );
+    const desiredSet = new Set(desiredTableNames.map((t) => t.toLowerCase()));
     return statements.filter((stmt) => {
       const dropMatch = stmt.match(
         /^DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:["`]?\w+["`]?\.)?["`]?(\w+)["`]?/i
       );
-      if (!dropMatch) return true;
-      const tableName = dropMatch[1] ?? "<unknown>";
-      const isInDesired = desiredSet.has(tableName.toLowerCase());
-      if (isInDesired) {
-        return true;
+      if (dropMatch) {
+        const tableName = dropMatch[1] ?? "<unknown>";
+        const isInDesired = desiredSet.has(tableName.toLowerCase());
+        if (isInDesired) {
+          return true;
+        }
+        console.warn(
+          `[Nextly schema] Blocked DROP TABLE "${tableName}" emitted by drizzle-kit pushSchema (table not in current desired schema). If this drop was intentional, route it through the pre-resolution executor with explicit user confirmation. (managed=${isManagedTable(tableName)})`
+        );
+        return false;
       }
-      console.warn(
-        `[Nextly schema] Blocked DROP TABLE "${tableName}" emitted by drizzle-kit pushSchema (table not in current desired schema). If this drop was intentional, route it through the pre-resolution executor with explicit user confirmation. (managed=${isManagedTable(tableName)})`
-      );
-      return false;
+      for (const { kind, re } of ORPHAN_DROP_PATTERNS) {
+        const m = stmt.match(re);
+        if (!m) continue;
+        const objectName = m[1] ?? "";
+        if (this.inferOwnerTableFromObjectName(objectName, desiredSet) !== null) {
+          return true;
+        }
+        console.warn(
+          `[Nextly schema] Blocked DROP ${kind} "${objectName}" emitted by drizzle-kit pushSchema (owner table not in current desired schema or name is non-conventional). If this drop was intentional, route it through the pre-resolution executor with explicit user confirmation, or drop it manually before re-running if the ${kind.toLowerCase()} name is custom.`
+        );
+        return false;
+      }
+      return true;
     });
   }
+  /**
+   * Infers the owner table of a sequence or index from its name using
+   * Postgres's default naming conventions:
+   *   - SERIAL / IDENTITY sequences: `<table>_<col>_seq`
+   *   - Indexes:                      `<table>_<col(s)>_idx | _key | _pkey | _unique`
+   *
+   * Strategy: walk underscore-delimited prefixes from longest to shortest
+   * and return the first candidate found in `desiredSet`. Longest-first
+   * ensures that multi-word table names like `email_templates` are
+   * preferred over the shorter prefix `email`.
+   *
+   * Examples:
+   *   accounts_id_seq          → "accounts"        (if in desiredSet)
+   *   email_templates_id_seq   → "email_templates" (if in desiredSet)
+   *   dc_posts_title_idx       → "dc_posts"        (if in desiredSet)
+   *   idx_completely_custom    → null              (no prefix matches)
+   *
+   * Returns the matched table name (lowercased) or `null` if no prefix
+   * in `desiredSet` was found. A `null` result means we can't identify
+   * the owner, and the caller should treat the statement as unsafe.
+   */
+  inferOwnerTableFromObjectName(objectName, desiredSet) {
+    const lower = objectName.toLowerCase();
+    const parts = lower.split("_");
+    for (let i = parts.length - 1; i > 0; i--) {
+      const candidate = parts.slice(0, i).join("_");
+      if (desiredSet.has(candidate)) return candidate;
+    }
+    return null;
+  }
   async runSqlitePragma(db, pragma) {
     const { sql: sqlTag } = await import("drizzle-orm");
     const dbTyped = db;
@@ -1455,6 +1682,8 @@ export {
   TTYRequiredError,
   PromptCancelledError,
   RealPreCleanupExecutor,
+  setLiveSnapshot,
+  clearLiveSnapshots,
   generateSQL,
   PushSchemaPipeline,
   noopPreRenameExecutor,

package/dist/{chunk-QOH5I67F.mjs → chunk-JAOH2TTZ.mjs}

@@ -1,6 +1,6 @@
 import {
   ClackTerminalPromptDispatcher
-} from "./chunk-FQH647CT.mjs";
+} from "./chunk-NJ3LXLSJ.mjs";
 import {
   getAdapterFromDI,
   getCollectionRegistryFromDI,
@@ -14,11 +14,11 @@ import {
   getProductionNotifier,
   noopMigrationJournal,
   noopPreRenameExecutor
-} from "./chunk-66ZNVKTF.mjs";
+} from "./chunk-HSIAXEYF.mjs";
 import {
   RealClassifier,
   RegexRenameDetector
-} from "./chunk-J4KHGYOM.mjs";
+} from "./chunk-JCQMC6HH.mjs";
 
 // src/domains/schema/pipeline/snapshot.ts
 function buildDesiredSchemaFromRegistry(registry, overrides) {

package/dist/{chunk-J4KHGYOM.mjs → chunk-JCQMC6HH.mjs}

@@ -1,7 +1,7 @@
 import {
   getColumnDescriptor,
   getSystemColumnDescriptors
-} from "./chunk-L5FA2FAY.mjs";
+} from "./chunk-463A2UDH.mjs";
 
 // src/domains/schema/pipeline/classifier/count-helpers.ts
 import { sql } from "drizzle-orm";
@@ -214,6 +214,17 @@ var RealClassifier = class {
             ]
           });
         }
+      } else if (op.type === "drop_column") {
+        const tableRowCount = await args.countRows(op.tableName);
+        events.push({
+          id: formatEventId("destructive_drop", op.tableName, op.columnName),
+          kind: "destructive_drop",
+          tableName: op.tableName,
+          columnName: op.columnName,
+          columnType: op.columnType,
+          tableRowCount,
+          applicableResolutions: ["confirm_drop", "abort"]
+        });
       }
     }
     const hasInteractive = events.some((e) => e.kind !== "type_change");
@@ -430,6 +441,62 @@ function buildDesiredTableFromComponentFields(tableName, fields, dialect) {
   return { name: tableName, columns };
 }
 
+// src/domains/schema/pipeline/diff/normalize-default.ts
+var PG_REDUNDANT_CAST_TYPES = [
+  // Two-word forms come first so the regex prefers the longer match.
+  "character varying",
+  "character",
+  "double precision",
+  "timestamp without time zone",
+  "timestamp with time zone",
+  "time without time zone",
+  "time with time zone",
+  // Single-word forms.
+  "text",
+  "varchar",
+  "bpchar",
+  "integer",
+  "bigint",
+  "smallint",
+  "numeric",
+  "real",
+  "boolean",
+  "uuid",
+  "jsonb",
+  "json"
+];
+var CAST_SUFFIX_RE = new RegExp(
+  `::(?:${PG_REDUNDANT_CAST_TYPES.join("|")})$`,
+  "i"
+);
+var NORMALIZE_LOWERCASE_FUNCTIONS = /* @__PURE__ */ new Set(["now()"]);
+function normalizeDefault(expr) {
+  if (expr === void 0) return void 0;
+  let normalised = stripRedundantCast(expr);
+  const lower = normalised.toLowerCase();
+  if (NORMALIZE_LOWERCASE_FUNCTIONS.has(lower)) {
+    normalised = lower;
+  }
+  return normalised;
+}
+function stripRedundantCast(expr) {
+  const match = expr.match(CAST_SUFFIX_RE);
+  if (!match) return expr;
+  const beforeCast = expr.slice(0, match.index);
+  if (isCompleteLiteral(beforeCast)) {
+    return beforeCast;
+  }
+  return expr;
+}
+function isCompleteLiteral(value) {
+  if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+    return true;
+  }
+  if (/^-?[0-9]+(?:\.[0-9]+)?$/.test(value)) return true;
+  if (value === "true" || value === "false") return true;
+  return false;
+}
+
 // src/domains/schema/pipeline/diff/diff.ts
 function diffSnapshots(prev, cur) {
   const prevByName = /* @__PURE__ */ new Map();
@@ -509,7 +576,7 @@ function diffColumns(tableName, prev, cur) {
           toNullable: curC.nullable
         });
       }
-      if (prevC.default !== curC.default) {
+      if (normalizeDefault(prevC.default) !== normalizeDefault(curC.default)) {
         defaultChanges.push({
           type: "change_column_default",
           tableName,

package/dist/{chunk-LPVOTXNV.mjs → chunk-KLICUQPV.mjs}

@@ -1,7 +1,7 @@
 import {
   CreatePermissionSchema,
   ServiceContainer
-} from "./chunk-ZVN3JILF.mjs";
+} from "./chunk-KPCSDPFQ.mjs";
 
 // src/database/seeders/permissions.ts
 var RESOURCES = ["users", "roles", "permissions"];