@invect/core 0.0.1

package/dist/database/adapter-factory.js

@@ -0,0 +1,187 @@
+import { getDefaultCapabilities } from "./adapter.js";
+import { randomUUID } from "crypto";
+//#region src/database/adapter-factory.ts
+function createInvectAdapterFactory(rawAdapter, config, schemaMeta) {
+	const caps = {
+		...getDefaultCapabilities(config.dialect),
+		...config
+	};
+	function transformInput(model, data) {
+		const tableMeta = schemaMeta[model];
+		if (!tableMeta) return data;
+		const out = {};
+		for (const [key, value] of Object.entries(data)) {
+			const meta = tableMeta[key];
+			if (!meta || value === void 0 || value === null) {
+				out[key] = value;
+				continue;
+			}
+			out[key] = coerceInput(value, meta.type);
+		}
+		return out;
+	}
+	function applyCreateDefaults(model, data) {
+		const tableMeta = schemaMeta[model];
+		if (!tableMeta) return data;
+		const out = { ...data };
+		for (const [key, meta] of Object.entries(tableMeta)) {
+			if (out[key] !== void 0 && out[key] !== null) continue;
+			if (meta.defaultValue === "uuid") out[key] = randomUUID();
+		}
+		return out;
+	}
+	function coerceInput(value, type) {
+		switch (type) {
+			case "boolean":
+				if (!caps.supportsBooleans && typeof value === "boolean") return value ? 1 : 0;
+				return value;
+			case "date":
+				if (!caps.supportsDates && value instanceof Date) return value.toISOString();
+				return value;
+			case "json":
+				if (!caps.supportsJSON && typeof value === "object" && value !== null) return JSON.stringify(value);
+				return value;
+			case "string[]":
+				if (!caps.supportsArrays && Array.isArray(value)) return JSON.stringify(value);
+				return value;
+			default: return value;
+		}
+	}
+	function transformOutput(model, data) {
+		if (!data) return null;
+		const tableMeta = schemaMeta[model];
+		if (!tableMeta) return data;
+		const out = {};
+		for (const [key, value] of Object.entries(data)) {
+			const meta = tableMeta[key];
+			if (!meta || value === void 0 || value === null) {
+				out[key] = value;
+				continue;
+			}
+			out[key] = coerceOutput(value, meta.type);
+		}
+		return out;
+	}
+	function coerceOutput(value, type) {
+		switch (type) {
+			case "boolean":
+				if (!caps.supportsBooleans && typeof value === "number") return value === 1;
+				return value;
+			case "date":
+				if (!caps.supportsDates && typeof value === "string") return new Date(value);
+				return value;
+			case "json":
+				if (!caps.supportsJSON && typeof value === "string") try {
+					return JSON.parse(value);
+				} catch {
+					return value;
+				}
+				return value;
+			case "string[]":
+				if (!caps.supportsArrays && typeof value === "string") try {
+					return JSON.parse(value);
+				} catch {
+					return value;
+				}
+				return value;
+			default: return value;
+		}
+	}
+	function transformWhere(model, where) {
+		const tableMeta = schemaMeta[model];
+		if (!tableMeta) return where;
+		return where.map((clause) => {
+			const meta = tableMeta[clause.field];
+			if (!meta || clause.value === null || clause.value === void 0) return clause;
+			return {
+				...clause,
+				value: coerceInput(clause.value, meta.type)
+			};
+		});
+	}
+	function wrapAdapter(raw) {
+		const executeRaw = raw.executeRaw;
+		return {
+			dialect: config.dialect,
+			async create({ model, data }) {
+				const transformed = transformInput(model, applyCreateDefaults(model, data));
+				return transformOutput(model, await raw.create({
+					model,
+					data: transformed
+				}));
+			},
+			async findOne({ model, where, select }) {
+				const transformedWhere = transformWhere(model, where);
+				return transformOutput(model, await raw.findOne({
+					model,
+					where: transformedWhere,
+					select
+				}));
+			},
+			async findMany({ model, where, limit, offset, sortBy, select }) {
+				const transformedWhere = where ? transformWhere(model, where) : void 0;
+				return (await raw.findMany({
+					model,
+					where: transformedWhere,
+					limit,
+					offset,
+					sortBy,
+					select
+				})).map((r) => transformOutput(model, r));
+			},
+			async count({ model, where }) {
+				const transformedWhere = where ? transformWhere(model, where) : void 0;
+				return raw.count({
+					model,
+					where: transformedWhere
+				});
+			},
+			async update({ model, where, update: updateData, returning }) {
+				const transformedWhere = transformWhere(model, where);
+				const transformedUpdate = transformInput(model, updateData);
+				return transformOutput(model, await raw.update({
+					model,
+					where: transformedWhere,
+					update: transformedUpdate,
+					returning
+				}));
+			},
+			async updateMany({ model, where, update: updateData }) {
+				const transformedWhere = transformWhere(model, where);
+				const transformedUpdate = transformInput(model, updateData);
+				return raw.updateMany({
+					model,
+					where: transformedWhere,
+					update: transformedUpdate
+				});
+			},
+			async delete({ model, where }) {
+				const transformedWhere = transformWhere(model, where);
+				return raw.delete({
+					model,
+					where: transformedWhere
+				});
+			},
+			async deleteMany({ model, where }) {
+				const transformedWhere = transformWhere(model, where);
+				return raw.deleteMany({
+					model,
+					where: transformedWhere
+				});
+			},
+			executeRaw: executeRaw ? async (sqlStr, params) => {
+				return executeRaw(sqlStr, params);
+			} : void 0,
+			async transaction(callback) {
+				return raw.transaction(async (rawTrx) => {
+					return callback(wrapAdapter(rawTrx));
+				});
+			}
+		};
+	}
+	return wrapAdapter(rawAdapter);
+}
+//#endregion
+export { createInvectAdapterFactory };
+
+//# sourceMappingURL=adapter-factory.js.map

