@stacksjs/database 0.70.256 → 0.70.258

package/dist/drivers/mysql.d.ts

@@ -2,6 +2,5 @@ import type { Ok } from '@stacksjs/error-handling';
 export declare function resetMysqlDatabase(): Promise<Ok<string, never>>;
 export declare function dropMysqlTables(): Promise<void>;
 export declare function generateMysqlMigration(modelPath: string): Promise<void>;
-export declare function generateMysqlTraitMigrations(): Promise<void>;
 export declare function createAlterTableMigration(modelPath: string): Promise<void>;
 export declare function generateIndexCreationSQL(tableName: string, index: { name: string, columns: string[], unique?: boolean, where?: string }): string;

package/dist/drivers/mysql.js

@@ -3,7 +3,6 @@ function italic(str) {
   return `\x1B[3m${str}\x1B[23m`;
 }
 import { db } from "../utils";
-import { createPasswordResetsTable } from "./defaults/passwords";
 import { ok } from "@stacksjs/error-handling";
 import { fetchOtherModelRelations, getModelName, getPivotTables, getTableName } from "@stacksjs/orm";
 import { path } from "@stacksjs/path";
@@ -24,7 +23,7 @@ import {
   mapFieldTypeToColumnType,
   pluckChanges
 } from "./helpers";
