@stacksjs/database 0.70.45 → 0.70.54

package/dist/migration-lock.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Acquire the distributed migration lock for the given dialect.
+ * Returns a handle whose `release()` method MUST be called in a
+ * `finally` to free the lock — even on error paths.
+ *
+ * @param dialect - which database driver is being migrated against
+ * @param adminDb - the bun-query-builder connection to issue lock SQL
+ *                  through (PG / MySQL). Ignored for SQLite.
+ * @param opts.timeoutMs - max time to wait for an existing holder
+ * @param opts.sqliteLockPath - override the file path SQLite uses
+ *
+ * Throws an error if the lock can't be acquired within `timeoutMs`.
+ */
+export declare function acquireMigrationLock(dialect: Dialect, adminDb: { unsafe: (sql: string) => Promise<unknown> } | null, opts?: { timeoutMs?: number, sqliteLockPath?: string }): Promise<MigrationLockHandle>;
+/**
+ * Returned by `acquireMigrationLock()`. Callers MUST invoke `release`
+ * in a finally block; the lock is process-external (file, advisory,
+ * or named) so leaking it strands future migration runs.
+ */
+export declare interface MigrationLockHandle {
+  release: () => Promise<void>
+}
+export type Dialect = 'sqlite' | 'mysql' | 'postgres';

package/dist/migrations.d.ts

@@ -1,5 +1,35 @@
+import type { MigrationOperation } from '@stacksjs/query-builder';
 import type { Result } from '@stacksjs/error-handling';
 export type { MigrationResult as MigrationResultType };
+/**
+ * SQLite compatibility preprocessing for migrations.
+ *
+ * SQLite does not support:
+ * - ALTER TABLE ADD CONSTRAINT (foreign keys must be defined at table creation)
+ * - CREATE TYPE ... AS ENUM (SQLite has no user-defined types; enum columns
+ *   are plain TEXT, with the allowed values enforced at the validation layer)
+ *
+ * Note: CREATE UNIQUE INDEX files are deliberately NOT skipped — the SQLite
+ * dialect driver never renders inline UNIQUE in CREATE TABLE, so the
+ * standalone index file is the only uniqueness enforcement on SQLite
+ * (stacksjs/stacks#1952).
+ *
+ * Two flavours of "no-op on SQLite" need different handling:
+ *
+ *   - **Skip-and-keep** (`skipMigration`): the file is portable — it would
+ *     run cleanly on MySQL/Postgres — but doesn't apply to SQLite. Record
+ *     it as executed in the migrations tracking table so it doesn't replay,
+ *     but **leave the file on disk** so a future `DB_CONNECTION` flip can
+ *     pick it up. This is the right path for FK constraint files.
+ *     (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.
+ */
+export declare function preprocessSqliteMigrations(): void;
 /**
  * Run database migrations
  */
@@ -8,6 +38,18 @@ export declare function runDatabaseMigration(): Promise<Result<string, Error>>;
  * Reset the database (drop all tables)
  */
 export declare function resetDatabase(): Promise<Result<string, Error>>;
+/**
+ * Preview the pending migration as a list of structured operations WITHOUT
+ * writing any files or advancing the snapshot. The `buddy migrate` command
+ * uses this (in the interactive parent process) to gate destructive changes
+ * behind confirmation before spawning the non-interactive migrate action.
+ */
+export declare function previewPendingMigrations(options?: GenerateMigrationsOptions): Promise<MigrationOperation[]>;
+export declare function generateMigrations(options?: GenerateMigrationsOptions): Promise<Result<string, Error>>;
+/**
+ * Generate fresh migrations (full regeneration, ignoring previous state)
+ */
+export declare function generateMigrations2(): Promise<Result<string, Error>>;
 /*` definitions to the stored snapshot
  * (`.qb/model-snapshot.<dialect>.json`) via bun-query-builder, then — if
  * there are changes — writes the resulting ALTER/CREATE/DROP statements
@@ -20,11 +62,10 @@ export declare function resetDatabase(): Promise<Result<string, Error>>;
  * the runner never sees it, so model edits silently no-op'd — defeating
  * the "models are the source of truth" promise.
  */