package/dist/database/adapter-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-factory.js","names":[],"sources":["../../src/database/adapter-factory.ts"],"sourcesContent":["/**\n * Adapter Factory\n *\n * Wraps a RawInvectAdapter with automatic type coercion based on dialect\n * capabilities. Inspired by better-auth's createAdapterFactory.\n *\n * This layer handles:\n * - boolean ↔ 0/1 integer (SQLite)\n * - Date ↔ ISO string (SQLite)\n * - JSON objects ↔ JSON string (SQLite, MySQL for text-mode JSON)\n * - string[] ↔ JSON string (SQLite, MySQL)\n */\n\nimport type { InvectAdapter, RawInvectAdapter, WhereClause, AdapterConfig } from './adapter';\nimport { getDefaultCapabilities } from './adapter';\nimport { randomUUID } from 'crypto';\n\n// ---------------------------------------------------------------------------\n// Column type metadata — tells the factory how to coerce values\n// ---------------------------------------------------------------------------\n\n/** Known column types for coercion. */\nexport type ColumnType = 'string' | 'number' | 'uuid' | 'boolean' | 'date' | 'json' | 'string[]';\n\nexport interface ColumnMeta {\n  type: ColumnType;\n  defaultValue?: 'uuid';\n}\n\n/**\n * Schema metadata: for each table, a map of column name → column type.\n * Only columns that require coercion need to be listed.\n * Unlisted columns are passed through as-is.\n */\nexport type SchemaMetadata = Record<string, Record<string, ColumnMeta>>;\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\nexport function createInvectAdapterFactory(\n  rawAdapter: RawInvectAdapter,\n  config: AdapterConfig,\n  schemaMeta: SchemaMetadata,\n): InvectAdapter {\n  const caps = {\n    ...getDefaultCapabilities(config.dialect),\n    ...config,\n  };\n\n  // -------------------------------------------------------------------------\n  // Input transform — before writing to DB\n  // -------------------------------------------------------------------------\n\n  function transformInput(model: string, data: Record<string, unknown>): Record<string, unknown> {\n    const tableMeta = schemaMeta[model];\n    if (!tableMeta) {\n      return data;\n    }\n\n    const out: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(data)) {\n      const meta = tableMeta[key];\n      if (!meta || value === undefined || value === null) {\n        out[key] = value;\n        continue;\n      }\n\n      out[key] = coerceInput(value, meta.type);\n    }\n    return out;\n  }\n\n  function applyCreateDefaults(\n    model: string,\n    data: Record<string, unknown>,\n  ): Record<string, unknown> {\n    const tableMeta = schemaMeta[model];\n    if (!tableMeta) {\n      return data;\n    }\n\n    const out = { ...data };\n    for (const [key, meta] of Object.entries(tableMeta)) {\n      if (out[key] !== undefined && out[key] !== null) {\n        continue;\n      }\n\n      if (meta.defaultValue === 'uuid') {\n        out[key] = randomUUID();\n      }\n    }\n\n    return out;\n  }\n\n  function coerceInput(value: unknown, type: ColumnType): unknown {\n    switch (type) {\n      case 'boolean':\n        if (!caps.supportsBooleans && typeof value === 'boolean') {\n          return value ? 1 : 0;\n        }\n        return value;\n\n      case 'date':\n        if (!caps.supportsDates && value instanceof Date) {\n          return value.toISOString();\n        }\n        return value;\n\n      case 'json':\n        if (!caps.supportsJSON && typeof value === 'object' && value !== null) {\n          return JSON.stringify(value);\n        }\n        return value;\n\n      case 'string[]':\n        if (!caps.supportsArrays && Array.isArray(value)) {\n          return JSON.stringify(value);\n        }\n        return value;\n\n      default:\n        return value;\n    }\n  }\n\n  // -------------------------------------------------------------------------\n  // Output transform — after reading from DB\n  // -------------------------------------------------------------------------\n\n  function transformOutput(\n    model: string,\n    data: Record<string, unknown> | null,\n  ): Record<string, unknown> | null {\n    if (!data) {\n      return null;\n    }\n\n    const tableMeta = schemaMeta[model];\n    if (!tableMeta) {\n      return data;\n    }\n\n    const out: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(data)) {\n      const meta = tableMeta[key];\n      if (!meta || value === undefined || value === null) {\n        out[key] = value;\n        continue;\n      }\n\n      out[key] = coerceOutput(value, meta.type);\n    }\n    return out;\n  }\n\n  function coerceOutput(value: unknown, type: ColumnType): unknown {\n    switch (type) {\n      case 'boolean':\n        if (!caps.supportsBooleans && typeof value === 'number') {\n          return value === 1;\n        }\n        return value;\n\n      case 'date':\n        if (!caps.supportsDates && typeof value === 'string') {\n          return new Date(value);\n        }\n        return value;\n\n      case 'json':\n        if (!caps.supportsJSON && typeof value === 'string') {\n          try {\n            return JSON.parse(value);\n          } catch {\n            return value;\n          }\n        }\n        return value;\n\n      case 'string[]':\n        if (!caps.supportsArrays && typeof value === 'string') {\n          try {\n            return JSON.parse(value);\n          } catch {\n            return value;\n          }\n        }\n        return value;\n\n      default:\n        return value;\n    }\n  }\n\n  // -------------------------------------------------------------------------\n  // Where clause coercion\n  // -------------------------------------------------------------------------\n\n  function transformWhere(model: string, where: WhereClause[]): WhereClause[] {\n    const tableMeta = schemaMeta[model];\n    if (!tableMeta) {\n      return where;\n    }\n\n    return where.map((clause) => {\n      const meta = tableMeta[clause.field];\n      if (!meta || clause.value === null || clause.value === undefined) {\n        return clause;\n      }\n      return { ...clause, value: coerceInput(clause.value, meta.type) };\n    });\n  }\n\n  // -------------------------------------------------------------------------\n  // Build the wrapped adapter\n  // -------------------------------------------------------------------------\n\n  function wrapAdapter(raw: RawInvectAdapter): InvectAdapter {\n    const executeRaw = raw.executeRaw;\n\n    return {\n      dialect: config.dialect,\n\n      async create<T extends Record<string, unknown>>({\n        model,\n        data,\n      }: {\n        model: string;\n        data: T;\n      }): Promise<T> {\n        const withDefaults = applyCreateDefaults(model, data);\n        const transformed = transformInput(model, withDefaults) as T;\n        const result = await raw.create({ model, data: transformed });\n        return transformOutput(model, result) as T;\n      },\n\n      async findOne<T extends Record<string, unknown>>({\n        model,\n        where,\n        select,\n      }: {\n        model: string;\n        where: WhereClause[];\n        select?: string[];\n      }): Promise<T | null> {\n        const transformedWhere = transformWhere(model, where);\n        const result = await raw.findOne({ model, where: transformedWhere, select });\n        return transformOutput(model, result) as T | null;\n      },\n\n      async findMany<T extends Record<string, unknown>>({\n        model,\n        where,\n        limit,\n        offset,\n        sortBy,\n        select,\n      }: {\n        model: string;\n        where?: WhereClause[];\n        limit?: number;\n        offset?: number;\n        sortBy?: { field: string; direction: 'asc' | 'desc' };\n        select?: string[];\n      }): Promise<T[]> {\n        const transformedWhere = where ? transformWhere(model, where) : undefined;\n        const results = await raw.findMany({\n          model,\n          where: transformedWhere,\n          limit,\n          offset,\n          sortBy,\n          select,\n        });\n        return results.map((r) => transformOutput(model, r) as T);\n      },\n\n      async count({ model, where }: { model: string; where?: WhereClause[] }): Promise<number> {\n        const transformedWhere = where ? transformWhere(model, where) : undefined;\n        return raw.count({ model, where: transformedWhere });\n      },\n\n      async update<T extends Record<string, unknown>>({\n        model,\n        where,\n        update: updateData,\n        returning,\n      }: {\n        model: string;\n        where: WhereClause[];\n        update: Record<string, unknown>;\n        returning?: boolean;\n      }): Promise<T | null> {\n        const transformedWhere = transformWhere(model, where);\n        const transformedUpdate = transformInput(model, updateData);\n        const result = await raw.update<T>({\n          model,\n          where: transformedWhere,\n          update: transformedUpdate,\n          returning,\n        });\n        return transformOutput(model, result) as T | null;\n      },\n\n      async updateMany({\n        model,\n        where,\n        update: updateData,\n      }: {\n        model: string;\n        where: WhereClause[];\n        update: Record<string, unknown>;\n      }): Promise<number> {\n        const transformedWhere = transformWhere(model, where);\n        const transformedUpdate = transformInput(model, updateData);\n        return raw.updateMany({\n          model,\n          where: transformedWhere,\n          update: transformedUpdate,\n        });\n      },\n\n      async delete({ model, where }: { model: string; where: WhereClause[] }): Promise<void> {\n        const transformedWhere = transformWhere(model, where);\n        return raw.delete({ model, where: transformedWhere });\n      },\n\n      async deleteMany({ model, where }: { model: string; where: WhereClause[] }): Promise<number> {\n        const transformedWhere = transformWhere(model, where);\n        return raw.deleteMany({ model, where: transformedWhere });\n      },\n\n      executeRaw: executeRaw\n        ? async <T extends Record<string, unknown>>(sqlStr: string, params?: unknown[]) => {\n            return executeRaw<T>(sqlStr, params);\n          }\n        : undefined,\n\n      async transaction<R>(callback: (trx: InvectAdapter) => Promise<R>): Promise<R> {\n        return raw.transaction(async (rawTrx) => {\n          const wrappedTrx = wrapAdapter(rawTrx);\n          return callback(wrappedTrx);\n        });\n      },\n    };\n  }\n\n  return wrapAdapter(rawAdapter);\n}\n"],"mappings":"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"}

