@zintrust/cache-mongodb 0.1.12

package/README.md

@@ -0,0 +1,24 @@
+# @zintrust/cache-mongodb
+
+MongoDB (Atlas Data API) cache driver for Zintrust.
+
+- Docs: https://zintrust.com/cache
+
+## Install
+
+```bash
+npm i @zintrust/cache-mongodb
+```
+
+## Usage
+
+Side-effect register (recommended):
+
+```ts
+import '@zintrust/cache-mongodb/register';
+```
+
+Then set `CACHE_DRIVER=mongodb` and configure:
+
+- `MONGO_URI` (Atlas Data API base URL)
+- `MONGO_DB`

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export interface CacheDriver {
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+}
+export type MongoCacheConfig = {
+    driver: 'mongodb';
+    uri: string;
+    db: string;
+    ttl: number;
+};
+export declare const MongoCacheDriver: Readonly<{
+    create(config: MongoCacheConfig): CacheDriver;
+}>;
+export default MongoCacheDriver;

package/dist/index.js

@@ -0,0 +1,68 @@
+import { Logger } from '@zintrust/core';
+export const MongoCacheDriver = Object.freeze({
+    create(config) {
+        const uri = String(config.uri ?? '').trim();
+        const db = String(config.db ?? '').trim();
+        const collection = 'cache';
+        const request = async (action, body) => {
+            if (uri === '') {
+                Logger.warn('MongoDB cache driver missing uri. Request ignored.');
+                return null;
+            }
+            try {
+                const response = await fetch(`${uri}/action/${action}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Access-Control-Request-Headers': '*',
+                    },
+                    body: JSON.stringify({
+                        dataSource: 'Cluster0',
+                        database: db,
+                        collection: collection,
+                        ...body,
+                    }),
+                });
+                return await response.json();
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                Logger.warn('MongoDB cache request failed', { message, action });
+                return null;
+            }
+        };
+        return {
+            async get(key) {
+                const result = (await request('findOne', { filter: { _id: key } }));
+                if (result?.document === undefined || result.document === null)
+                    return null;
+                const doc = result.document;
+                if (doc.expires !== null && doc.expires < Date.now()) {
+                    await this.delete(key);
+                    return null;
+                }
+                return doc.value;
+            },
+            async set(key, value, ttl) {
+                const effectiveTtl = ttl ?? config.ttl;
+                const expires = effectiveTtl === undefined ? null : Date.now() + effectiveTtl * 1000;
+                await request('updateOne', {
+                    filter: { _id: key },
+                    update: { $set: { value, expires } },
+                    upsert: true,
+                });
+            },
+            async delete(key) {
+                await request('deleteOne', { filter: { _id: key } });
+            },
+            async clear() {
+                await request('deleteMany', { filter: {} });
+            },
+            async has(key) {
+                const result = (await request('findOne', { filter: { _id: key } }));
+                return result?.document !== undefined && result.document !== null;
+            },
+        };
+    },
+});
+export default MongoCacheDriver;

package/dist/register.d.ts

@@ -0,0 +1,5 @@
+type Registry = {
+    register: (driver: string, factory: (cfg: unknown) => unknown) => void;
+};
+export declare function registerMongoCacheDriver(registry: Registry): void;
+export {};

package/dist/register.js

@@ -0,0 +1,16 @@
+import { MongoCacheDriver } from './index.js';
+export function registerMongoCacheDriver(registry) {
+    registry.register('mongodb', (config) => MongoCacheDriver.create(config));
+}
+const importCore = async () => {
+    try {
+        return await import('@zintrust/core');
+    }
+    catch {
+        return {};
+    }
+};
+const core = (await importCore());
+if (core.CacheDriverRegistry !== undefined) {
+    registerMongoCacheDriver(core.CacheDriverRegistry);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@zintrust/cache-mongodb",
+  "version": "0.1.12",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@zintrust/core": "^0.1.12"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  }
+}