@stacksjs/database 0.70.88 → 0.70.91

package/dist/utils.d.ts

@@ -0,0 +1,189 @@
+import { createQueryBuilder, setConfig } 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>;
+declare function getDb(): ReturnType<typeof createQueryBuilder>;
+/**
+ * Lazy proxy for the query builder - connection is only made when first used.
+ * This is the main entry point for database operations.
+ */
+export declare const db: Proxy;
+/**
+ * Fluent chain returned by entry-point methods like `selectFrom`/`updateTable`.
+ *
+ * bun-query-builder marks legacy chain methods (e.g. `selectAll`, `whereILike`,
+ * `selectAllRelations`) as optional in its declarations even though they're
+ * always present at runtime. Re-typing them here avoids forcing every call
+ * site to use `?.()` or `!` on the chain.
+ *
+ * Returns are typed as `any` deliberately — typing each variant precisely
+ * would re-introduce the optional methods, and we already lose strict column
+ * typing one step into a chain (the underlying query builder is constructed
+ * with no schema). Tests cover the runtime semantics.
+ */
+export declare interface FluentChain {
+  where(callback: (eb: import('./types').StacksExpressionBuilder) => unknown): FluentChain
+  where(...args: any[]): FluentChain
+  whereNull: (...args: any[]) => FluentChain
+  whereNotNull: (...args: any[]) => FluentChain
+  whereIn: (...args: any[]) => FluentChain
+  whereNotIn: (...args: any[]) => FluentChain
+  whereLike: (...args: any[]) => FluentChain
+  whereNotLike: (...args: any[]) => FluentChain
+  whereILike: (...args: any[]) => FluentChain
+  whereNotILike: (...args: any[]) => FluentChain
+  whereBetween: (...args: any[]) => FluentChain
+  whereNotBetween: (...args: any[]) => FluentChain
+  whereRaw: (...args: any[]) => FluentChain
+  whereColumn: (...args: any[]) => FluentChain
+  orWhere: (...args: any[]) => FluentChain
+  orWhereNull: (...args: any[]) => FluentChain
+  orWhereNotNull: (...args: any[]) => FluentChain
+  orWhereIn: (...args: any[]) => FluentChain
+  orWhereNotIn: (...args: any[]) => FluentChain
+  orWhereLike: (...args: any[]) => FluentChain
+  orWhereNotLike: (...args: any[]) => FluentChain
+  orWhereILike: (...args: any[]) => FluentChain
+  orWhereColumn: (...args: any[]) => FluentChain
+  andWhere: (...args: any[]) => FluentChain
+  having: (...args: any[]) => FluentChain
+  groupBy: (...args: any[]) => FluentChain
+  orderBy: (...args: any[]) => FluentChain
+  limit: (...args: any[]) => FluentChain
+  offset: (...args: any[]) => FluentChain
+  select(selection: ((eb: import('./types').StacksExpressionBuilder) => unknown) | ReadonlyArray<string | ((eb: import('./types').StacksExpressionBuilder) => unknown) | unknown>): FluentChain
+  select(...args: any[]): FluentChain
+  selectAll: () => FluentChain
+  selectAllRelations: () => FluentChain
+  selectRaw: (...args: any[]) => FluentChain
+  distinct: () => FluentChain
+  distinctOn: (...args: any[]) => FluentChain
+  innerJoin: (...args: any[]) => FluentChain
+  leftJoin: (...args: any[]) => FluentChain
+  rightJoin: (...args: any[]) => FluentChain
+  fullJoin: (...args: any[]) => FluentChain
+  crossJoin: (...args: any[]) => FluentChain
+  with: (...args: any[]) => FluentChain
+  union: (...args: any[]) => FluentChain
+  unionAll: (...args: any[]) => FluentChain
+  values: (...args: any[]) => FluentChain
+  set: (...args: any[]) => FluentChain
+  returning: (...args: any[]) => FluentChain
+  returningAll: () => FluentChain
+  onConflict: (...args: any[]) => FluentChain
+  onDuplicateKeyUpdate: (...args: any[]) => FluentChain
+  onConflictDoNothing: (...args: any[]) => FluentChain
+  onDuplicateKeyIgnore: () => FluentChain
+  forUpdate: () => FluentChain
+  forShare: () => FluentChain
+  toSQL: () => string
+  execute: () => Promise<any>
+  executeTakeFirst: () => Promise<any>
+  executeTakeFirstOrThrow: () => Promise<any>
+  pluck: (...args: any[]) => Promise<any>
+  count: (...args: any[]) => Promise<number>
+  sum: (...args: any[]) => Promise<number>
+  avg: (...args: any[]) => Promise<number>
+  min: (...args: any[]) => Promise<any>
+  max: (...args: any[]) => Promise<any>
+  exists: () => Promise<boolean>
+  doesntExist: () => Promise<boolean>
+  $call: (callback: (query: FluentChain) => FluentChain) => FluentChain
+  [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 {}
+declare interface Db extends Pick<Required<RawQueryBuilder>, GenericPassthroughKeys> {
+  fn: import('./types').ExpressionFunctions
+  selectFrom: (table: TableName) => FluentChain
+  insertInto: (table: TableName) => FluentChain
+  updateTable: (table: TableName) => FluentChain
+  deleteFrom: (table: TableName) => FluentChain
+  table: (table: TableName) => FluentChain
+  selectFromSub: (sub: any, alias: string) => FluentChain
+  select: (table: TableName, ...columns: string[]) => FluentChain
+  unsafe: (query: string, params?: any[]) => UnsafeReturn
+}
+// The bun-query-builder types `unsafe()` as returning `Promise<any>`, but at
+// runtime it returns a Bun SQL Statement that has `.execute()`. This interface
+// corrects the return type so callers can chain `.execute()` without type errors.
+declare type UnsafeReturn = Promise<any> & { execute: () => Promise<any> }
+/**
+ * Top-level surface of the lazy `db` proxy. Methods that return a chainable
+ * builder are typed as `FluentChain` to flatten the optional-method noise
+ * inherent in bun-query-builder's declarations. Methods that introduce their
+ * own generics (`transaction<T>`, etc.) are kept as their original signatures
+ * via the underlying QueryBuilder type so call-site inference still works.
+ */
+declare type RawQueryBuilder = ReturnType<typeof createQueryBuilder>;
+declare type GenericPassthroughKeys = | 'transaction'
+  | 'savepoint'
+  | 'beginDistributed'
+  | 'transactional'
+  | 'configure'
+  | 'reserve'
+  | 'commitDistributed'
+  | 'rollbackDistributed'
+  | 'setTransactionDefaults'
+  | 'close'
+  | 'listen'
+  | 'unlisten'
+  | 'notify'
+  | 'copyTo'
+  | 'copyFrom'
+  | 'ping'
+  | 'waitForReady'
+  | 'count'
+  | 'sum'
+  | 'avg'
+  | 'min'
+  | 'max'
+  | 'insertOrIgnore'
+  | 'insertGetId'
+  | 'updateOrInsert'
+  | 'upsert'
+  | 'create'
+  | 'createMany'
+  | 'sql'
+  | '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/utils.js

@@ -0,0 +1,163 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createQueryBuilder, setConfig } from "@stacksjs/query-builder";
+import { env as envVars } from "@stacksjs/env";
+import { getConnectionDefaults } from "./defaults";
+const sqliteDefaults = getConnectionDefaults("sqlite", envVars), mysqlDefaults = getConnectionDefaults("mysql", envVars), postgresDefaults = getConnectionDefaults("postgres", envVars);
+let appEnv = envVars.APP_ENV || "local", dbDriver = envVars.DB_CONNECTION || "sqlite", dbConfig = {
+  connections: {
+    sqlite: { database: sqliteDefaults.database, prefix: "" },
+    mysql: { name: mysqlDefaults.database, host: mysqlDefaults.host, username: mysqlDefaults.username, password: mysqlDefaults.password, port: mysqlDefaults.port, prefix: "" },
+    singlestore: { name: mysqlDefaults.database, host: mysqlDefaults.host, username: mysqlDefaults.username, password: mysqlDefaults.password, port: mysqlDefaults.port, prefix: "" },
+    postgres: { name: postgresDefaults.database, host: postgresDefaults.host, username: postgresDefaults.username, password: postgresDefaults.password, port: postgresDefaults.port, prefix: "" }
+  }
+}, dbConfigLockTail = Promise.resolve();
+export function acquireDbConfigLock() {
+  let release = () => {};
+  const held = new Promise((resolve) => {
+    release = resolve;
+  }), acquired = dbConfigLockTail.then(() => release);
+  dbConfigLockTail = dbConfigLockTail.then(() => held);
+  return acquired;
+}
+export function initializeDbConfig(config) {
+  if (config?.app?.env)
+    appEnv = config.app.env;
+  if (config?.database?.default)
+    dbDriver = config.database.default;
+  if (config?.database)
+    dbConfig = config.database;
+  updateQueryBuilderConfig();
+  _dbInstance = null;
+}
+function getEnv() {
+  return appEnv;
+}
+function getDriver() {
+  return dbDriver;
+}
+function getDatabaseConfig() {
+  return dbConfig;
+}
+function getDialect() {
+  const driver = getDriver();
+  if (driver === "sqlite")
+    return "sqlite";
+  if (driver === "mysql")
+    return "mysql";
+  if (driver === "singlestore")
+    return "singlestore";
+  if (driver === "postgres")
+    return "postgres";
+  return "sqlite";
+}
+function getDbConfig() {
+  const driver = getDriver(), database = getDatabaseConfig(), env = getEnv();
+  if (driver === "sqlite") {
+    const defaultName = env !== "testing" ? "database/stacks.sqlite" : "database/stacks_testing.sqlite";
+    return {
+      database: database.connections?.sqlite?.database ?? defaultName
+    };
+  }
+  if (driver === "mysql")
+    return {
+      database: database.connections?.mysql?.name || "stacks",
+      host: database.connections?.mysql?.host ?? "127.0.0.1",
+      username: database.connections?.mysql?.username ?? "root",
+      password: database.connections?.mysql?.password ?? "",
+      port: database.connections?.mysql?.port ?? 3306
+    };
+  if (driver === "singlestore")
+    return {
+      database: database.connections?.singlestore?.name || "stacks",
+      host: database.connections?.singlestore?.host ?? "127.0.0.1",
+      username: database.connections?.singlestore?.username ?? "root",
+      password: database.connections?.singlestore?.password ?? "",
+      port: database.connections?.singlestore?.port ?? 3306
+    };
+  if (driver === "postgres") {
+    const dbName = database.connections?.postgres?.name ?? "stacks";
+    return {
+      database: env === "testing" ? `${dbName}_testing` : dbName,
+      host: database.connections?.postgres?.host ?? "127.0.0.1",
+      username: database.connections?.postgres?.username ?? "",
+      password: database.connections?.postgres?.password ?? "",
+      port: database.connections?.postgres?.port ?? 5432
+    };
+  }
+  return { database: ":memory:" };
+}
+function updateQueryBuilderConfig() {
+  const dialect = getDialect(), dbConfigForQb = getDbConfig();
+  setConfig({
+    dialect,
+    database: dbConfigForQb,
+    verbose: getEnv() !== "production",
+    timestamps: {
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      defaultOrderColumn: "created_at"
+    },
+    softDeletes: {
+      enabled: !0,
+      column: "deleted_at",
+      defaultFilter: !0
+    }
+  });
+}
+updateQueryBuilderConfig();
+let _dbInstance = null, _configInitPromise = null;
+function ensureConfigLoaded() {
+  if (!_configInitPromise)
+    _configInitPromise = (async () => {
+      try {
+        const { config, overridesReady } = await import("@stacksjs/config");
+        await overridesReady;
+        if (config) {
+          initializeDbConfig(config);
+          _dbInstance = null;
+        }
+      } catch {}
+    })();
+  return _configInitPromise;
+}
+export async function ensureDatabaseConfigLoaded() {
+  await ensureConfigLoaded();
+}
+export { applySqlitePragmas, SQLITE_BOOTSTRAP_PRAGMAS } from "@stacksjs/query-builder";
+const sqliteTxOwner = new AsyncLocalStorage;
+let sqliteTxTail = Promise.resolve();
+function serializeSqliteTransaction(run) {
+  if (sqliteTxOwner.getStore())
+    return run();
+  const result = sqliteTxTail.then(() => sqliteTxOwner.run(!0, run));
+  sqliteTxTail = result.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return result;
+}
+function applySqliteTransactionSerialization(instance) {
+  const original = instance.transaction.bind(instance);
+  instance.transaction = (...args) => serializeSqliteTransaction(() => original(...args));
+}
+function getDb() {
+  if (!_dbInstance) {
+    updateQueryBuilderConfig();
+    _dbInstance = createQueryBuilder();
+    if (getDialect() === "sqlite")
+      applySqliteTransactionSerialization(_dbInstance);
+  }
+  return _dbInstance;
+}
+ensureConfigLoaded();
+export const db = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getDb(), value = instance[prop];
+    if (typeof value === "function")
+      return value.bind(instance);
+    return value;
+  }
+});
+
+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/dist/uuid-columns.js

