@stacksjs/database 0.70.87 → 0.70.90

package/dist/auth-tables.js

@@ -0,0 +1,220 @@
+import process from "node:process";
+import { randomBytes } from "node:crypto";
+import { log } from "@stacksjs/logging";
+import { env as envVars } from "@stacksjs/env";
+import { db } from "./utils";
+import { sqlHelpers } from "./sql-helpers";
+function getDbDriver() {
+  return envVars.DB_CONNECTION || "sqlite";
+}
+export function usersEmailVerifiedAtSql(sql) {
+  return `ALTER TABLE users ADD COLUMN email_verified_at ${sql.nullableTimestamp}`;
+}
+export function usersPasswordChangedAtSql(sql) {
+  return `ALTER TABLE users ADD COLUMN password_changed_at ${sql.nullableTimestamp}`;
+}
+export function usersTwoFactorColumnsSql(sql) {
+  return [
+    "ALTER TABLE users ADD COLUMN two_factor_secret VARCHAR(255)",
+    `ALTER TABLE users ADD COLUMN two_factor_enabled BOOLEAN NOT NULL DEFAULT ${sql.boolFalse}`,
+    "ALTER TABLE users ADD COLUMN two_factor_last_used_step BIGINT"
+  ];
+}
+export function usersStripeIdSql() {
+  return "ALTER TABLE users ADD COLUMN stripe_id VARCHAR(255)";
+}
+export async function ensureUsersAuthColumns(sql, options = {}) {
+  const alters = [
+    usersEmailVerifiedAtSql(sql),
+    usersPasswordChangedAtSql(sql),
+    ...usersTwoFactorColumnsSql(sql),
+    usersStripeIdSql()
+  ];
+  for (const alterSql of alters)
+    try {
+      await db.unsafe(alterSql).execute();
+    } catch {
+      if (options.verbose)
+        log.debug(`[auth-tables] Skipped (already applied or users missing): ${alterSql}`);
+    }
+  try {
+    await db.unsafe("CREATE UNIQUE INDEX IF NOT EXISTS idx_users_stripe_id ON users(stripe_id)").execute();
+  } catch {
+    if (options.verbose)
+      log.debug("[auth-tables] Skipped users.stripe_id unique index (already applied or users missing)");
+  }
+}
+export async function migrateAuthTables(options = {}) {
+  const dbDriver = getDbDriver(), sql = sqlHelpers(dbDriver), { isPostgres, boolTrue, now, pkColumn, nullableTimestamp } = sql;
+  if (options.verbose)
+    log.info(`Creating auth tables for ${dbDriver}...`);
+  try {
+    if (options.verbose)
+      log.info("Creating oauth_clients table...");
+    await db.unsafe(`
+      CREATE TABLE IF NOT EXISTS oauth_clients (
+        ${pkColumn},
+        name VARCHAR(255) NOT NULL,
+        secret VARCHAR(100),
+        provider VARCHAR(255),
+        redirect VARCHAR(2000) NOT NULL,
+        personal_access_client BOOLEAN NOT NULL DEFAULT ${sql.boolFalse},
+        password_client BOOLEAN NOT NULL DEFAULT ${sql.boolFalse},
+        revoked BOOLEAN NOT NULL DEFAULT ${sql.boolFalse},
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at ${nullableTimestamp}
+      )
+    `).execute();
+    if (options.verbose)
+      log.info("Creating oauth_access_tokens table...");
+    await db.unsafe(`
+      CREATE TABLE IF NOT EXISTS oauth_access_tokens (
+        ${pkColumn},
+        user_id INTEGER NOT NULL,
+        oauth_client_id INTEGER NOT NULL,
+        token TEXT NOT NULL,
+        name VARCHAR(255),
+        scopes TEXT,
+        revoked BOOLEAN NOT NULL DEFAULT ${sql.boolFalse},
+        expires_at ${nullableTimestamp},
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at ${nullableTimestamp}
+      )
+    `).execute();
+    await createTokenIndex("idx_oauth_access_tokens_token", "oauth_access_tokens", "token");
+    if (options.verbose)
+      log.info("Creating oauth_refresh_tokens table...");
+    await db.unsafe(`
+      CREATE TABLE IF NOT EXISTS oauth_refresh_tokens (
+        ${pkColumn},
+        access_token_id INTEGER NOT NULL,
+        token TEXT NOT NULL,
+        revoked BOOLEAN NOT NULL DEFAULT ${sql.boolFalse},
+        expires_at ${nullableTimestamp},
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `).execute();
+    await createTokenIndex("idx_oauth_refresh_tokens_token", "oauth_refresh_tokens", "token");
+    if (options.verbose)
+      log.info("Creating password_resets table...");
+    await db.unsafe(`
+      CREATE TABLE IF NOT EXISTS password_resets (
+        ${pkColumn},
+        email VARCHAR(255) NOT NULL,
+        token VARCHAR(255) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `).execute();
+    try {
+      await db.unsafe(`
+        CREATE INDEX IF NOT EXISTS idx_password_resets_email ON password_resets(email)
+      `).execute();
+    } catch {}
+    if (options.verbose)
+      log.info("Creating passkeys table...");
+    await db.unsafe(`
+      CREATE TABLE IF NOT EXISTS passkeys (
+        id VARCHAR(255) PRIMARY KEY,
+        cred_public_key TEXT NOT NULL,
+        user_id INTEGER NOT NULL,
+        webauthn_user_id VARCHAR(255) NOT NULL,
+        counter INTEGER NOT NULL DEFAULT 0,
+        credential_type VARCHAR(50),
+        device_type VARCHAR(50),
+        backup_eligible BOOLEAN NOT NULL DEFAULT ${sql.boolFalse},
+        backup_status BOOLEAN NOT NULL DEFAULT ${sql.boolFalse},
+        transports TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        last_used_at ${nullableTimestamp}
+      )
+    `).execute();
+    try {
+      await db.unsafe(`
+        CREATE INDEX IF NOT EXISTS idx_passkeys_user_id ON passkeys(user_id)
+      `).execute();
+    } catch {}
+    if (options.verbose)
+      log.info("Creating webauthn_challenges table...");
+    await db.unsafe(`
+      CREATE TABLE IF NOT EXISTS webauthn_challenges (
+        ${pkColumn},
+        user_id INTEGER NOT NULL,
+        challenge TEXT NOT NULL,
+        purpose VARCHAR(20) NOT NULL,
+        expires_at TIMESTAMP NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `).execute();
+    try {
+      await db.unsafe(`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_webauthn_challenges_user_purpose ON webauthn_challenges(user_id, purpose)
+      `).execute();
+    } catch {}
+    if (options.verbose)
+      log.info("Creating two_factor_challenges table...");
+    await db.unsafe(`
+      CREATE TABLE IF NOT EXISTS two_factor_challenges (
+        id VARCHAR(255) PRIMARY KEY,
+        user_id INTEGER NOT NULL,
+        expires_at TIMESTAMP NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `).execute();
+    try {
+      await db.unsafe(`
+        CREATE INDEX IF NOT EXISTS idx_two_factor_challenges_user_id ON two_factor_challenges(user_id)
+      `).execute();
+    } catch {}
+    if (options.verbose)
+      log.info("Creating two_factor_pending_secrets table...");
+    await db.unsafe(`
+      CREATE TABLE IF NOT EXISTS two_factor_pending_secrets (
+        user_id INTEGER PRIMARY KEY,
+        secret VARCHAR(255) NOT NULL,
+        expires_at TIMESTAMP NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `).execute();
+    if (options.verbose)
+      log.info("Ensuring users auth columns exist (users may not exist yet on a fresh install \u2014 see ensureUsersAuthColumns)...");
+    await ensureUsersAuthColumns(sql, options);
+    if (options.verbose)
+      log.info("Ensuring personal access client exists...");
+    if ((await db.unsafe(`
+      SELECT id FROM oauth_clients WHERE personal_access_client = ${boolTrue} LIMIT 1
+    `).execute())?.length === 0) {
+      const secret = randomBytes(40).toString("hex");
+      if (isPostgres)
+        await db.unsafe(`
+          INSERT INTO oauth_clients (name, secret, provider, redirect, personal_access_client, password_client, revoked, created_at)
+          VALUES ($1, $2, $3, $4, $5, $6, $7, NOW())
+        `, ["Personal Access Client", secret, "local", "http://localhost", !0, !1, !1]).execute();
+      else
+        await db.unsafe(`
+          INSERT INTO oauth_clients (name, secret, provider, redirect, personal_access_client, password_client, revoked, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ${now})
+        `, ["Personal Access Client", secret, "local", "http://localhost", 1, 0, 0]).execute();
+      if (options.verbose)
+        log.success("Personal access client created");
+    }
+    log.debug("Auth tables migrated successfully");
+    return { success: !0 };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log.error("Failed to migrate auth tables:", errorMessage);
+    return { success: !1, error: errorMessage };
+  }
+}
+async function createTokenIndex(indexName, tableName, column) {
+  try {
+    await db.unsafe(`
+      CREATE INDEX IF NOT EXISTS ${indexName} ON ${tableName}(${column}(255))
+    `).execute();
+  } catch {
+    try {
+      await db.unsafe(`
+        CREATE INDEX IF NOT EXISTS ${indexName} ON ${tableName}(${column})
+      `).execute();
+    } catch {}
+  }
+}

