@frogfish/k2db 2.0.7 → 3.0.1

package/README.md

@@ -23,9 +23,10 @@ Where it fits in the stack
 
 Deployment tips (Nomad, Lambda, etc.)
 - Environments: Targets Node.js runtimes (Node 18/20). Not suitable for non‑TCP “edge JS” (e.g., Cloudflare Workers) that cannot open Mongo sockets.
-- Connection reuse: Create one `K2DB` instance per process and reuse it.
-  - Lambda: instantiate outside the handler and `await init()` lazily once.
-  - Nomad: init on service start; reuse for the lifetime of the task.
+- Connection reuse: Create and reuse `K2DB` instances.
+  - The underlying MongoDB connection pool is shared across `K2DB` instances created with the same cluster/auth settings (hosts/user/password/authSource/replicaset).
+  - This means you can safely keep one `K2DB` instance per logical database name (`name`) without creating a new TCP pool per database.
+  - `release()` is ref-counted: it only closes the shared pool when the last instance releases it.
 - Example (AWS Lambda):
   ```ts
   import { K2DB } from "@frogfish/k2db";
@@ -38,7 +39,24 @@ Deployment tips (Nomad, Lambda, etc.)
     return { statusCode: 200, body: JSON.stringify(res) };
   };
   ```
-- Pooling and timeouts: The driver manages a small pool by default.
+  If you serve multiple logical databases (multi-project / multi-tenant), cache `K2DB` by database name. Instances will still share a single underlying connection pool:
+
+  ```ts
+  import { K2DB } from "@frogfish/k2db";
+
+  const base = { hosts: [{ host: "cluster0.example.mongodb.net" }], user: process.env.DB_USER, password: process.env.DB_PASS };
+  const byName = new Map<string, K2DB>();
+
+  function dbFor(name: string) {
+    let db = byName.get(name);
+    if (!db) {
+      db = new K2DB({ ...base, name });
+      byName.set(name, db);
+    }
+    return db;
+  }
+  ```
+- Pooling and timeouts: The MongoDB driver manages a small pool by default, and k2db reuses that pool across `K2DB` instances that share cluster/auth config.
   - Serverless: keep `minPoolSize=0` (default), consider `maxIdleTimeMS` to drop idle sockets faster.
   - Long‑lived services (Nomad): you can tune pool sizing if needed.
   - You can adjust `connectTimeoutMS/serverSelectionTimeoutMS` in the code if your environment needs higher values.