package/dist/database/adapter.cjs

@@ -0,0 +1,33 @@
+//#region src/database/adapter.ts
+/**
+* Default capabilities per dialect.
+*/
+function getDefaultCapabilities(dialect) {
+	switch (dialect) {
+		case "sqlite": return {
+			supportsBooleans: false,
+			supportsDates: false,
+			supportsJSON: false,
+			supportsReturning: true,
+			supportsArrays: false
+		};
+		case "postgresql": return {
+			supportsBooleans: true,
+			supportsDates: true,
+			supportsJSON: true,
+			supportsReturning: true,
+			supportsArrays: true
+		};
+		case "mysql": return {
+			supportsBooleans: true,
+			supportsDates: true,
+			supportsJSON: true,
+			supportsReturning: false,
+			supportsArrays: false
+		};
+	}
+}
+//#endregion
+exports.getDefaultCapabilities = getDefaultCapabilities;
+
+//# sourceMappingURL=adapter.cjs.map

package/dist/database/adapter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.cjs","names":[],"sources":["../../src/database/adapter.ts"],"sourcesContent":["/**\n * Invect Database Adapter Interface\n *\n * Inspired by better-auth's adapter pattern. Provides a model-string-based\n * interface for CRUD operations so that model classes no longer need 3-way\n * dialect branching.\n *\n * The adapter factory wraps a raw adapter with type coercion (booleans,\n * dates, JSON, arrays) so that raw adapters stay simple.\n */\n\n// ---------------------------------------------------------------------------\n// Where clause types\n// ---------------------------------------------------------------------------\n\nexport type WhereOperator =\n  | 'eq'\n  | 'ne'\n  | 'lt'\n  | 'lte'\n  | 'gt'\n  | 'gte'\n  | 'in'\n  | 'not_in'\n  | 'like'\n  | 'is_null'\n  | 'is_not_null';\n\nexport interface WhereClause {\n  field: string;\n  operator?: WhereOperator; // default: 'eq'\n  value: unknown;\n  connector?: 'AND' | 'OR'; // default: 'AND'\n}\n\n// ---------------------------------------------------------------------------\n// Adapter interface — what model classes call\n// ---------------------------------------------------------------------------\n\nexport interface InvectAdapter {\n  readonly dialect: 'sqlite' | 'postgresql' | 'mysql';\n\n  create<T extends Record<string, unknown>>(params: { model: string; data: T }): Promise<T>;\n\n  findOne<T extends Record<string, unknown>>(params: {\n    model: string;\n    where: WhereClause[];\n    select?: string[];\n  }): Promise<T | null>;\n\n  findMany<T extends Record<string, unknown>>(params: {\n    model: string;\n    where?: WhereClause[];\n    limit?: number;\n    offset?: number;\n    sortBy?: { field: string; direction: 'asc' | 'desc' };\n    select?: string[];\n  }): Promise<T[]>;\n\n  count(params: { model: string; where?: WhereClause[] }): Promise<number>;\n\n  update<T extends Record<string, unknown>>(params: {\n    model: string;\n    where: WhereClause[];\n    update: Record<string, unknown>;\n    /** Return the updated record (needs extra SELECT on MySQL). */\n    returning?: boolean;\n  }): Promise<T | null>;\n\n  updateMany(params: {\n    model: string;\n    where: WhereClause[];\n    update: Record<string, unknown>;\n  }): Promise<number>;\n\n  delete(params: { model: string; where: WhereClause[] }): Promise<void>;\n\n  deleteMany(params: { model: string; where: WhereClause[] }): Promise<number>;\n\n  /**\n   * Execute a raw SQL query string. Primarily used by the sql_query action\n   * and the postgres action for user-provided queries against external DBs.\n   */\n  executeRaw?<T extends Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;\n\n  /**\n   * Run multiple operations in a database transaction.\n   */\n  transaction<R>(callback: (trx: InvectAdapter) => Promise<R>): Promise<R>;\n}\n\n// ---------------------------------------------------------------------------\n// Raw adapter interface — what backend implementations provide\n//\n// This is the minimal set of operations a new adapter must implement.\n// The adapter factory wraps this with type coercion.\n// ---------------------------------------------------------------------------\n\nexport interface RawInvectAdapter {\n  create<T extends Record<string, unknown>>(params: { model: string; data: T }): Promise<T>;\n\n  findOne<T extends Record<string, unknown>>(params: {\n    model: string;\n    where: WhereClause[];\n    select?: string[];\n  }): Promise<T | null>;\n\n  findMany<T extends Record<string, unknown>>(params: {\n    model: string;\n    where?: WhereClause[];\n    limit?: number;\n    offset?: number;\n    sortBy?: { field: string; direction: 'asc' | 'desc' };\n    select?: string[];\n  }): Promise<T[]>;\n\n  count(params: { model: string; where?: WhereClause[] }): Promise<number>;\n\n  update<T extends Record<string, unknown>>(params: {\n    model: string;\n    where: WhereClause[];\n    update: Record<string, unknown>;\n    returning?: boolean;\n  }): Promise<T | null>;\n\n  updateMany(params: {\n    model: string;\n    where: WhereClause[];\n    update: Record<string, unknown>;\n  }): Promise<number>;\n\n  delete(params: { model: string; where: WhereClause[] }): Promise<void>;\n\n  deleteMany(params: { model: string; where: WhereClause[] }): Promise<number>;\n\n  executeRaw?<T extends Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;\n\n  transaction<R>(callback: (trx: RawInvectAdapter) => Promise<R>): Promise<R>;\n}\n\n// ---------------------------------------------------------------------------\n// Adapter config — dialect capabilities\n// ---------------------------------------------------------------------------\n\nexport interface AdapterConfig {\n  dialect: 'sqlite' | 'postgresql' | 'mysql';\n  /** SQLite stores booleans as 0/1 integers. @default true */\n  supportsBooleans?: boolean;\n  /** SQLite stores dates as ISO strings. @default true */\n  supportsDates?: boolean;\n  /** Only PostgreSQL has native JSON columns. @default false */\n  supportsJSON?: boolean;\n  /** MySQL doesn't support RETURNING. @default true */\n  supportsReturning?: boolean;\n  /** No native array columns outside PostgreSQL. @default false */\n  supportsArrays?: boolean;\n}\n\n/**\n * Default capabilities per dialect.\n */\nexport function getDefaultCapabilities(\n  dialect: AdapterConfig['dialect'],\n): Required<Omit<AdapterConfig, 'dialect'>> {\n  switch (dialect) {\n    case 'sqlite':\n      return {\n        supportsBooleans: false,\n        supportsDates: false,\n        supportsJSON: false,\n        supportsReturning: true,\n        supportsArrays: false,\n      };\n    case 'postgresql':\n      return {\n        supportsBooleans: true,\n        supportsDates: true,\n        supportsJSON: true,\n        supportsReturning: true,\n        supportsArrays: true,\n      };\n    case 'mysql':\n      return {\n        supportsBooleans: true,\n        supportsDates: true,\n        supportsJSON: true,\n        supportsReturning: false,\n        supportsArrays: false,\n      };\n  }\n}\n"],"mappings":";;;;AAiKA,SAAgB,uBACd,SAC0C;AAC1C,SAAQ,SAAR;EACE,KAAK,SACH,QAAO;GACL,kBAAkB;GAClB,eAAe;GACf,cAAc;GACd,mBAAmB;GACnB,gBAAgB;GACjB;EACH,KAAK,aACH,QAAO;GACL,kBAAkB;GAClB,eAAe;GACf,cAAc;GACd,mBAAmB;GACnB,gBAAgB;GACjB;EACH,KAAK,QACH,QAAO;GACL,kBAAkB;GAClB,eAAe;GACf,cAAc;GACd,mBAAmB;GACnB,gBAAgB;GACjB"}