package/dist/class-seeder.js

@@ -0,0 +1,116 @@
+import { log } from "@stacksjs/logging";
+import { path } from "@stacksjs/path";
+import { fs } from "@stacksjs/storage";
+
+export class Seeder {
+  dependencies;
+  async call(other) {
+    await new other().run();
+  }
+}
+export function topoSortSeeders(seeders) {
+  const known = new Set(seeders.map((s) => s.name)), effectiveDeps = new Map;
+  for (const s of seeders) {
+    const deps = new Set;
+    for (const dep of s.dependencies ?? []) {
+      if (dep === s.name)
+        continue;
+      if (!known.has(dep)) {
+        log.warn(`[seeder] ${s.name} depends on '${dep}' but no seeder by that name was discovered \u2014 ignoring`);
+        continue;
+      }
+      deps.add(dep);
+    }
+    effectiveDeps.set(s.name, deps);
+  }
+  const indegree = new Map, successors = new Map;
+  for (const s of seeders) {
+    indegree.set(s.name, effectiveDeps.get(s.name).size);
+    successors.set(s.name, new Set);
+  }
+  for (const s of seeders)
+    for (const dep of effectiveDeps.get(s.name))
+      successors.get(dep).add(s.name);
+  const ready = seeders.filter((s) => indegree.get(s.name) === 0).map((s) => s.name).sort(), result = [];
+  while (ready.length > 0) {
+    const next = ready.shift();
+    result.push(next);
+    const newlyReady = [];
+    for (const succ of successors.get(next)) {
+      const left = (indegree.get(succ) ?? 0) - 1;
+      indegree.set(succ, left);
+      if (left === 0)
+        newlyReady.push(succ);
+    }
+    if (newlyReady.length > 0) {
+      ready.push(...newlyReady);
+      ready.sort();
+    }
+  }
+  if (result.length !== seeders.length) {
+    const unresolved = seeders.map((s) => s.name).filter((n) => !result.includes(n));
+    throw Error(`[seeder] Cycle in seeder \`dependencies\` among: ${unresolved.join(", ")}`);
+  }
+  return result;
+}
+export async function runClassSeeders(options = {}) {
+  try {
+    const { injectGlobalAutoImports } = await import("@stacksjs/server");
+    await injectGlobalAutoImports();
+  } catch {}
+  const dir = options.dir ?? path.projectPath("database/seeders"), ran = [], skipped = [];
+  if (!fs.existsSync(dir)) {
+    log.info(`[seeder] No class seeders directory at ${dir}`);
+    return { ran, skipped };
+  }
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".ts") && !f.startsWith("_")).sort(), loaded = [];
+  for (const file of files) {
+    const className = file.replace(/\.ts$/, "");
+    try {
+      const mod = await import(`${dir}/${file}`), Klass = mod.default ?? mod[className];
+      if (!Klass) {
+        log.warn(`[seeder] ${file} has no default export`);
+        skipped.push(className);
+        continue;
+      }
+      const inst = new Klass;
+      if (typeof inst.run !== "function") {
+        log.warn(`[seeder] ${className} does not implement run()`);
+        skipped.push(className);
+        continue;
+      }
+      loaded.push({ className, inst });
+    } catch (err) {
+      log.error(`[seeder] ${className} failed to load:`, err);
+      skipped.push(className);
+    }
+  }
+  const declaresDeps = loaded.some((l) => (l.inst.dependencies?.length ?? 0) > 0);
+  let order;
+  if (declaresDeps)
+    try {
+      order = topoSortSeeders(loaded.map((l) => ({ name: l.className, dependencies: l.inst.dependencies })));
+    } catch (err) {
+      log.error(err instanceof Error ? err.message : String(err));
+      return { ran, skipped: [...skipped, ...loaded.map((l) => l.className)] };
+    }
+  else
+    order = loaded.map((l) => l.className);
+  const byName = new Map(loaded.map((l) => [l.className, l.inst]));
+  for (const className of order) {
+    if (options.class && className !== options.class) {
+      skipped.push(className);
+      continue;
+    }
+    const inst = byName.get(className);
+    try {
+      log.info(`[seeder] Running ${className}\u2026`);
+      await inst.run();
+      ran.push(className);
+    } catch (err) {
+      log.error(`[seeder] ${className} failed:`, err);
+      skipped.push(className);
+    }
+  }
+  return { ran, skipped };
+}