@@ -90,10 +108,11 @@ Config
 import { K2DB } from "@frogfish/k2db";
 
 const db = new K2DB({
-  name: "mydb",
+  name: "mydb", // logical database name; instances with the same hosts/auth share one connection pool
   hosts: [{ host: "cluster0.example.mongodb.net" }], // SRV if single host without port
   user: process.env.DB_USER,
   password: process.env.DB_PASS,
+  authSource: process.env.DB_AUTH_SOURCE, // optional (defaults to "admin" when user+password provided)
   slowQueryMs: 300,
   hooks: {
     beforeQuery: (op, d) => {},
@@ -107,7 +126,19 @@ await db.ensureIndexes("myCollection");
 
 Environment loader
 ```ts
-const conf = K2DB.fromEnv(); // K2DB_NAME, K2DB_HOSTS, K2DB_USER, K2DB_PASSWORD, K2DB_REPLICASET, K2DB_SLOW_MS
+const conf = K2DB.fromEnv(); // K2DB_NAME (logical db), K2DB_HOSTS, K2DB_USER, K2DB_PASSWORD, K2DB_AUTH_SOURCE, K2DB_REPLICASET, K2DB_SLOW_MS
+```
+
+Testing
+
+If you run many test suites in a single Node process and want to fully tear down shared MongoDB pools between suites, you can use the test helper:
+
+```ts
+import { resetSharedMongoClientsForTests } from "@frogfish/k2db";
+
+afterAll(async () => {
+  await resetSharedMongoClientsForTests();
+});
 ```
 
 Tips
@@ -168,6 +199,7 @@ export K2DB_NAME=mydb
 export K2DB_HOSTS=cluster0.xxxxxx.mongodb.net
 export K2DB_USER=your_user
 export K2DB_PASSWORD=your_pass
+export K2DB_AUTH_SOURCE=admin
 node hello.mjs
 ```
 ```ts
@@ -194,7 +226,7 @@ const db = new K2DB({
   password: process.env.DB_PASS,
 });
 
-await db.init();
+await db.init(); // safe to call multiple times; concurrent calls are deduped
 await db.ensureIndexes("hello"); // unique _uuid among non-deleted, plus helpful indexes
 
 // Create a document (owner is required)
@@ -302,7 +334,7 @@ _uuid = Crockford Base32 encoded UUID V7, Uppercase, with hyphens
 
 0J4F2-H6M8Q-7RX4V-9D3TN-8K2WZ
 
-// Canonical uppercase form with hyphens
+// Canonical uppercase form with hyphens Crockford 32
 const CROCKFORD_ID_REGEX = /^[0-9A-HJKMNP-TV-Z]{5}-[0-9A-HJKMNP-TV-Z]{5}-[0-9A-HJKMNP-TV-Z]{5}-[0-9A-HJKMNP-TV-Z]{5}-[0-9A-HJKMNP-TV-Z]{6}$/;
 
 // Example usage:

package/{dist/db.d.ts → db.d.ts}

@@ -1,5 +1,12 @@
 import { ObjectId } from "mongodb";
 import { ZodTypeAny } from "zod";
+/**
+ * Test helper: fully reset the shared MongoClient pool.
+ *
+ * Not for production usage; intended for test runners to clean up
+ * between suites without restarting the process.
+ */
+export declare function resetSharedMongoClientsForTests(): Promise<void>;
 export interface HostConfig {
     host: string;
     port?: number;
@@ -8,6 +15,7 @@ export interface DatabaseConfig {
     name: string;
     user?: string;
     password?: string;
+    authSource?: string;
     hosts?: HostConfig[];
     replicaset?: string;
     slowQueryMs?: number;
@@ -63,6 +71,9 @@ export declare class K2DB {
     private conf;
     private db;
     private connection;
+    private clientKey?;
+    private initialized;
+    private initPromise?;
     private schemas;
     constructor(conf: DatabaseConfig);
     /**
@@ -240,12 +251,6 @@ export declare class K2DB {
      * Optional: Checks the health of the database connection.
      */
     isHealthy(): Promise<boolean>;
-    /**
-     * Utility to normalize the error type.
-     * @param err - The caught error of type `unknown`.
-     * @returns A normalized error of type `Error`.
-     */
-    private normalizeError;
     /** Name of the history collection for a given collection. */
     private historyName;
     /** Register a Zod schema for a collection. */

package/{dist/db.js → db.js}

@@ -1,10 +1,82 @@
 // src/db.ts
-import { K2Error, ServiceError } from "@frogfish/k2error"; // Keep the existing error structure
+import { K2Error, ServiceError, wrap } from "@frogfish/k2error"; // Keep the existing error structure
 import { MongoClient, } from "mongodb";
-import { randomBytes } from "crypto";
-import debugLib from "debug";
+import { randomBytes, createHash } from "crypto";
+// import debugLib from "debug";
+import { Topic } from '@frogfish/ratatouille';
 import { z } from "zod";
-const debug = debugLib("k2:db");
+// const debug = debugLib("k2:db");
+const debug = Topic('k2db#random');
+function _hashSecret(secret) {
+    return createHash("sha256").update(secret).digest("hex");
+}
+// ---- Shared MongoClient pool (per cluster+auth), reused across DB names ----
+const _clientByKey = new Map();
+const _connectingByKey = new Map();
+const _refCountByKey = new Map();
+function _hostsKey(hosts) {
+    const hs = hosts ?? [];
+    return hs
+        .map((h) => `${h.host}:${h.port ?? ""}`)
+        .sort()
+        .join(",");
+}
+/**
+ * Cache key for a MongoClient pool. Intentionally excludes `conf.name` (db name),
+ * so multiple DBs share the same connection pool.
+ */
+function _clientCacheKey(conf) {
+    const user = conf.user ?? "";
+    const pass = conf.password ?? "";
+    const passKey = pass ? `sha256:${_hashSecret(pass)}` : "";
+    const authSource = user && pass ? (conf.authSource ?? "admin") : "";
+    const rs = conf.replicaset ?? "";
+    const hosts = _hostsKey(conf.hosts);
+    return `hosts=${hosts}|user=${user}|pass=${passKey}|authSource=${authSource}|rs=${rs}`;
+}
+async function _acquireClient(key, uri, options) {
+    const existing = _clientByKey.get(key);
+    if (existing)
+        return existing;
+    const inflight = _connectingByKey.get(key);
+    if (inflight)
+        return inflight;
+    const p = MongoClient.connect(uri, options)
+        .then((client) => {
+        _clientByKey.set(key, client);
+        _connectingByKey.delete(key);
+        return client;
+    })
+        .catch((err) => {
+        _connectingByKey.delete(key);
+        throw err;
+    });
+    _connectingByKey.set(key, p);
+    return p;
+}
+function _increfClient(key) {
+    _refCountByKey.set(key, (_refCountByKey.get(key) ?? 0) + 1);
+}
+async function _decrefClient(key) {
+    const next = (_refCountByKey.get(key) ?? 0) - 1;
+    if (next <= 0) {
+        _refCountByKey.delete(key);
+        const client = _clientByKey.get(key);
+        if (client) {
+            _clientByKey.delete(key);
+            try {
+                await client.close();
+            }
+            catch (err) {
+                // Best-effort shutdown: never throw from release/close paths.
+                debug(`MongoClient close failed for key=${key}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return;
+    }
+    _refCountByKey.set(key, next);
+}
+// ---- End shared MongoClient pool helpers ----
 // Crockford Base32 alphabet (no I, L, O, U)
 const CROCKFORD32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 /**
@@ -57,10 +129,33 @@ function uuidv7Base32Hyphenated() {
         "-" +
         encoded.slice(20));
 }
+/**
+ * Test helper: fully reset the shared MongoClient pool.
+ *
+ * Not for production usage; intended for test runners to clean up
+ * between suites without restarting the process.
+ */
+export async function resetSharedMongoClientsForTests() {
+    const entries = Array.from(_clientByKey.entries());
+    for (const [key, client] of entries) {
+        try {
+            await client.close();
+        }
+        catch (err) {
+            debug(`MongoClient close failed during reset for key=${key}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    _clientByKey.clear();
+    _connectingByKey.clear();
+    _refCountByKey.clear();
+}
 export class K2DB {
     conf;
     db;
     connection;
+    clientKey;
+    initialized = false;
+    initPromise;
     schemas = new Map();
     constructor(conf) {
         this.conf = conf;
@@ -69,22 +164,41 @@ export class K2DB {
      * Initializes the MongoDB connection.
      */
     async init() {
-        // Build URI and options
-        const { uri, options } = this.buildMongoUri();
-        const dbName = this.conf.name;
-        // Mask sensitive information in logs
-        const safeConnectUrl = uri.replace(/\/\/.*?:.*?@/, "//*****:*****@");
-        debug(`Connecting to MongoDB: ${safeConnectUrl}`);
-        try {
-            // 8. Establish MongoDB connection
-            this.connection = await MongoClient.connect(uri, options);
-            this.db = this.connection.db(dbName);
-            debug("Successfully connected to MongoDB");
-        }
-        catch (err) {
-            // 9. Handle connection error
-            throw new K2Error(ServiceError.SYSTEM_ERROR, `Failed to connect to MongoDB: ${err.message}`, "sys_mdb_init", this.normalizeError(err));
-        }
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            // Build URI and options
+            const { uri, options } = this.buildMongoUri();
+            // Mask sensitive information in logs
+            const safeConnectUrl = uri.replace(/\/\/.*?:.*?@/, "//*****:*****@");
+            debug(`Connecting to MongoDB: ${safeConnectUrl}`);
+            try {
+                // Establish (or reuse) a shared MongoClient pool per cluster+auth (NOT per db name)
+                const key = _clientCacheKey(this.conf);
+                const client = await _acquireClient(key, uri, options);
+                this.connection = client;
+                this.db = this.connection.db(this.conf.name);
+                this.clientKey = key;
+                if (!this.initialized) {
+                    _increfClient(key);
+                    this.initialized = true;
+                }
+                debug("Successfully connected to MongoDB");
+            }
+            catch (err) {
+                // Handle connection error
+                const msg = err instanceof Error
+                    ? `Failed to connect to MongoDB: ${err.message}`
+                    : `Failed to connect to MongoDB: ${String(err)}`;
+                throw wrap(err, ServiceError.SERVICE_UNAVAILABLE, "sys_mdb_init", msg);
+            }
+        })().finally(() => {
+            // Allow retry after failure; once initialized, subsequent calls return early.
+            this.initPromise = undefined;
+        });
+        return this.initPromise;
     }
     /**
      * Build a robust MongoDB URI based on config (supports SRV and standard).
@@ -102,7 +216,7 @@ export class K2DB {
         let uri;
         if (useSrv) {
             const host = this.conf.hosts[0].host;
-            uri = `mongodb+srv://${auth}${host}/${dbName}?retryWrites=true&w=majority`;
+            uri = `mongodb+srv://${auth}${host}/?retryWrites=true&w=majority`;
         }
         else {
             const hostList = this.conf.hosts
@@ -111,11 +225,16 @@ export class K2DB {
             const params = ["retryWrites=true", "w=majority"];
             if (this.conf.replicaset)
                 params.push(`replicaSet=${this.conf.replicaset}`);
-            uri = `mongodb://${auth}${hostList}/${dbName}?${params.join("&")}`;
+            uri = `mongodb://${auth}${hostList}/?${params.join("&")}`;
         }
+        // Determine authSource based on user and password presence
+        const authSource = this.conf.user && this.conf.password
+            ? this.conf.authSource ?? "admin"
+            : undefined;
         const options = {
             connectTimeoutMS: 2000,
             serverSelectionTimeoutMS: 2000,
+            ...(authSource ? { authSource } : {}),
         };
         return { uri, options };
     }
@@ -136,6 +255,7 @@ export class K2DB {
             hosts,
             user: get("USER"),
             password: get("PASSWORD"),
+            authSource: get("AUTH_SOURCE"),
             replicaset: get("REPLICASET"),
         };
         const slow = get("SLOW_MS");
@@ -154,11 +274,7 @@ export class K2DB {
             return collection;
         }
         catch (err) {
-            // If the error is already an K2Error, rethrow it
-            if (err instanceof K2Error) {
-                throw err;
-            }
-            throw new K2Error(ServiceError.SYSTEM_ERROR, `Error getting collection: ${collectionName}`, "sys_mdb_gc", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_gc", `Error getting collection: ${collectionName}`);
         }
     }
     async get(collectionName, uuid) {
@@ -204,7 +320,7 @@ export class K2DB {
             return null;
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, "Error finding document", "sys_mdb_fo", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_fo", "Error finding document");
         }
     }
     /**
@@ -274,7 +390,7 @@ export class K2DB {
             return result;
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, "Error executing find query", "sys_mdb_find_error", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_find_error", "Error executing find query");
         }
     }
     /**
@@ -312,7 +428,7 @@ export class K2DB {
             return data.map((doc) => doc);
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, "Aggregation failed", "sys_mdb_ag", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_ag", "Aggregation failed");
         }
     }
     /**
@@ -427,7 +543,7 @@ export class K2DB {
             _uuid: newUuid,
         };
         try {
-            const result = await this.runTimed("insertOne", { collectionName }, async () => await collection.insertOne(document));
+            await this.runTimed("insertOne", { collectionName }, async () => await collection.insertOne(document));
             return { id: document._uuid };
         }
         catch (err) {
@@ -439,7 +555,7 @@ export class K2DB {
             // Log the error details for debugging
             debug(`Was trying to insert into collection ${collectionName}, data: ${JSON.stringify(document)}`);
             debug(err);
-            throw new K2Error(ServiceError.SYSTEM_ERROR, "Error saving object to database", "sys_mdb_sav", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_sav", "Error saving object to database");
         }
     }
     /**
@@ -478,7 +594,7 @@ export class K2DB {
             };
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, `Error updating ${collectionName}`, "sys_mdb_update1", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_update1", `Error updating ${collectionName}`);
         }
     }
     /**
@@ -526,11 +642,7 @@ export class K2DB {
             return { updated: res.modifiedCount };
         }
         catch (err) {
-            if (err instanceof K2Error) {
-                throw err;
-            }
-            // Catch any other unhandled errors and throw a system error
-            throw new K2Error(ServiceError.SYSTEM_ERROR, `Error updating ${collectionName}`, "sys_mdb_update_error", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_update_error", `Error updating ${collectionName}`);
         }
     }
     /**
@@ -541,13 +653,13 @@ export class K2DB {
     async deleteAll(collectionName, criteria) {
         this.validateCollectionName(collectionName);
         try {
-            let result = await this.updateAll(collectionName, criteria, {
+            const result = await this.updateAll(collectionName, criteria, {
                 _deleted: true,
             });
             return { deleted: result.updated };
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, `Error updating ${collectionName}`, "sys_mdb_deleteall_update", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_deleteall_update", `Error updating ${collectionName}`);
         }
     }
     /**
@@ -575,11 +687,7 @@ export class K2DB {
             }
         }
         catch (err) {
-            // Preserve existing K2Error classifications (e.g., NOT_FOUND)
-            if (err instanceof K2Error) {
-                throw err;
-            }
-            throw new K2Error(ServiceError.SYSTEM_ERROR, "Error removing object from collection", "sys_mdb_remove_upd", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_remove_upd", "Error removing object from collection");
         }
     }
     /**
@@ -602,10 +710,7 @@ export class K2DB {
             return { id };
         }
         catch (err) {
-            if (err instanceof K2Error) {
-                throw err;
-            }
-            throw new K2Error(ServiceError.SYSTEM_ERROR, `Error purging item with id: ${id}`, "sys_mdb_pg", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_pg", `Error purging item with id: ${id}`);
         }
     }
     /**
@@ -630,7 +735,7 @@ export class K2DB {
             return { purged: res.deletedCount ?? 0 };
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, 'Error purging deleted items by age', 'sys_mdb_purge_older', this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, 'sys_mdb_purge_older', 'Error purging deleted items by age');
         }
     }
     /**
@@ -650,7 +755,7 @@ export class K2DB {
             return { status: "restored", modified: res.modifiedCount };
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, "Error restoring a deleted item", "sys_mdb_pres", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_pres", "Error restoring a deleted item");
         }
     }
     /**
@@ -672,7 +777,7 @@ export class K2DB {
             return { count: cnt };
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, "Error counting objects with given criteria", "sys_mdb_cn", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_cn", "Error counting objects with given criteria");
         }
     }
     /**
@@ -686,7 +791,7 @@ export class K2DB {
             return { status: "ok" };
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, "Error dropping collection", "sys_mdb_drop", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_drop", "Error dropping collection");
         }
     }
     /**
@@ -837,7 +942,7 @@ export class K2DB {
         }
         catch (error) {
             await session.abortTransaction();
-            throw this.normalizeError(error);
+            throw wrap(error, ServiceError.BAD_GATEWAY, "sys_mdb_txn", "Transaction failed");
         }
         finally {
             session.endSession();
@@ -856,21 +961,29 @@ export class K2DB {
             debug(`Index created on ${collectionName}: ${JSON.stringify(indexSpec)}`);
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, `Error creating index on ${collectionName}`, "sys_mdb_idx", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_idx", `Error creating index on ${collectionName}`);
         }
     }
     /**
      * Releases the MongoDB connection.
      */
     async release() {
-        await this.connection.close();
+        if (this.initialized && this.clientKey) {
+            const key = this.clientKey;
+            this.initialized = false;
+            this.clientKey = undefined;
+            await _decrefClient(key);
+            debug("MongoDB connection released");
+            return;
+        }
         debug("MongoDB connection released");
     }
     /**
      * Closes the MongoDB connection.
      */
     close() {
-        this.connection.close();
+        // Fire-and-forget async release (shared pool is refcounted)
+        void this.release();
     }
     /**
      * Drops the entire database.
@@ -881,7 +994,7 @@ export class K2DB {
             debug("Database dropped successfully");
         }
         catch (err) {
-            throw new K2Error(ServiceError.SYSTEM_ERROR, "Error dropping database", "sys_mdb_drop_db", this.normalizeError(err));
+            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_drop_db", "Error dropping database");
         }
     }
     /**
@@ -916,14 +1029,6 @@ export class K2DB {
             return false;
         }
     }
-    /**
-     * Utility to normalize the error type.
-     * @param err - The caught error of type `unknown`.
-     * @returns A normalized error of type `Error`.
-     */
-    normalizeError(err) {
-        return err instanceof Error ? err : new Error(String(err));
-    }
     // ===== Versioning helpers and APIs =====
     /** Name of the history collection for a given collection. */
     historyName(collectionName) {
@@ -960,7 +1065,7 @@ export class K2DB {
         }
         const parsed = s.safeParse(data);
         if (!parsed.success) {
-            throw new K2Error(ServiceError.BAD_REQUEST, "Validation failed", "sys_mdb_schema_validation", new Error(parsed.error.message));
+            throw new K2Error(ServiceError.VALIDATION_ERROR, parsed.error.message, "sys_mdb_schema_validation", parsed.error);
         }
         return parsed.data;
     }

package/package.json

@@ -1,55 +1,33 @@
 {
   "name": "@frogfish/k2db",
-  "version": "2.0.7",
+  "version": "3.0.1",
   "description": "A data handling library for K2 applications.",
-  "main": "./dist/data.js",
-  "types": "./dist/data.d.ts",
   "type": "module",
+  "main": "data.js",
+  "types": "data.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/data.d.ts",
-      "import": "./dist/data.js"
+      "types": "./data.d.ts",
+      "import": "./data.js"
     },
     "./db": {
-      "types": "./dist/db.d.ts",
-      "import": "./dist/db.js"
+      "types": "./db.d.ts",
+      "import": "./db.js"
     }
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/prepare-dist.mjs",
-    "build:watch": "tsc --watch -p tsconfig.json",
-    "test": "jest",
-    "test:coverage": "jest --coverage",
-    "prepublishOnly": "npm run build"
-  },
-  "author": "El'Diablo",
   "license": "GPL-3.0-only",
-  "devDependencies": {
-    "@types/axios": "^0.9.36",
-    "@types/debug": "^4.1.12",
-    "@types/jest": "^29.5.13",
-    "@types/mongodb": "^4.0.6",
-    "@types/uuid": "^10.0.0",
-    "jest": "^29.7.0",
-    "mongodb-memory-server": "^10.0.1",
-    "ts-jest": "^29.2.5",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.6.2"
-  },
+  "author": "El'Diablo",
   "dependencies": {
-    "@frogfish/k2error": "^1.0.5",
+    "@frogfish/k2error": "^3.0.1",
+    "@frogfish/ratatouille": "^0.1.7",
     "debug": "^4.3.7",
     "mongodb": "^6.9.0",
     "uuid": "^10.0.0",
     "zod": "^3.23.8"
   },
-  "files": [
-    "dist/**",
-    "README.md",
-    "LICENSE"
-  ],
+  "peerDependencies": {},
+  "optionalDependencies": {},
   "publishConfig": {
-    "access": "public",
-    "directory": "dist"
+    "access": "public"
   }
 }