-export declare function generateMigrations(): Promise<Result<string, Error>>;
-/**
- * Generate fresh migrations (full regeneration, ignoring previous state)
- */
-export declare function generateMigrations2(): Promise<Result<string, Error>>;
+export declare interface GenerateMigrationsOptions {
+  applyRenames?: boolean
+  fromDb?: boolean
+}
 /**
  * Migration result type for compatibility
  */

package/dist/notification-tables.d.ts

@@ -0,0 +1,20 @@
+import { sqlHelpers } from './sql-helpers';
+/**
+ * `CREATE TABLE IF NOT EXISTS notifications` for the given dialect.
+ * Pure (no execution) so the cross-dialect DDL is unit-testable.
+ * Columns match the `DatabaseNotification` interface in
+ * `notifications/src/drivers/database.ts`.
+ */
+export declare function notificationsTableSql(sql: SqlHelpers): string;
+/**
+ * `CREATE TABLE IF NOT EXISTS notification_preferences`. The
+ * `UNIQUE (user_id, channel, category)` constraint is what makes the
+ * preference upsert safe — matches `NotificationPreferenceRow`.
+ */
+export declare function notificationPreferencesTableSql(sql: SqlHelpers): string;
+/**
+ * Create the notification + notification_preferences tables. Idempotent
+ * (`IF NOT EXISTS`), so it's safe to run on every `buddy migrate`.
+ */
+export declare function migrateNotificationTables(options?: { verbose?: boolean }): Promise<{ success: boolean, error?: string }>;
+declare type SqlHelpers = ReturnType<typeof sqlHelpers>;

package/dist/rbac-tables.d.ts

@@ -0,0 +1,17 @@
+import { sqlHelpers } from './sql-helpers';
+/** `roles` table — id + name + guard + timestamps with UNIQUE(name, guard_name). */
+export declare function rolesTableSql(sql: SqlHelpers): string;
+/** `permissions` table — same shape as `roles`. */
+export declare function permissionsTableSql(sql: SqlHelpers): string;
+/** `user_roles` pivot — composite PK makes double-assign a unique violation. */
+export declare function userRolesTableSql(): string;
+/** `user_permissions` pivot. */
+export declare function userPermissionsTableSql(): string;
+/** `role_permissions` pivot. */
+export declare function rolePermissionsTableSql(): string;
+/**
+ * Create the 5 RBAC tables. Idempotent (`IF NOT EXISTS`), so it's
+ * safe to run on every `buddy migrate`.
+ */
+export declare function migrateRbacTables(options?: { verbose?: boolean }): Promise<{ success: boolean, error?: string }>;
+declare type SqlHelpers = ReturnType<typeof sqlHelpers>;

package/dist/seed-scaffold.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Remove a single `useSeeder` / `seedable` object-property from model
+ * source text (stacksjs/stacks#1929). Brace-aware (balances nested
+ * `{}` and skips string literals) and conservative: only strips the
+ * documented value shapes (`true`, `false`, or a `{ … }` object). For
+ * anything else (an identifier, a function call, a spread) it returns
+ * `changed: false` so the caller can flag it for manual cleanup
+ * instead of risking a mangled file.
+ *
+ * Exported for unit tests.
+ */
+export declare function stripUseSeederTrait(source: string): { source: string, changed: boolean, skipped: boolean };
+/**
+ * Walk the configured models directory, find every model whose
+ * `traits.useSeeder` is truthy, and write a class-seeder file for it.
+ * Returns a structured report so the CLI command can render a summary
+ * without re-parsing log lines.
+ */
+export declare function scaffoldClassSeedersFromModels(options?: ScaffoldOptions): Promise<ScaffoldResult>;
+/** Pure renderer — exported for unit tests. */
+export declare function renderSeederFile(modelName: string, modelImportPath: string, count: number): string;
+export declare interface ScaffoldOptions {
+  modelsDir?: string
+  seedersDir?: string
+  force?: boolean
+  dryRun?: boolean
+}
+export declare interface ScaffoldResult {
+  generated: Array<{ model: string, file: string }>
+  skipped: Array<{ model: string, file: string, reason: 'already-exists' | 'no-useseeder' }>
+  errors: Array<{ model: string, error: string }>
+  strippedTrait: Array<{ model: string, file: string }>
+  traitStripSkipped: Array<{ model: string, file: string }>
+}

