@stacksjs/database 0.70.87 → 0.70.88

package/dist/migration-lock.d.ts

@@ -1,23 +0,0 @@
-/**
- * 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,76 +0,0 @@
-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
- */
-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
- * out to a fresh file in `database/migrations/`. Each statement is
- * grouped by table + DDL verb and lands in its own file using the
- * runner's existing naming convention so it picks them up the same way
- * as a hand-written migration.
- *
- * Without this write step the qb generator stages the diff in memory but
- * the runner never sees it, so model edits silently no-op'd — defeating
- * the "models are the source of truth" promise.
- */
-export declare interface GenerateMigrationsOptions {
-  applyRenames?: boolean
-  fromDb?: boolean
-}
-/**
- * Migration result type for compatibility
- */
-export declare interface MigrationResult {
-  migrationName: string
-  direction: 'Up' | 'Down'
-  status: 'Success' | 'Error' | 'NotExecuted'
-}

package/dist/notification-tables.d.ts

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

@@ -1,26 +0,0 @@
-export declare function setQueryTracker(fn: QueryTracker): void;
-/**
- * Process an executed query and store it in the database
- */
-export declare function logQuery(event: LogEvent): Promise<void>;
-/**
- * Query log event type - compatible with bun-query-builder hooks
- */
-declare interface LogEvent {
-  query?: {
-    sql?: string
-    parameters?: unknown[]
-  }
-  queryDurationMillis?: number
-  error?: Error | unknown
-}
-/**
- * Soft dependency on the router's query tracker. Importing it directly
- * creates the cycle `database → router → database` (router uses db
- * helpers transitively via middleware). The DI shape below lets the
- * router register its tracker at module-init time and lets the database
- * package stay leaf-node — runs that don't load the router (CLI tools,
- * cron tasks) silently no-op the tracker call.
- */
-// eslint-disable-next-line pickier/no-unused-vars
-declare type QueryTracker = (query: string, durationMs?: number, connection?: string) => void;

package/dist/query-parser.d.ts

@@ -1,4 +0,0 @@
-/**
- * Parse and normalize a SQL query
- */
-export declare function parseQuery(sql: string): { normalized: string, type: string, tables: string[] };

package/dist/rbac-tables.d.ts

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

@@ -1,72 +0,0 @@
-import { db } from './utils';
-/**
- * Add a column to `tableName` without taking a table-level lock long
- * enough to disrupt traffic. The column is created nullable, backfilled
- * in batches, and (if `notNull: true`) the constraint is added at the
- * end.
- *
- * Pre-conditions:
- *   - `tableName` exists
- *   - `columnName` does NOT already exist (this helper doesn't gracefully
- *     handle the rerun case — wrap in `if (!columnExists)` if you need that)
- *
- * Caveats:
- *   - SQLite doesn't support adding NOT NULL columns to existing tables
- *     without a default; we work around it by always supplying one
- *   - Postgres < 11 rewrites the entire table when a default is added;
- *     this helper assumes ≥ 11
- *
- * @example
- * ```ts
- * await addColumnSafely(db, 'users', 'email_verified', {
- *   type: 'boolean',
- *   defaultValue: false,
- *   notNull: true,
- * })
- * ```
- */
-export declare function addColumnSafely(db: Database, tableName: string, columnName: string, options: AddColumnSafelyOptions): Promise<void>;
-/**
- * Back-fill `columnName` with `value` for any row where it's currently
- * NULL. Runs in batches so the UPDATE doesn't lock the entire table.
- *
- * Useful as a standalone helper when you want to backfill an *existing*
- * column (e.g. populating a denormalized count) — `addColumnSafely`
- * uses it internally.
- */
-export declare function backfillInBatches(db: Database, tableName: string, columnName: string, value: string | number | boolean | null, batchSize?: number): Promise<void>;
-/**
- * Rename a column safely on a table that's actively serving traffic.
- *
- * Most database engines DO support `RENAME COLUMN` as a metadata-only
- * operation (no rewrite, no long lock), which means the headline
- * concern is *application-side*: app code reads the old column name,
- * the migration renames it, and the next request 500s.
- *
- * This helper wraps the rename in a multi-step sequence the framework
- * docs can teach as the canonical pattern:
- *
- *   1. Add the new column
- *   2. Backfill from old → new
- *   3. Update writes to dual-write old AND new (app-level, deploy step)
- *   4. Update reads to read from new (app-level, deploy step)
- *   5. Drop the old column (separate migration)
- *
- * For the rare case where the rename *can* happen atomically (small
- * table, no live traffic), pass `{ atomic: true }` and we'll just emit
- * the RENAME COLUMN.
- *
- * @example
- * ```ts
- * // Step 1 of the rename sequence — the rest is app-side coordination.
- * await renameColumnSafely(db, 'users', 'name', 'full_name', { type: 'varchar(255)' })
- * ```
- */
-export declare function renameColumnSafely(db: Database, tableName: string, oldName: string, newName: string, options: { type: string, atomic?: boolean }): Promise<void>;
-declare interface AddColumnSafelyOptions {
-  type: string
-  defaultValue?: string | number | boolean | null
-  notNull?: boolean
-  batchSize?: number
-}
-declare type Database = typeof db;

