@stacksjs/database 0.70.228 → 0.70.230

package/dist/custom/jobs.js

@@ -87,7 +87,12 @@ CREATE TABLE IF NOT EXISTS failed_jobs (
   queue TEXT NOT NULL,
   payload TEXT NOT NULL,
   exception TEXT NOT NULL,
-  failed_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  attempts INTEGER,
+  max_attempts INTEGER,
+  duration_ms INTEGER,
+  failed_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME
 );
 
 -- Create job_batches table
@@ -179,7 +184,12 @@ CREATE TABLE IF NOT EXISTS failed_jobs (
   queue VARCHAR(255) NOT NULL,
   payload LONGTEXT NOT NULL,
   exception LONGTEXT NOT NULL,
-  failed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  attempts INT NULL,
+  max_attempts INT NULL,
+  duration_ms INT NULL,
+  failed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP NULL
 );
 
 -- Create job_batches table
@@ -256,7 +266,12 @@ CREATE TABLE IF NOT EXISTS failed_jobs (
   queue VARCHAR(255) NOT NULL,
   payload TEXT NOT NULL,
   exception TEXT NOT NULL,
-  failed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  attempts INTEGER,
+  max_attempts INTEGER,
+  duration_ms INTEGER,
+  failed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP
 );
 
 -- Create job_batches table