package/dist/seeder.d.ts

@@ -1,8 +1,29 @@
+import type { Attribute, Model } from '@stacksjs/types';
+/**
+ * Test whether a model name is on the protected list.
+ * Exported for downstream tooling (CI lint rules, custom seeders) so the
+ * list stays a single source of truth.
+ */
+export declare function isProtectedModel(name: string): boolean;
+/**
+ * Direct entry point for `factory.generate(Model, opts)` — exported
+ * under a distinct name so the new public API in `factory.ts` can call
+ * into the same insert path the legacy walker uses without leaking the
+ * `SeederModel` type. See stacksjs/stacks#1919.
+ */
+export declare function seedModelDirect(model: SeederModel, options: SeederConfig): Promise<SeedResult>;
 /**
  * Main seeding function
  * Seeds the database using model factory functions
  * Loads models from both framework defaults and user-defined models,
  * with user models taking precedence.
+ *
+ * @deprecated stacksjs/stacks#1919 — the model auto-walker is no
+ * longer invoked by `./buddy seed`. Migrate each `useSeeder` trait to
+ * a class seeder via `./buddy seed:scaffold`, then call
+ * `factory.generate(Model, opts)` from inside each seeder. This
+ * function remains exported for programmatic back-compat but is
+ * scheduled for removal.
  */
 export declare function seed(config?: SeederConfig): Promise<SeedSummary>;
 /**
@@ -19,6 +40,31 @@ export declare function freshSeed(config?: SeederConfig): Promise<SeedSummary>;
  * Returns models from both default and user directories
  */
 export declare function listSeedableModels(): Promise<Array<{ name: string, table: string, count: number, source: 'default' | 'user' }>>;
+/**
+ * Models that touch live auth state and are unsafe to auto-seed on an
+ * already-populated database (stacksjs/stacks#1852).
+ *
+ * The motivating incident: a userland `app/Models/OauthClient.ts` shipped
+ * with the default `useSeeder: { count: 10 }` trait. Every `./buddy seed`
+ * re-rolled the `oauth_clients` table — including the row at id=1, the
+ * Personal Access Client whose `secret` is part of the encryption key
+ * used to derive each issued access token's `encryptedId`. With the
+ * secret rotated, every previously-issued token failed validation at
+ * `decrypt(encryptedId, clientSecret)`, surfacing as a generic
+ * "Unauthorized. Invalid token." 401 with no log line indicating what
+ * actually happened.
+ *
+ * Models on this list are skipped by default. They are seeded when:
+ *
+ *   - `fresh: true` is passed (the seeder truncates first; live tokens
+ *     are gone anyway, so re-rolling the PAC secret is harmless), OR
+ *   - `allowProtected: true` is passed (explicit opt-in escape hatch
+ *     surfaced as `./buddy seed --allow-protected`).
+ *
+ * The list is conservative: any model whose rows participate in token
+ * issuance / validation / refresh belongs here.
+ */
+export declare const PROTECTED_MODELS: readonly string[];
 /**
  * Seeder configuration options
  */
@@ -30,6 +76,7 @@ export declare interface SeederConfig {
   only?: string[]
   except?: string[]
   includeDefaults?: boolean
+  allowProtected?: boolean
 }
 /**
  * Result of a single model seeding operation
@@ -52,6 +99,18 @@ export declare interface SeedSummary {
   results: SeedResult[]
   duration: number
 }
+/**
+ * Parsed model with seeding information
+ */
+export declare interface SeederModel {
+  name: string
+  table: string
+  count: number
+  fixtures: Array<Record<string, unknown>>
+  attributes: Record<string, Attribute>
+  model: Model
+  filePath: string
+}
 // Legacy exports for backwards compatibility
 export { seed as runSeeders };
 export { freshSeed as freshWithSeed };

