@stacksjs/database 0.70.86 → 0.70.88

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/database",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.86",
+  "version": "0.70.88",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "contributors": [
@@ -58,15 +58,15 @@
     "bun-query-builder": "^0.1.47"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.86",
-    "@stacksjs/config": "0.70.86",
-    "@stacksjs/logging": "0.70.86",
-    "@stacksjs/router": "0.70.86",
+    "@stacksjs/cli": "0.70.88",
+    "@stacksjs/config": "0.70.88",
+    "@stacksjs/logging": "0.70.88",
+    "@stacksjs/router": "0.70.88",
     "better-dx": "^0.2.16",
-    "@stacksjs/path": "0.70.86",
-    "@stacksjs/query-builder": "0.70.86",
-    "@stacksjs/storage": "0.70.86",
-    "@stacksjs/strings": "0.70.86",
-    "@stacksjs/utils": "0.70.86"
+    "@stacksjs/path": "0.70.88",
+    "@stacksjs/query-builder": "0.70.88",
+    "@stacksjs/storage": "0.70.88",
+    "@stacksjs/strings": "0.70.88",
+    "@stacksjs/utils": "0.70.88"
   }
 }

package/dist/auth-tables.d.ts

@@ -1,60 +0,0 @@
-import { sqlHelpers } from './sql-helpers';
-/**
- * Defensive ALTER guaranteeing `users.email_verified_at` — the column
- * `verifyEmail()` writes and the `verified` middleware reads, but which
- * no generated users migration ever creates (stacksjs/stacks#1948).
- * Pure builder so tests can assert per-dialect DDL without a live DB.
- */
-export declare function usersEmailVerifiedAtSql(sql: SqlHelpers): string;
-/**
- * Defensive ALTER guaranteeing `users.password_changed_at` — the column
- * `resetPassword()` stamps and the token-validation paths read to bind a
- * token's validity to the user's credential state (stacksjs/stacks#1957,
- * a #1947 follow-up). No generated users migration creates it, so the
- * same pure-builder + try/catch-swallow pattern as
- * {@link usersEmailVerifiedAtSql} guarantees it from both schema paths.
- */
-export declare function usersPasswordChangedAtSql(sql: SqlHelpers): string;
-/**
- * Defensive ALTER guaranteeing `users.two_factor_secret` and
- * `users.two_factor_enabled` — storage/framework/core/auth/src/
- * authenticator.ts's TOTP helpers (generateTwoFactorSecret,
- * verifyTwoFactorCode) have existed since early in the framework's
- * history, but nothing ever created the columns a caller would persist
- * them to, or the `passkeys`/`webauthn_challenges` tables
- * storage/framework/core/auth/src/passkey.ts's WebAuthn helpers
- * unconditionally query against — every passkey/2FA call site was
- * dead code pointed at tables that never existed on any install,
- * `buddy new` included. Same defensive ALTER + swallow pattern as
- * {@link usersEmailVerifiedAtSql}.
- */
-export declare function usersTwoFactorColumnsSql(sql: SqlHelpers): string[];
-/**
- * Defensive ALTER guaranteeing `users.stripe_id` — the `billable`
- * model trait's methods (createStripeCustomer/createOrGetStripeUser,
- * used by `user.checkout(...)`) read and write this column
- * unconditionally, but it's runtime-mixin-only (createBillableMethods
- * in orm/define-model.ts, gated behind `traits.billable`): nothing in
- * migration codegen ever creates the column itself, on any model, with
- * or without the trait enabled. Every Stripe checkout call site was
- * dead code pointed at a column that never existed, `buddy new`
- * included — same shape as the passkeys/two_factor gap above (see
- * stacksjs/status#1 Phase 9).
- */
-export declare function usersStripeIdSql(): string;
-/**
- * Runs every `users` guarantee-column ALTER (email_verified_at,
- * 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
- * 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.
- */
-export declare function ensureUsersAuthColumns(sql: SqlHelpers, options?: { verbose?: boolean }): Promise<void>;
-/**
- * Create all authentication tables
- */
-export declare function migrateAuthTables(options?: { verbose?: boolean }): Promise<{ success: boolean, error?: string }>;
-declare type SqlHelpers = ReturnType<typeof sqlHelpers>;