package/dist/database/adapter.d.cts

@@ -0,0 +1,76 @@
+//#region src/database/adapter.d.ts
+/**
+ * Invect Database Adapter Interface
+ *
+ * Inspired by better-auth's adapter pattern. Provides a model-string-based
+ * interface for CRUD operations so that model classes no longer need 3-way
+ * dialect branching.
+ *
+ * The adapter factory wraps a raw adapter with type coercion (booleans,
+ * dates, JSON, arrays) so that raw adapters stay simple.
+ */
+type WhereOperator = 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'in' | 'not_in' | 'like' | 'is_null' | 'is_not_null';
+interface WhereClause {
+  field: string;
+  operator?: WhereOperator;
+  value: unknown;
+  connector?: 'AND' | 'OR';
+}
+interface InvectAdapter {
+  readonly dialect: 'sqlite' | 'postgresql' | 'mysql';
+  create<T extends Record<string, unknown>>(params: {
+    model: string;
+    data: T;
+  }): Promise<T>;
+  findOne<T extends Record<string, unknown>>(params: {
+    model: string;
+    where: WhereClause[];
+    select?: string[];
+  }): Promise<T | null>;
+  findMany<T extends Record<string, unknown>>(params: {
+    model: string;
+    where?: WhereClause[];
+    limit?: number;
+    offset?: number;
+    sortBy?: {
+      field: string;
+      direction: 'asc' | 'desc';
+    };
+    select?: string[];
+  }): Promise<T[]>;
+  count(params: {
+    model: string;
+    where?: WhereClause[];
+  }): Promise<number>;
+  update<T extends Record<string, unknown>>(params: {
+    model: string;
+    where: WhereClause[];
+    update: Record<string, unknown>; /** Return the updated record (needs extra SELECT on MySQL). */
+    returning?: boolean;
+  }): Promise<T | null>;
+  updateMany(params: {
+    model: string;
+    where: WhereClause[];
+    update: Record<string, unknown>;
+  }): Promise<number>;
+  delete(params: {
+    model: string;
+    where: WhereClause[];
+  }): Promise<void>;
+  deleteMany(params: {
+    model: string;
+    where: WhereClause[];
+  }): Promise<number>;
+  /**
+   * Execute a raw SQL query string. Primarily used by the sql_query action
+   * and the postgres action for user-provided queries against external DBs.
+   */
+  executeRaw?<T extends Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+  /**
+   * Run multiple operations in a database transaction.
+   */
+  transaction<R>(callback: (trx: InvectAdapter) => Promise<R>): Promise<R>;
+}
+//#endregion
+export { InvectAdapter };
+//# sourceMappingURL=adapter.d.cts.map

package/dist/database/adapter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.cts","names":[],"sources":["../../src/database/adapter.ts"],"mappings":";;AAeA;;;;;AAaA;;;;KAbY,aAAA;AAAA,UAaK,WAAA;EACf,KAAA;EACA,QAAA,GAAW,aAAA;EACX,KAAA;EACA,SAAA;AAAA;AAAA,UAOe,aAAA;EAAA,SACN,OAAA;EAET,MAAA,WAAiB,MAAA,mBAAyB,MAAA;IAAU,KAAA;IAAe,IAAA,EAAM,CAAA;EAAA,IAAM,OAAA,CAAQ,CAAA;EAEvF,OAAA,WAAkB,MAAA,mBAAyB,MAAA;IACzC,KAAA;IACA,KAAA,EAAO,WAAA;IACP,MAAA;EAAA,IACE,OAAA,CAAQ,CAAA;EAEZ,QAAA,WAAmB,MAAA,mBAAyB,MAAA;IAC1C,KAAA;IACA,KAAA,GAAQ,WAAA;IACR,KAAA;IACA,MAAA;IACA,MAAA;MAAW,KAAA;MAAe,SAAA;IAAA;IAC1B,MAAA;EAAA,IACE,OAAA,CAAQ,CAAA;EAEZ,KAAA,CAAM,MAAA;IAAU,KAAA;IAAe,KAAA,GAAQ,WAAA;EAAA,IAAkB,OAAA;EAEzD,MAAA,WAAiB,MAAA,mBAAyB,MAAA;IACxC,KAAA;IACA,KAAA,EAAO,WAAA;IACP,MAAA,EAAQ,MAAA,mBAmB+E;IAjBvF,SAAA;EAAA,IACE,OAAA,CAAQ,CAAA;EAEZ,UAAA,CAAW,MAAA;IACT,KAAA;IACA,KAAA,EAAO,WAAA;IACP,MAAA,EAAQ,MAAA;EAAA,IACN,OAAA;EAEJ,MAAA,CAAO,MAAA;IAAU,KAAA;IAAe,KAAA,EAAO,WAAA;EAAA,IAAkB,OAAA;EAEzD,UAAA,CAAW,MAAA;IAAU,KAAA;IAAe,KAAA,EAAO,WAAA;EAAA,IAAkB,OAAA;EAnCnB;;;;EAyC1C,UAAA,YAAsB,MAAA,mBAAyB,GAAA,UAAa,MAAA,eAAqB,OAAA,CAAQ,CAAA;EAvCvE;;;EA4ClB,WAAA,IAAe,QAAA,GAAW,GAAA,EAAK,aAAA,KAAkB,OAAA,CAAQ,CAAA,IAAK,OAAA,CAAQ,CAAA;AAAA"}

package/dist/database/adapter.d.ts

