@unhandled/instrumentation-drizzle 0.0.0-stage → 0.0.1

package/README.md

@@ -1,3 +1,74 @@
-# Temporary Holding Version
+# @unhandled/instrumentation-drizzle
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Traces [Drizzle ORM](https://orm.drizzle.team) queries and prepared queries as `CLIENT` spans. Needs `drizzle-orm >= 0.28.0` and your own database driver. This package is opt-in: the AdonisJS agent never enables it, and it has no `/integration` entry.
+
+## Install
+
+```sh
+npm i @unhandled/instrumentation-drizzle
+```
+
+## Use
+
+Initialise OpenTelemetry first, then pick exactly one entry point per database.
+
+Wrap the database returned by `drizzle()` (works with any Drizzle driver):
+
+```ts
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { instrumentDrizzleClient } from '@unhandled/instrumentation-drizzle'
+
+export const db = instrumentDrizzleClient(drizzle(pool), { dbSystem: 'postgresql', dbName: 'app' })
+```
+
+Or wrap the node-postgres `Pool` or `Client` before handing it to `drizzle()`:
+
+```ts
+import { instrumentDrizzle } from '@unhandled/instrumentation-drizzle'
+
+export const db = drizzle(instrumentDrizzle(pool, { dbSystem: 'postgresql', dbName: 'app' }))
+```
+
+Do not use both on the same database. Every query would be traced twice, once at the Drizzle layer and once at the driver, with the driver span nested inside the other.
+
+## Config
+
+| Option               | Default   | Effect                                                                      |
+| -------------------- | --------- | --------------------------------------------------------------------------- |
+| `dbSystem`           | `unknown` | Value of `db.system.name`: `postgresql`, `mysql`, `sqlite`. Set it.         |
+| `dbName`             | none      | `db.namespace`                                                              |
+| `peerName`           | none      | `server.address`, the database host                                         |
+| `peerPort`           | none      | `server.port`                                                               |
+| `captureQueryText`   | `true`    | `false` leaves `db.query.text` off every span                               |
+| `maxQueryTextLength` | `1000`    | Query text is cut to this many characters. Operation and table still come from the full SQL. |
+
+SQL text can contain sensitive literals. Bound parameters are never recorded, and a failed query's span carries the driver's error message rather than Drizzle's wrapper, which embeds the parameters.
+
+## Spans
+
+Every span is `CLIENT` kind, named `<OPERATION> <table>` (`SELECT users`), or just the operation when no table can be parsed. A prepared query produces one span per execution.
+
+| Attribute            | Value                                                    |
+| -------------------- | -------------------------------------------------------- |
+| `db.system.name`     | `dbSystem`                                               |
+| `db.query.text`      | SQL with placeholders, truncated, when captured          |
+| `db.operation.name`  | Upper-cased first keyword, for example `SELECT`          |
+| `db.collection.name` | Target table when it can be parsed                       |
+| `db.namespace`       | `dbName`                                                 |
+| `server.address`     | `peerName`                                               |
+| `server.port`        | `peerPort`                                               |
+| `db.transaction`     | `true` for queries inside a transaction                  |
+| `error.type`         | Error class name on failures, plus the recorded exception and `ERROR` status |
+
+### Transactions
+
+- `instrumentDrizzle` sees what the connection sees, so `BEGIN`, `COMMIT`, `ROLLBACK`, savepoints and every query between them are spans flagged `db.transaction`.
+- `instrumentDrizzleClient` traces queries run through `db.transaction` and flags them. The control statements Drizzle issues itself (`BEGIN`, `COMMIT`, `ROLLBACK`, savepoints) are not traced.
+
+### Drizzle's own spans
+
+When `@opentelemetry/api` is installed, Drizzle itself emits `drizzle.*` spans under the `drizzle-orm` scope. They are independent of this package and cannot be turned off from here.
+
+## Drivers
+
+`instrumentDrizzleClient` patches the session behind `db`, so it is driver-agnostic. `instrumentDrizzle` wraps `query()` on a node-postgres `Pool` (including the clients it hands out) or `Client`; any other object throws a `TypeError`.

package/build/guards.d.ts

@@ -0,0 +1,3 @@
+export type Method = (...args: unknown[]) => unknown;
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const isMethod: (value: unknown) => value is Method;

package/build/guards.js

@@ -0,0 +1,2 @@
+export const isRecord = (value) => typeof value === "object" && value !== null;
+export const isMethod = (value) => typeof value === "function";

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export { instrumentDrizzleClient } from "./instrument_client.ts";
+export { instrumentDrizzle } from "./instrument_driver.ts";
+export type { ParsedSql } from "./sql_parser.ts";
+export { parseSql } from "./sql_parser.ts";
+export type { InstrumentDrizzleConfig } from "./types.ts";

package/build/index.js

@@ -0,0 +1,3 @@
+export { instrumentDrizzleClient } from "./instrument_client.js";
+export { instrumentDrizzle } from "./instrument_driver.js";
+export { parseSql } from "./sql_parser.js";

package/build/instrument_client.d.ts

@@ -0,0 +1,2 @@
+import type { InstrumentDrizzleConfig } from "./types.ts";
+export declare const instrumentDrizzleClient: <TDb extends object>(db: TDb, config?: InstrumentDrizzleConfig) => TDb;

package/build/instrument_client.js

@@ -0,0 +1,75 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { isMethod, isRecord } from "./guards.js";
+import { resolveSettings, runTraced, startQuerySpan } from "./query_span.js";
+import { isTransactionControl } from "./transaction_state.js";
+const EXECUTION_METHODS = ["execute", "all", "get", "values", "run"];
+const instrumentedSessions = new WeakSet();
+const transactionSessions = new AsyncLocalStorage();
+const isSession = (value) => isRecord(value) && isMethod(value.prepareQuery);
+const sessionOf = (db) => (isRecord(db) && isSession(db.session) ? db.session : undefined);
+const sqlOf = (query) => (isRecord(query) && typeof query.sql === "string" ? query.sql : undefined);
+const instrumentPreparedQuery = (prepared, sql, session, settings) => {
+    let running = false;
+    for (const name of EXECUTION_METHODS) {
+        const original = prepared[name];
+        if (!isMethod(original)) {
+            continue;
+        }
+        prepared[name] = (...args) => {
+            if (running) {
+                return Reflect.apply(original, prepared, args);
+            }
+            const inTransaction = transactionSessions.getStore()?.has(session) === true;
+            const query = startQuerySpan(settings, sql, inTransaction);
+            running = true;
+            try {
+                return runTraced(query, () => Reflect.apply(original, prepared, args));
+            }
+            finally {
+                running = false;
+            }
+        };
+    }
+};
+const instrumentSession = (session, settings) => {
+    if (instrumentedSessions.has(session)) {
+        return;
+    }
+    instrumentedSessions.add(session);
+    const { prepareQuery } = session;
+    session.prepareQuery = (...args) => {
+        const prepared = Reflect.apply(prepareQuery, session, args);
+        const sql = sqlOf(args[0]);
+        if (sql !== undefined && isRecord(prepared) && !isTransactionControl(sql)) {
+            instrumentPreparedQuery(prepared, sql, session, settings);
+        }
+        return prepared;
+    };
+    const { transaction } = session;
+    if (!isMethod(transaction)) {
+        return;
+    }
+    session.transaction = (callback, ...rest) => {
+        if (!isMethod(callback)) {
+            return Reflect.apply(transaction, session, [callback, ...rest]);
+        }
+        const traced = (tx) => {
+            const transactionSession = sessionOf(tx);
+            if (!transactionSession) {
+                return callback(tx);
+            }
+            instrumentSession(transactionSession, settings);
+            const sessions = new Set([...(transactionSessions.getStore() ?? []), transactionSession]);
+            return transactionSessions.run(sessions, () => callback(tx));
+        };
+        return Reflect.apply(transaction, session, [traced, ...rest]);
+    };
+};
+export const instrumentDrizzleClient = (db, config = {}) => {
+    const session = sessionOf(db);
+    if (!session) {
+        throw new TypeError("instrumentDrizzleClient() expects the database returned by drizzle(); it has no session to instrument.");
+    }
+    instrumentSession(session, resolveSettings(config));
+    return db;
+};

package/build/instrument_driver.d.ts

@@ -0,0 +1,2 @@
+import type { InstrumentDrizzleConfig } from "./types.ts";
+export declare const instrumentDrizzle: <TClient extends object>(client: TClient, config?: InstrumentDrizzleConfig) => TClient;

package/build/instrument_driver.js

@@ -0,0 +1,95 @@
+import { context } from "@opentelemetry/api";
+import { isMethod, isRecord } from "./guards.js";
+import { resolveSettings, runTraced, startQuerySpan } from "./query_span.js";
+import { transactionEffect } from "./transaction_state.js";
+const instrumentedClients = new WeakSet();
+const queryTextOf = (query) => {
+    if (typeof query === "string") {
+        return query;
+    }
+    return isRecord(query) && typeof query.text === "string" && !isMethod(query.submit) ? query.text : undefined;
+};
+const instrumentQuery = (client, original, settings) => {
+    let inTransaction = false;
+    client.query = (...args) => {
+        const sql = queryTextOf(args[0]);
+        if (sql === undefined) {
+            return Reflect.apply(original, client, args);
+        }
+        const effect = transactionEffect(sql);
+        const wasInTransaction = inTransaction;
+        if (effect === "begin") {
+            inTransaction = true;
+        }
+        const span = startQuerySpan(settings, sql, inTransaction);
+        const query = {
+            context: span.context,
+            end: (error) => {
+                if (effect === "begin" && error !== undefined) {
+                    inTransaction = wasInTransaction;
+                }
+                if (effect === "end") {
+                    inTransaction = false;
+                }
+                span.end(error);
+            },
+        };
+        const callback = args.at(-1);
+        if (!isMethod(callback)) {
+            return runTraced(query, () => Reflect.apply(original, client, args));
+        }
+        const parent = context.active();
+        const traced = (error, ...rest) => {
+            query.end(error ?? undefined);
+            return context.with(parent, () => Reflect.apply(callback, undefined, [error, ...rest]));
+        };
+        try {
+            return context.with(query.context, () => Reflect.apply(original, client, [...args.slice(0, -1), traced]));
+        }
+        catch (error) {
+            query.end(error);
+            throw error;
+        }
+    };
+};
+const instrumentClient = (client, settings) => {
+    if (!isRecord(client) || instrumentedClients.has(client) || !isMethod(client.query)) {
+        return;
+    }
+    instrumentedClients.add(client);
+    instrumentQuery(client, client.query, settings);
+};
+const instrumentPoolConnections = (pool, settings) => {
+    const { connect } = pool;
+    if (!isMethod(connect)) {
+        return;
+    }
+    pool.connect = (...args) => {
+        const callback = args.at(-1);
+        if (isMethod(callback)) {
+            const instrumented = (error, client, ...rest) => {
+                instrumentClient(client, settings);
+                return Reflect.apply(callback, undefined, [error, client, ...rest]);
+            };
+            return Reflect.apply(connect, pool, [...args.slice(0, -1), instrumented]);
+        }
+        return Promise.resolve(Reflect.apply(connect, pool, args)).then((client) => {
+            instrumentClient(client, settings);
+            return client;
+        });
+    };
+};
+const isPgPool = (client) => typeof client.totalCount === "number" && typeof client.idleCount === "number";
+export const instrumentDrizzle = (client, config = {}) => {
+    if (!(isRecord(client) && isMethod(client.query))) {
+        throw new TypeError("instrumentDrizzle() expects a node-postgres Pool or Client (an object with query()). Use instrumentDrizzleClient() on the drizzle() result for other drivers.");
+    }
+    const settings = resolveSettings(config);
+    if (isPgPool(client)) {
+        instrumentPoolConnections(client, settings);
+    }
+    else {
+        instrumentClient(client, settings);
+    }
+    return client;
+};

package/build/query_span.d.ts

@@ -0,0 +1,10 @@
+import { type Context } from "@opentelemetry/api";
+import type { InstrumentDrizzleConfig, SpanSettings } from "./types.ts";
+export interface QuerySpan {
+    context: Context;
+    end: (error?: unknown) => void;
+}
+export declare const resolveSettings: (config?: InstrumentDrizzleConfig) => SpanSettings;
+export declare const isPromiseLike: (value: unknown) => value is PromiseLike<unknown>;
+export declare const startQuerySpan: (settings: SpanSettings, sql: string, inTransaction: boolean) => QuerySpan;
+export declare const runTraced: (query: QuerySpan, call: () => unknown) => unknown;

package/build/query_span.js

@@ -0,0 +1,92 @@
+import { context, SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
+import { ATTR } from "@unhandled/protocol";
+import { parseSql } from "./sql_parser.js";
+const INSTRUMENTATION_NAME = "@unhandled/instrumentation-drizzle";
+const INSTRUMENTATION_VERSION = "0.1.0";
+const DEFAULT_MAX_QUERY_TEXT_LENGTH = 1000;
+export const resolveSettings = (config = {}) => ({
+    dbSystem: config.dbSystem ?? "unknown",
+    dbName: config.dbName,
+    peerName: config.peerName,
+    peerPort: config.peerPort,
+    captureQueryText: config.captureQueryText ?? true,
+    maxQueryTextLength: config.maxQueryTextLength ?? DEFAULT_MAX_QUERY_TEXT_LENGTH,
+});
+export const isPromiseLike = (value) => typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+// Drizzle wraps driver failures in an error whose message embeds the SQL and its bound parameters.
+const unwrapDriverError = (error) => error instanceof Error && "query" in error && "params" in error && error.cause !== undefined ? error.cause : error;
+const failure = (error) => {
+    const cause = unwrapDriverError(error);
+    return cause instanceof Error ? cause : new Error(String(cause));
+};
+export const startQuerySpan = (settings, sql, inTransaction) => {
+    const { operation, collection } = parseSql(sql);
+    const attributes = { [ATTR.dbSystemName]: settings.dbSystem };
+    if (settings.captureQueryText) {
+        attributes[ATTR.dbQueryText] = sql.slice(0, settings.maxQueryTextLength);
+    }
+    if (operation) {
+        attributes[ATTR.dbOperationName] = operation;
+    }
+    if (collection) {
+        attributes[ATTR.dbCollectionName] = collection;
+    }
+    if (settings.dbName) {
+        attributes[ATTR.dbNamespace] = settings.dbName;
+    }
+    if (settings.peerName) {
+        attributes[ATTR.serverAddress] = settings.peerName;
+    }
+    if (settings.peerPort !== undefined) {
+        attributes[ATTR.serverPort] = settings.peerPort;
+    }
+    if (inTransaction) {
+        attributes[ATTR.dbTransaction] = true;
+    }
+    let name = settings.dbSystem;
+    if (operation) {
+        name = collection ? `${operation} ${collection}` : operation;
+    }
+    const parent = context.active();
+    const span = trace
+        .getTracer(INSTRUMENTATION_NAME, INSTRUMENTATION_VERSION)
+        .startSpan(name, { kind: SpanKind.CLIENT, attributes }, parent);
+    let ended = false;
+    return {
+        context: trace.setSpan(parent, span),
+        end: (error) => {
+            if (ended) {
+                return;
+            }
+            ended = true;
+            if (error !== undefined) {
+                const cause = failure(error);
+                span.setAttribute(ATTR.errorType, cause.name);
+                span.recordException(cause);
+                span.setStatus({ code: SpanStatusCode.ERROR, message: cause.message });
+            }
+            span.end();
+        },
+    };
+};
+export const runTraced = (query, call) => {
+    let result;
+    try {
+        result = context.with(query.context, call);
+    }
+    catch (error) {
+        query.end(error);
+        throw error;
+    }
+    if (!isPromiseLike(result)) {
+        query.end();
+        return result;
+    }
+    return Promise.resolve(result).then((value) => {
+        query.end();
+        return value;
+    }, (error) => {
+        query.end(error);
+        throw error;
+    });
+};

package/build/sql_parser.d.ts

@@ -0,0 +1,5 @@
+export interface ParsedSql {
+    collection?: string;
+    operation?: string;
+}
+export declare const parseSql: (sql: string) => ParsedSql;

package/build/sql_parser.js

@@ -0,0 +1,151 @@
+const WHITESPACE_CHAR_PATTERN = /\s/;
+const STATEMENTS = new Set(["SELECT", "INSERT", "UPDATE", "DELETE", "MERGE"]);
+const DDL = new Set(["CREATE", "ALTER", "DROP", "TRUNCATE"]);
+const WORD = /[A-Za-z_]/;
+const WORD_PART = /[\w$]/;
+const skipBlanks = (sql, from) => {
+    let index = from;
+    while (index < sql.length) {
+        if (WHITESPACE_CHAR_PATTERN.test(sql[index])) {
+            index += 1;
+        }
+        else if (sql.startsWith("--", index)) {
+            const end = sql.indexOf("\n", index);
+            index = end === -1 ? sql.length : end + 1;
+        }
+        else if (sql.startsWith("/*", index)) {
+            const end = sql.indexOf("*/", index + 2);
+            index = end === -1 ? sql.length : end + 2;
+        }
+        else {
+            break;
+        }
+    }
+    return index;
+};
+const skipQuoted = (sql, from, close) => {
+    let index = from + 1;
+    while (index < sql.length) {
+        if (sql[index] === close) {
+            if (sql[index + 1] === close) {
+                index += 2;
+                continue;
+            }
+            return index + 1;
+        }
+        index += 1;
+    }
+    return sql.length;
+};
+const readWord = (sql, from) => {
+    if (!WORD.test(sql[from] ?? "")) {
+        return undefined;
+    }
+    let end = from + 1;
+    while (end < sql.length && WORD_PART.test(sql[end])) {
+        end += 1;
+    }
+    return { text: sql.slice(from, end), end };
+};
+const findKeyword = (sql, keywords, from) => {
+    let depth = 0;
+    let index = from;
+    while (index < sql.length) {
+        const char = sql[index];
+        if (char === "'" || char === '"' || char === "`") {
+            index = skipQuoted(sql, index, char);
+        }
+        else if (char === "[") {
+            index = skipQuoted(sql, index, "]");
+        }
+        else if (char === "(") {
+            depth += 1;
+            index += 1;
+        }
+        else if (char === ")") {
+            depth -= 1;
+            index += 1;
+        }
+        else if (WORD.test(char) && (index === 0 || !WORD_PART.test(sql[index - 1]))) {
+            const word = readWord(sql, index);
+            if (word && depth === 0 && keywords.has(word.text.toUpperCase())) {
+                return word;
+            }
+            index = word ? word.end : index + 1;
+        }
+        else {
+            index += 1;
+        }
+    }
+    return undefined;
+};
+const readIdentifier = (sql, from) => {
+    const char = sql[from];
+    if (char === '"' || char === "`" || char === "[") {
+        const end = skipQuoted(sql, from, char === "[" ? "]" : char);
+        return { text: sql.slice(from + 1, end - 1), end };
+    }
+    return readWord(sql, from);
+};
+const readQualifiedName = (sql, from) => {
+    const parts = [];
+    let index = skipBlanks(sql, from);
+    for (;;) {
+        const part = readIdentifier(sql, index);
+        if (!part) {
+            break;
+        }
+        parts.push(part.text);
+        const next = skipBlanks(sql, part.end);
+        if (sql[next] !== ".") {
+            break;
+        }
+        index = skipBlanks(sql, next + 1);
+    }
+    return parts.length > 0 ? parts.join(".") : undefined;
+};
+const SKIPPED_MODIFIERS = new Set(["ONLY", "IF", "NOT", "EXISTS"]);
+const readTarget = (sql, from) => {
+    let index = skipBlanks(sql, from);
+    for (;;) {
+        const word = readWord(sql, index);
+        if (!(word && SKIPPED_MODIFIERS.has(word.text.toUpperCase()))) {
+            break;
+        }
+        index = skipBlanks(sql, word.end);
+    }
+    return readQualifiedName(sql, index);
+};
+const statementStart = (sql, from) => {
+    const first = readWord(sql, from);
+    if (first?.text.toUpperCase() !== "WITH") {
+        return from;
+    }
+    const main = findKeyword(sql, STATEMENTS, first.end);
+    return main ? main.end - main.text.length : from;
+};
+export const parseSql = (sql) => {
+    const start = statementStart(sql, skipBlanks(sql, 0));
+    const first = readWord(sql, start);
+    if (!first) {
+        return {};
+    }
+    const operation = first.text.toUpperCase();
+    const after = first.end;
+    if (operation === "SELECT" || operation === "DELETE") {
+        const from = findKeyword(sql, new Set(["FROM"]), after);
+        return { operation, collection: from ? readTarget(sql, from.end) : undefined };
+    }
+    if (operation === "INSERT" || operation === "MERGE") {
+        const into = findKeyword(sql, new Set(["INTO"]), after);
+        return { operation, collection: into ? readTarget(sql, into.end) : undefined };
+    }
+    if (operation === "UPDATE") {
+        return { operation, collection: readTarget(sql, after) };
+    }
+    if (DDL.has(operation)) {
+        const table = findKeyword(sql, new Set(["TABLE"]), after);
+        return { operation, collection: table ? readTarget(sql, table.end) : undefined };
+    }
+    return { operation };
+};

package/build/transaction_state.d.ts

@@ -0,0 +1,3 @@
+export type TransactionEffect = "begin" | "end";
+export declare const transactionEffect: (sql: string) => TransactionEffect | undefined;
+export declare const isTransactionControl: (sql: string) => boolean;

package/build/transaction_state.js

@@ -0,0 +1,20 @@
+import { parseSql } from "./sql_parser.js";
+const ROLLBACK_TO_SAVEPOINT = /^\s*rollback\s+(?:work\s+|transaction\s+)?to\b/i;
+export const transactionEffect = (sql) => {
+    const { operation } = parseSql(sql);
+    if (operation === "BEGIN" || operation === "START") {
+        return "begin";
+    }
+    if (operation === "COMMIT" || operation === "END") {
+        return "end";
+    }
+    if (operation === "ROLLBACK" && !ROLLBACK_TO_SAVEPOINT.test(sql)) {
+        return "end";
+    }
+    return undefined;
+};
+const CONTROL_OPERATIONS = new Set(["BEGIN", "START", "COMMIT", "END", "ROLLBACK", "ABORT", "SAVEPOINT", "RELEASE"]);
+export const isTransactionControl = (sql) => {
+    const { operation } = parseSql(sql);
+    return operation !== undefined && CONTROL_OPERATIONS.has(operation);
+};

package/build/types.d.ts

@@ -0,0 +1,16 @@
+export interface InstrumentDrizzleConfig {
+    captureQueryText?: boolean;
+    dbName?: string;
+    dbSystem?: string;
+    maxQueryTextLength?: number;
+    peerName?: string;
+    peerPort?: number;
+}
+export interface SpanSettings {
+    captureQueryText: boolean;
+    dbName?: string;
+    dbSystem: string;
+    maxQueryTextLength: number;
+    peerName?: string;
+    peerPort?: number;
+}

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@unhandled/instrumentation-drizzle",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.1",
+  "description": "Drizzle ORM query tracing for Unhandled",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/treboryx/unhandled.git",
+    "directory": "packages/instrumentation-drizzle"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    }
+  },
+  "files": [
+    "build"
+  ],
+  "dependencies": {
+    "@opentelemetry/api": "~1.9.1",
+    "@opentelemetry/core": "^2.12.0",
+    "@unhandled/protocol": "0.0.1"
+  },
+  "devDependencies": {
+    "@adonisjs/tsconfig": "^2.0.0",
+    "@opentelemetry/context-async-hooks": "^2.12.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.223.0",
+    "@opentelemetry/sdk-trace-base": "^2.12.0",
+    "@types/node": "^25.9.9",
+    "@types/pg": "^8.23.1",
+    "@unhandled/otlp-receiver": "0.0.0",
+    "drizzle-orm": "^0.45.4",
+    "pg": "^8.23.1",
+    "typescript": "~6.0.2"
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.28.0"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "test": "node --test 'tests/**/*.test.ts'",
+    "typecheck": "tsrs --noEmit",
+    "typecheck:tsc": "tsc --noEmit"
+  }
 }