package/dist/class-seeder.d.ts

@@ -1,65 +0,0 @@
-/**
- * Topologically sort seeders by their declared `dependencies`. Ties
- * (and dependency-free seeders) come out in alphabetical order so the
- * result is deterministic across filesystems and runs.
- *
- * Unknown dependency names are dropped from the graph with a warning —
- * they may refer to model-factory seeders that ran earlier in the
- * `buddy seed` pipeline, or be stale references from a rename. The run
- * doesn't fail because of them.
- *
- * Cycles throw with the offending class names in the error message.
- *
- * Exported for testing.
- */
-export declare function topoSortSeeders(seeders: Array<{ name: string, dependencies?: string[] }>): string[];
-/*.ts`; an explicit `--class` filters to one.
- *
- * Ordering:
- *   1. Files matching `*.ts` (excluding `_*.ts`) are imported.
- *   2. If any seeder declares `dependencies`, the runnable set is
- *      topologically sorted (alphabetical tie-break).
- *   3. Otherwise, the alphabetical order from `Array.sort()` wins —
- *      cheaper than the topo path and predictable across filesystems.
- *
- * Class-name filtering via `options.class` short-circuits both paths
- * and runs only that one seeder. Cross-seeder dependencies are NOT
- * resolved transitively in that mode — the caller takes responsibility
- * for whatever prereqs are needed.
- *
- * See stacksjs/stacks#1855 for the original report of unsorted FS
- * iteration producing zero-row seed runs.
- */
-export declare function runClassSeeders(options?: RunOptions): Promise<{ ran: string[], skipped: string[] }>;
-declare interface RunOptions {
-  class?: string
-  dir?: string
-}
-/**
- * Base class for class-based seeders. Subclass this and implement
- * `async run()`. Seeders may call `this.call()` to invoke other
- * seeders, mirroring Laravel's nested-seeder pattern.
- *
- * Cross-seeder ordering can be declared explicitly via `dependencies`:
- *
- *   ```ts
- *   export default class JudgeSeeder extends Seeder {
- *     dependencies = ['CourtHouseSeeder']
- *     async run() { ... }
- *   }
- *   ```
- *
- * The class name of each dependency is matched against the class names
- * `runClassSeeders` discovered in the seeders directory. Unknown
- * dependency names are warned about but don't fail the run (they may
- * refer to a model-factory seeder run earlier in `buddy seed`).
- *
- * When no `dependencies` are declared, seeders run in alphabetical
- * order — predictable across filesystems and good enough for projects
- * that name seeders by data flow (CourtHouse → Judge → Review).
- */
-export declare abstract class Seeder {
-  dependencies?: string[];
-  abstract run(): Promise<void> | void;
-  protected call(other: new () => Seeder): Promise<void>;
-}

package/dist/custom/audits.d.ts

@@ -1,16 +0,0 @@
-/**
- * Create the `model_audits` table used by the `useAudit` ORM trait.
- *
- * The trait writes one row per create/update/delete on any model that
- * declares `traits: { useAudit: true }`. The schema is intentionally
- * polymorphic — `auditable_type` + `auditable_id` rather than per-table
- * audit columns — so adding the trait to a new model never requires a
- * follow-up migration.
- *
- * @example
- * ```ts
- * import { createModelAuditsTable } from '@stacksjs/database'
- * await createModelAuditsTable() // idempotent — checks before writing
- * ```
- */
-export declare function createModelAuditsTable(): Promise<void>;

package/dist/custom/errors.d.ts

@@ -1 +0,0 @@
-export declare function createErrorsTable(): Promise<void>;