@@ -0,0 +1,76 @@
+//#region src/database/adapter.d.ts
+/**
+ * Invect Database Adapter Interface
+ *
+ * Inspired by better-auth's adapter pattern. Provides a model-string-based
+ * interface for CRUD operations so that model classes no longer need 3-way
+ * dialect branching.
+ *
+ * The adapter factory wraps a raw adapter with type coercion (booleans,
+ * dates, JSON, arrays) so that raw adapters stay simple.
+ */
+type WhereOperator = 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'in' | 'not_in' | 'like' | 'is_null' | 'is_not_null';
+interface WhereClause {
+  field: string;
+  operator?: WhereOperator;
+  value: unknown;
+  connector?: 'AND' | 'OR';
+}
+interface InvectAdapter {
+  readonly dialect: 'sqlite' | 'postgresql' | 'mysql';
+  create<T extends Record<string, unknown>>(params: {
+    model: string;
+    data: T;
+  }): Promise<T>;
+  findOne<T extends Record<string, unknown>>(params: {
+    model: string;
+    where: WhereClause[];
+    select?: string[];
+  }): Promise<T | null>;
+  findMany<T extends Record<string, unknown>>(params: {
+    model: string;
+    where?: WhereClause[];
+    limit?: number;
+    offset?: number;
+    sortBy?: {
+      field: string;
+      direction: 'asc' | 'desc';
+    };
+    select?: string[];
+  }): Promise<T[]>;
+  count(params: {
+    model: string;
+    where?: WhereClause[];
+  }): Promise<number>;
+  update<T extends Record<string, unknown>>(params: {
+    model: string;
+    where: WhereClause[];
+    update: Record<string, unknown>; /** Return the updated record (needs extra SELECT on MySQL). */
+    returning?: boolean;
+  }): Promise<T | null>;
+  updateMany(params: {
+    model: string;
+    where: WhereClause[];
+    update: Record<string, unknown>;
+  }): Promise<number>;
+  delete(params: {
+    model: string;
+    where: WhereClause[];
+  }): Promise<void>;
+  deleteMany(params: {
+    model: string;
+    where: WhereClause[];
+  }): Promise<number>;
+  /**
+   * Execute a raw SQL query string. Primarily used by the sql_query action
+   * and the postgres action for user-provided queries against external DBs.
+   */
+  executeRaw?<T extends Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+  /**
+   * Run multiple operations in a database transaction.
+   */
+  transaction<R>(callback: (trx: InvectAdapter) => Promise<R>): Promise<R>;
+}
+//#endregion
+export { InvectAdapter };
+//# sourceMappingURL=adapter.d.ts.map

package/dist/database/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","names":[],"sources":["../../src/database/adapter.ts"],"mappings":";;AAeA;;;;;AAaA;;;;KAbY,aAAA;AAAA,UAaK,WAAA;EACf,KAAA;EACA,QAAA,GAAW,aAAA;EACX,KAAA;EACA,SAAA;AAAA;AAAA,UAOe,aAAA;EAAA,SACN,OAAA;EAET,MAAA,WAAiB,MAAA,mBAAyB,MAAA;IAAU,KAAA;IAAe,IAAA,EAAM,CAAA;EAAA,IAAM,OAAA,CAAQ,CAAA;EAEvF,OAAA,WAAkB,MAAA,mBAAyB,MAAA;IACzC,KAAA;IACA,KAAA,EAAO,WAAA;IACP,MAAA;EAAA,IACE,OAAA,CAAQ,CAAA;EAEZ,QAAA,WAAmB,MAAA,mBAAyB,MAAA;IAC1C,KAAA;IACA,KAAA,GAAQ,WAAA;IACR,KAAA;IACA,MAAA;IACA,MAAA;MAAW,KAAA;MAAe,SAAA;IAAA;IAC1B,MAAA;EAAA,IACE,OAAA,CAAQ,CAAA;EAEZ,KAAA,CAAM,MAAA;IAAU,KAAA;IAAe,KAAA,GAAQ,WAAA;EAAA,IAAkB,OAAA;EAEzD,MAAA,WAAiB,MAAA,mBAAyB,MAAA;IACxC,KAAA;IACA,KAAA,EAAO,WAAA;IACP,MAAA,EAAQ,MAAA,mBAmB+E;IAjBvF,SAAA;EAAA,IACE,OAAA,CAAQ,CAAA;EAEZ,UAAA,CAAW,MAAA;IACT,KAAA;IACA,KAAA,EAAO,WAAA;IACP,MAAA,EAAQ,MAAA;EAAA,IACN,OAAA;EAEJ,MAAA,CAAO,MAAA;IAAU,KAAA;IAAe,KAAA,EAAO,WAAA;EAAA,IAAkB,OAAA;EAEzD,UAAA,CAAW,MAAA;IAAU,KAAA;IAAe,KAAA,EAAO,WAAA;EAAA,IAAkB,OAAA;EAnCnB;;;;EAyC1C,UAAA,YAAsB,MAAA,mBAAyB,GAAA,UAAa,MAAA,eAAqB,OAAA,CAAQ,CAAA;EAvCvE;;;EA4ClB,WAAA,IAAe,QAAA,GAAW,GAAA,EAAK,aAAA,KAAkB,OAAA,CAAQ,CAAA,IAAK,OAAA,CAAQ,CAAA;AAAA"}

package/dist/database/adapter.js

@@ -0,0 +1,33 @@
+//#region src/database/adapter.ts
+/**
+* Default capabilities per dialect.
+*/
+function getDefaultCapabilities(dialect) {
+	switch (dialect) {
+		case "sqlite": return {
+			supportsBooleans: false,
+			supportsDates: false,
+			supportsJSON: false,
+			supportsReturning: true,
+			supportsArrays: false
+		};
+		case "postgresql": return {
+			supportsBooleans: true,
+			supportsDates: true,
+			supportsJSON: true,
+			supportsReturning: true,
+			supportsArrays: true
+		};
+		case "mysql": return {
+			supportsBooleans: true,
+			supportsDates: true,
+			supportsJSON: true,
+			supportsReturning: false,
+			supportsArrays: false
+		};
+	}
+}
+//#endregion
+export { getDefaultCapabilities };
+
+//# sourceMappingURL=adapter.js.map