package/dist/sql-helpers.d.ts

@@ -26,6 +26,8 @@ export declare interface SqlDialectHelpers {
   boolFalse: string
   autoIncrement: string
   primaryKey: string
+  pkColumn: string
+  nullableTimestamp: string
   param: (index: number) => string
   params: (...values: unknown[]) => { sql: string, values: unknown[] }
 }

package/dist/transaction-context.d.ts

@@ -0,0 +1,52 @@
+/**
+ * True if the current async context is inside an active transaction
+ * scope. Queue dispatch (and other side-effect emitters) read this
+ * to decide between immediate execution and buffering.
+ */
+export declare function isInTransaction(): boolean;
+/**
+ * Enqueue a callback to fire after the surrounding transaction
+ * commits. Returns:
+ *   - `true`  — buffered; caller should NOT execute the side-effect now
+ *   - `false` — no active transaction; caller should execute immediately
+ *
+ * This is the low-level primitive. Higher-level facades (queue
+ * dispatch, mailer send, event emit) wrap it with their own
+ * "respect transaction context unless overridden" logic.
+ */
+export declare function enqueueAfterCommit(callback: AfterCommitCallback): boolean;
+/**
+ * Run `fn` inside a transaction scope. Returns whatever `fn`
+ * returns. On success, fires every buffered after-commit callback
+ * in insertion order. On error, discards them — the transaction
+ * rolled back so the side-effects shouldn't happen.
+ *
+ * Used by `@stacksjs/orm`'s `transaction()` wrapper to thread the
+ * scope through user code. Apps don't call this directly.
+ *
+ * Nested calls reuse the outer scope rather than nesting — flush
+ * happens on the OUTERMOST commit, matching the savepoint
+ * semantics of every relational database. The depth counter is
+ * tracked so the outer call knows when it owns the flush.
+ */
+export declare function runInTransactionScope<T>(fn: () => Promise<T>, options?: { onError?: (err: unknown, index: number) => void }): Promise<T>;
+/**
+ * Test-only escape hatch — manually flush the current scope's
+ * buffered callbacks without ending the transaction. Production
+ * code never needs this; tests use it to assert intermediate
+ * state. Returns the number of callbacks fired.
+ */
+export declare function __flushAfterCommitNow(): Promise<number>;
+/**
+ * Test-only escape hatch — peek at the number of buffered
+ * callbacks without firing them. Returns 0 outside a scope.
+ */
+export declare function __pendingAfterCommitCount(): number;
+/**
+ * One buffered side-effect waiting for the surrounding transaction
+ * to commit. Errors thrown during flush are NOT re-thrown — the
+ * transaction itself already committed, so failing the whole flow
+ * after-the-fact would corrupt the caller's mental model. Errors
+ * are logged via `onError` if the scope supplied one.
+ */
+declare type AfterCommitCallback = () => Promise<void> | void;

package/dist/types.d.ts

@@ -25,6 +25,80 @@ export declare interface Sql {
   readonly sql: string
   readonly parameters: unknown[]
 }
