@stacksjs/database 0.70.88 → 0.70.91

package/dist/auth-tables.d.ts

@@ -0,0 +1,60 @@
+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/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.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 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/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.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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/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.d.ts

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

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.d.ts

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

package/dist/custom/index.js

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

package/dist/custom/jobs.d.ts

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