package/dist/database/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","names":[],"sources":["../../src/database/adapter.ts"],"sourcesContent":["/**\n * Invect Database Adapter Interface\n *\n * Inspired by better-auth's adapter pattern. Provides a model-string-based\n * interface for CRUD operations so that model classes no longer need 3-way\n * dialect branching.\n *\n * The adapter factory wraps a raw adapter with type coercion (booleans,\n * dates, JSON, arrays) so that raw adapters stay simple.\n */\n\n// ---------------------------------------------------------------------------\n// Where clause types\n// ---------------------------------------------------------------------------\n\nexport type WhereOperator =\n  | 'eq'\n  | 'ne'\n  | 'lt'\n  | 'lte'\n  | 'gt'\n  | 'gte'\n  | 'in'\n  | 'not_in'\n  | 'like'\n  | 'is_null'\n  | 'is_not_null';\n\nexport interface WhereClause {\n  field: string;\n  operator?: WhereOperator; // default: 'eq'\n  value: unknown;\n  connector?: 'AND' | 'OR'; // default: 'AND'\n}\n\n// ---------------------------------------------------------------------------\n// Adapter interface — what model classes call\n// ---------------------------------------------------------------------------\n\nexport interface InvectAdapter {\n  readonly dialect: 'sqlite' | 'postgresql' | 'mysql';\n\n  create<T extends Record<string, unknown>>(params: { model: string; data: T }): Promise<T>;\n\n  findOne<T extends Record<string, unknown>>(params: {\n    model: string;\n    where: WhereClause[];\n    select?: string[];\n  }): Promise<T | null>;\n\n  findMany<T extends Record<string, unknown>>(params: {\n    model: string;\n    where?: WhereClause[];\n    limit?: number;\n    offset?: number;\n    sortBy?: { field: string; direction: 'asc' | 'desc' };\n    select?: string[];\n  }): Promise<T[]>;\n\n  count(params: { model: string; where?: WhereClause[] }): Promise<number>;\n\n  update<T extends Record<string, unknown>>(params: {\n    model: string;\n    where: WhereClause[];\n    update: Record<string, unknown>;\n    /** Return the updated record (needs extra SELECT on MySQL). */\n    returning?: boolean;\n  }): Promise<T | null>;\n\n  updateMany(params: {\n    model: string;\n    where: WhereClause[];\n    update: Record<string, unknown>;\n  }): Promise<number>;\n\n  delete(params: { model: string; where: WhereClause[] }): Promise<void>;\n\n  deleteMany(params: { model: string; where: WhereClause[] }): Promise<number>;\n\n  /**\n   * Execute a raw SQL query string. Primarily used by the sql_query action\n   * and the postgres action for user-provided queries against external DBs.\n   */\n  executeRaw?<T extends Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;\n\n  /**\n   * Run multiple operations in a database transaction.\n   */\n  transaction<R>(callback: (trx: InvectAdapter) => Promise<R>): Promise<R>;\n}\n\n// ---------------------------------------------------------------------------\n// Raw adapter interface — what backend implementations provide\n//\n// This is the minimal set of operations a new adapter must implement.\n// The adapter factory wraps this with type coercion.\n// ---------------------------------------------------------------------------\n\nexport interface RawInvectAdapter {\n  create<T extends Record<string, unknown>>(params: { model: string; data: T }): Promise<T>;\n\n  findOne<T extends Record<string, unknown>>(params: {\n    model: string;\n    where: WhereClause[];\n    select?: string[];\n  }): Promise<T | null>;\n\n  findMany<T extends Record<string, unknown>>(params: {\n    model: string;\n    where?: WhereClause[];\n    limit?: number;\n    offset?: number;\n    sortBy?: { field: string; direction: 'asc' | 'desc' };\n    select?: string[];\n  }): Promise<T[]>;\n\n  count(params: { model: string; where?: WhereClause[] }): Promise<number>;\n\n  update<T extends Record<string, unknown>>(params: {\n    model: string;\n    where: WhereClause[];\n    update: Record<string, unknown>;\n    returning?: boolean;\n  }): Promise<T | null>;\n\n  updateMany(params: {\n    model: string;\n    where: WhereClause[];\n    update: Record<string, unknown>;\n  }): Promise<number>;\n\n  delete(params: { model: string; where: WhereClause[] }): Promise<void>;\n\n  deleteMany(params: { model: string; where: WhereClause[] }): Promise<number>;\n\n  executeRaw?<T extends Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;\n\n  transaction<R>(callback: (trx: RawInvectAdapter) => Promise<R>): Promise<R>;\n}\n\n// ---------------------------------------------------------------------------\n// Adapter config — dialect capabilities\n// ---------------------------------------------------------------------------\n\nexport interface AdapterConfig {\n  dialect: 'sqlite' | 'postgresql' | 'mysql';\n  /** SQLite stores booleans as 0/1 integers. @default true */\n  supportsBooleans?: boolean;\n  /** SQLite stores dates as ISO strings. @default true */\n  supportsDates?: boolean;\n  /** Only PostgreSQL has native JSON columns. @default false */\n  supportsJSON?: boolean;\n  /** MySQL doesn't support RETURNING. @default true */\n  supportsReturning?: boolean;\n  /** No native array columns outside PostgreSQL. @default false */\n  supportsArrays?: boolean;\n}\n\n/**\n * Default capabilities per dialect.\n */\nexport function getDefaultCapabilities(\n  dialect: AdapterConfig['dialect'],\n): Required<Omit<AdapterConfig, 'dialect'>> {\n  switch (dialect) {\n    case 'sqlite':\n      return {\n        supportsBooleans: false,\n        supportsDates: false,\n        supportsJSON: false,\n        supportsReturning: true,\n        supportsArrays: false,\n      };\n    case 'postgresql':\n      return {\n        supportsBooleans: true,\n        supportsDates: true,\n        supportsJSON: true,\n        supportsReturning: true,\n        supportsArrays: true,\n      };\n    case 'mysql':\n      return {\n        supportsBooleans: true,\n        supportsDates: true,\n        supportsJSON: true,\n        supportsReturning: false,\n        supportsArrays: false,\n      };\n  }\n}\n"],"mappings":";;;;AAiKA,SAAgB,uBACd,SAC0C;AAC1C,SAAQ,SAAR;EACE,KAAK,SACH,QAAO;GACL,kBAAkB;GAClB,eAAe;GACf,cAAc;GACd,mBAAmB;GACnB,gBAAgB;GACjB;EACH,KAAK,aACH,QAAO;GACL,kBAAkB;GAClB,eAAe;GACf,cAAc;GACd,mBAAmB;GACnB,gBAAgB;GACjB;EACH,KAAK,QACH,QAAO;GACL,kBAAkB;GAClB,eAAe;GACf,cAAc;GACd,mBAAmB;GACnB,gBAAgB;GACjB"}

package/dist/database/adapters/connection-bridge.cjs