package/dist/column.d.ts

@@ -0,0 +1,17 @@
+declare interface Options {
+  notNull?: boolean
+  default?: any
+  primaryKey?: boolean
+  autoIncrement?: boolean
+}
+declare type ColumnType = 'integer' | 'varchar' | 'timestamp' | `varchar(${number})`;
+export declare class Column {
+  public name: string;
+  public type: ColumnType;
+  public options?: Options;
+  constructor(name: string, type: ColumnType, options?: Options);
+  notNullable(): this;
+  defaultTo(value: any): this;
+  primary(): this;
+  autoIncrement(): this;
+}

package/dist/column.js

@@ -0,0 +1,26 @@
+export class Column {
+  name;
+  type;
+  options;
+  constructor(name, type, options = {}) {
+    this.name = name;
+    this.type = type;
+    this.options = options;
+  }
+  notNullable() {
+    this.options.notNull = !0;
+    return this;
+  }
+  defaultTo(value) {
+    this.options.default = value;
+    return this;
+  }
+  primary() {
+    this.options.primaryKey = !0;
+    return this;
+  }
+  autoIncrement() {
+    this.options.autoIncrement = !0;
+    return this;
+  }
+}

package/dist/custom/audits.js

@@ -0,0 +1,57 @@
+import { log } from "@stacksjs/logging";
+import { database } from "@stacksjs/config";
+import { path } from "@stacksjs/path";
+import { hasTableBeenMigrated } from "../drivers/helpers";
+export async function createModelAuditsTable() {
+  if (!["sqlite", "mysql"].includes(getDriver()))
+    return;
+  if (await hasTableBeenMigrated("model_audits"))
+    return;
+  let migrationContent = `import type { Database } from '@stacksjs/database'
+import { sql } from '@stacksjs/database'
+
+`;
+  migrationContent += `export async function up(db: Database<any>) {
+`;
+  migrationContent += `  await db.schema
+`;
+  migrationContent += `    .createTable('model_audits')
+`;
+  migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+`;
+  migrationContent += `    .addColumn('auditable_type', 'varchar(255)', col => col.notNull())
+`;
+  migrationContent += `    .addColumn('auditable_id', 'varchar(255)', col => col.notNull())
+`;
+  migrationContent += `    .addColumn('event', 'varchar(32)', col => col.notNull())
+`;
+  migrationContent += `    .addColumn('old_values', 'text')
+`;
+  migrationContent += `    .addColumn('new_values', 'text')
+`;
+  migrationContent += `    .addColumn('user_id', 'integer')
+`;
+  migrationContent += `    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+  migrationContent += `    .execute()
+
+`;
+  migrationContent += `  await db.schema
+`;
+  migrationContent += `    .createIndex('idx_model_audits_lookup')
+`;
+  migrationContent += `    .on('model_audits')
+`;
+  migrationContent += `    .columns(['auditable_type', 'auditable_id', 'created_at'])
+`;
+  migrationContent += `    .execute()
+`;
+  migrationContent += `}
+`;
+  const migrationFileName = `${new Date().getTime().toString()}-create-model-audits-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+  await Bun.write(migrationFilePath, migrationContent);
+  log.success("Created model_audits table migration");
+}
+function getDriver() {
+  return database.default || "";
+}

package/dist/custom/errors.js

@@ -0,0 +1,48 @@
+import { log } from "@stacksjs/logging";
+import { database } from "@stacksjs/config";
+import { path } from "@stacksjs/path";
+import { hasTableBeenMigrated } from "../drivers/helpers";
+export async function createErrorsTable() {
+  if (["sqlite", "mysql"].includes(getDriver())) {
+    if (await hasTableBeenMigrated("errors"))
+      return;
+    let migrationContent = `import type { Database } from '@stacksjs/database'
+import { sql } from '@stacksjs/database'
+
+`;
+    migrationContent += `export async function up(db: Database<any>) {
+`;
+    migrationContent += `  await db.schema
+`;
+    migrationContent += `    .createTable('errors')
+`;
+    migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+`;
+    migrationContent += `    .addColumn('type', 'varchar(255)', col => col.notNull())
+`;
+    migrationContent += `    .addColumn('message', 'text', col => col.notNull())
+`;
+    migrationContent += `    .addColumn('stack', 'text')
+`;
+    migrationContent += `    .addColumn('status', 'integer', col => col.notNull().defaultTo(0))
+`;
+    migrationContent += `    .addColumn('user_id', 'integer')
+`;
+    migrationContent += `    .addColumn('additional_info', 'text')
+`;
+    migrationContent += `    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+    migrationContent += `    .addColumn('updated_at', 'timestamp')
+`;
+    migrationContent += `    .execute()
+`;
+    migrationContent += `}
+`;
+    const migrationFileName = `${new Date().getTime().toString()}-create-errors-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+    await Bun.write(migrationFilePath, migrationContent);
+    log.success("Created errors table");
+  }
+}
+function getDriver() {
+  return database.default || "";
+}

package/dist/custom/index.js

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