-import { createCategorizableTable, createCommentablesTable, createCommentUpvoteMigration, createPasskeyMigration, createQueryLogsTable, createTaggablesTable, createTaggableTable, dropCommonTables } from "./defaults/traits";
+import { dropCommonTables } from "./defaults/traits";
 export async function resetMysqlDatabase() {
   await dropMysqlTables();
   await deleteFrameworkModels();
@@ -70,18 +69,6 @@ export async function generateMysqlMigration(modelPath) {
   else
     await createTableMigration(modelPath);
 }
-export async function generateMysqlTraitMigrations() {
-  await Promise.all([
-    createCategorizableTable(),
-    createCommentablesTable(),
-    createTaggableTable(),
-    createTaggablesTable(),
-    createPasswordResetsTable(),
-    createPasskeyMigration(),
-    createQueryLogsTable(),
-    createCommentUpvoteMigration()
-  ]);
-}
 async function createTableMigration(modelPath) {
   log.debug("createTableMigration modelPath:", modelPath);
   const model = (await import(modelPath)).default, tableName = getTableName(model, modelPath), twoFactorEnabled = model.traits?.useAuth && typeof model.traits.useAuth !== "boolean" ? model.traits.useAuth.useTwoFactor : !1;

package/dist/drivers/postgres.d.ts

@@ -1,6 +1,5 @@
 import type { Ok } from '@stacksjs/error-handling';
 export declare function dropPostgresTables(): Promise<void>;
-export declare function generatePostgresTraitMigrations(): Promise<void>;
 export declare function resetPostgresDatabase(): Promise<Ok<string, never>>;
 export declare function generatePostgresMigration(modelPath: string): Promise<void>;
 export declare function generateIndexCreationSQL(tableName: string, index: { name: string, columns: string[], unique?: boolean, where?: string }): string;

package/dist/drivers/postgres.js

@@ -3,7 +3,6 @@ function italic(str) {
   return `\x1B[3m${str}\x1B[23m`;
 }
 import { db } from "../utils";
-import { createPasswordResetsTable } from "./defaults/passwords";
 import { ok } from "@stacksjs/error-handling";
 import { fetchOtherModelRelations, getModelName, getPivotTables, getTableName } from "@stacksjs/orm";
 import { path } from "@stacksjs/path";
@@ -23,51 +22,19 @@ import {
   mapFieldTypeToColumnType,
   pluckChanges
 } from "./helpers";
-import {
-  createPostgresCategorizableTable,
-  createPostgresCommentablesPivotTable,
-  createPostgresCommentsTable,
-  createPostgresCommentUpvoteMigration,
-  createPostgresPasskeyMigration,
-  createPostgresQueryLogsTable,
-  createPostgresTaggablesTable,
-  createPostgresTagsTable,
-  dropMigrationTables
-} from "./defaults/traits";
+import { dropCommonTables, dropMigrationTables } from "./defaults/traits";
 export async function dropPostgresTables() {
   const tables = await fetchPostgresTables(), userModelFiles = globSync([path.userModelsPath("*.ts"), path.storagePath("framework/defaults/app/Models/**/*.ts")], { absolute: !0 });
   await dropMigrationTables();
   for (const table of tables)
     await db.unsafe(`DROP TABLE IF EXISTS "${table}" CASCADE`).execute();
-  await dropCommonPostgresTables();
+  await dropCommonTables();
   for (const userModel of userModelFiles) {
     const userModelPath = (await import(userModel)).default, pivotTables = await getPivotTables(userModelPath, userModel);
     for (const pivotTable of pivotTables)
       await db.unsafe(`DROP TABLE IF EXISTS "${pivotTable.table}" CASCADE`).execute();
   }
 }
-async function dropCommonPostgresTables() {
-  await db.unsafe('DROP TABLE IF EXISTS "passkeys" CASCADE').execute();
-  await db.unsafe('DROP TABLE IF EXISTS "password_resets" CASCADE').execute();
-  await db.unsafe('DROP TABLE IF EXISTS "query_logs" CASCADE').execute();
-  await db.unsafe('DROP TABLE IF EXISTS "categorizables" CASCADE').execute();
-  await db.unsafe('DROP TABLE IF EXISTS "commentables" CASCADE').execute();
-  await db.unsafe('DROP TABLE IF EXISTS "comments" CASCADE').execute();
-  await db.unsafe('DROP TABLE IF EXISTS "tags" CASCADE').execute();
-  await db.unsafe('DROP TABLE IF EXISTS "taggables" CASCADE').execute();
-  await db.unsafe('DROP TABLE IF EXISTS "commentable_upvotes" CASCADE').execute();
-}
-export async function generatePostgresTraitMigrations() {
-  await createPostgresCategorizableTable();
-  await createPostgresCommentsTable();
-  await createPostgresTagsTable();
-  await createPostgresCommentUpvoteMigration();
-  await createPostgresPasskeyMigration();
-  await createPostgresQueryLogsTable();
-  await createPasswordResetsTable();
-  await createPostgresCommentablesPivotTable();
-  await createPostgresTaggablesTable();
-}
 export async function resetPostgresDatabase() {
   await dropPostgresTables();
   await deleteFrameworkModels();

package/dist/index.d.ts

@@ -101,6 +101,26 @@ export * from './relation-columns';
 export { migrateNotificationTables } from './notification-tables';
 // RBAC tables migration (stacksjs/stacks#1941 Phase A)
 export { migrateRbacTables } from './rbac-tables';
+// Polymorphic trait tables (commentables/taggables/categorizables/upvotes).
+// Exported wholesale like auth-tables: the pure DDL builders are how tests and
+// tooling stand up the same schema `buddy migrate` creates.
+export * from './trait-tables';
+// MySQL TIMESTAMP -> DATETIME guarantee for framework tables
+export * from './datetime-columns';
+// Dialect capability table — the single source of truth for what each
+// dialect speaks (wire protocol) and what it accepts (DDL features).
+export * from './dialect';
+// Read replica routing policy (auto-route opt-in, transaction and
+// read-your-writes carve-outs, replica selection).
+export * from './replicas';
+// DDL capability audit — catches a corpus that is valid SQL for the target's
+// wire protocol but uses a feature the engine does not implement (foreign
+// keys and AUTO_INCREMENT on a sharded engine).
+export * from './ddl-constraints';
+// VSchema derivation — turns the model relationship graph into a Vitess
+// keyspace topology, co-locating child tables with their parents so joins
+// between them do not scatter across shards.
+export * from './vschema';
 // SQL dialect helpers & connection defaults
 export * from './sql-helpers';
 export * from './defaults';

package/dist/index.js

@@ -27,6 +27,12 @@ export * from "./managed-columns";
 export * from "./relation-columns";
 export { migrateNotificationTables } from "./notification-tables";
 export { migrateRbacTables } from "./rbac-tables";
+export * from "./trait-tables";
+export * from "./datetime-columns";
+export * from "./dialect";
+export * from "./replicas";
+export * from "./ddl-constraints";
+export * from "./vschema";
 export * from "./sql-helpers";
 export * from "./defaults";
 export * from "./migration-dialect";

package/dist/notification-tables.js

@@ -6,7 +6,7 @@ function getDbDriver() {
   return process.env.DB_CONNECTION || envVars.DB_CONNECTION || "sqlite";
 }
 export function notificationsTableSql(sql) {
-  const { pkColumn, nullableTimestamp } = sql;
+  const { pkColumn, nullableTimestamp, datetime } = sql;
   return `CREATE TABLE IF NOT EXISTS notifications (
     ${pkColumn},
     user_id INTEGER NOT NULL,
@@ -14,25 +14,25 @@ export function notificationsTableSql(sql) {
     data TEXT NOT NULL,
     read_at ${nullableTimestamp},
     uuid VARCHAR(36),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_at ${datetime} DEFAULT CURRENT_TIMESTAMP,
     updated_at ${nullableTimestamp}
   )`;
 }
 export function notificationPreferencesTableSql(sql) {
-  const { pkColumn, boolTrue, nullableTimestamp } = sql;
+  const { pkColumn, boolTrue, nullableTimestamp, datetime } = sql;
   return `CREATE TABLE IF NOT EXISTS notification_preferences (
     ${pkColumn},
     user_id INTEGER NOT NULL,
     channel VARCHAR(50) NOT NULL,
     enabled BOOLEAN NOT NULL DEFAULT ${boolTrue},
     category VARCHAR(255),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_at ${datetime} DEFAULT CURRENT_TIMESTAMP,
     updated_at ${nullableTimestamp},
     UNIQUE (user_id, channel, category)
   )`;
 }
 export function notificationDeliveriesTableSql(sql) {
-  const { pkColumn, nullableTimestamp } = sql;
+  const { pkColumn, nullableTimestamp, datetime } = sql;
   return `CREATE TABLE IF NOT EXISTS notification_deliveries (
     ${pkColumn},
     user_id INTEGER,
@@ -44,7 +44,7 @@ export function notificationDeliveriesTableSql(sql) {
     error TEXT,
     metadata TEXT,
     sent_at ${nullableTimestamp},
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_at ${datetime} DEFAULT CURRENT_TIMESTAMP,
     updated_at ${nullableTimestamp}
   )`;
 }

package/dist/query-logger.js

@@ -1,3 +1,4 @@
+import { sqlDateTime } from "./sql-helpers";
 import { memoryUsage } from "node:process";
 import { config } from "@stacksjs/config";
 import { log } from "@stacksjs/logging";
@@ -89,7 +90,7 @@ async function createQueryLogRecord(query, durationMs, status, error, bindings)
     connection,
     status,
     error: error ? String(error) : void 0,
-    executed_at: new Date().toISOString(),
+    executed_at: sqlDateTime(),
     bindings,
     trace,
     ...caller,

package/dist/rbac-tables.d.ts

@@ -4,11 +4,11 @@ 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;
+export declare function userRolesTableSql(sql: SqlHelpers): string;
 /** `user_permissions` pivot. */
-export declare function userPermissionsTableSql(): string;
+export declare function userPermissionsTableSql(sql: SqlHelpers): string;
 /** `role_permissions` pivot. */
-export declare function rolePermissionsTableSql(): string;
+export declare function rolePermissionsTableSql(sql: SqlHelpers): string;
 /**
  * Create the 5 RBAC tables. Idempotent (`IF NOT EXISTS`), so it's
  * safe to run on every `buddy migrate`.

package/dist/rbac-tables.js

@@ -6,50 +6,53 @@ function getDbDriver() {
   return envVars.DB_CONNECTION || "sqlite";
 }
 export function rolesTableSql(sql) {
-  const { pkColumn, nullableTimestamp } = sql;
+  const { pkColumn, nullableTimestamp, datetime } = sql;
   return `CREATE TABLE IF NOT EXISTS roles (
     ${pkColumn},
     name VARCHAR(255) NOT NULL,
     guard_name VARCHAR(255) NOT NULL DEFAULT 'web',
     description TEXT,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_at ${datetime} DEFAULT CURRENT_TIMESTAMP,
     updated_at ${nullableTimestamp},
     UNIQUE (name, guard_name)
   )`;
 }
 export function permissionsTableSql(sql) {
-  const { pkColumn, nullableTimestamp } = sql;
+  const { pkColumn, nullableTimestamp, datetime } = sql;
   return `CREATE TABLE IF NOT EXISTS permissions (
     ${pkColumn},
     name VARCHAR(255) NOT NULL,
     guard_name VARCHAR(255) NOT NULL DEFAULT 'web',
     description TEXT,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_at ${datetime} DEFAULT CURRENT_TIMESTAMP,
     updated_at ${nullableTimestamp},
     UNIQUE (name, guard_name)
   )`;
 }
-export function userRolesTableSql() {
+export function userRolesTableSql(sql) {
+  const { datetime } = sql;
   return `CREATE TABLE IF NOT EXISTS user_roles (
     user_id INTEGER NOT NULL,
     role_id INTEGER NOT NULL,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_at ${datetime} DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (user_id, role_id)
   )`;
 }
-export function userPermissionsTableSql() {
+export function userPermissionsTableSql(sql) {
+  const { datetime } = sql;
   return `CREATE TABLE IF NOT EXISTS user_permissions (
     user_id INTEGER NOT NULL,
     permission_id INTEGER NOT NULL,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_at ${datetime} DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (user_id, permission_id)
   )`;
 }
-export function rolePermissionsTableSql() {
+export function rolePermissionsTableSql(sql) {
+  const { datetime } = sql;
   return `CREATE TABLE IF NOT EXISTS role_permissions (
     role_id INTEGER NOT NULL,
     permission_id INTEGER NOT NULL,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_at ${datetime} DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (role_id, permission_id)
   )`;
 }
@@ -66,13 +69,13 @@ export async function migrateRbacTables(options = {}) {
     await db.unsafe(permissionsTableSql(sql)).execute();
     if (options.verbose)
       log.info("Creating user_roles pivot...");
-    await db.unsafe(userRolesTableSql()).execute();
+    await db.unsafe(userRolesTableSql(sql)).execute();
     if (options.verbose)
       log.info("Creating user_permissions pivot...");
-    await db.unsafe(userPermissionsTableSql()).execute();
+    await db.unsafe(userPermissionsTableSql(sql)).execute();
     if (options.verbose)
       log.info("Creating role_permissions pivot...");
-    await db.unsafe(rolePermissionsTableSql()).execute();
+    await db.unsafe(rolePermissionsTableSql(sql)).execute();
     if (options.verbose)
       log.success("RBAC tables created");
     return { success: !0 };

package/dist/replicas.d.ts

@@ -0,0 +1,52 @@
+import type { ReadPolicyConfig, ReplicaConfig } from './driver-config';
+/**
+ * Run `fn` in a fresh routing context.
+ *
+ * Called per request by the HTTP layer so read-your-writes is scoped to
+ * one request. Without an enclosing context the router falls back to
+ * treating every read as routable, which is the correct behavior for
+ * background work that has no request boundary to speak of — such work
+ * should use `db.read` explicitly if it wants a replica.
+ */
+export declare function withRoutingContext<T>(fn: () => T): T;
+/** Record that the current context has written, pinning its later reads. */
+export declare function markContextWrote(): void;
+/**
+ * Mark the current context as inside a transaction for the duration of
+ * `fn`, restoring the previous value afterwards so nested transactions
+ * unwind correctly.
+ */
+export declare function withTransactionContext<T>(fn: () => Promise<T>): Promise<T>;
+/** Whether the current async context has already issued a write. */
+export declare function contextHasWritten(): boolean;
+/** Whether the current async context is inside a transaction. */
+export declare function contextInTransaction(): boolean;
+/**
+ * Whether a read issued right now may go to a replica.
+ *
+ * The single decision point for rules 1-3. Exported so the routing
+ * behavior can be asserted directly in tests without standing up two
+ * database servers.
+ */
+export declare function shouldRouteToReplica(options: {
+  policy?: ReadPolicyConfig
+  replicas?: ReplicaConfig[]
+}): boolean;
+/** Reset the cursor. Test-only — keeps selection assertions deterministic. */
+export declare function resetReplicaCursor(): void;
+/**
+ * Pick a replica according to the configured strategy.
+ *
+ * Returns `undefined` for an empty list so callers fall back to the
+ * primary rather than having to pre-check.
+ */
+export declare function selectReplica(replicas: ReplicaConfig[], strategy?: ReadPolicyConfig['strategy']): ReplicaConfig | undefined;
+/**
+ * Resolve a replica's connection settings against its primary.
+ *
+ * A replica declares only what differs — usually just the host — so
+ * everything else is inherited. Getting this wrong in the other direction
+ * (requiring full credentials per replica) is how host lists drift out of
+ * sync with a rotated password.
+ */
+export declare function resolveReplicaConnection(replica: ReplicaConfig, primary: { name?: string, database?: string, host?: string, port?: number, username?: string, password?: string }): { database: string, host: string, port?: number, username?: string, password?: string };

package/dist/replicas.js

@@ -0,0 +1,74 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const routingContext = new AsyncLocalStorage;
+export function withRoutingContext(fn) {
+  return routingContext.run({ wroteInContext: !1, inTransaction: !1 }, fn);
+}
+export function markContextWrote() {
+  const store = routingContext.getStore();
+  if (store)
+    store.wroteInContext = !0;
+}
+export async function withTransactionContext(fn) {
+  const store = routingContext.getStore();
+  if (!store)
+    return fn();
+  const previous = store.inTransaction;
+  store.inTransaction = !0;
+  try {
+    return await fn();
+  } finally {
+    store.inTransaction = previous;
+  }
+}
+export function contextHasWritten() {
+  return routingContext.getStore()?.wroteInContext ?? !1;
+}
+export function contextInTransaction() {
+  return routingContext.getStore()?.inTransaction ?? !1;
+}
+export function shouldRouteToReplica(options) {
+  const { policy, replicas } = options;
+  if (!replicas?.length)
+    return !1;
+  if (!policy?.autoRoute)
+    return !1;
+  if (contextInTransaction())
+    return !1;
+  if (contextHasWritten())
+    return !1;
+  return !0;
+}
+let roundRobinCursor = 0;
+export function resetReplicaCursor() {
+  roundRobinCursor = 0;
+}
+export function selectReplica(replicas, strategy = "round-robin", random = Math.random) {
+  if (!replicas.length)
+    return;
+  if (replicas.length === 1)
+    return replicas[0];
+  if (strategy === "random")
+    return replicas[Math.floor(random() * replicas.length)];
+  if (strategy === "weighted") {
+    const weights = replicas.map((r) => Math.max(0, r.weight ?? 1)), total = weights.reduce((sum, w) => sum + w, 0);
+    if (total <= 0)
+      return replicas[roundRobinCursor++ % replicas.length];
+    let ticket = random() * total;
+    for (let i = 0;i < replicas.length; i++) {
+      ticket -= weights[i];
+      if (ticket < 0)
+        return replicas[i];
+    }
+    return replicas[replicas.length - 1];
+  }
+  return replicas[roundRobinCursor++ % replicas.length];
+}
+export function resolveReplicaConnection(replica, primary) {
+  return {
+    database: primary.name ?? primary.database ?? "",
+    host: replica.host,
+    port: replica.port ?? primary.port,
+    username: replica.username ?? primary.username,
+    password: replica.password ?? primary.password
+  };
+}

package/dist/schema.d.ts

@@ -1,3 +1,4 @@
+import { Table } from './table';
 /**
  * @defaultValue
  * ```ts

package/dist/sql-helpers.d.ts

@@ -1,3 +1,62 @@
+/**
+ * The framework's canonical datetime literal: ISO-8601 UTC **without** the
+ * trailing `Z` (`2026-08-04T01:52:47.417`).
+ *
+ * One format for every dialect, because the alternatives are all broken:
+ *
+ * - `new Date().toISOString()` — what the framework used to write — is
+ *   rejected outright by MySQL in strict mode ("Incorrect datetime value"),
+ *   so any insert into a TIMESTAMP column threw. Dropping the `Z` is the
+ *   whole difference; MySQL accepts the rest of the ISO shape.
+ * - A space-separated literal (`2026-08-04 01:52:47`) is accepted everywhere
+ *   but sorts BEFORE an ISO string on SQLite, where these columns hold text.
+ *   Mixing it with already-stored ISO rows would corrupt every ordering and
+ *   range query over existing data.
+ *
+ * Keeping the `T` and dropping only the `Z` satisfies all three engines and
+ * still sorts correctly against rows written in the old format, since the
+ * value is a prefix of the old one for the same instant.
+ *
+ * Use this for every app-generated timestamp written to, or compared against,
+ * a framework table — never the raw `toISOString()`, and never the database's
+ * own clock (see below).
+ *
+ * ## Do not compare these against `NOW()` / `datetime('now')`
+ *
+ * The DB clock renders as `2026-08-04 01:52:47` — space-separated. On SQLite
+ * these columns are text, and `'T' > ' '`, so an ISO value always compares
+ * greater than a same-day DB-clock value regardless of the actual instant.
+ * That silently made every `expires_at > datetime('now')` check pass for
+ * already-expired rows. Compare app-written columns against `sqlDateTime()`.
+ */
+export declare function sqlDateTime(value?: Date): string;
+/**
+ * {@link sqlDateTime} pre-quoted for interpolation into a raw SQL string.
+ * The value is generated from a `Date`, never from user input, so it cannot
+ * carry a quote to escape.
+ */
+export declare function sqlDateTimeLiteral(value?: Date): string;
+/**
+ * Read a timestamp back out of a framework table.
+ *
+ * The counterpart to {@link sqlDateTime}, and mandatory wherever a stored
+ * timestamp is compared in JavaScript. `new Date('2026-08-04T01:52:47.417')`
+ * — an ISO date-time with no offset — is parsed as **local** time per the ES
+ * spec, while the same string with a `Z` is UTC. Since the stored format
+ * cannot carry the `Z` (MySQL rejects it), a bare `new Date(...)` on these
+ * values silently shifts every comparison by the host's UTC offset. Only a
+ * server already running in UTC would look correct.
+ *
+ * Accepts every shape these columns hold: the canonical `T` format, the
+ * space-separated form the database clocks emit, values that still carry a
+ * `Z` or an explicit offset from before this format existed, and the `Date`
+ * objects the MySQL driver hands back. Anything without an explicit offset is
+ * read as UTC, which is what the framework writes.
+ *
+ * Returns null for missing or unparseable input so callers can fail closed
+ * rather than treating a bad value as the epoch.
+ */
+export declare function parseSqlDateTime(value: unknown): Date | null;
 /**
  * Create SQL dialect helpers for a given driver.
  *
@@ -9,13 +68,6 @@
  * ```
  */
 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
@@ -27,6 +79,7 @@ export declare interface SqlDialectHelpers {
   autoIncrement: string
   primaryKey: string
   pkColumn: string
+  datetime: string
   nullableTimestamp: string
   param: (index: number) => string
   params: (...values: unknown[]) => { sql: string, values: unknown[] }

package/dist/sql-helpers.js

@@ -1,17 +1,43 @@
+import { dialectCapabilities } from "./dialect";
+export function sqlDateTime(value = new Date) {
+  return value.toISOString().slice(0, -1);
+}
+export function sqlDateTimeLiteral(value = new Date) {
+  return `'${sqlDateTime(value)}'`;
+}
+export function parseSqlDateTime(value) {
+  if (value === null || value === void 0)
+    return null;
+  if (value instanceof Date)
+    return Number.isNaN(value.getTime()) ? null : value;
+  if (typeof value === "number")
+    return Number.isNaN(value) ? null : new Date(value);
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return null;
+  let normalized = trimmed.replace(" ", "T");
+  if (!/(?:Z|[+-]\d{2}:?\d{2})$/i.test(normalized))
+    normalized += "Z";
+  const parsed = new Date(normalized);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
 export function sqlHelpers(driver) {
-  const isPostgres = driver === "postgres", isMysql = driver === "mysql" || driver === "singlestore";
+  const caps = dialectCapabilities(driver), isPostgres = caps.wire === "postgres", isMysql = caps.wire === "mysql", isSqlite = caps.wire === "sqlite";
   return {
     driver,
     isPostgres,
     isMysql,
-    isSqlite: !isPostgres && !isMysql,
+    isSqlite,
     now: isPostgres || isMysql ? "NOW()" : "datetime('now')",
     boolTrue: isPostgres ? "true" : "1",
     boolFalse: isPostgres ? "false" : "0",
     autoIncrement: isPostgres ? "SERIAL" : "INTEGER",
-    primaryKey: isPostgres ? "PRIMARY KEY" : isMysql ? "PRIMARY KEY AUTO_INCREMENT" : "PRIMARY KEY AUTOINCREMENT",
-    pkColumn: isPostgres ? "id SERIAL PRIMARY KEY" : isMysql ? "id INTEGER PRIMARY KEY AUTO_INCREMENT" : "id INTEGER PRIMARY KEY AUTOINCREMENT",
-    nullableTimestamp: isMysql ? "TIMESTAMP NULL" : "TIMESTAMP",
+    primaryKey: !caps.supportsAutoIncrement ? "PRIMARY KEY" : isPostgres ? "PRIMARY KEY" : isMysql ? "PRIMARY KEY AUTO_INCREMENT" : "PRIMARY KEY AUTOINCREMENT",
+    pkColumn: !caps.supportsAutoIncrement ? "id BIGINT NOT NULL PRIMARY KEY" : isPostgres ? "id SERIAL PRIMARY KEY" : isMysql ? "id INTEGER PRIMARY KEY AUTO_INCREMENT" : "id INTEGER PRIMARY KEY AUTOINCREMENT",
+    datetime: isMysql ? "DATETIME" : "TIMESTAMP",
+    nullableTimestamp: isMysql ? "DATETIME NULL" : "TIMESTAMP",
     param(index) {
       return isPostgres ? `$${index}` : "?";
     },