package/dist/custom/index.d.ts

@@ -1,3 +0,0 @@
-export * from './audits';
-export * from './errors';
-export * from './jobs';

package/dist/custom/jobs.d.ts

@@ -1,3 +0,0 @@
-import type { MigrationResult } from '../migrations';
-import type { Result } from '@stacksjs/error-handling';
-export declare function createJobsMigration(): Promise<Result<MigrationResult[] | string, Error>>;

package/dist/database.d.ts

@@ -1,89 +0,0 @@
-import { createQueryBuilder } from '@stacksjs/query-builder';
-import type { QueryBuilderConfig, StacksDialect } from '@stacksjs/query-builder';
-/**
- * Create a database connection with the given options
- */
-export declare function createDatabase(options: DatabaseOptions): Database;
-/**
- * Create a SQLite database connection
- */
-export declare function createSqliteDatabase(database: string, options?: Partial<Omit<DatabaseOptions, 'driver' | 'connection'>>): Database;
-/**
- * Create a PostgreSQL database connection
- */
-export declare function createPostgresDatabase(connection: DatabaseConnectionConfig, options?: Partial<Omit<DatabaseOptions, 'driver' | 'connection'>>): Database;
-/**
- * Create a MySQL database connection
- */
-export declare function createMysqlDatabase(connection: DatabaseConnectionConfig, options?: Partial<Omit<DatabaseOptions, 'driver' | 'connection'>>): Database;
-export declare interface DatabaseConnectionConfig {
-  database: string
-  host?: string
-  port?: number
-  username?: string
-  password?: string
-  url?: string
-}
-export declare interface DatabaseOptions {
-  driver: StacksDialect
-  connection: DatabaseConnectionConfig
-  verbose?: boolean
-  timestamps?: {
-    createdAt?: string
-    updatedAt?: string
-    defaultOrderColumn?: string
-  }
-  softDeletes?: {
-    enabled?: boolean
-    column?: string
-    defaultFilter?: boolean
-  }
-  hooks?: QueryBuilderConfig['hooks']
-}
-/**
- * Database class for managing database connections
- *
- * @example
- * ```ts
- * // Initialize with SQLite
- * const db = new Database({
- *   driver: 'sqlite',
- *   connection: { database: 'database/app.sqlite' }
- * })
- *
- * // Initialize with PostgreSQL
- * const db = new Database({
- *   driver: 'postgres',
- *   connection: {
- *     database: 'myapp',
- *     host: 'localhost',
- *     port: 5432,
- *     username: 'postgres',
- *     password: 'secret'
- *   }
- * })
- *
- * // Use the query builder
- * const users = await db.query.selectFrom('users').where('active', '=', true).get()
- * ```
- */
-export declare class Database {
-  constructor(options: DatabaseOptions);
-  get driver(): StacksDialect;
-  get connection(): DatabaseConnectionConfig;
-  get isInitialized(): boolean;
-  get query(): ReturnType<typeof createQueryBuilder>;
-  initialize(): void;
-  switchDriver(driver: StacksDialect, connection: DatabaseConnectionConfig): void;
-  close(): Promise<void>;
-  static fromConfig(config: {
-    default: StacksDialect
-    connections: {
-      sqlite?: { database: string }
-      mysql?: { name: string, host?: string, port?: number, username?: string, password?: string }
-      singlestore?: { name: string, host?: string, port?: number, username?: string, password?: string }
-      postgres?: { name: string, host?: string, port?: number, username?: string, password?: string }
-    }
-  }, env?: string): Database;
-  static fromEnv(): Database;
-}

package/dist/defaults.d.ts