package/dist/seed-scaffold.d.ts

@@ -1,34 +0,0 @@
-/**
- * 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,116 +0,0 @@
-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>;
-/**
- * Seed a specific model by name
- * Searches both default and user models
- */
-export declare function seedModel$(modelName: string, options?: { count?: number, fresh?: boolean, verbose?: boolean }): Promise<SeedResult>;
-/**
- * Fresh seed - truncate all tables and reseed
- */
-export declare function freshSeed(config?: SeederConfig): Promise<SeedSummary>;
-/**
- * Get list of seedable models without seeding
- * 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
- */
-export declare interface SeederConfig {
-  modelsDir?: string
-  defaultCount?: number
-  verbose?: boolean
-  fresh?: boolean
-  only?: string[]
-  except?: string[]
-  includeDefaults?: boolean
-  allowProtected?: boolean
-}
-/**
- * Result of a single model seeding operation
- */
-export declare interface SeedResult {
-  model: string
-  table: string
-  count: number
-  success: boolean
-  error?: string
-  duration: number
-}
-/**
- * Result of the entire seeding operation
- */
-export declare interface SeedSummary {
-  total: number
-  successful: number
-  failed: number
-  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

@@ -1,33 +0,0 @@
-/**
- * Create SQL dialect helpers for a given driver.
- *
- * @example
- * ```ts
- * import { sqlHelpers } from '@stacksjs/database'
- * const sql = sqlHelpers('postgres')
- * await db.unsafe(`SELECT * FROM users WHERE id = ${sql.param(1)}`, [userId])
- * ```
- */
-export declare function sqlHelpers(driver: string): SqlDialectHelpers;
-/**
- * SQL Dialect Helpers
- *
- * Cross-database compatibility utilities for PostgreSQL, MySQL, and SQLite.
- * Centralizes the isPostgres/isMysql/now/boolTrue/boolFalse/param helpers
- * that were previously duplicated across tokens.ts, auth-tables.ts, and setup.ts.
- */
-export declare interface SqlDialectHelpers {
-  driver: string
-  isPostgres: boolean
-  isMysql: boolean
-  isSqlite: boolean
-  now: string
-  boolTrue: string
-  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

@@ -1,52 +0,0 @@
-/**
- * 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

@@ -1,151 +0,0 @@
-/**
- * SQL template tag function.
- * Creates parameterized SQL queries from template literals.
- *
- * @example
- * ```ts
- * const query = sql`SELECT * FROM users WHERE id = ${userId}`
- * ```
- */
-export declare function sql(strings: TemplateStringsArray, ...values: unknown[]): Sql;
-/**
- * Type for raw SQL expressions.
- * Used when building dynamic SQL queries.
- */
-export declare interface RawBuilder<T = unknown> {
-  readonly sql: string
-  readonly parameters?: unknown[]
-  readonly __result?: T
-}
-/**
- * SQL template tag type.
- * Used for tagged template literals that produce SQL.
- */
-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
-  as: (alias: string) => ColumnRef
-}
-/**
- * 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 {
-  countAll: () => AggregateExpression
-  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 {
-  (left: unknown, op: ExpressionOperator | string, right: unknown): unknown
-  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
- *
- * These types provide backwards compatibility with code that
- * previously used Kysely types. They work with bun-query-builder's
- * native type system.
- */
-/**
- * Marks a column as auto-generated (e.g., auto-increment primary keys).
- * When inserting, this field is optional. When selecting, it's required.
- */
-export type Generated<T> = T;
-/**
- * Marks a column as always generated (computed columns).
- * This field cannot be inserted or updated directly.
- */
-export type GeneratedAlways<T> = T;
-/**
- * Utility type for insert operations.
- * Makes Generated fields optional, keeps required fields required.
- */
-export type Insertable<T> = {
-  [K in keyof T]?: T[K]
-}
-/**
- * Utility type for select operations.
- * All fields are as defined in the table type.
- */
-export type Selectable<T> = T;
-/**
- * Utility type for update operations.
- * All fields are optional since you may update only some fields.
- */
-export type Updateable<T> = Partial<T>;
-/**
- * Database type alias for backwards compatibility.
- * 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';