@logtape/drizzle-orm 1.3.0-dev.1

package/dist/mod.js

@@ -0,0 +1,145 @@
+import { getLogger as getLogger$1 } from "@logtape/logtape";
+
+//#region src/mod.ts
+/**
+* A Drizzle ORM-compatible logger that wraps LogTape.
+*
+* @example
+* ```typescript
+* import { drizzle } from "drizzle-orm/postgres-js";
+* import { getLogger } from "@logtape/drizzle-orm";
+* import postgres from "postgres";
+*
+* const client = postgres(process.env.DATABASE_URL!);
+* const db = drizzle(client, {
+*   logger: getLogger(),
+* });
+* ```
+*
+* @since 1.3.0
+*/
+var DrizzleLogger = class {
+	#logger;
+	#level;
+	/**
+	* Creates a new DrizzleLogger instance.
+	* @param logger The LogTape logger to use.
+	* @param level The log level to use for query logging.
+	*/
+	constructor(logger, level = "debug") {
+		this.#logger = logger;
+		this.#level = level;
+	}
+	/**
+	* Logs a database query with its parameters.
+	*
+	* The log output includes:
+	* - `formattedQuery`: The query with parameter placeholders replaced with
+	*   actual values (for readability)
+	* - `query`: The original query string with placeholders
+	* - `params`: The original parameters array
+	*
+	* @param query The SQL query string with parameter placeholders.
+	* @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 logMethod = this.#logger[this.#level].bind(this.#logger);
+		logMethod("Query: {formattedQuery}", {
+			formattedQuery,
+			query,
+			params
+		});
+	}
+};
+/**
+* Serializes a parameter value to a SQL-safe string representation.
+*
+* @param value The value to serialize.
+* @returns The serialized string representation.
+* @since 1.3.0
+*/
+function serialize(value) {
+	if (typeof value === "undefined" || value === null) return "NULL";
+	if (typeof value === "string") return stringLiteral(value);
+	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));
+}
+/**
+* Converts a string to a SQL string literal with proper escaping.
+*
+* @param str The string to convert.
+* @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}'`;
+	}
+	return `'${str}'`;
+}
+/**
+* Normalize category to array format.
+*/
+function normalizeCategory(category) {
+	return typeof category === "string" ? [category] : category;
+}
+/**
+* Creates a Drizzle ORM-compatible logger that wraps LogTape.
+*
+* @example Basic usage
+* ```typescript
+* import { drizzle } from "drizzle-orm/postgres-js";
+* import { configure } from "@logtape/logtape";
+* import { getLogger } from "@logtape/drizzle-orm";
+* import postgres from "postgres";
+*
+* await configure({
+*   // ... LogTape configuration
+* });
+*
+* const client = postgres(process.env.DATABASE_URL!);
+* const db = drizzle(client, {
+*   logger: getLogger(),
+* });
+* ```
+*
+* @example With custom category and level
+* ```typescript
+* const db = drizzle(client, {
+*   logger: getLogger({
+*     category: ["my-app", "database"],
+*     level: "info",
+*   }),
+* });
+* ```
+*
+* @param options Configuration options for the logger.
+* @returns A Drizzle ORM-compatible logger wrapping LogTape.
+* @since 1.3.0
+*/
+function getLogger(options = {}) {
+	const category = normalizeCategory(options.category ?? ["drizzle-orm"]);
+	const logger = getLogger$1(category);
+	return new DrizzleLogger(logger, options.level ?? "debug");
+}
+
+//#endregion
+export { DrizzleLogger, getLogger, serialize, stringLiteral };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +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"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@logtape/drizzle-orm",
+  "version": "1.3.0-dev.1",
+  "description": "Drizzle ORM adapter for LogTape logging library",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "drizzle",
+    "drizzle-orm",
+    "orm",
+    "database",
+    "sql",
+    "adapter",
+    "logtape"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Hong Minhee",
+    "email": "hong@minhee.org",
+    "url": "https://hongminhee.org/"
+  },
+  "homepage": "https://logtape.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dahlia/logtape.git",
+    "directory": "packages/drizzle-orm/"
+  },
+  "bugs": {
+    "url": "https://github.com/dahlia/logtape/issues"
+  },
+  "funding": [
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "module": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts"
+      },
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "@logtape/logtape": "^1.3.0"
+  },
+  "devDependencies": {
+    "@alinea/suite": "^0.6.3",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test",
+    "test:deno": "deno test --allow-env --allow-sys --allow-net",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test && deno test"
+  }
+}