@logtape/drizzle-orm 1.3.0-dev.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2025 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
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+<!-- deno-fmt-ignore-file -->
+
+@logtape/drizzle-orm
+====================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+*@logtape/drizzle-orm* is a [Drizzle ORM] adapter that allows you to use
+[LogTape] as Drizzle's logging backend for database query logging.  This
+enables seamless integration between Drizzle ORM applications and LogTape's
+structured logging capabilities.
+
+[JSR]: https://jsr.io/@logtape/drizzle-orm
+[JSR badge]: https://jsr.io/badges/@logtape/drizzle-orm
+[npm]: https://www.npmjs.com/package/@logtape/drizzle-orm
+[npm badge]: https://img.shields.io/npm/v/@logtape/drizzle-orm?logo=npm
+[LogTape]: https://logtape.org/
+[Drizzle ORM]: https://orm.drizzle.team/
+
+
+Installation
+------------
+
+~~~~ sh
+deno add jsr:@logtape/drizzle-orm  # for Deno
+npm  add     @logtape/drizzle-orm  # for npm
+pnpm add     @logtape/drizzle-orm  # for pnpm
+yarn add     @logtape/drizzle-orm  # for Yarn
+bun  add     @logtape/drizzle-orm  # for Bun
+~~~~
+
+
+Usage
+-----
+
+~~~~ typescript
+import { configure, getConsoleSink } from "@logtape/logtape";
+import { getLogger } from "@logtape/drizzle-orm";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+await configure({
+  sinks: { console: getConsoleSink() },
+  loggers: [
+    { category: ["drizzle-orm"], sinks: ["console"], lowestLevel: "debug" }
+  ],
+});
+
+const client = postgres(process.env.DATABASE_URL!);
+const db = drizzle(client, {
+  logger: getLogger(),
+});
+
+// Now all database queries will be logged through LogTape
+~~~~
+
+
+Custom category
+---------------
+
+You can specify a custom category for the logger:
+
+~~~~ typescript
+const db = drizzle(client, {
+  logger: getLogger({
+    category: ["myapp", "database"],
+  }),
+});
+~~~~
+
+
+Custom log level
+----------------
+
+By default, queries are logged at the `debug` level.  You can change this:
+
+~~~~ typescript
+const db = drizzle(client, {
+  logger: getLogger({
+    level: "info",
+  }),
+});
+~~~~
+
+
+Structured logging
+------------------
+
+The adapter logs queries with structured data that includes:
+
+- `formattedQuery`: The query with parameter placeholders (e.g., `$1`, `$2`)
+  replaced with actual values for easier reading
+- `query`: The original query string with placeholders
+- `params`: The original parameters array
+
+This allows you to:
+
+- Get human-readable output with text formatters
+- Get machine-parseable output with JSON Lines formatter
+- Use full query and params data with OpenTelemetry, Sentry, and other sinks
+
+
+Docs
+----
+
+The docs of this package is available at
+<https://logtape.org/manual/integrations#drizzle-orm>.
+For the API references, see <https://jsr.io/@logtape/drizzle-orm/doc>.

package/deno.json

@@ -0,0 +1,34 @@
+{
+  "name": "@logtape/drizzle-orm",
+  "version": "1.3.0",
+  "license": "MIT",
+  "exports": "./src/mod.ts",
+  "exclude": [
+    "coverage/",
+    "npm/",
+    "dist/"
+  ],
+  "tasks": {
+    "build": "pnpm build",
+    "test": "deno test --allow-env --allow-sys --allow-net",
+    "test:node": {
+      "dependencies": [
+        "build"
+      ],
+      "command": "node --experimental-transform-types --test"
+    },
+    "test:bun": {
+      "dependencies": [
+        "build"
+      ],
+      "command": "bun test"
+    },
+    "test-all": {
+      "dependencies": [
+        "test",
+        "test:node",
+        "test:bun"
+      ]
+    }
+  }
+}

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/mod.cjs

@@ -0,0 +1,148 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@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 = (0, __logtape_logtape.getLogger)(category);
+	return new DrizzleLogger(logger, options.level ?? "debug");
+}
+
+//#endregion
+exports.DrizzleLogger = DrizzleLogger;
+exports.getLogger = getLogger;
+exports.serialize = serialize;
+exports.stringLiteral = stringLiteral;

package/dist/mod.d.cts

@@ -0,0 +1,121 @@
+import { LogLevel, LogLevel as LogLevel$1, Logger as Logger$1 } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * Options for configuring the Drizzle ORM LogTape logger.
+ * @since 1.3.0
+ */
+interface DrizzleLoggerOptions {
+  /**
+   * The LogTape category to use for logging.
+   * @default ["drizzle-orm"]
+   */
+  readonly category?: string | readonly string[];
+  /**
+   * The log level to use for query logging.
+   * @default "debug"
+   */
+  readonly level?: LogLevel$1;
+}
+/**
+ * Drizzle ORM's Logger interface.
+ * @since 1.3.0
+ */
+interface Logger {
+  logQuery(query: string, params: unknown[]): void;
+}
+/**
+ * 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
+ */
+declare class DrizzleLogger implements Logger {
+  #private;
+  /**
+   * Creates a new DrizzleLogger instance.
+   * @param logger The LogTape logger to use.
+   * @param level The log level to use for query logging.
+   */
+  constructor(logger: Logger$1, level?: LogLevel$1);
+  /**
+   * 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: string, params: unknown[]): void;
+}
+/**
+ * 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
+ */
+declare function serialize(value: unknown): string;
+/**
+ * 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
+ */
+declare function stringLiteral(str: string): string;
+/**
+ * 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
+ */
+declare function getLogger(options?: DrizzleLoggerOptions): DrizzleLogger;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { DrizzleLogger, DrizzleLoggerOptions, LogLevel, Logger, getLogger, serialize, stringLiteral };
+//# sourceMappingURL=mod.d.cts.map

package/dist/mod.d.cts.map

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

package/dist/mod.d.ts

@@ -0,0 +1,121 @@
+import { LogLevel, LogLevel as LogLevel$1, Logger as Logger$1 } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * Options for configuring the Drizzle ORM LogTape logger.
+ * @since 1.3.0
+ */
+interface DrizzleLoggerOptions {
+  /**
+   * The LogTape category to use for logging.
+   * @default ["drizzle-orm"]
+   */
+  readonly category?: string | readonly string[];
+  /**
+   * The log level to use for query logging.
+   * @default "debug"
+   */
+  readonly level?: LogLevel$1;
+}
+/**
+ * Drizzle ORM's Logger interface.
+ * @since 1.3.0
+ */
+interface Logger {
+  logQuery(query: string, params: unknown[]): void;
+}
+/**
+ * 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
+ */
+declare class DrizzleLogger implements Logger {
+  #private;
+  /**
+   * Creates a new DrizzleLogger instance.
+   * @param logger The LogTape logger to use.
+   * @param level The log level to use for query logging.
+   */
+  constructor(logger: Logger$1, level?: LogLevel$1);
+  /**
+   * 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: string, params: unknown[]): void;
+}
+/**
+ * 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
+ */
+declare function serialize(value: unknown): string;
+/**
+ * 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
+ */
+declare function stringLiteral(str: string): string;
+/**
+ * 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
+ */
+declare function getLogger(options?: DrizzleLoggerOptions): DrizzleLogger;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { DrizzleLogger, DrizzleLoggerOptions, LogLevel, Logger, getLogger, serialize, stringLiteral };
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

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