@@ -0,0 +1,68 @@
+import process from "node:process";
+import { log } from "@stacksjs/logging";
+import { path } from "@stacksjs/path";
+import { getModelName, getTableName } from "@stacksjs/orm";
+import { fs } from "@stacksjs/storage";
+import { db } from "./utils";
+import { sqlHelpers } from "./sql-helpers";
+function getDbDriver() {
+  return process.env.DB_CONNECTION || "sqlite";
+}
+function uuidColumnType(sql) {
+  if (sql.isPostgres)
+    return "UUID";
+  if (sql.isMysql)
+    return "VARCHAR(255)";
+  return "TEXT";
+}
+export function uuidColumnSql(table, sql) {
+  return `ALTER TABLE ${table} ADD COLUMN uuid ${uuidColumnType(sql)}`;
+}
+async function loadModelsFrom(dir) {
+  const out = [];
+  if (!fs.existsSync(dir))
+    return out;
+  const entries = fs.readdirSync(dir, { withFileTypes: !0 });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await loadModelsFrom(fullPath));
+      continue;
+    }
+    if (!entry.name.endsWith(".ts"))
+      continue;
+    if (entry.name.startsWith("_") || entry.name.startsWith("index"))
+      continue;
+    try {
+      const imported = (await import(fullPath)).default;
+      if (imported?.name || imported?.table)
+        out.push({ filePath: fullPath, model: imported });
+    } catch {}
+  }
+  return out;
+}
+export async function findUuidTables() {
+  const dirs = [path.userModelsPath(), path.frameworkPath("defaults/app/Models")], tables = new Set;
+  for (const dir of dirs)
+    for (const { filePath, model } of await loadModelsFrom(dir)) {
+      if (!model.traits?.useUuid)
+        continue;
+      tables.add(getTableName(model, filePath));
+    }
+  return [...tables];
+}
+export async function ensureUuidColumns(sql, options = {}) {
+  const tables = await findUuidTables();
+  for (const table of tables)
+    try {
+      await db.unsafe(uuidColumnSql(table, sql)).execute();
+      if (options.verbose)
+        log.debug(`[uuid-columns] Added uuid column to ${table}`);
+    } catch {
+      if (options.verbose)
+        log.debug(`[uuid-columns] Skipped (already applied or ${table} missing): uuid column`);
+    }
+}
+export async function ensureUuidColumnsForCurrentDriver(options = {}) {
+  await ensureUuidColumns(sqlHelpers(getDbDriver()), options);
+}