+/**
+ * Reference to a column for use inside an expression. Returned by
+ * {@link StacksExpressionBuilder.ref} and accepted everywhere a value
+ * or column is expected (e.g. inside `sql\`\${ref} > 0\`\`).
+ *
+ * The shape matches `sql.ref()`'s return so a raw fragment from either
+ * source is interoperable.
+ */
+export declare interface ColumnRef {
+  readonly raw: string
+}
+/**
+ * Fluent aggregate-function builder accessible via
+ * `eb.fn.count(...)`, `eb.fn.sum(...)`, etc. The chained `.as(name)`
+ * names the resulting column in the projection; `.filterWhere(...)`
+ * scopes the aggregate to a sub-population (`COUNT(*) FILTER (WHERE
+ * status = 'success')` style).
+ */
+export declare interface AggregateExpression {
+  as: (alias: string) => AggregateExpression
+  filterWhere: (column: string, op: ExpressionOperator | string, value: unknown) => AggregateExpression
+}
+/**
+ * Aggregate-function accessor exposed on the expression builder.
+ *
+ * Covers the call sites in commerce today (`count`, `sum`, `avg`,
+ * `min`, `max`). Other Kysely-side aggregates (`countAll`,
+ * `coalesce`, etc.) can be added here as call sites surface; we
+ * deliberately don't widen to "everything Kysely exposes" because
+ * that surface keeps growing and an `any`-typed escape hatch always
+ * exists (`eb.fn as any).newThing(...)`) if a one-off bypass is
+ * genuinely needed.
+ */
+export declare interface ExpressionFunctions {
+  count: (column: string) => AggregateExpression
+  sum: (column: string) => AggregateExpression
+  avg: (column: string) => AggregateExpression
+  min: (column: string) => AggregateExpression
+  max: (column: string) => AggregateExpression
+}
+/**
+ * Minimal typed expression-builder surface for sub-query / inline-
+ * expression callbacks (stacksjs/stacks#1892, T-2 from #1875).
+ *
+ * Background: the framework's commerce module passed `(eb: any) => …`
+ * to `.where()` / `.select()` callbacks across 80+ sites. The `any`
+ * escape meant typos like `eb.compare(...)` (no such method — it's
+ * `cmpr`) only surfaced at runtime, and any later rename in
+ * bun-query-builder couldn't break here at type-check time.
+ *
+ * This interface declares the methods commerce actually uses today —
+ * `or`, `cmpr`, `ref`, `raw`, plus the `fn` aggregate accessor. It
+ * intentionally does NOT claim to be the full Kysely
+ * `ExpressionBuilder<DB, TB>` type:
+ *
+ *   - Stacks's `Database` is still typed as `any` (no generated
+ *     schema map yet) so the table-aware narrowing Kysely offers
+ *     can't be expressed here yet.
+ *   - bun-query-builder doesn't currently re-export its internal
+ *     `ExpressionBuilder` type, so we can't alias to the canonical
+ *     shape upstream.
+ *
+ * When either of those changes upstream, swap this interface's
+ * implementation in one place rather than re-typing every call site.
+ */
+export declare interface StacksExpressionBuilder {
+  or: (expressions: ReadonlyArray<unknown>) => unknown
+  and?: (expressions: ReadonlyArray<unknown>) => unknown
+  cmpr: (left: unknown, op: ExpressionOperator, right: unknown) => unknown
+  ref: (column: string) => ColumnRef
+  raw: (value: string) => ColumnRef
+  fn: ExpressionFunctions
+  readonly [extra: string]: unknown
+}
 /**
  * Database types - Compatibility layer
  *
@@ -64,3 +138,11 @@ export type Updateable<T> = Partial<T>;
  * Use the query builder from bun-query-builder instead.
  */
 export type Database = any;
+/**
+ * Comparison operator accepted by {@link StacksExpressionBuilder.cmpr}
+ * and friends. Mirrors the standard SQL operators the underlying
+ * Kysely-style builder supports.
+ */
+export type ExpressionOperator = | '=' | '!=' | '<>' | '<' | '<=' | '>' | '>='
+  | 'in' | 'not in' | 'is' | 'is not'
+  | 'like' | 'not like' | 'ilike' | 'not ilike';

