@logtape/drizzle-orm 1.4.0-dev.409 → 1.4.0-dev.413

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/drizzle-orm",
-  "version": "1.4.0-dev.409+63c2cd45",
+  "version": "1.4.0-dev.413+1097da33",
   "description": "Drizzle ORM adapter for LogTape logging library",
   "keywords": [
     "logging",
@@ -48,8 +48,11 @@
     "./package.json": "./package.json"
   },
   "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
   "peerDependencies": {
-    "@logtape/logtape": "^1.4.0-dev.409+63c2cd45"
+    "@logtape/logtape": "^1.4.0-dev.413+1097da33"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",

package/deno.json

@@ -1,34 +0,0 @@
-{
-  "name": "@logtape/drizzle-orm",
-  "version": "1.4.0-dev.409+63c2cd45",
-  "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/src/mod.test.ts

@@ -1,632 +0,0 @@
-import { suite } from "@alinea/suite";
-import { assertEquals } from "@std/assert/equals";
-import { configure, type LogRecord, reset } from "@logtape/logtape";
-import { DrizzleLogger, getLogger, serialize, stringLiteral } from "./mod.ts";
-
-const test = suite(import.meta);
-
-// Test fixture: Collect log records, filtering out internal LogTape meta logs
-function createTestSink(): {
-  sink: (record: LogRecord) => void;
-  logs: LogRecord[];
-} {
-  const logs: LogRecord[] = [];
-  return {
-    // Filter out logtape meta logs automatically
-    sink: (record: LogRecord) => {
-      if (record.category[0] !== "logtape") {
-        logs.push(record);
-      }
-    },
-    logs,
-  };
-}
-
-// Setup helper
-async function setupLogtape(): Promise<{
-  logs: LogRecord[];
-  cleanup: () => Promise<void>;
-}> {
-  const { sink, logs } = createTestSink();
-  await configure({
-    sinks: { test: sink },
-    loggers: [{ category: [], sinks: ["test"] }],
-  });
-  return { logs, cleanup: () => reset() };
-}
-
-// ============================================
-// Basic Logger Creation Tests
-// ============================================
-
-test("getLogger(): creates a Drizzle ORM-compatible logger", async () => {
-  const { cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-
-    assertEquals(typeof logger.logQuery, "function");
-    assertEquals(logger instanceof DrizzleLogger, true);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("getLogger(): uses default category ['drizzle-orm']", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery("SELECT 1", []);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["drizzle-orm"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("getLogger(): uses custom category array", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger({ category: ["myapp", "database"] });
-    logger.logQuery("SELECT 1", []);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["myapp", "database"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("getLogger(): accepts string category", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger({ category: "database" });
-    logger.logQuery("SELECT 1", []);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["database"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Log Level Tests
-// ============================================
-
-test("getLogger(): uses default level 'debug'", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery("SELECT 1", []);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].level, "debug");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("getLogger(): uses custom level", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger({ level: "info" });
-    logger.logQuery("SELECT 1", []);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].level, "info");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("getLogger(): supports all log levels", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const levels = [
-      "trace",
-      "debug",
-      "info",
-      "warning",
-      "error",
-      "fatal",
-    ] as const;
-
-    for (const level of levels) {
-      logs.length = 0; // Clear logs
-      const logger = getLogger({ level });
-      logger.logQuery("SELECT 1", []);
-
-      assertEquals(logs.length, 1);
-      assertEquals(logs[0].level, level);
-    }
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Query Logging Tests
-// ============================================
-
-test("logQuery(): logs query with structured data", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery("SELECT * FROM users WHERE id = $1", ["123"]);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.query, "SELECT * FROM users WHERE id = $1");
-    assertEquals(logs[0].properties.params, ["123"]);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "SELECT * FROM users WHERE id = '123'",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): formats query with multiple parameters", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery(
-      "SELECT * FROM users WHERE name = $1 AND age > $2",
-      ["Alice", 25],
-    );
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "SELECT * FROM users WHERE name = 'Alice' AND age > 25",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles empty parameters", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery("SELECT * FROM users", []);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.formattedQuery, "SELECT * FROM users");
-    assertEquals(logs[0].properties.params, []);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles unmatched placeholders", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery("SELECT * FROM users WHERE id = $1 AND name = $2", ["123"]);
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "SELECT * FROM users WHERE id = '123' AND name = $2",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): log message contains formatted query", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery("SELECT 1", []);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].rawMessage, "Query: {formattedQuery}");
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Parameter Serialization Tests
-// ============================================
-
-test("serialize(): handles null", () => {
-  assertEquals(serialize(null), "NULL");
-});
-
-test("serialize(): handles undefined", () => {
-  assertEquals(serialize(undefined), "NULL");
-});
-
-test("serialize(): handles strings", () => {
-  assertEquals(serialize("hello"), "'hello'");
-});
-
-test("serialize(): handles strings with special characters", () => {
-  assertEquals(serialize("hello\nworld"), "E'hello\\nworld'");
-  assertEquals(serialize("it's"), "E'it\\'s'");
-  assertEquals(serialize("back\\slash"), "E'back\\\\slash'");
-  assertEquals(serialize("tab\there"), "E'tab\\there'");
-  assertEquals(serialize("carriage\rreturn"), "E'carriage\\rreturn'");
-});
-
-test("serialize(): handles numbers", () => {
-  assertEquals(serialize(42), "42");
-  assertEquals(serialize(3.14), "3.14");
-  assertEquals(serialize(-10), "-10");
-  assertEquals(serialize(0), "0");
-});
-
-test("serialize(): handles bigints", () => {
-  assertEquals(serialize(BigInt(9007199254740991)), "9007199254740991");
-});
-
-test("serialize(): handles booleans", () => {
-  assertEquals(serialize(true), "'t'");
-  assertEquals(serialize(false), "'f'");
-});
-
-test("serialize(): handles Date objects", () => {
-  const date = new Date("2024-01-15T10:30:00.000Z");
-  assertEquals(serialize(date), "'2024-01-15T10:30:00.000Z'");
-});
-
-test("serialize(): handles arrays", () => {
-  assertEquals(serialize([1, 2, 3]), "ARRAY[1, 2, 3]");
-  assertEquals(serialize(["a", "b"]), "ARRAY['a', 'b']");
-  assertEquals(serialize([]), "ARRAY[]");
-});
-
-test("serialize(): handles nested arrays", () => {
-  assertEquals(serialize([[1, 2], [3, 4]]), "ARRAY[ARRAY[1, 2], ARRAY[3, 4]]");
-});
-
-test("serialize(): handles objects as JSON", () => {
-  assertEquals(serialize({ key: "value" }), '\'{"key":"value"}\'');
-  assertEquals(serialize({ nested: { a: 1 } }), '\'{"nested":{"a":1}}\'');
-});
-
-test("serialize(): handles mixed arrays", () => {
-  assertEquals(serialize([1, "two", true]), "ARRAY[1, 'two', 't']");
-});
-
-// ============================================
-// String Literal Tests
-// ============================================
-
-test("stringLiteral(): wraps simple strings", () => {
-  assertEquals(stringLiteral("hello"), "'hello'");
-  assertEquals(stringLiteral("world"), "'world'");
-});
-
-test("stringLiteral(): escapes single quotes", () => {
-  assertEquals(stringLiteral("it's"), "E'it\\'s'");
-  assertEquals(stringLiteral("don't"), "E'don\\'t'");
-});
-
-test("stringLiteral(): escapes backslashes", () => {
-  assertEquals(stringLiteral("back\\slash"), "E'back\\\\slash'");
-});
-
-test("stringLiteral(): escapes newlines", () => {
-  assertEquals(stringLiteral("line1\nline2"), "E'line1\\nline2'");
-});
-
-test("stringLiteral(): escapes carriage returns", () => {
-  assertEquals(stringLiteral("line1\rline2"), "E'line1\\rline2'");
-});
-
-test("stringLiteral(): escapes tabs", () => {
-  assertEquals(stringLiteral("col1\tcol2"), "E'col1\\tcol2'");
-});
-
-test("stringLiteral(): escapes multiple special characters", () => {
-  assertEquals(
-    stringLiteral("it's\na\ttest\\"),
-    "E'it\\'s\\na\\ttest\\\\'",
-  );
-});
-
-test("stringLiteral(): handles empty string", () => {
-  assertEquals(stringLiteral(""), "''");
-});
-
-// ============================================
-// DrizzleLogger Class Tests
-// ============================================
-
-test("DrizzleLogger: can be instantiated directly", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const { getLogger: getLogtapeLogger } = await import("@logtape/logtape");
-    const logtapeLogger = getLogtapeLogger(["custom"]);
-    const drizzleLogger = new DrizzleLogger(logtapeLogger, "info");
-
-    drizzleLogger.logQuery("SELECT 1", []);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["custom"]);
-    assertEquals(logs[0].level, "info");
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Complex Query Tests
-// ============================================
-
-test("logQuery(): handles INSERT with multiple values", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery(
-      "INSERT INTO users (name, email, age) VALUES ($1, $2, $3)",
-      ["John Doe", "john@example.com", 30],
-    );
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "INSERT INTO users (name, email, age) VALUES ('John Doe', 'john@example.com', 30)",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles UPDATE with JSON data", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery(
-      "UPDATE users SET metadata = $1 WHERE id = $2",
-      [{ role: "admin", permissions: ["read", "write"] }, 1],
-    );
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      'UPDATE users SET metadata = \'{"role":"admin","permissions":["read","write"]}\' WHERE id = 1',
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles DELETE query", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery(
-      "DELETE FROM sessions WHERE expires_at < $1",
-      [new Date("2024-01-01T00:00:00.000Z")],
-    );
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "DELETE FROM sessions WHERE expires_at < '2024-01-01T00:00:00.000Z'",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles array parameter for IN clause", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery(
-      "SELECT * FROM users WHERE id = ANY($1)",
-      [[1, 2, 3]],
-    );
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "SELECT * FROM users WHERE id = ANY(ARRAY[1, 2, 3])",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles null parameter", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery(
-      "UPDATE users SET deleted_at = $1 WHERE id = $2",
-      [null, 1],
-    );
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "UPDATE users SET deleted_at = NULL WHERE id = 1",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles boolean parameters", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery(
-      "SELECT * FROM users WHERE active = $1 AND verified = $2",
-      [true, false],
-    );
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "SELECT * FROM users WHERE active = 't' AND verified = 'f'",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Edge Cases
-// ============================================
-
-test("logQuery(): handles empty string parameter", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery("INSERT INTO users (name) VALUES ($1)", [""]);
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "INSERT INTO users (name) VALUES ('')",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles very long query", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    const longValue = "x".repeat(10000);
-    logger.logQuery("SELECT * FROM users WHERE data = $1", [longValue]);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.params, [longValue]);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      `SELECT * FROM users WHERE data = '${longValue}'`,
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles multiple consecutive calls", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    logger.logQuery("SELECT 1", []);
-    logger.logQuery("SELECT 2", []);
-    logger.logQuery("SELECT 3", []);
-
-    assertEquals(logs.length, 3);
-    assertEquals(logs[0].properties.formattedQuery, "SELECT 1");
-    assertEquals(logs[1].properties.formattedQuery, "SELECT 2");
-    assertEquals(logs[2].properties.formattedQuery, "SELECT 3");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("logQuery(): handles high placeholder numbers", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    // Build an array of 100 items: index 0="a", index 9="j", index 99="hundred"
-    const params = Array(100).fill("x");
-    params[0] = "a"; // $1
-    params[9] = "j"; // $10
-    params[99] = "hundred"; // $100
-    logger.logQuery(
-      "SELECT * FROM t WHERE a=$1 AND b=$10 AND c=$100",
-      params,
-    );
-
-    assertEquals(logs.length, 1);
-    assertEquals(
-      logs[0].properties.formattedQuery,
-      "SELECT * FROM t WHERE a='a' AND b='j' AND c='hundred'",
-    );
-  } finally {
-    await cleanup();
-  }
-});
-
-test("serialize(): handles special number values", () => {
-  assertEquals(serialize(Infinity), "Infinity");
-  assertEquals(serialize(-Infinity), "-Infinity");
-  assertEquals(serialize(NaN), "NaN");
-});
-
-test("serialize(): handles negative bigint", () => {
-  assertEquals(serialize(BigInt(-9007199254740991)), "-9007199254740991");
-});
-
-test("serialize(): handles deeply nested objects", () => {
-  const nested = { a: { b: { c: { d: 1 } } } };
-  assertEquals(serialize(nested), '\'{"a":{"b":{"c":{"d":1}}}}\'');
-});
-
-test("serialize(): handles array with null and undefined", () => {
-  assertEquals(serialize([1, null, undefined, 2]), "ARRAY[1, NULL, NULL, 2]");
-});
-
-test("stringLiteral(): handles backspace and form feed", () => {
-  assertEquals(stringLiteral("a\bb"), "E'a\\bb'");
-  assertEquals(stringLiteral("a\fb"), "E'a\\fb'");
-});
-
-// ============================================
-// Type Compatibility Tests
-// ============================================
-
-test("getLogger(): returns Drizzle Logger interface compatible object", async () => {
-  const { cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-
-    // Drizzle's Logger interface only requires logQuery method
-    // Verify it matches the expected signature
-    const drizzleLogger: { logQuery(query: string, params: unknown[]): void } =
-      logger;
-
-    assertEquals(typeof drizzleLogger.logQuery, "function");
-
-    // Verify it can be called with the expected arguments
-    drizzleLogger.logQuery("SELECT 1", []);
-    drizzleLogger.logQuery("SELECT $1", ["test"]);
-    drizzleLogger.logQuery("SELECT $1, $2", [1, "two"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("Logger interface: logQuery returns void", async () => {
-  const { cleanup } = await setupLogtape();
-  try {
-    const logger = getLogger();
-    const result = logger.logQuery("SELECT 1", []);
-
-    assertEquals(result, undefined);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Readonly Category Tests
-// ============================================
-
-test("getLogger(): handles readonly string array category", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const category = ["app", "db"] as const;
-    const logger = getLogger({ category });
-    logger.logQuery("SELECT 1", []);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["app", "db"]);
-  } finally {
-    await cleanup();
-  }
-});

package/src/mod.ts

@@ -1,188 +0,0 @@
-import {
-  getLogger as getLogTapeLogger,
-  type Logger as LogTapeLogger,
-  type LogLevel,
-} from "@logtape/logtape";
-
-export type { LogLevel } from "@logtape/logtape";
-
-/**
- * Options for configuring the Drizzle ORM LogTape logger.
- * @since 1.3.0
- */
-export 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;
-}
-
-/**
- * Drizzle ORM's Logger interface.
- * @since 1.3.0
- */
-export 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
- */
-export class DrizzleLogger implements Logger {
-  readonly #logger: LogTapeLogger;
-  readonly #level: LogLevel;
-
-  /**
-   * Creates a new DrizzleLogger instance.
-   * @param logger The LogTape logger to use.
-   * @param level The log level to use for query logging.
-   */
-  constructor(logger: LogTapeLogger, level: LogLevel = "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: string, params: unknown[]): void {
-    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
- */
-export function serialize(value: unknown): string {
-  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") {
-    // Assume it's a JSON 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
- */
-export function stringLiteral(str: string): string {
-  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", "\\t");
-    escaped = escaped.replaceAll("\b", "\\b");
-    escaped = escaped.replaceAll("\f", "\\f");
-    return `E'${escaped}'`;
-  }
-  return `'${str}'`;
-}
-
-/**
- * Normalize category to array format.
- */
-function normalizeCategory(
-  category: string | readonly string[],
-): readonly string[] {
-  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
- */
-export function getLogger(options: DrizzleLoggerOptions = {}): DrizzleLogger {
-  const category = normalizeCategory(options.category ?? ["drizzle-orm"]);
-  const logger = getLogTapeLogger(category);
-  return new DrizzleLogger(logger, options.level ?? "debug");
-}

package/tsdown.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-  entry: "src/mod.ts",
-  dts: {
-    sourcemap: true,
-  },
-  format: ["esm", "cjs"],
-  platform: "neutral",
-  unbundle: true,
-});