@@ -1,48 +0,0 @@
-/**
- * Get default connection config for a given database driver.
- * Reads from the typed env proxy so values are auto-coerced.
- */
-export declare function getConnectionDefaults(driver: string, envProxy?: Record<string, any>): ConnectionDefaults;
-/**
- * Database Defaults & Constants
- *
- * Centralizes all hardcoded default values for database connections
- * so they are defined once and easily discoverable.
- */
-// ============================================================================
-// HOST / PORT DEFAULTS
-// ============================================================================
-export declare const DB_HOST_DEFAULT: '127.0.0.1';
-export declare const DB_PORTS: {
-  mysql: 3306;
-  postgres: 5432;
-  sqlite: 0
-};
-export declare const DB_NAMES: {
-  default: 'stacks';
-  sqlitePath: 'database/stacks.sqlite';
-  sqliteTestingPath: 'database/stacks_testing.sqlite'
-};
-export declare const DB_USERS: {
-  mysql: 'root';
-  postgres: 'postgres';
-  sqlite: ''
-};
-export declare const REDIS_DEFAULTS: {
-  host: 'localhost';
-  port: 6379
-};
-export declare const AWS_DEFAULTS: {
-  region: 'us-east-1'
-};
-// ============================================================================
-// CONNECTION CONFIG BUILDERS
-// ============================================================================
-export declare interface ConnectionDefaults {
-  database: string
-  host?: string
-  port?: number
-  username?: string
-  password?: string
-  prefix?: string
-}

package/dist/driver-config.d.ts

@@ -1,149 +0,0 @@
-import type { StacksDialect } from '@stacksjs/query-builder';
-/**
- * Get the connection string for a given driver and configuration
- */
-export declare function getConnectionString(driver: StacksDialect, config: DatabaseConnections[keyof DatabaseConnections]): string;
-/**
- * Validate driver configuration
- */
-export declare function validateDriverConfig(driver: StacksDialect, config: DatabaseConnections[keyof DatabaseConnections]): { valid: boolean, errors: string[] };
-/**
- * Merge user configuration with defaults
- */
-export declare function mergeWithDefaults<T extends keyof DatabaseConnections>(driver: T, config: Partial<DatabaseConnections[T]>): DatabaseConnections[T];
-/**
- * Get the appropriate configuration for a driver from environment variables
- */
-export declare function getConfigFromEnv(driver: StacksDialect): DatabaseConnections[keyof DatabaseConnections];
-/**
- * Detect the best available driver based on environment
- */
-export declare function detectDriver(): StacksDialect;
-/**
- * Default configuration values for each driver
- * @defaultValue
- * ```ts
- * {
- *   sqlite: { database: 'database/stacks.sqlite', prefix: '' },
- *   mysql: {
- *     name: 'stacks',
- *     host: '127.0.0.1',
- *     port: 3306,
- *     username: 'root',
- *     password: '',
- *     prefix: '',
- *     charset: 'utf8mb4',
- *     collation: 'utf8mb4_unicode_ci'
- *   },
- *   singlestore: {
- *     name: 'stacks',
- *     host: '127.0.0.1',
- *     port: 3306,
- *     username: 'root',
- *     password: '',
- *     prefix: '',
- *     charset: 'utf8mb4',
- *     ssl: false
- *   },
- *   postgres: {
- *     name: 'stacks',
- *     host: '127.0.0.1',
- *     port: 5432,
- *     username: 'postgres',
- *     password: '',
- *     prefix: '',
- *     schema: 'public'
- *   }
- * }
- * ```
- */
-export declare const driverDefaults: Record<StacksDialect, Partial<SqliteConfig | MysqlConfig | SinglestoreConfig | PostgresConfig | DynamoDbConfig>>;
-/**
- * SQLite specific configuration
- */
-export declare interface SqliteConfig {
-  database: string
-  prefix?: string
-}
-/**
- * MySQL specific configuration
- */
-export declare interface MysqlConfig {
-  name: string
-  host?: string
-  port?: number
-  username?: string
-  password?: string
-  prefix?: string
-  charset?: string
-  collation?: string
-}
-/**
- * SingleStore specific configuration.
- *
- * SingleStore (formerly MemSQL) speaks the MySQL wire protocol, so it shares
- * MySQL's connection shape. It diverges only in DDL (distributed tables with
- * SHARD KEY / SORT KEY, no foreign keys) — handled by the migration generator,
- * not by the connection layer.
- */
-export declare interface SinglestoreConfig {
-  name: string
-  host?: string
-  port?: number
-  username?: string
-  password?: string
-  prefix?: string
-  charset?: string
-  ssl?: boolean
-}
-/**
- * PostgreSQL specific configuration
- */
-export declare interface PostgresConfig {
-  name: string
-  host?: string
-  port?: number
-  username?: string
-  password?: string
-  prefix?: string
-  schema?: string
-  sslMode?: 'disable' | 'require' | 'verify-ca' | 'verify-full'
-}
-/**
- * DynamoDB specific configuration
- */
-export declare interface DynamoDbConfig {
-  key: string
-  secret: string
-  region?: string
-  prefix?: string
-  endpoint?: string
-  tableName?: string
-  singleTable?: {
-    enabled?: boolean
-    pkAttribute?: string
-    skAttribute?: string
-    entityTypeAttribute?: string
-    keyDelimiter?: string
-    gsiCount?: number
-  }
-}
-/**
- * All database connections configuration
- */
-export declare interface DatabaseConnections {
-  sqlite?: SqliteConfig
-  mysql?: MysqlConfig
-  singlestore?: SinglestoreConfig
-  postgres?: PostgresConfig
-  dynamodb?: DynamoDbConfig
-}
-/**
- * Full database configuration
- */
-export declare interface FullDatabaseConfig {
-  default: StacksDialect
-  connections: DatabaseConnections
-  migrations?: string
-  migrationLocks?: string
-}