package/dist/unique-audit.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Walk every model file (user + framework defaults) and return the
+ * full list of declared unique constraints — both single-column
+ * `unique: true` attributes and `unique: true` composite indexes.
+ */
+export declare function getDeclaredUniques(): Promise<DeclaredUnique[]>;
+/**
+ * Query the live database for every UNIQUE index, returning a
+ * normalised `{ table, name, columns }` shape. Dialect-aware: PRAGMA
+ * on SQLite, information_schema / pg_index on MySQL / PostgreSQL.
+ *
+ * The optional `dialect` parameter is the test seam — production code
+ * leaves it undefined so it's derived from `DB_CONNECTION`.
+ */
+export declare function getLiveUniqueIndexes(dialect?: Dialect): Promise<LiveUniqueIndex[]>;
+/**
+ * Diff declared unique constraints against live UNIQUE indexes. A
+ * declared entry is satisfied iff some live unique index on the same
+ * table has an equal column SET (sorted, case-insensitive). Declared
+ * entries whose table is absent from the live DB go to `skippedTables`
+ * (feature-gated commerce/CMS models legitimately have no table yet)
+ * rather than `missing`.
+ */
+export declare function auditUniqueIndexes(dialect?: Dialect): Promise<UniqueAuditResult>;
+// stacksjs/stacks#1952 — Unique-index drift audit. Compares each
+// model's declared uniqueness (`unique: true` attributes and
+// `unique: true` composite indexes) against the UNIQUE indexes that
+// actually exist in the live database.
+//
+// This is the `buddy doctor` companion to the migrate-side self-heal
+// (#1952): `buddy migrate` already re-queues missing unique-index
+// migrations, but that only fires when you run migrate, doesn't help
+// apps scaffolded during the stub era (whose own repos carry
+// `SELECT 1;` stub migrations), and hard-fails mid-migrate on
+// pre-existing duplicate rows instead of reporting first. This audit
+// surfaces the drift read-only, before you migrate.
+//
+// Matching is by COLUMN SET, never by index name — the generator
+// emits names like `users_users_email_unique` while migration
+// filenames say `users_email_unique`, so names are not stable.
+export declare interface DeclaredUnique {
+  table: string
+  columns: string[]
+  model: string
+  source: 'attribute' | 'index'
+  indexName?: string
+}
+export declare interface LiveUniqueIndex {
+  table: string
+  name: string
+  columns: string[]
+}
+export declare interface UniqueAuditResult {
+  supported: boolean
+  declared: DeclaredUnique[]
+  live: LiveUniqueIndex[]
+  missing: DeclaredUnique[]
+  skippedTables: string[]
+}
+declare type Dialect = 'sqlite' | 'mysql' | 'postgres' | 'other';

package/dist/utils.d.ts

@@ -1,5 +1,6 @@
-import { createQueryBuilder, setConfig } from 'bun-query-builder';
-import type { DatabaseSchema } from 'bun-query-builder';
+import { createQueryBuilder, setConfig } from '@stacksjs/query-builder';
+import type { DatabaseSchema } from '@stacksjs/query-builder';
+export declare function acquireDbConfigLock(): Promise<() => void>;
 // Function to initialize the config when it's available
 export declare function initializeDbConfig(config: any): void;
 export declare function ensureDatabaseConfigLoaded(): Promise<void>;
@@ -88,6 +89,26 @@ export declare interface FluentChain {
   doesntExist: () => Promise<boolean>
   [key: string]: any
 }
+/*.ts` and
+ * emits `database/types.d.ts` containing:
+ *
+ * ```ts
+ * declare module '@stacksjs/database' {
+ *   interface DatabaseSchema {
+ *     court_houses: { columns: { id: number; name: string; ... } }
+ *     judges:       { columns: { id: number; name: string; court_id: number; ... } }
+ *   }
+ * }
+ * ```
+ *
+ * Once that file is loaded into the TS project, `db.selectFrom('co|')`
+ * autocompletes to known table names. Apps without a generated file
+ * still compile — the `(string & {})` branch on `TableName` keeps the
+ * type as a literal-union+escape-hatch, so any string is accepted
+ * but known keys are surfaced first by the language server.
+ */
+// eslint-disable-next-line ts/no-empty-object-type
+export declare interface DatabaseSchema {}
 // Permissive schema type that accepts any table name with any columns
 // This allows the query builder to work before model types are generated
 declare type AnySchema = DatabaseSchema<any> & Record<string, { columns: Record<string, any>, primaryKey: string }>;