@@ -342,7 +357,12 @@ CREATE TABLE IF NOT EXISTS queue_circuit_state (
             queue TEXT NOT NULL,
             payload TEXT NOT NULL,
             exception TEXT NOT NULL,
-            failed_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            attempts INTEGER,
+            max_attempts INTEGER,
+            duration_ms INTEGER,
+            failed_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            updated_at DATETIME
           )`);
           sqlite.close();
         } else if (driver === "mysql") {
@@ -364,7 +384,12 @@ CREATE TABLE IF NOT EXISTS queue_circuit_state (
             queue VARCHAR(255) NOT NULL,
             payload LONGTEXT NOT NULL,
             exception LONGTEXT NOT NULL,
-            failed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            attempts INT NULL,
+            max_attempts INT NULL,
+            duration_ms INT NULL,
+            failed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP NULL
           )`).execute();
         } else if (driver === "postgres") {
           const { db } = await import("../utils");
@@ -385,7 +410,12 @@ CREATE TABLE IF NOT EXISTS queue_circuit_state (
             queue VARCHAR(255) NOT NULL,
             payload TEXT NOT NULL,
             exception TEXT NOT NULL,
-            failed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            attempts INTEGER,
+            max_attempts INTEGER,
+            duration_ms INTEGER,
+            failed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP
           )`).execute();
         }
         console.log("\u2713 Jobs and failed_jobs tables created");

package/dist/drivers/defaults/traits.js

@@ -964,14 +964,26 @@ export async function createQueryLogsTable() {
   migrationContent += `    .addColumn('connection', 'varchar(255)')
 `;
   migrationContent += `    .addColumn('status', 'varchar(50)')
+`;
+  migrationContent += `    .addColumn('error', 'text')
 `;
   migrationContent += `    .addColumn('executed_at', 'timestamp', col => col.notNull())
+`;
+  migrationContent += `    .addColumn('trace', 'text')
 `;
   migrationContent += `    .addColumn('model', 'varchar(255)')
 `;
   migrationContent += `    .addColumn('method', 'varchar(255)')
+`;
+  migrationContent += `    .addColumn('file', 'text')
+`;
+  migrationContent += `    .addColumn('line', 'integer')
+`;
+  migrationContent += `    .addColumn('memory_usage', 'real')
 `;
   migrationContent += `    .addColumn('rows_affected', 'integer')
+`;
+  migrationContent += `    .addColumn('transaction_id', 'varchar(255)')
 `;
   migrationContent += `    .addColumn('optimization_suggestions', 'json')
 `;
@@ -980,6 +992,8 @@ export async function createQueryLogsTable() {
   migrationContent += `    .addColumn('indexes_used', 'json')
 `;
   migrationContent += `    .addColumn('missing_indexes', 'json')
+`;
+  migrationContent += `    .addColumn('explain_plan', 'json')
 `;
   migrationContent += `    .addColumn('tags', 'json')
 `;
@@ -1056,14 +1070,26 @@ export async function createPostgresQueryLogsTable() {
   migrationContent += `    .addColumn('connection', 'varchar(255)')
 `;
   migrationContent += `    .addColumn('status', 'varchar(50)')
+`;
+  migrationContent += `    .addColumn('error', 'text')
 `;
   migrationContent += `    .addColumn('executed_at', 'timestamp', col => col.notNull())
+`;
+  migrationContent += `    .addColumn('trace', 'text')
 `;
   migrationContent += `    .addColumn('model', 'varchar(255)')
 `;
   migrationContent += `    .addColumn('method', 'varchar(255)')
+`;
+  migrationContent += `    .addColumn('file', 'text')
+`;
+  migrationContent += `    .addColumn('line', 'integer')
+`;
+  migrationContent += `    .addColumn('memory_usage', 'double precision')
 `;
   migrationContent += `    .addColumn('rows_affected', 'integer')
+`;
+  migrationContent += `    .addColumn('transaction_id', 'varchar(255)')
 `;
   migrationContent += `    .addColumn('optimization_suggestions', 'jsonb')
 `;
@@ -1072,6 +1098,8 @@ export async function createPostgresQueryLogsTable() {
   migrationContent += `    .addColumn('indexes_used', 'jsonb')
 `;
   migrationContent += `    .addColumn('missing_indexes', 'jsonb')
+`;
+  migrationContent += `    .addColumn('explain_plan', 'jsonb')
 `;
   migrationContent += `    .addColumn('tags', 'jsonb')
 `;

package/dist/index.d.ts

@@ -95,6 +95,8 @@ export * from './auth-tables';
 export * from './uuid-columns';
 // Schema-diff guards so trait-managed columns aren't proposed for dropping (stacksjs/stacks#2075)
 export * from './managed-columns';
+// Foreign keys a model gets from `belongsTo` rather than from `attributes`
+export * from './relation-columns';
 // Notification tables migration (stacksjs/stacks#1937)
 export { migrateNotificationTables } from './notification-tables';
 // RBAC tables migration (stacksjs/stacks#1941 Phase A)

package/dist/index.js

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

package/dist/managed-columns.d.ts

@@ -9,7 +9,25 @@ import type { MigrationOperation } from '@stacksjs/query-builder';
 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. */
+/**
+ * Return `operations` without any drop of a framework-managed column, and
+ * without the operation that would have carried it out.
+ *
+ * SQLite has no `DROP COLUMN` before 3.35, so the differ drops one by
+ * rebuilding the table without it — and emits that single rebuild statement as
+ * TWO operations: a `drop_column` naming the casualty, and a `rebuild_table`
+ * whose `sql` is the very same statement. Filtering only the `drop_column`
+ * left the rebuild in the list, which is the worst of both: the confirmation
+ * gate still warns on every run, and answering yes still drops the column the
+ * guard exists to protect.
+ *
+ * So a rebuild that IS a suppressed drop goes with it. That can cost an
+ * unrelated constraint change riding along in the same rebuild, which is the
+ * right trade: a skipped constraint tweak is visible and repeatable, a
+ * silently dropped ownership column is neither. `withoutManagedColumnDropSql`
+ * has always removed this statement from the generated migration — this is the
+ * preview finally agreeing with what actually runs.
+ */
 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
@@ -27,5 +45,10 @@ export declare function withoutManagedColumnDropSql(statements: string[], manage
  * 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'>;
+/**
+ * A minimal view of a migration operation — all these helpers need.
+ *
+ * `sql` is optional because the pairing check below degrades to a no-op
+ * without it, and several callers only have the classified operation.
+ */
+declare type ColumnOp = Pick<MigrationOperation, 'kind' | 'table' | 'column'> & { sql?: string }

package/dist/managed-columns.js

@@ -9,13 +9,21 @@ export const USERS_GUARANTEED_COLUMNS = [
 export async function frameworkManagedColumns() {
   const managed = new Map;
   managed.set("users", new Set(USERS_GUARANTEED_COLUMNS));
+  const add = (table, column) => {
+    const columns = managed.get(table) ?? new Set;
+    columns.add(column);
+    managed.set(table, 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);
-    }
+    for (const table of await findUuidTables())
+      add(table, "uuid");
+  } catch {}
+  try {
+    const { findRelationForeignKeys } = await import("./relation-columns");
+    for (const [table, columns] of await findRelationForeignKeys())
+      for (const column of columns)
+        add(table, column);
   } catch {}
   return managed;
 }
@@ -23,7 +31,12 @@ 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));
+  const suppressed = new Set(operations.filter((op) => isManagedColumnDrop(op, managed)).map((op) => op.sql ? normalizeSql(op.sql) : "").filter((sql) => sql.length > 0));
+  return operations.filter((op) => {
+    if (isManagedColumnDrop(op, managed))
+      return !1;
+    return !(op.sql && suppressed.has(normalizeSql(op.sql)));
+  });
 }
 function normalizeSql(sql) {
   return sql.trim().replace(/\s+/g, " ").replace(/;+\s*$/, "");

package/dist/migrations.d.ts

@@ -1,6 +1,7 @@
-import type { MigrationOperation } from '@stacksjs/query-builder';
+import type { MigrationOperation, MigrationPlan } from '@stacksjs/query-builder';
 import type { Result } from '@stacksjs/error-handling';
 export type { MigrationResult as MigrationResultType };
+export declare function prepareMigrationModelsDir(): { modelsDir: string, skip: boolean };
 /**
  * SQLite compatibility preprocessing for migrations.
  *
@@ -24,11 +25,23 @@ export type { MigrationResult as MigrationResultType };
  *     (stacksjs/stacks#1916)
  *
  *   - **Drop-and-delete** (`deleteMigration`): the file is genuinely dead
- *     — a duplicate CREATE TABLE created by `buddy generate:migrations`
- *     regenerating against an already-modeled table, or a DROP COLUMN
- *     migration whose target column never existed. Removing it keeps the
- *     directory clean and prevents future runs from re-discovering it.
+ *     — currently limited to an unrecorded duplicate CREATE TABLE created by
+ *     `buddy generate:migrations`. Recorded files are immutable migration
+ *     history, regardless of the current live schema.
  */
+/**
+ * Split a migration file into its statements.
+ *
+ * Comments come out FIRST, before the split on `;`. Splitting first and then
+ * dropping the chunks that begin with `--` looks equivalent and is not: a
+ * file that opens with a comment header — which every hand-written migration
+ * in this repo does — glues that header to its first statement, so the chunk
+ * begins with `--` and the statement disappears with the comment. Everything
+ * downstream then reasons about a file it has only partly read, and the
+ * ADD COLUMN reconciliation below would happily record a file as fully
+ * applied while its first column had never been created.
+ */
+export declare function sqlStatementsOf(content: string): string[];
 export declare function preprocessSqliteMigrations(): void;
 /**
  * Public bootstrap entry point.
@@ -45,6 +58,25 @@ export declare function preprocessSqliteMigrations(): void;
 export declare function ensureDatabaseReady(): Promise<void>;
 /** Test seam: forget that the bootstrap already ran. */
 export declare function resetDatabaseBootstrapCache(): void;
+/**
+ * The table a single DDL statement acts on, or null when it names none.
+ *
+ * Only the forms the generator emits are recognised; anything unrecognised
+ * comes back null and is therefore kept, which is the safe direction.
+ */
+export declare function statementTable(statement: string): string | null;
+/**
+ * Drop the statements that act on a table a disabled feature owns.
+ *
+ * The generator emits a catch-all `auto-misc` migration holding stray alters
+ * for every table at once. Its filename names no table, so the file-level gate
+ * cannot classify it, and it ran in full: the first statement touching a gated
+ * table failed with "relation ... does not exist" and took the whole migration
+ * run with it. Gating has to reach inside a file that mixes them.
+ *
+ * A statement whose table cannot be identified is kept.
+ */
+export declare function withoutGatedStatements(sql: string, gated: ReadonlySet<string>): string;
 /**
  * Count how many migrations have been recorded as applied in the
  * `migrations` table. Returns 0 when the table doesn't exist yet
@@ -78,6 +110,7 @@ export declare function resetDatabase(): Promise<Result<string, Error>>;
  * behind confirmation before spawning the non-interactive migrate action.
  */
 export declare function previewPendingMigrations(options?: GenerateMigrationsOptions): Promise<MigrationOperation[]>;
+export declare function preserveMigrationPlanTableOrder(next: MigrationPlan, previous?: MigrationPlan): MigrationPlan;
 export declare function generateMigrations(options?: GenerateMigrationsOptions): Promise<Result<string, Error>>;
 /**
  * Write generated SQL to `database/migrations/` so the runner picks it up.
@@ -90,7 +123,22 @@ export declare function generateMigrations(options?: GenerateMigrationsOptions):
  * dangling reference is a guaranteed mid-migration failure rather than a
  * cosmetic problem.
  */
+/**
+ * Whether a statement references one of the enum types nothing creates.
+ *
+ * Matches on the quoted name so a column or table that merely contains the same
+ * word is not caught.
+ */
+export declare function referencesUndefinedType(statement: string, dangling: string[]): boolean;
 export declare function findDanglingTypeReferences(statements: string[]): string[];
+/**
+ * SQLite supports a nullable foreign key on `ADD COLUMN`, but not a later
+ * `ADD CONSTRAINT`. bun-query-builder emits the new relation column without
+ * its reference on incremental SQLite diffs, leaving the live schema weaker
+ * than the model. Recover the reference from the generated current plan and
+ * declare it inline while the column is added.
+ */
+export declare function inlineSqliteAddedColumnReferences(statements: string[], plan: MigrationPlanLike | undefined): string[];
 /**
  * Rebuild the whole migration corpus for one dialect, from the models.
  *
@@ -138,6 +186,20 @@ export declare interface GenerateMigrationsOptions {
   applyRenames?: boolean
   fromDb?: boolean
 }
+declare interface MigrationPlanColumn {
+  name?: string
+  references?: {
+    table?: string
+    column?: string
+  }
+}
+declare interface MigrationPlanTable {
+  table?: string
+  columns?: MigrationPlanColumn[]
+}
+declare interface MigrationPlanLike {
+  tables?: MigrationPlanTable[]
+}
 export declare interface RegeneratedCorpus {
   dialect: string
   models: number