@stacksjs/database 0.70.161 → 0.70.162

package/dist/auth-tables.d.ts

@@ -47,7 +47,9 @@ export declare function usersStripeIdSql(): string;
  * password_changed_at, two_factor_secret, two_factor_enabled,
  * stripe_id), each independently try/catch-swallowed so one
  * already-existing column (or a not-yet-existing `users` table) never
- * skips the others. Exported so `buddy migrate`/`migrate:fresh` can
+ * skips the others. The schema-diff guard mirrors this set in
+ * `managed-columns.ts` (`USERS_GUARANTEED_COLUMNS`) so the differ never
+ * proposes dropping them (stacksjs/stacks#2075) — keep the two in sync. Exported so `buddy migrate`/`migrate:fresh` can
  * call it a second time after the numbered model migrations run — see
  * the call site in {@link migrateAuthTables} for why a single call
  * isn't enough.

package/dist/index.d.ts

@@ -107,6 +107,8 @@ export * from './custom/index';
 export * from './auth-tables';
 // uuid column guarantee for `useUuid` models (stacksjs/status#1 Phase 9)
 export * from './uuid-columns';
+// Schema-diff guards so trait-managed columns aren't proposed for dropping (stacksjs/stacks#2075)
+export * from './managed-columns';
 // Notification tables migration (stacksjs/stacks#1937)
 export { migrateNotificationTables } from './notification-tables';
 // RBAC tables migration (stacksjs/stacks#1941 Phase A)

package/dist/index.js

@@ -26,6 +26,7 @@ export * from "./drivers";
 export * from "./custom";
 export * from "./auth-tables";
 export * from "./uuid-columns";
+export * from "./managed-columns";
 export { migrateNotificationTables } from "./notification-tables";
 export { migrateRbacTables } from "./rbac-tables";
 export * from "./sql-helpers";

package/dist/managed-columns.d.ts

@@ -0,0 +1,31 @@
+import type { MigrationOperation } from '@stacksjs/query-builder';
+/**
+ * Resolve `table -> protected column names`: the `users` auth/billing columns
+ * plus `uuid` on every table backing a `useUuid` model. `findUuidTables` is
+ * lazy-imported so this module stays free of the model-walking ORM graph until
+ * actually resolving. Best-effort on the uuid side — if that walk fails we still
+ * guard the hardcoded `users` columns rather than losing the protection.
+ */
+export declare function frameworkManagedColumns(): Promise<Map<string, Set<string>>>;
+/** True when `op` would drop a column the framework guarantees at runtime. */
+export declare function isManagedColumnDrop(op: ColumnOp, managed: Map<string, Set<string>>): boolean;
+/** Return `operations` without any drop of a framework-managed column. */
+export declare function withoutManagedColumnDrops<T extends ColumnOp>(operations: T[], managed: Map<string, Set<string>>): T[];
+/**
+ * Remove generated SQL statements that drop a framework-managed column, so the
+ * drop is never written to a migration file. Catches both the direct
+ * `ALTER TABLE ... DROP COLUMN` form and, by matching the structured
+ * operations' own `sql`, the SQLite table-rebuild form (which drops a column by
+ * recreating the table without it). Pass `operations` when available for the
+ * rebuild case; the regex alone still covers the common direct form.
+ */
+export declare function withoutManagedColumnDropSql(statements: string[], managed: Map<string, Set<string>>, operations?: MigrationOperation[]): { statements: string[], removed: string[] };
+/**
+ * The `users` columns the framework guarantees via `ensureUsersAuthColumns`'s
+ * defensive ALTERs (auth-tables.ts) — created OUTSIDE any model's `attributes`.
+ * Kept here (a dependency-light module) so the differ guard doesn't drag in the
+ * ORM/query-builder graph. Keep in sync with `ensureUsersAuthColumns`.
+ */
+export declare const USERS_GUARANTEED_COLUMNS: readonly string[];
+/** A minimal view of a migration operation — all these helpers need. */
+declare type ColumnOp = Pick<MigrationOperation, 'kind' | 'table' | 'column'>;

package/dist/managed-columns.js

@@ -0,0 +1,46 @@
+export const USERS_GUARANTEED_COLUMNS = [
+  "email_verified_at",
+  "password_changed_at",
+  "two_factor_secret",
+  "two_factor_enabled",
+  "two_factor_last_used_step",
+  "stripe_id"
+];
+export async function frameworkManagedColumns() {
+  const managed = new Map;
+  managed.set("users", new Set(USERS_GUARANTEED_COLUMNS));
+  try {
+    const { findUuidTables } = await import("./uuid-columns");
+    for (const table of await findUuidTables()) {
+      const columns = managed.get(table) ?? new Set;
+      columns.add("uuid");
+      managed.set(table, columns);
+    }
+  } catch {}
+  return managed;
+}
+export function isManagedColumnDrop(op, managed) {
+  return op.kind === "drop_column" && op.column != null && (managed.get(op.table)?.has(op.column) ?? !1);
+}
+export function withoutManagedColumnDrops(operations, managed) {
+  return operations.filter((op) => !isManagedColumnDrop(op, managed));
+}
+function normalizeSql(sql) {
+  return sql.trim().replace(/\s+/g, " ").replace(/;+\s*$/, "");
+}
+const DROP_COLUMN_RE = /ALTER\s+TABLE\s+["'`]?(\w+)["'`]?\s+DROP\s+COLUMN\s+(?:IF\s+EXISTS\s+)?["'`]?(\w+)["'`]?/i;
+export function withoutManagedColumnDropSql(statements, managed, operations = []) {
+  const protectedSql = new Set(operations.filter((op) => isManagedColumnDrop(op, managed)).map((op) => normalizeSql(op.sql))), removed = [];
+  return { statements: statements.filter((statement) => {
+    if (protectedSql.has(normalizeSql(statement))) {
+      removed.push(statement);
+      return !1;
+    }
+    const match = statement.match(DROP_COLUMN_RE);
+    if (match?.[1] && match[2] && (managed.get(match[1])?.has(match[2]) ?? !1)) {
+      removed.push(statement);
+      return !1;
+    }
+    return !0;
+  }), removed };
+}

package/dist/migrations.js

@@ -20,6 +20,7 @@ import {
   setConfig
 } from "@stacksjs/query-builder";
 import { db } from "./utils";
+import { frameworkManagedColumns, withoutManagedColumnDrops, withoutManagedColumnDropSql } from "./managed-columns";
 import { acquireMigrationLock } from "./migration-lock";
 import { env as envVars } from "@stacksjs/env";
 import { getConnectionDefaults } from "./defaults";
@@ -454,8 +455,10 @@ export async function previewPendingMigrations(options = {}) {
     const dialect = getDialect(), { modelsDir, skip } = prepareMigrationModelsDir();
     if (skip)
       return [];
-    const { applyRenames, fromDb } = resolveGenerateOptions(options);
-    return (await qbGenerateMigration(modelsDir, { dialect: getQbDialect(), dryRun: !0, applyRenames, fromDb })).operations ?? [];
+    const { applyRenames, fromDb } = resolveGenerateOptions(options), operations = (await qbGenerateMigration(modelsDir, { dialect: getQbDialect(), dryRun: !0, applyRenames, fromDb })).operations ?? [];
+    if (!operations.some((op) => op.kind === "drop_column"))
+      return operations;
+    return withoutManagedColumnDrops(operations, await frameworkManagedColumns());
   } catch (error) {
     log.debug(`[migration] preview failed: ${error instanceof Error ? error.message : String(error)}`);
     return [];
@@ -494,8 +497,15 @@ export async function generateMigrations(options = {}) {
     const { applyRenames, fromDb } = resolveGenerateOptions(options);
     log.debug(`[migration] Generating migrations for dialect: ${dialect}, models: ${modelsDir}`);
     const result = await qbGenerateMigration(modelsDir, { dialect: getQbDialect(), dryRun: !0, applyRenames, fromDb });
+    let sqlStatements = result.sqlStatements ?? [];
+    if (result.hasChanges && sqlStatements.length > 0) {
+      const filtered = withoutManagedColumnDropSql(sqlStatements, await frameworkManagedColumns(), result.operations ?? []);
+      if (filtered.removed.length > 0)
+        log.debug(`[migration] Skipped ${filtered.removed.length} generated drop(s) of framework-managed column(s) (stacksjs/stacks#2075)`);
+      sqlStatements = filtered.statements;
+    }
     if (result.hasChanges) {
-      const written = persistGeneratedMigrations(result.sqlStatements ?? []);
+      const written = persistGeneratedMigrations(sqlStatements);
       if (written > 0)
         log.success(`Generated ${written} migration file${written === 1 ? "" : "s"}`);
       else

package/dist/types.js

@@ -54,7 +54,7 @@ const SAFE_FILTER_OPERATORS = new Set([
   "is",
   "is not"
 ]);
-function inlineSqlLiteral(value) {
+function inlineSqlLiteral(_value) {
   if (value === null || value === void 0)
     return "NULL";
   if (typeof value === "number") {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/database",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.161",
+  "version": "0.70.162",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "contributors": [
@@ -60,15 +60,15 @@
     "dynamodb-tooling": "^0.3.2"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.161",
-    "@stacksjs/config": "0.70.161",
-    "@stacksjs/logging": "0.70.161",
-    "@stacksjs/router": "0.70.161",
+    "@stacksjs/cli": "0.70.162",
+    "@stacksjs/config": "0.70.162",
+    "@stacksjs/logging": "0.70.162",
+    "@stacksjs/router": "0.70.162",
     "better-dx": "^0.2.17",
-    "@stacksjs/path": "0.70.161",
-    "@stacksjs/query-builder": "0.70.161",
-    "@stacksjs/storage": "0.70.161",
-    "@stacksjs/strings": "0.70.161",
-    "@stacksjs/utils": "0.70.161"
+    "@stacksjs/path": "0.70.162",
+    "@stacksjs/query-builder": "0.70.162",
+    "@stacksjs/storage": "0.70.162",
+    "@stacksjs/strings": "0.70.162",
+    "@stacksjs/utils": "0.70.162"
   }
 }