@@ -135,5 +156,23 @@ declare type GenericPassthroughKeys = | 'transaction'
   | 'raw'
   | 'simple'
   | 'file';
+/**
+ * Accept either a registered table name (from augmented
+ * `DatabaseSchema`) for autocomplete, or any other string for apps
+ * that haven't generated types yet / tables not in a model file.
+ *
+ * The `(string & {})` branch prevents TS from collapsing the union
+ * back to `string` and losing the autocomplete narrowing — a
+ * well-documented LiteralUnion trick.
+ */
+// eslint-disable-next-line ts/no-empty-object-type
+export type TableName = (keyof DatabaseSchema & string) | (string & {});
+// SQLite bootstrap pragmas (stacksjs/stacks#1951) now live in
+// @stacksjs/query-builder — the one chokepoint every framework
+// query-builder instance is created through — so EVERY fresh sqlite
+// connection gets `foreign_keys = ON`, including builders created outside
+// this module (e.g. the ORM auto-CRUD routes). Re-exported here for
+// backwards compatibility with existing imports.
+export { applySqlitePragmas, SQLITE_BOOTSTRAP_PRAGMAS } from '@stacksjs/query-builder';
 // Export setConfig if available
 export { setConfig };

package/dist/uuid-columns.d.ts

@@ -0,0 +1,22 @@
+import { sqlHelpers } from './sql-helpers';
+/** Pure builder so tests can assert per-dialect DDL without a live DB. */
+export declare function uuidColumnSql(table: string, sql: SqlHelpers): string;
+/**
+ * Resolve every table backing a model with `useUuid: true`, across both
+ * userland (`app/Models`) and framework-default (`defaults/app/Models`)
+ * model directories. Exported so tests (and `doctor`-style diagnostics) can
+ * inspect the resolved set without touching a live database.
+ */
+export declare function findUuidTables(): Promise<string[]>;
+/**
+ * Guarantee-ALTER `uuid` onto every table whose model declares
+ * `useUuid: true`, independently try/catch-swallowed per table so one
+ * already-having-the-column (or not-yet-existing) table never skips the
+ * rest. Exported so `buddy migrate`/`migrate:fresh` can call it after model
+ * migrations run, same pattern as {@link ensureUsersAuthColumns} — see the
+ * call sites in buddy/src/commands/migrate.ts.
+ */
+export declare function ensureUuidColumns(sql: SqlHelpers, options?: { verbose?: boolean }): Promise<void>;
+/** Convenience wrapper resolving dialect helpers from `DB_CONNECTION`, for call sites that don't already have a `SqlHelpers` instance. */
+export declare function ensureUuidColumnsForCurrentDriver(options?: { verbose?: boolean }): Promise<void>;
+declare type SqlHelpers = ReturnType<typeof sqlHelpers>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/database",
   "type": "module",
-  "version": "0.70.45",
+  "version": "0.70.54",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "contributors": [
@@ -50,18 +50,18 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "bun-query-builder": "^0.1.21"
+    "bun-query-builder": "^0.1.38"
   },
   "devDependencies": {
-    "@stacksjs/cli": "^0.70.45",
-    "@stacksjs/config": "^0.70.45",
-    "@stacksjs/logging": "^0.70.45",
-    "@stacksjs/router": "^0.70.45",
+    "@stacksjs/cli": "0.70.54",
+    "@stacksjs/config": "0.70.54",
+    "@stacksjs/logging": "0.70.54",
+    "@stacksjs/router": "0.70.54",
     "better-dx": "^0.2.12",
-    "@stacksjs/path": "^0.70.45",
-    "@stacksjs/query-builder": "^0.70.45",
-    "@stacksjs/storage": "^0.70.45",
-    "@stacksjs/strings": "^0.70.45",
-    "@stacksjs/utils": "^0.70.45"
+    "@stacksjs/path": "0.70.54",
+    "@stacksjs/query-builder": "0.70.54",
+    "@stacksjs/storage": "0.70.54",
+    "@stacksjs/strings": "0.70.54",
+    "@stacksjs/utils": "0.70.54"
   }
 }