package/dist/validators.d.ts

@@ -0,0 +1,26 @@
+import type { BigintValidatorType, BinaryValidatorType, BlobValidatorType, BooleanValidatorType, DatetimeValidatorType, DateValidatorType, DecimalValidatorType, EnumValidatorType, FloatValidatorType, IntegerValidatorType, JsonValidatorType, NumberValidatorType, SmallintValidatorType, StringValidatorType, TimestampTzValidatorType, TimestampValidatorType, UnixValidatorType, ValidationType } from '@stacksjs/ts-validation';
+export declare function isStringValidator(v: ValidationType): v is StringValidatorType;
+export declare function isNumberValidator(v: ValidationType): v is NumberValidatorType;
+export declare function enumValidator(v: ValidationType): v is EnumValidatorType;
+export declare function isBooleanValidator(v: ValidationType): v is BooleanValidatorType;
+export declare function isDateValidator(v: ValidationType): v is DateValidatorType;
+export declare function isUnixValidator(v: ValidationType): v is UnixValidatorType;
+export declare function isFloatValidator(v: ValidationType): v is FloatValidatorType;
+export declare function isDatetimeValidator(v: ValidationType): v is DatetimeValidatorType;
+export declare function isTimestampValidator(v: ValidationType): v is TimestampValidatorType;
+export declare function isTimestampTzValidator(v: ValidationType): v is TimestampTzValidatorType;
+export declare function isDecimalValidator(v: ValidationType): v is DecimalValidatorType;
+export declare function isSmallintValidator(v: ValidationType): v is SmallintValidatorType;
+export declare function isIntegerValidator(v: ValidationType): v is IntegerValidatorType;
+export declare function isBigintValidator(v: ValidationType): v is BigintValidatorType;
+export declare function isBinaryValidator(v: ValidationType): v is BinaryValidatorType;
+export declare function isBlobValidator(v: ValidationType): v is BlobValidatorType;
+export declare function isJsonValidator(v: ValidationType): v is JsonValidatorType;
+export declare function checkValidator(validator: ValidationType, driver: string): string;
+export declare function prepareNumberColumnType(validator: NumberValidatorType, driver?: string): string;
+// Add new function for enum column types
+export declare function prepareEnumColumnType(validator: EnumValidatorType, driver?: string): string;
+export declare function prepareTextColumnType(validator: StringValidatorType, driver?: string): string;
+// Add new function for date/time column types
+export declare function prepareDateTimeColumnType(validator: DateValidatorType, driver?: string): string;
+export declare function findCharacterLength(validator: ValidationType): number;