@@ -0,0 +1,119 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_kysely_adapter = require("./kysely-adapter.cjs");
+const require_adapter_factory = require("../adapter-factory.cjs");
+const require_schema_metadata = require("../schema-metadata.cjs");
+let kysely = require("kysely");
+//#region src/database/adapters/connection-bridge.ts
+/**
+* Bridge between Invect's existing DatabaseConnection (Drizzle-based)
+* and the new Kysely-based adapter system.
+*
+* Creates a Kysely instance that shares the same underlying database
+* connection (postgres.js client, better-sqlite3, mysql2 pool).
+*/
+/**
+* Create an InvectAdapter from an existing DatabaseConnection.
+*
+* The Kysely instance shares the same underlying database client
+* (no new connections are created).
+*/
+function createAdapterFromConnection(connection) {
+	const kyselyDb = createKyselyFromConnection(connection);
+	const config = { dialect: connection.type };
+	return require_adapter_factory.createInvectAdapterFactory(require_kysely_adapter.createKyselyAdapter(kyselyDb, config), config, require_schema_metadata.INVECT_SCHEMA_META);
+}
+/**
+* Create a Kysely instance that reuses the underlying client from
+* a Drizzle DatabaseConnection.
+*/
+function createKyselyFromConnection(connection) {
+	switch (connection.type) {
+		case "sqlite": {
+			const sqliteDb = connection.db.$client;
+			return new kysely.Kysely({ dialect: {
+				createAdapter: () => new kysely.SqliteAdapter(),
+				createDriver: () => createBetterSqlite3Driver(sqliteDb),
+				createIntrospector: (db) => new kysely.SqliteIntrospector(db),
+				createQueryCompiler: () => new kysely.SqliteQueryCompiler()
+			} });
+		}
+		case "postgresql": {
+			const pgClient = connection.db.$client;
+			return new kysely.Kysely({ dialect: {
+				createAdapter: () => new kysely.PostgresAdapter(),
+				createDriver: () => createPostgresJsDriver(pgClient),
+				createIntrospector: (db) => new kysely.PostgresIntrospector(db),
+				createQueryCompiler: () => new kysely.PostgresQueryCompiler()
+			} });
+		}
+		case "mysql": {
+			const mysqlPool = connection.db.$client;
+			return new kysely.Kysely({ dialect: new kysely.MysqlDialect({ pool: mysqlPool }) });
+		}
+	}
+}
+async function noopAsync() {}
+function createBetterSqlite3Driver(db) {
+	return {
+		init: noopAsync,
+		async acquireConnection() {
+			return {
+				executeQuery: async (compiledQuery) => {
+					const sql = compiledQuery.sql.trimStart();
+					const isSelect = /^(SELECT|PRAGMA|WITH|EXPLAIN)/i.test(sql);
+					const hasReturning = /\bRETURNING\b/i.test(sql);
+					if (isSelect || hasReturning) {
+						const rows = db.prepare(compiledQuery.sql).all(...compiledQuery.parameters);
+						return {
+							rows,
+							numAffectedRows: BigInt(rows.length)
+						};
+					} else {
+						const result = db.prepare(compiledQuery.sql).run(...compiledQuery.parameters);
+						return {
+							rows: [],
+							numAffectedRows: BigInt(result.changes),
+							insertId: result.lastInsertRowid !== void 0 ? BigInt(result.lastInsertRowid) : void 0
+						};
+					}
+				},
+				streamQuery: () => {
+					throw new Error("Streaming not supported with better-sqlite3 driver");
+				}
+			};
+		},
+		beginTransaction: noopAsync,
+		commitTransaction: noopAsync,
+		rollbackTransaction: noopAsync,
+		releaseConnection: noopAsync,
+		destroy: noopAsync
+	};
+}
+function createPostgresJsDriver(client) {
+	return {
+		init: noopAsync,
+		async acquireConnection() {
+			return {
+				executeQuery: async (compiledQuery) => {
+					const result = await client.unsafe(compiledQuery.sql, compiledQuery.parameters);
+					return {
+						rows: result,
+						numAffectedRows: BigInt(result.length)
+					};
+				},
+				streamQuery: () => {
+					throw new Error("Streaming not supported with postgres.js driver bridge");
+				}
+			};
+		},
+		beginTransaction: noopAsync,
+		commitTransaction: noopAsync,
+		rollbackTransaction: noopAsync,
+		releaseConnection: noopAsync,
+		destroy: noopAsync
+	};
+}
+//#endregion
+exports.createAdapterFromConnection = createAdapterFromConnection;
+
+//# sourceMappingURL=connection-bridge.cjs.map