package/dist/drivers/defaults/index.d.ts

@@ -1,2 +0,0 @@
-export * from './passwords';
-export * from './traits';

package/dist/drivers/defaults/passwords.d.ts

@@ -1,4 +0,0 @@
-// SQLite/MySQL version
-export declare function createPasswordResetsTable(): Promise<void>;
-// PostgreSQL version
-export declare function createPostgresPasswordResetsTable(): Promise<void>;

package/dist/drivers/defaults/traits.d.ts

@@ -1,33 +0,0 @@
-// bun-query-builder utilities are used via db.unsafe() for raw SQL
-export declare function getTraitTables(): string[];
-// SQLite/MySQL version
-export declare function createPasskeyMigration(): Promise<void>;
-// PostgreSQL version
-export declare function createPostgresPasskeyMigration(): Promise<void>;
-export declare function createTaggableTable(): Promise<void>;
-export declare function createPostgresTagsTable(): Promise<void>;
-// SQLite/MySQL version
-export declare function createCategorizableTable(): Promise<void>;
-// PostgreSQL version
-export declare function createPostgresCategorizableTable(): Promise<void>;
-// SQLite/MySQL version
-export declare function createCommentablesTable(options?: {
-  requiresApproval?: boolean
-  reportable?: boolean
-  votable?: boolean
-  requiresAuth?: boolean
-}): Promise<void>;
-// PostgreSQL version
-export declare function createPostgresCommentsTable(): Promise<void>;
-export declare function dropCommonTables(): Promise<void>;
-export declare function truncateMigrationTables(): Promise<void>;
-export declare function dropMigrationTables(): Promise<void>;
-export declare function createCommentUpvoteMigration(): Promise<void>;
-export declare function createPostgresCommentUpvoteMigration(): Promise<void>;
-export declare function createCommentablesPivotTable(): Promise<void>;
-export declare function createPostgresCommentablesPivotTable(): Promise<void>;
-export declare function createTaggablesTable(): Promise<void>;
-export declare function createPostgresTaggablesTable(): Promise<void>;
-export declare function createQueryLogsTable(): Promise<void>;
-// PostgreSQL version
-export declare function createPostgresQueryLogsTable(): Promise<void>;