@logtape/drizzle-orm 2.2.0-dev.620 → 2.2.0-dev.626

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright 2024–2025 Hong Minhee
+Copyright 2024–2026 Hong Minhee
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

package/README.md

@@ -84,6 +84,20 @@ const db = drizzle(client, {
 ~~~~
 
 
+Dialects
+--------
+
+By default, the PostgreSQL dialect (`"pg"`) is used. You can change this:
+
+~~~~ typescript
+const db = drizzle(client, {
+  logger: getLogger({
+    dialect: "sqlite",  // "pg" | "sqlite"
+  }),
+});
+~~~~
+
+
 Structured logging
 ------------------
 

package/dist/mod.cjs

@@ -22,14 +22,17 @@ const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/log
 var DrizzleLogger = class {
 	#logger;
 	#level;
+	#dialect;
 	/**
 	* Creates a new DrizzleLogger instance.
 	* @param logger The LogTape logger to use.
 	* @param level The log level to use for query logging.
+	* @param dialect The dialect used for drizzle-orm
 	*/
-	constructor(logger, level = "debug") {
+	constructor(logger, level = "debug", dialect = "pg") {
 		this.#logger = logger;
 		this.#level = level;
+		this.#dialect = dialect;
 	}
 	/**
 	* Logs a database query with its parameters.
@@ -44,11 +47,26 @@ var DrizzleLogger = class {
 	* @param params The parameter values.
 	*/
 	logQuery(query, params) {
-		const stringifiedParams = params.map(serialize);
-		const formattedQuery = query.replace(/\$(\d+)/g, (match) => {
-			const index = Number.parseInt(match.slice(1), 10);
-			return stringifiedParams[index - 1] ?? match;
-		});
+		const stringifiedParams = params.map((param) => serialize(param, this.#dialect));
+		let formattedQuery;
+		switch (this.#dialect) {
+			case "pg": {
+				formattedQuery = query.replace(/\$(\d+)/g, (match) => {
+					const index = Number.parseInt(match.slice(1), 10);
+					return stringifiedParams[index - 1] ?? match;
+				});
+				break;
+			}
+			case "sqlite": {
+				let index = -1;
+				formattedQuery = query.replace(/\?/g, (match) => {
+					index += 1;
+					return stringifiedParams[index] ?? match;
+				});
+				break;
+			}
+			default: throw new Error(`${this.#dialect} is not supported`);
+		}
 		const logMethod = this.#logger[this.#level].bind(this.#logger);
 		logMethod("Query: {formattedQuery}", {
 			formattedQuery,
@@ -61,39 +79,55 @@ var DrizzleLogger = class {
 * Serializes a parameter value to a SQL-safe string representation.
 *
 * @param value The value to serialize.
+* @param dialect The SQL dialect to format for. Defaults to PostgreSQL.
 * @returns The serialized string representation.
 * @since 1.3.0
 */
-function serialize(value) {
+function serialize(value, dialect = "pg") {
 	if (typeof value === "undefined" || value === null) return "NULL";
-	if (typeof value === "string") return stringLiteral(value);
+	if (typeof value === "string") return stringLiteral(value, dialect);
 	if (typeof value === "number" || typeof value === "bigint") return value.toString();
-	if (typeof value === "boolean") return value ? "'t'" : "'f'";
-	if (value instanceof Date) return stringLiteral(value.toISOString());
-	if (Array.isArray(value)) return `ARRAY[${value.map(serialize).join(", ")}]`;
-	if (typeof value === "object") return stringLiteral(JSON.stringify(value));
-	return stringLiteral(String(value));
+	if (typeof value === "boolean") switch (dialect) {
+		case "sqlite": return value ? "1" : "0";
+		case "pg": return value ? "'t'" : "'f'";
+		default: throw new Error(`${dialect} is not supported`);
+	}
+	if (value instanceof Date) return stringLiteral(value.toISOString(), dialect);
+	if (Array.isArray(value)) switch (dialect) {
+		case "sqlite": return stringLiteral(JSON.stringify(value), dialect);
+		case "pg": return `ARRAY[${value.map((item) => serialize(item, dialect)).join(", ")}]`;
+		default: throw new Error(`${dialect} is not supported`);
+	}
+	if (typeof value === "object") return stringLiteral(JSON.stringify(value), dialect);
+	return stringLiteral(String(value), dialect);
 }
 /**
 * Converts a string to a SQL string literal with proper escaping.
 *
 * @param str The string to convert.
+* @param dialect The SQL dialect to format for. Defaults to PostgreSQL.
 * @returns The escaped SQL string literal.
 * @since 1.3.0
 */
-function stringLiteral(str) {
-	if (/[\\'\n\r\t\b\f]/.test(str)) {
-		let escaped = str;
-		escaped = escaped.replaceAll("\\", "\\\\");
-		escaped = escaped.replaceAll("'", "\\'");
-		escaped = escaped.replaceAll("\n", "\\n");
-		escaped = escaped.replaceAll("\r", "\\r");
-		escaped = escaped.replaceAll("	", "\\t");
-		escaped = escaped.replaceAll("\b", "\\b");
-		escaped = escaped.replaceAll("\f", "\\f");
-		return `E'${escaped}'`;
+function stringLiteral(str, dialect = "pg") {
+	switch (dialect) {
+		case "sqlite": return `'${str.replaceAll("'", "''")}'`;
+		case "pg": {
+			if (/[\\'\n\r\t\b\f]/.test(str)) {
+				let escaped = str;
+				escaped = escaped.replaceAll("\\", "\\\\");
+				escaped = escaped.replaceAll("'", "\\'");
+				escaped = escaped.replaceAll("\n", "\\n");
+				escaped = escaped.replaceAll("\r", "\\r");
+				escaped = escaped.replaceAll("	", "\\t");
+				escaped = escaped.replaceAll("\b", "\\b");
+				escaped = escaped.replaceAll("\f", "\\f");
+				return `E'${escaped}'`;
+			}
+			return `'${str}'`;
+		}
+		default: throw new Error(`${dialect} is not supported`);
 	}
-	return `'${str}'`;
 }
 /**
 * Normalize category to array format.
@@ -138,7 +172,7 @@ function normalizeCategory(category) {
 function getLogger(options = {}) {
 	const category = normalizeCategory(options.category ?? ["drizzle-orm"]);
 	const logger = (0, __logtape_logtape.getLogger)(category);
-	return new DrizzleLogger(logger, options.level ?? "debug");
+	return new DrizzleLogger(logger, options.level ?? "debug", options.dialect ?? "pg");
 }
 
 //#endregion

package/dist/mod.d.cts

@@ -2,6 +2,10 @@ import { LogLevel, LogLevel as LogLevel$1, Logger as Logger$1 } from "@logtape/l
 
 //#region src/mod.d.ts
 
+/**
+ * Supported Drizzle Dialects
+ */
+type DrizzleDialects = "pg" | "sqlite";
 /**
  * Options for configuring the Drizzle ORM LogTape logger.
  * @since 1.3.0
@@ -17,6 +21,11 @@ interface DrizzleLoggerOptions {
    * @default "debug"
    */
   readonly level?: LogLevel$1;
+  /**
+   * The dialect used for drizzle-orm
+   * @default "pg"
+   */
+  readonly dialect?: DrizzleDialects;
 }
 /**
  * Drizzle ORM's Logger interface.
@@ -48,8 +57,9 @@ declare class DrizzleLogger implements Logger {
    * Creates a new DrizzleLogger instance.
    * @param logger The LogTape logger to use.
    * @param level The log level to use for query logging.
+   * @param dialect The dialect used for drizzle-orm
    */
-  constructor(logger: Logger$1, level?: LogLevel$1);
+  constructor(logger: Logger$1, level?: LogLevel$1, dialect?: DrizzleDialects);
   /**
    * Logs a database query with its parameters.
    *
@@ -68,18 +78,20 @@ declare class DrizzleLogger implements Logger {
  * Serializes a parameter value to a SQL-safe string representation.
  *
  * @param value The value to serialize.
+ * @param dialect The SQL dialect to format for. Defaults to PostgreSQL.
  * @returns The serialized string representation.
  * @since 1.3.0
  */
-declare function serialize(value: unknown): string;
+declare function serialize(value: unknown, dialect?: DrizzleDialects): string;
 /**
  * Converts a string to a SQL string literal with proper escaping.
  *
  * @param str The string to convert.
+ * @param dialect The SQL dialect to format for. Defaults to PostgreSQL.
  * @returns The escaped SQL string literal.
  * @since 1.3.0
  */
-declare function stringLiteral(str: string): string;
+declare function stringLiteral(str: string, dialect?: DrizzleDialects): string;
 /**
  * Creates a Drizzle ORM-compatible logger that wraps LogTape.
  *
@@ -117,5 +129,5 @@ declare function stringLiteral(str: string): string;
 declare function getLogger(options?: DrizzleLoggerOptions): DrizzleLogger;
 //# sourceMappingURL=mod.d.ts.map
 //#endregion
-export { DrizzleLogger, DrizzleLoggerOptions, LogLevel, Logger, getLogger, serialize, stringLiteral };
+export { DrizzleDialects, DrizzleLogger, DrizzleLoggerOptions, LogLevel, Logger, getLogger, serialize, stringLiteral };
 //# sourceMappingURL=mod.d.cts.map

package/dist/mod.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;AAYA;AAkBA;AAqBA;AAA2B,UAvCV,oBAAA,CAuCU;EAAA;;;AAAiB;EAiD5B,SAAA,QAAS,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA;EAyBT;AA0DhB;;;EAA4D,SAAG,KAAA,CAAA,EAhK5C,UAgK4C;AAAa;;;;;UAzJ3D,MAAA;;;;;;;;;;;;;;;;;;;;cAqBJ,aAAA,YAAyB;;;;;;;sBAShB,kBAAsB;;;;;;;;;;;;;;;;;;;;;;iBAwC5B,SAAA;;;;;;;;iBAyBA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DA,SAAA,WAAmB,uBAA4B"}
+{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;AAWA;AAMA;AAAqC,KANzB,eAAA,GAMyB,IAAA,GAAA,QAAA;;;AAiBD;AAOpC;AAqBa,UA7CI,oBAAA,CA6CU;EAAA;;;;EAcQ,SAdG,QAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA;EAAM;AA4E5C;AAgDA;AAqEA;EAAyB,SAAA,KAAA,CAAA,EAnON,UAmOM;EAAA;;AAAmD;;qBA7NvD;;;;;;UAOJ,MAAA;;;;;;;;;;;;;;;;;;;;cAqBJ,aAAA,YAAyB;;;;;;;;sBAY1B,kBACD,sBACE;;;;;;;;;;;;;;;;;;;;;;;iBA8DG,SAAA,2BAEL;;;;;;;;;iBA8CK,aAAA,wBAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmEK,SAAA,WAAmB,uBAA4B"}

package/dist/mod.d.ts

@@ -2,6 +2,10 @@ import { LogLevel, LogLevel as LogLevel$1, Logger as Logger$1 } from "@logtape/l
 
 //#region src/mod.d.ts
 
+/**
+ * Supported Drizzle Dialects
+ */
+type DrizzleDialects = "pg" | "sqlite";
 /**
  * Options for configuring the Drizzle ORM LogTape logger.
  * @since 1.3.0
@@ -17,6 +21,11 @@ interface DrizzleLoggerOptions {
    * @default "debug"
    */
   readonly level?: LogLevel$1;
+  /**
+   * The dialect used for drizzle-orm
+   * @default "pg"
+   */
+  readonly dialect?: DrizzleDialects;
 }
 /**
  * Drizzle ORM's Logger interface.
@@ -48,8 +57,9 @@ declare class DrizzleLogger implements Logger {
    * Creates a new DrizzleLogger instance.
    * @param logger The LogTape logger to use.
    * @param level The log level to use for query logging.
+   * @param dialect The dialect used for drizzle-orm
    */
-  constructor(logger: Logger$1, level?: LogLevel$1);
+  constructor(logger: Logger$1, level?: LogLevel$1, dialect?: DrizzleDialects);
   /**
    * Logs a database query with its parameters.
    *
@@ -68,18 +78,20 @@ declare class DrizzleLogger implements Logger {
  * Serializes a parameter value to a SQL-safe string representation.
  *
  * @param value The value to serialize.
+ * @param dialect The SQL dialect to format for. Defaults to PostgreSQL.
  * @returns The serialized string representation.
  * @since 1.3.0
  */
-declare function serialize(value: unknown): string;
+declare function serialize(value: unknown, dialect?: DrizzleDialects): string;
 /**
  * Converts a string to a SQL string literal with proper escaping.
  *
  * @param str The string to convert.
+ * @param dialect The SQL dialect to format for. Defaults to PostgreSQL.
  * @returns The escaped SQL string literal.
  * @since 1.3.0
  */
-declare function stringLiteral(str: string): string;
+declare function stringLiteral(str: string, dialect?: DrizzleDialects): string;
 /**
  * Creates a Drizzle ORM-compatible logger that wraps LogTape.
  *
@@ -117,5 +129,5 @@ declare function stringLiteral(str: string): string;
 declare function getLogger(options?: DrizzleLoggerOptions): DrizzleLogger;
 //# sourceMappingURL=mod.d.ts.map
 //#endregion
-export { DrizzleLogger, DrizzleLoggerOptions, LogLevel, Logger, getLogger, serialize, stringLiteral };
+export { DrizzleDialects, DrizzleLogger, DrizzleLoggerOptions, LogLevel, Logger, getLogger, serialize, stringLiteral };
 //# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;AAYA;AAkBA;AAqBA;AAA2B,UAvCV,oBAAA,CAuCU;EAAA;;;AAAiB;EAiD5B,SAAA,QAAS,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA;EAyBT;AA0DhB;;;EAA4D,SAAG,KAAA,CAAA,EAhK5C,UAgK4C;AAAa;;;;;UAzJ3D,MAAA;;;;;;;;;;;;;;;;;;;;cAqBJ,aAAA,YAAyB;;;;;;;sBAShB,kBAAsB;;;;;;;;;;;;;;;;;;;;;;iBAwC5B,SAAA;;;;;;;;iBAyBA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DA,SAAA,WAAmB,uBAA4B"}
+{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;AAWA;AAMA;AAAqC,KANzB,eAAA,GAMyB,IAAA,GAAA,QAAA;;;AAiBD;AAOpC;AAqBa,UA7CI,oBAAA,CA6CU;EAAA;;;;EAcQ,SAdG,QAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA;EAAM;AA4E5C;AAgDA;AAqEA;EAAyB,SAAA,KAAA,CAAA,EAnON,UAmOM;EAAA;;AAAmD;;qBA7NvD;;;;;;UAOJ,MAAA;;;;;;;;;;;;;;;;;;;;cAqBJ,aAAA,YAAyB;;;;;;;;sBAY1B,kBACD,sBACE;;;;;;;;;;;;;;;;;;;;;;;iBA8DG,SAAA,2BAEL;;;;;;;;;iBA8CK,aAAA,wBAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmEK,SAAA,WAAmB,uBAA4B"}

package/dist/mod.js

@@ -21,14 +21,17 @@ import { getLogger as getLogger$1 } from "@logtape/logtape";
 var DrizzleLogger = class {
 	#logger;
 	#level;
+	#dialect;
 	/**
 	* Creates a new DrizzleLogger instance.
 	* @param logger The LogTape logger to use.
 	* @param level The log level to use for query logging.
+	* @param dialect The dialect used for drizzle-orm
 	*/
-	constructor(logger, level = "debug") {
+	constructor(logger, level = "debug", dialect = "pg") {
 		this.#logger = logger;
 		this.#level = level;
+		this.#dialect = dialect;
 	}
 	/**
 	* Logs a database query with its parameters.
@@ -43,11 +46,26 @@ var DrizzleLogger = class {
 	* @param params The parameter values.
 	*/
 	logQuery(query, params) {
-		const stringifiedParams = params.map(serialize);
-		const formattedQuery = query.replace(/\$(\d+)/g, (match) => {
-			const index = Number.parseInt(match.slice(1), 10);
-			return stringifiedParams[index - 1] ?? match;
-		});
+		const stringifiedParams = params.map((param) => serialize(param, this.#dialect));
+		let formattedQuery;
+		switch (this.#dialect) {
+			case "pg": {
+				formattedQuery = query.replace(/\$(\d+)/g, (match) => {
+					const index = Number.parseInt(match.slice(1), 10);
+					return stringifiedParams[index - 1] ?? match;
+				});
+				break;
+			}
+			case "sqlite": {
+				let index = -1;
+				formattedQuery = query.replace(/\?/g, (match) => {
+					index += 1;
+					return stringifiedParams[index] ?? match;
+				});
+				break;
+			}
+			default: throw new Error(`${this.#dialect} is not supported`);
+		}
 		const logMethod = this.#logger[this.#level].bind(this.#logger);
 		logMethod("Query: {formattedQuery}", {
 			formattedQuery,
@@ -60,39 +78,55 @@ var DrizzleLogger = class {
 * Serializes a parameter value to a SQL-safe string representation.
 *
 * @param value The value to serialize.
+* @param dialect The SQL dialect to format for. Defaults to PostgreSQL.
 * @returns The serialized string representation.
 * @since 1.3.0
 */
-function serialize(value) {
+function serialize(value, dialect = "pg") {
 	if (typeof value === "undefined" || value === null) return "NULL";
-	if (typeof value === "string") return stringLiteral(value);
+	if (typeof value === "string") return stringLiteral(value, dialect);
 	if (typeof value === "number" || typeof value === "bigint") return value.toString();
-	if (typeof value === "boolean") return value ? "'t'" : "'f'";
-	if (value instanceof Date) return stringLiteral(value.toISOString());
-	if (Array.isArray(value)) return `ARRAY[${value.map(serialize).join(", ")}]`;
-	if (typeof value === "object") return stringLiteral(JSON.stringify(value));
-	return stringLiteral(String(value));
+	if (typeof value === "boolean") switch (dialect) {
+		case "sqlite": return value ? "1" : "0";
+		case "pg": return value ? "'t'" : "'f'";
+		default: throw new Error(`${dialect} is not supported`);
+	}
+	if (value instanceof Date) return stringLiteral(value.toISOString(), dialect);
+	if (Array.isArray(value)) switch (dialect) {
+		case "sqlite": return stringLiteral(JSON.stringify(value), dialect);
+		case "pg": return `ARRAY[${value.map((item) => serialize(item, dialect)).join(", ")}]`;
+		default: throw new Error(`${dialect} is not supported`);
+	}
+	if (typeof value === "object") return stringLiteral(JSON.stringify(value), dialect);
+	return stringLiteral(String(value), dialect);
 }
 /**
 * Converts a string to a SQL string literal with proper escaping.
 *
 * @param str The string to convert.
+* @param dialect The SQL dialect to format for. Defaults to PostgreSQL.
 * @returns The escaped SQL string literal.
 * @since 1.3.0
 */
-function stringLiteral(str) {
-	if (/[\\'\n\r\t\b\f]/.test(str)) {
-		let escaped = str;
-		escaped = escaped.replaceAll("\\", "\\\\");
-		escaped = escaped.replaceAll("'", "\\'");
-		escaped = escaped.replaceAll("\n", "\\n");
-		escaped = escaped.replaceAll("\r", "\\r");
-		escaped = escaped.replaceAll("	", "\\t");
-		escaped = escaped.replaceAll("\b", "\\b");
-		escaped = escaped.replaceAll("\f", "\\f");
-		return `E'${escaped}'`;
+function stringLiteral(str, dialect = "pg") {
+	switch (dialect) {
+		case "sqlite": return `'${str.replaceAll("'", "''")}'`;
+		case "pg": {
+			if (/[\\'\n\r\t\b\f]/.test(str)) {
+				let escaped = str;
+				escaped = escaped.replaceAll("\\", "\\\\");
+				escaped = escaped.replaceAll("'", "\\'");
+				escaped = escaped.replaceAll("\n", "\\n");
+				escaped = escaped.replaceAll("\r", "\\r");
+				escaped = escaped.replaceAll("	", "\\t");
+				escaped = escaped.replaceAll("\b", "\\b");
+				escaped = escaped.replaceAll("\f", "\\f");
+				return `E'${escaped}'`;
+			}
+			return `'${str}'`;
+		}
+		default: throw new Error(`${dialect} is not supported`);
 	}
-	return `'${str}'`;
 }
 /**
 * Normalize category to array format.
@@ -137,7 +171,7 @@ function normalizeCategory(category) {
 function getLogger(options = {}) {
 	const category = normalizeCategory(options.category ?? ["drizzle-orm"]);
 	const logger = getLogger$1(category);
-	return new DrizzleLogger(logger, options.level ?? "debug");
+	return new DrizzleLogger(logger, options.level ?? "debug", options.dialect ?? "pg");
 }
 
 //#endregion

package/dist/mod.js.map

@@ -1 +1 @@
-{"version":3,"file":"mod.js","names":["#logger","#level","logger: LogTapeLogger","level: LogLevel","query: string","params: unknown[]","value: unknown","str: string","category: string | readonly string[]","options: DrizzleLoggerOptions"],"sources":["../src/mod.ts"],"sourcesContent":["import {\n  getLogger as getLogTapeLogger,\n  type Logger as LogTapeLogger,\n  type LogLevel,\n} from \"@logtape/logtape\";\n\nexport type { LogLevel } from \"@logtape/logtape\";\n\n/**\n * Options for configuring the Drizzle ORM LogTape logger.\n * @since 1.3.0\n */\nexport interface DrizzleLoggerOptions {\n  /**\n   * The LogTape category to use for logging.\n   * @default [\"drizzle-orm\"]\n   */\n  readonly category?: string | readonly string[];\n\n  /**\n   * The log level to use for query logging.\n   * @default \"debug\"\n   */\n  readonly level?: LogLevel;\n}\n\n/**\n * Drizzle ORM's Logger interface.\n * @since 1.3.0\n */\nexport interface Logger {\n  logQuery(query: string, params: unknown[]): void;\n}\n\n/**\n * A Drizzle ORM-compatible logger that wraps LogTape.\n *\n * @example\n * ```typescript\n * import { drizzle } from \"drizzle-orm/postgres-js\";\n * import { getLogger } from \"@logtape/drizzle-orm\";\n * import postgres from \"postgres\";\n *\n * const client = postgres(process.env.DATABASE_URL!);\n * const db = drizzle(client, {\n *   logger: getLogger(),\n * });\n * ```\n *\n * @since 1.3.0\n */\nexport class DrizzleLogger implements Logger {\n  readonly #logger: LogTapeLogger;\n  readonly #level: LogLevel;\n\n  /**\n   * Creates a new DrizzleLogger instance.\n   * @param logger The LogTape logger to use.\n   * @param level The log level to use for query logging.\n   */\n  constructor(logger: LogTapeLogger, level: LogLevel = \"debug\") {\n    this.#logger = logger;\n    this.#level = level;\n  }\n\n  /**\n   * Logs a database query with its parameters.\n   *\n   * The log output includes:\n   * - `formattedQuery`: The query with parameter placeholders replaced with\n   *   actual values (for readability)\n   * - `query`: The original query string with placeholders\n   * - `params`: The original parameters array\n   *\n   * @param query The SQL query string with parameter placeholders.\n   * @param params The parameter values.\n   */\n  logQuery(query: string, params: unknown[]): void {\n    const stringifiedParams = params.map(serialize);\n    const formattedQuery = query.replace(/\\$(\\d+)/g, (match) => {\n      const index = Number.parseInt(match.slice(1), 10);\n      return stringifiedParams[index - 1] ?? match;\n    });\n\n    const logMethod = this.#logger[this.#level].bind(this.#logger);\n    logMethod(\"Query: {formattedQuery}\", {\n      formattedQuery,\n      query,\n      params,\n    });\n  }\n}\n\n/**\n * Serializes a parameter value to a SQL-safe string representation.\n *\n * @param value The value to serialize.\n * @returns The serialized string representation.\n * @since 1.3.0\n */\nexport function serialize(value: unknown): string {\n  if (typeof value === \"undefined\" || value === null) return \"NULL\";\n  if (typeof value === \"string\") return stringLiteral(value);\n  if (typeof value === \"number\" || typeof value === \"bigint\") {\n    return value.toString();\n  }\n  if (typeof value === \"boolean\") return value ? \"'t'\" : \"'f'\";\n  if (value instanceof Date) return stringLiteral(value.toISOString());\n  if (Array.isArray(value)) {\n    return `ARRAY[${value.map(serialize).join(\", \")}]`;\n  }\n  if (typeof value === \"object\") {\n    // Assume it's a JSON object\n    return stringLiteral(JSON.stringify(value));\n  }\n  return stringLiteral(String(value));\n}\n\n/**\n * Converts a string to a SQL string literal with proper escaping.\n *\n * @param str The string to convert.\n * @returns The escaped SQL string literal.\n * @since 1.3.0\n */\nexport function stringLiteral(str: string): string {\n  if (/[\\\\'\\n\\r\\t\\b\\f]/.test(str)) {\n    let escaped = str;\n    escaped = escaped.replaceAll(\"\\\\\", \"\\\\\\\\\");\n    escaped = escaped.replaceAll(\"'\", \"\\\\'\");\n    escaped = escaped.replaceAll(\"\\n\", \"\\\\n\");\n    escaped = escaped.replaceAll(\"\\r\", \"\\\\r\");\n    escaped = escaped.replaceAll(\"\\t\", \"\\\\t\");\n    escaped = escaped.replaceAll(\"\\b\", \"\\\\b\");\n    escaped = escaped.replaceAll(\"\\f\", \"\\\\f\");\n    return `E'${escaped}'`;\n  }\n  return `'${str}'`;\n}\n\n/**\n * Normalize category to array format.\n */\nfunction normalizeCategory(\n  category: string | readonly string[],\n): readonly string[] {\n  return typeof category === \"string\" ? [category] : category;\n}\n\n/**\n * Creates a Drizzle ORM-compatible logger that wraps LogTape.\n *\n * @example Basic usage\n * ```typescript\n * import { drizzle } from \"drizzle-orm/postgres-js\";\n * import { configure } from \"@logtape/logtape\";\n * import { getLogger } from \"@logtape/drizzle-orm\";\n * import postgres from \"postgres\";\n *\n * await configure({\n *   // ... LogTape configuration\n * });\n *\n * const client = postgres(process.env.DATABASE_URL!);\n * const db = drizzle(client, {\n *   logger: getLogger(),\n * });\n * ```\n *\n * @example With custom category and level\n * ```typescript\n * const db = drizzle(client, {\n *   logger: getLogger({\n *     category: [\"my-app\", \"database\"],\n *     level: \"info\",\n *   }),\n * });\n * ```\n *\n * @param options Configuration options for the logger.\n * @returns A Drizzle ORM-compatible logger wrapping LogTape.\n * @since 1.3.0\n */\nexport function getLogger(options: DrizzleLoggerOptions = {}): DrizzleLogger {\n  const category = normalizeCategory(options.category ?? [\"drizzle-orm\"]);\n  const logger = getLogTapeLogger(category);\n  return new DrizzleLogger(logger, options.level ?? \"debug\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmDA,IAAa,gBAAb,MAA6C;CAC3C,AAASA;CACT,AAASC;;;;;;CAOT,YAAYC,QAAuBC,QAAkB,SAAS;AAC5D,OAAKH,UAAU;AACf,OAAKC,SAAS;CACf;;;;;;;;;;;;;CAcD,SAASG,OAAeC,QAAyB;EAC/C,MAAM,oBAAoB,OAAO,IAAI,UAAU;EAC/C,MAAM,iBAAiB,MAAM,QAAQ,YAAY,CAAC,UAAU;GAC1D,MAAM,QAAQ,OAAO,SAAS,MAAM,MAAM,EAAE,EAAE,GAAG;AACjD,UAAO,kBAAkB,QAAQ,MAAM;EACxC,EAAC;EAEF,MAAM,YAAY,KAAKL,QAAQ,KAAKC,QAAQ,KAAK,KAAKD,QAAQ;AAC9D,YAAU,2BAA2B;GACnC;GACA;GACA;EACD,EAAC;CACH;AACF;;;;;;;;AASD,SAAgB,UAAUM,OAAwB;AAChD,YAAW,UAAU,eAAe,UAAU,KAAM,QAAO;AAC3D,YAAW,UAAU,SAAU,QAAO,cAAc,MAAM;AAC1D,YAAW,UAAU,mBAAmB,UAAU,SAChD,QAAO,MAAM,UAAU;AAEzB,YAAW,UAAU,UAAW,QAAO,QAAQ,QAAQ;AACvD,KAAI,iBAAiB,KAAM,QAAO,cAAc,MAAM,aAAa,CAAC;AACpE,KAAI,MAAM,QAAQ,MAAM,CACtB,SAAQ,QAAQ,MAAM,IAAI,UAAU,CAAC,KAAK,KAAK,CAAC;AAElD,YAAW,UAAU,SAEnB,QAAO,cAAc,KAAK,UAAU,MAAM,CAAC;AAE7C,QAAO,cAAc,OAAO,MAAM,CAAC;AACpC;;;;;;;;AASD,SAAgB,cAAcC,KAAqB;AACjD,KAAI,kBAAkB,KAAK,IAAI,EAAE;EAC/B,IAAI,UAAU;AACd,YAAU,QAAQ,WAAW,MAAM,OAAO;AAC1C,YAAU,QAAQ,WAAW,KAAK,MAAM;AACxC,YAAU,QAAQ,WAAW,MAAM,MAAM;AACzC,YAAU,QAAQ,WAAW,MAAM,MAAM;AACzC,YAAU,QAAQ,WAAW,KAAM,MAAM;AACzC,YAAU,QAAQ,WAAW,MAAM,MAAM;AACzC,YAAU,QAAQ,WAAW,MAAM,MAAM;AACzC,UAAQ,IAAI,QAAQ;CACrB;AACD,SAAQ,GAAG,IAAI;AAChB;;;;AAKD,SAAS,kBACPC,UACmB;AACnB,eAAc,aAAa,WAAW,CAAC,QAAS,IAAG;AACpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCD,SAAgB,UAAUC,UAAgC,CAAE,GAAiB;CAC3E,MAAM,WAAW,kBAAkB,QAAQ,YAAY,CAAC,aAAc,EAAC;CACvE,MAAM,SAAS,YAAiB,SAAS;AACzC,QAAO,IAAI,cAAc,QAAQ,QAAQ,SAAS;AACnD"}
+{"version":3,"file":"mod.js","names":["#logger","#level","#dialect","logger: LogTapeLogger","level: LogLevel","dialect: DrizzleDialects","query: string","params: unknown[]","formattedQuery: string","value: unknown","str: string","category: string | readonly string[]","options: DrizzleLoggerOptions"],"sources":["../src/mod.ts"],"sourcesContent":["import {\n  getLogger as getLogTapeLogger,\n  type Logger as LogTapeLogger,\n  type LogLevel,\n} from \"@logtape/logtape\";\n\nexport type { LogLevel } from \"@logtape/logtape\";\n\n/**\n * Supported Drizzle Dialects\n */\nexport type DrizzleDialects = \"pg\" | \"sqlite\";\n\n/**\n * Options for configuring the Drizzle ORM LogTape logger.\n * @since 1.3.0\n */\nexport interface DrizzleLoggerOptions {\n  /**\n   * The LogTape category to use for logging.\n   * @default [\"drizzle-orm\"]\n   */\n  readonly category?: string | readonly string[];\n\n  /**\n   * The log level to use for query logging.\n   * @default \"debug\"\n   */\n  readonly level?: LogLevel;\n\n  /**\n   * The dialect used for drizzle-orm\n   * @default \"pg\"\n   */\n  readonly dialect?: DrizzleDialects;\n}\n\n/**\n * Drizzle ORM's Logger interface.\n * @since 1.3.0\n */\nexport interface Logger {\n  logQuery(query: string, params: unknown[]): void;\n}\n\n/**\n * A Drizzle ORM-compatible logger that wraps LogTape.\n *\n * @example\n * ```typescript\n * import { drizzle } from \"drizzle-orm/postgres-js\";\n * import { getLogger } from \"@logtape/drizzle-orm\";\n * import postgres from \"postgres\";\n *\n * const client = postgres(process.env.DATABASE_URL!);\n * const db = drizzle(client, {\n *   logger: getLogger(),\n * });\n * ```\n *\n * @since 1.3.0\n */\nexport class DrizzleLogger implements Logger {\n  readonly #logger: LogTapeLogger;\n  readonly #level: LogLevel;\n  readonly #dialect: DrizzleDialects;\n\n  /**\n   * Creates a new DrizzleLogger instance.\n   * @param logger The LogTape logger to use.\n   * @param level The log level to use for query logging.\n   * @param dialect The dialect used for drizzle-orm\n   */\n  constructor(\n    logger: LogTapeLogger,\n    level: LogLevel = \"debug\",\n    dialect: DrizzleDialects = \"pg\",\n  ) {\n    this.#logger = logger;\n    this.#level = level;\n    this.#dialect = dialect;\n  }\n\n  /**\n   * Logs a database query with its parameters.\n   *\n   * The log output includes:\n   * - `formattedQuery`: The query with parameter placeholders replaced with\n   *   actual values (for readability)\n   * - `query`: The original query string with placeholders\n   * - `params`: The original parameters array\n   *\n   * @param query The SQL query string with parameter placeholders.\n   * @param params The parameter values.\n   */\n  logQuery(query: string, params: unknown[]): void {\n    const stringifiedParams = params.map((param) =>\n      serialize(param, this.#dialect)\n    );\n    let formattedQuery: string;\n    switch (this.#dialect) {\n      case \"pg\": {\n        formattedQuery = query.replace(/\\$(\\d+)/g, (match) => {\n          const index = Number.parseInt(match.slice(1), 10);\n          return stringifiedParams[index - 1] ?? match;\n        });\n        break;\n      }\n      case \"sqlite\": {\n        let index = -1;\n        formattedQuery = query.replace(/\\?/g, (match) => {\n          index += 1;\n          return stringifiedParams[index] ?? match;\n        });\n        break;\n      }\n      default: {\n        throw new Error(`${this.#dialect satisfies never} is not supported`);\n      }\n    }\n\n    const logMethod = this.#logger[this.#level].bind(this.#logger);\n    logMethod(\"Query: {formattedQuery}\", {\n      formattedQuery,\n      query,\n      params,\n    });\n  }\n}\n\n/**\n * Serializes a parameter value to a SQL-safe string representation.\n *\n * @param value The value to serialize.\n * @param dialect The SQL dialect to format for. Defaults to PostgreSQL.\n * @returns The serialized string representation.\n * @since 1.3.0\n */\nexport function serialize(\n  value: unknown,\n  dialect: DrizzleDialects = \"pg\",\n): string {\n  if (typeof value === \"undefined\" || value === null) return \"NULL\";\n  if (typeof value === \"string\") return stringLiteral(value, dialect);\n  if (typeof value === \"number\" || typeof value === \"bigint\") {\n    return value.toString();\n  }\n  if (typeof value === \"boolean\") {\n    switch (dialect) {\n      case \"sqlite\":\n        return value ? \"1\" : \"0\";\n      case \"pg\":\n        return value ? \"'t'\" : \"'f'\";\n      default:\n        throw new Error(`${dialect satisfies never} is not supported`);\n    }\n  }\n  if (value instanceof Date) {\n    return stringLiteral(value.toISOString(), dialect);\n  }\n  if (Array.isArray(value)) {\n    switch (dialect) {\n      case \"sqlite\":\n        return stringLiteral(JSON.stringify(value), dialect);\n      case \"pg\":\n        return `ARRAY[${\n          value.map((item) => serialize(item, dialect)).join(\", \")\n        }]`;\n      default:\n        throw new Error(`${dialect satisfies never} is not supported`);\n    }\n  }\n  if (typeof value === \"object\") {\n    return stringLiteral(JSON.stringify(value), dialect);\n  }\n  return stringLiteral(String(value), dialect);\n}\n\n/**\n * Converts a string to a SQL string literal with proper escaping.\n *\n * @param str The string to convert.\n * @param dialect The SQL dialect to format for. Defaults to PostgreSQL.\n * @returns The escaped SQL string literal.\n * @since 1.3.0\n */\nexport function stringLiteral(\n  str: string,\n  dialect: DrizzleDialects = \"pg\",\n): string {\n  switch (dialect) {\n    case \"sqlite\":\n      return `'${str.replaceAll(\"'\", \"''\")}'`;\n    case \"pg\": {\n      if (/[\\\\'\\n\\r\\t\\b\\f]/.test(str)) {\n        let escaped = str;\n        escaped = escaped.replaceAll(\"\\\\\", \"\\\\\\\\\");\n        escaped = escaped.replaceAll(\"'\", \"\\\\'\");\n        escaped = escaped.replaceAll(\"\\n\", \"\\\\n\");\n        escaped = escaped.replaceAll(\"\\r\", \"\\\\r\");\n        escaped = escaped.replaceAll(\"\\t\", \"\\\\t\");\n        escaped = escaped.replaceAll(\"\\b\", \"\\\\b\");\n        escaped = escaped.replaceAll(\"\\f\", \"\\\\f\");\n        return `E'${escaped}'`;\n      }\n      return `'${str}'`;\n    }\n    default:\n      throw new Error(`${dialect satisfies never} is not supported`);\n  }\n}\n\n/**\n * Normalize category to array format.\n */\nfunction normalizeCategory(\n  category: string | readonly string[],\n): readonly string[] {\n  return typeof category === \"string\" ? [category] : category;\n}\n\n/**\n * Creates a Drizzle ORM-compatible logger that wraps LogTape.\n *\n * @example Basic usage\n * ```typescript\n * import { drizzle } from \"drizzle-orm/postgres-js\";\n * import { configure } from \"@logtape/logtape\";\n * import { getLogger } from \"@logtape/drizzle-orm\";\n * import postgres from \"postgres\";\n *\n * await configure({\n *   // ... LogTape configuration\n * });\n *\n * const client = postgres(process.env.DATABASE_URL!);\n * const db = drizzle(client, {\n *   logger: getLogger(),\n * });\n * ```\n *\n * @example With custom category and level\n * ```typescript\n * const db = drizzle(client, {\n *   logger: getLogger({\n *     category: [\"my-app\", \"database\"],\n *     level: \"info\",\n *   }),\n * });\n * ```\n *\n * @param options Configuration options for the logger.\n * @returns A Drizzle ORM-compatible logger wrapping LogTape.\n * @since 1.3.0\n */\nexport function getLogger(options: DrizzleLoggerOptions = {}): DrizzleLogger {\n  const category = normalizeCategory(options.category ?? [\"drizzle-orm\"]);\n  const logger = getLogTapeLogger(category);\n  return new DrizzleLogger(\n    logger,\n    options.level ?? \"debug\",\n    options.dialect ?? \"pg\",\n  );\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/drizzle-orm",
-  "version": "2.2.0-dev.620+455a47e2",
+  "version": "2.2.0-dev.626+7dce7b35",
   "description": "Drizzle ORM adapter for LogTape logging library",
   "keywords": [
     "logging",
@@ -52,7 +52,7 @@
     "dist/"
   ],
   "peerDependencies": {
-    "@logtape/logtape": "^2.2.0-dev.620+455a47e2"
+    "@logtape/logtape": "^2.2.0-dev.626+7dce7b35"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",