package/dist/validators.js

@@ -0,0 +1,122 @@
+export function isStringValidator(v) {
+  return v.name === "string";
+}
+export function isNumberValidator(v) {
+  return v.name === "number";
+}
+export function enumValidator(v) {
+  return v.name === "enum";
+}
+export function isBooleanValidator(v) {
+  return v.name === "boolean";
+}
+export function isDateValidator(v) {
+  return v.name === "date";
+}
+export function isUnixValidator(v) {
+  return v.name === "unix";
+}
+export function isFloatValidator(v) {
+  return v.name === "float";
+}
+export function isDatetimeValidator(v) {
+  return v.name === "datetime";
+}
+export function isTimestampValidator(v) {
+  return v.name === "timestamp";
+}
+export function isTimestampTzValidator(v) {
+  return v.name === "timestampTz";
+}
+export function isDecimalValidator(v) {
+  return v.name === "decimal";
+}
+export function isSmallintValidator(v) {
+  return v.name === "smallint";
+}
+export function isIntegerValidator(v) {
+  return v.name === "integer";
+}
+export function isBigintValidator(v) {
+  return v.name === "bigint";
+}
+export function isBinaryValidator(v) {
+  return v.name === "binary";
+}
+export function isBlobValidator(v) {
+  return v.name === "blob";
+}
+export function isJsonValidator(v) {
+  return v.name === "json";
+}
+export function checkValidator(validator, driver) {
+  if (enumValidator(validator))
+    return prepareEnumColumnType(validator, driver);
+  if (isStringValidator(validator))
+    return prepareTextColumnType(validator, driver);
+  if (isNumberValidator(validator))
+    return prepareNumberColumnType(validator, driver);
+  if (isBooleanValidator(validator))
+    return "'boolean'";
+  if (isDateValidator(validator))
+    return "'date'";
+  if (isDatetimeValidator(validator))
+    return "'datetime'";
+  if (isUnixValidator(validator))
+    return "'bigint'";
+  if (isTimestampValidator(validator))
+    return "'timestamp'";
+  if (isTimestampTzValidator(validator))
+    return "'timestamp'";
+  if (isFloatValidator(validator))
+    return "'float'";
+  if (isSmallintValidator(validator))
+    return "'smallint'";
+  if (isDecimalValidator(validator))
+    return "'decimal'";
+  if (isIntegerValidator(validator))
+    return "'integer'";
+  if (isBigintValidator(validator))
+    return "'bigint'";
+  if (isBinaryValidator(validator))
+    return "'binary'";
+  return "";
+}
+export function prepareNumberColumnType(validator, driver = "mysql") {
+  if (driver === "sqlite")
+    return "'integer'";
+  if ("getRules" in validator) {
+    const minRule = validator.getRules().find((rule) => rule.name === "min"), maxRule = validator.getRules().find((rule) => rule.name === "max"), min = minRule?.params?.min ?? -2147483648, max = maxRule?.params?.max ?? 2147483647;
+    return min >= -2147483648 && max <= 2147483647 ? "'integer'" : "'bigint'";
+  }
+  return "'integer'";
+}
+export function prepareEnumColumnType(validator, driver = "mysql") {
+  const allowedValues = validator.getAllowedValues();
+  if (!allowedValues)
+    throw Error("Enum rule found but no allowedValues defined");
+  const enumStructure = allowedValues.map((value) => `'${value}'`).join(", ");
+  if (driver === "sqlite")
+    return "'text'";
+  return `sql\`enum(${enumStructure})\``;
+}
+export function prepareTextColumnType(validator, driver = "mysql") {
+  if (driver === "sqlite")
+    return "'text'";
+  return `'varchar(${findCharacterLength(validator)})'`;
+}
+export function prepareDateTimeColumnType(validator, driver = "mysql") {
+  if (driver === "sqlite")
+    return "'text'";
+  const name = validator.name;
+  if (name === "unix")
+    return "'bigint'";
+  return name || "date";
+}
+export function findCharacterLength(validator) {
+  if ("getRules" in validator) {
+    const maxLengthRule = validator.getRules().find((rule) => rule.name === "max");
+    return maxLengthRule?.params?.length || maxLengthRule?.params?.max || 255;
+  }
+  return 255;
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/database",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.88",
+  "version": "0.70.91",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "contributors": [
@@ -55,18 +55,18 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "bun-query-builder": "^0.1.47"
+    "bun-query-builder": "^0.1.50"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.88",
-    "@stacksjs/config": "0.70.88",
-    "@stacksjs/logging": "0.70.88",
-    "@stacksjs/router": "0.70.88",
+    "@stacksjs/cli": "0.70.91",
+    "@stacksjs/config": "0.70.91",
+    "@stacksjs/logging": "0.70.91",
+    "@stacksjs/router": "0.70.91",
     "better-dx": "^0.2.16",
-    "@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"
+    "@stacksjs/path": "0.70.91",
+    "@stacksjs/query-builder": "0.70.91",
+    "@stacksjs/storage": "0.70.91",
+    "@stacksjs/strings": "0.70.91",
+    "@stacksjs/utils": "0.70.91"
   }
 }