package/dist/database/adapters/connection-bridge.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-bridge.cjs","names":["createInvectAdapterFactory","createKyselyAdapter","INVECT_SCHEMA_META","Kysely","SqliteAdapter","SqliteIntrospector","SqliteQueryCompiler","PostgresAdapter","PostgresIntrospector","PostgresQueryCompiler","MysqlDialect"],"sources":["../../../src/database/adapters/connection-bridge.ts"],"sourcesContent":["/**\n * Bridge between Invect's existing DatabaseConnection (Drizzle-based)\n * and the new Kysely-based adapter system.\n *\n * Creates a Kysely instance that shares the same underlying database\n * connection (postgres.js client, better-sqlite3, mysql2 pool).\n */\n\nimport {\n  Kysely,\n  MysqlDialect,\n  PostgresAdapter,\n  PostgresIntrospector,\n  PostgresQueryCompiler,\n  SqliteAdapter,\n  SqliteIntrospector,\n  SqliteQueryCompiler,\n} from 'kysely';\nimport type { DatabaseConnection } from '../connection';\nimport type { InvectAdapter, AdapterConfig } from '../adapter';\nimport { createKyselyAdapter } from './kysely-adapter';\nimport { createInvectAdapterFactory } from '../adapter-factory';\nimport { INVECT_SCHEMA_META } from '../schema-metadata';\n\ntype KyselyDb = Kysely<Record<string, Record<string, unknown>>>;\n\n/**\n * Create an InvectAdapter from an existing DatabaseConnection.\n *\n * The Kysely instance shares the same underlying database client\n * (no new connections are created).\n */\nexport function createAdapterFromConnection(connection: DatabaseConnection): InvectAdapter {\n  const kyselyDb = createKyselyFromConnection(connection);\n\n  const config: AdapterConfig = {\n    dialect: connection.type,\n  };\n\n  const rawAdapter = createKyselyAdapter(kyselyDb, config);\n  return createInvectAdapterFactory(rawAdapter, config, INVECT_SCHEMA_META);\n}\n\n/**\n * Create a Kysely instance that reuses the underlying client from\n * a Drizzle DatabaseConnection.\n */\nfunction createKyselyFromConnection(connection: DatabaseConnection): KyselyDb {\n  switch (connection.type) {\n    case 'sqlite': {\n      // Drizzle's better-sqlite3 driver exposes $client which is a Database instance.\n      // We wrap it as a Kysely SqliteDialect driver.\n      const sqliteDb = (connection.db as unknown as { $client: BetterSqlite3Database }).$client;\n\n      return new Kysely({\n        dialect: {\n          createAdapter: () => new SqliteAdapter(),\n          createDriver: () => createBetterSqlite3Driver(sqliteDb),\n          createIntrospector: (db: Kysely<unknown>) => new SqliteIntrospector(db),\n          createQueryCompiler: () => new SqliteQueryCompiler(),\n        } as never,\n      }) as unknown as KyselyDb;\n    }\n\n    case 'postgresql': {\n      // Drizzle's postgres.js driver exposes $client which is a postgres.Sql instance.\n      // We wrap it as a Kysely PostgresDialect pool.\n      const pgClient = (connection.db as unknown as { $client: PgClient }).$client;\n\n      return new Kysely({\n        dialect: {\n          createAdapter: () => new PostgresAdapter(),\n          createDriver: () => createPostgresJsDriver(pgClient),\n          createIntrospector: (db: Kysely<unknown>) => new PostgresIntrospector(db),\n          createQueryCompiler: () => new PostgresQueryCompiler(),\n        } as never,\n      }) as unknown as KyselyDb;\n    }\n\n    case 'mysql': {\n      // Drizzle's mysql2 driver exposes $client which is a mysql2 Pool.\n      const mysqlPool = (connection.db as unknown as { $client: MysqlPool }).$client;\n\n      return new Kysely({\n        dialect: new MysqlDialect({ pool: mysqlPool as never }),\n      }) as unknown as KyselyDb;\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Type stubs for underlying clients (avoid importing full packages)\n// ---------------------------------------------------------------------------\n\ninterface BetterSqlite3Database {\n  prepare(sql: string): {\n    all(...params: unknown[]): Record<string, unknown>[];\n    run(...params: unknown[]): { changes: number; lastInsertRowid: number | bigint };\n  };\n  exec(sql: string): void;\n}\n\ninterface PgClient {\n  <T = Record<string, unknown>[]>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T>;\n  (query: string): Promise<Record<string, unknown>[]>;\n  unsafe(query: string, params?: unknown[]): Promise<Record<string, unknown>[]>;\n}\n\ninterface MysqlPool {\n  getConnection(): Promise<unknown>;\n  execute(sql: string, params?: unknown[]): Promise<[unknown[], unknown]>;\n}\n\n// ---------------------------------------------------------------------------\n// Custom Kysely drivers wrapping existing clients\n// ---------------------------------------------------------------------------\n\nasync function noopAsync(): Promise<void> {\n  return undefined;\n}\n\nfunction createBetterSqlite3Driver(db: BetterSqlite3Database) {\n  return {\n    init: noopAsync,\n    async acquireConnection() {\n      return {\n        executeQuery: async (compiledQuery: { sql: string; parameters: unknown[] }) => {\n          // Detect if this is a SELECT/RETURNING query or a mutation\n          const sql = compiledQuery.sql.trimStart();\n          const isSelect = /^(SELECT|PRAGMA|WITH|EXPLAIN)/i.test(sql);\n          const hasReturning = /\\bRETURNING\\b/i.test(sql);\n\n          if (isSelect || hasReturning) {\n            const rows = db.prepare(compiledQuery.sql).all(...compiledQuery.parameters);\n            return {\n              rows,\n              numAffectedRows: BigInt(rows.length),\n            };\n          } else {\n            const result = db.prepare(compiledQuery.sql).run(...compiledQuery.parameters);\n            return {\n              rows: [],\n              numAffectedRows: BigInt(result.changes),\n              insertId:\n                result.lastInsertRowid !== undefined ? BigInt(result.lastInsertRowid) : undefined,\n            };\n          }\n        },\n        streamQuery: () => {\n          throw new Error('Streaming not supported with better-sqlite3 driver');\n        },\n      };\n    },\n    beginTransaction: noopAsync,\n    commitTransaction: noopAsync,\n    rollbackTransaction: noopAsync,\n    releaseConnection: noopAsync,\n    destroy: noopAsync,\n  };\n}\n\nfunction createPostgresJsDriver(client: PgClient) {\n  return {\n    init: noopAsync,\n    async acquireConnection() {\n      return {\n        executeQuery: async (compiledQuery: { sql: string; parameters: unknown[] }) => {\n          // postgres.js uses $1, $2 placeholders natively\n          const result = await client.unsafe(compiledQuery.sql, compiledQuery.parameters);\n\n          return {\n            rows: result as Record<string, unknown>[],\n            numAffectedRows: BigInt(result.length),\n          };\n        },\n        streamQuery: () => {\n          throw new Error('Streaming not supported with postgres.js driver bridge');\n        },\n      };\n    },\n    beginTransaction: noopAsync,\n    commitTransaction: noopAsync,\n    rollbackTransaction: noopAsync,\n    releaseConnection: noopAsync,\n    destroy: noopAsync,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,4BAA4B,YAA+C;CACzF,MAAM,WAAW,2BAA2B,WAAW;CAEvD,MAAM,SAAwB,EAC5B,SAAS,WAAW,MACrB;AAGD,QAAOA,wBAAAA,2BADYC,uBAAAA,oBAAoB,UAAU,OAAO,EACV,QAAQC,wBAAAA,mBAAmB;;;;;;AAO3E,SAAS,2BAA2B,YAA0C;AAC5E,SAAQ,WAAW,MAAnB;EACE,KAAK,UAAU;GAGb,MAAM,WAAY,WAAW,GAAqD;AAElF,UAAO,IAAIC,OAAAA,OAAO,EAChB,SAAS;IACP,qBAAqB,IAAIC,OAAAA,eAAe;IACxC,oBAAoB,0BAA0B,SAAS;IACvD,qBAAqB,OAAwB,IAAIC,OAAAA,mBAAmB,GAAG;IACvE,2BAA2B,IAAIC,OAAAA,qBAAqB;IACrD,EACF,CAAC;;EAGJ,KAAK,cAAc;GAGjB,MAAM,WAAY,WAAW,GAAwC;AAErE,UAAO,IAAIH,OAAAA,OAAO,EAChB,SAAS;IACP,qBAAqB,IAAII,OAAAA,iBAAiB;IAC1C,oBAAoB,uBAAuB,SAAS;IACpD,qBAAqB,OAAwB,IAAIC,OAAAA,qBAAqB,GAAG;IACzE,2BAA2B,IAAIC,OAAAA,uBAAuB;IACvD,EACF,CAAC;;EAGJ,KAAK,SAAS;GAEZ,MAAM,YAAa,WAAW,GAAyC;AAEvE,UAAO,IAAIN,OAAAA,OAAO,EAChB,SAAS,IAAIO,OAAAA,aAAa,EAAE,MAAM,WAAoB,CAAC,EACxD,CAAC;;;;AAgCR,eAAe,YAA2B;AAI1C,SAAS,0BAA0B,IAA2B;AAC5D,QAAO;EACL,MAAM;EACN,MAAM,oBAAoB;AACxB,UAAO;IACL,cAAc,OAAO,kBAA0D;KAE7E,MAAM,MAAM,cAAc,IAAI,WAAW;KACzC,MAAM,WAAW,iCAAiC,KAAK,IAAI;KAC3D,MAAM,eAAe,iBAAiB,KAAK,IAAI;AAE/C,SAAI,YAAY,cAAc;MAC5B,MAAM,OAAO,GAAG,QAAQ,cAAc,IAAI,CAAC,IAAI,GAAG,cAAc,WAAW;AAC3E,aAAO;OACL;OACA,iBAAiB,OAAO,KAAK,OAAO;OACrC;YACI;MACL,MAAM,SAAS,GAAG,QAAQ,cAAc,IAAI,CAAC,IAAI,GAAG,cAAc,WAAW;AAC7E,aAAO;OACL,MAAM,EAAE;OACR,iBAAiB,OAAO,OAAO,QAAQ;OACvC,UACE,OAAO,oBAAoB,KAAA,IAAY,OAAO,OAAO,gBAAgB,GAAG,KAAA;OAC3E;;;IAGL,mBAAmB;AACjB,WAAM,IAAI,MAAM,qDAAqD;;IAExE;;EAEH,kBAAkB;EAClB,mBAAmB;EACnB,qBAAqB;EACrB,mBAAmB;EACnB,SAAS;EACV;;AAGH,SAAS,uBAAuB,QAAkB;AAChD,QAAO;EACL,MAAM;EACN,MAAM,oBAAoB;AACxB,UAAO;IACL,cAAc,OAAO,kBAA0D;KAE7E,MAAM,SAAS,MAAM,OAAO,OAAO,cAAc,KAAK,cAAc,WAAW;AAE/E,YAAO;MACL,MAAM;MACN,iBAAiB,OAAO,OAAO,OAAO;MACvC;;IAEH,mBAAmB;AACjB,WAAM,IAAI,MAAM,yDAAyD;;IAE5E;;EAEH,kBAAkB;EAClB,mBAAmB;EACnB,qBAAqB;EACrB,mBAAmB;EACnB,SAAS;EACV"}