@efebia/pino-mongodb 0.0.1

package/lib/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@efebia/pino-mongodb",
+    "version": "0.0.1",
+    "license": "MIT",
+    "dependencies": {
+        "mongodb": "^4.8.1",
+        "pino-abstract-transport": "^1.0.0"
+    },
+    "devDependencies": {
+        "@types/node": "18",
+        "typescript": "^4.7.4"
+    },
+    "files": [
+        "/lib"
+    ],
+    "scripts": {
+        "build": "tsc"
+    },
+    "main": "./lib"
+}

package/lib/src/index.d.ts

@@ -0,0 +1,13 @@
+import { type MongoClientOptions } from 'mongodb';
+import { type Options as QueueOptions } from './queue.js';
+export type Options = {
+    uri?: string;
+    database?: string;
+    collection?: string;
+    unified?: boolean;
+    clientOptions?: MongoClientOptions;
+    queueOptions?: Omit<QueueOptions<unknown>, 'callback'>;
+};
+export declare const defaultOption: Options;
+declare const bulkTransport: (opts: Options) => Promise<import("stream").Transform & import("pino-abstract-transport").OnUnknown>;
+export default bulkTransport;

package/lib/src/index.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOption = void 0;
+const mongodb_1 = require("mongodb");
+const pino_abstract_transport_1 = __importDefault(require("pino-abstract-transport"));
+const stream_1 = require("stream");
+const package_json_1 = require("../package.json");
+const log_js_1 = __importDefault(require("./log.js"));
+const queue_js_1 = require("./queue.js");
+exports.defaultOption = {
+    uri: 'mongodb://localhost:27017/logs',
+    collection: 'logs',
+    unified: false,
+    queueOptions: {
+        cache: [],
+        interval: 1000,
+        maxMessages: 10
+    }
+};
+const bulkTransport = async (opts) => {
+    const { uri, database: databaseName, collection: collectionName, clientOptions, queueOptions } = Object.assign(Object.assign({}, exports.defaultOption), opts);
+    if (!uri)
+        throw new Error(`${package_json_1.name}: URI_NOT_SPECIFIED`);
+    if (!collectionName)
+        throw new Error(`${package_json_1.name}: COLLECTION_NAME_NOT_SPECIFIED`);
+    const client = new mongodb_1.MongoClient(uri, clientOptions);
+    await client.connect();
+    const db = client.db(databaseName);
+    const collection = db.collection(collectionName);
+    const messageQueue = (0, queue_js_1.createMessageQueue)(Object.assign({ callback: (messages, errorCallback) => collection.bulkWrite(messages.map(e => ({
+            insertOne: {
+                document: (0, log_js_1.default)(e)
+            }
+        })), { forceServerObjectId: true }).catch((e) => {
+            if (e instanceof Error) {
+                errorCallback === null || errorCallback === void 0 ? void 0 : errorCallback(e);
+            }
+        }) }, queueOptions));
+    const stream = new stream_1.Writable({
+        objectMode: true,
+        autoDestroy: true,
+        write(chunk, encoding, callback) {
+            messageQueue.push(chunk, callback);
+        },
+        destroy(err, cb) {
+            client.close((closeErr) => {
+                cb(err || closeErr || null);
+            });
+        }
+    });
+    return (0, pino_abstract_transport_1.default)((source) => {
+        source.pipe(stream);
+    }, {
+        close(err, cb) {
+            stream.end();
+            stream.once('close', cb.bind(null, err));
+        }
+    });
+};
+exports.default = bulkTransport;

package/lib/src/log.d.ts

@@ -0,0 +1 @@
+export default function (data: any): any;

package/lib/src/log.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(data) {
+    let log;
+    try {
+        log = typeof data === 'string' ? JSON.parse(data) : data;
+        if (log.time) {
+            log.time = new Date(log.time);
+        }
+    }
+    catch (e) {
+        log = {
+            msg: data
+        };
+    }
+    return log;
+}
+exports.default = default_1;

package/lib/src/queue.d.ts

@@ -0,0 +1,13 @@
+import { AnyError } from 'mongodb';
+type ErrorCallback = (error?: AnyError) => void;
+export interface Options<TItem> {
+    callback: (messages: TItem[], bufferCallback?: ErrorCallback) => any | Promise<any>;
+    cache?: TItem[];
+    interval?: number;
+    maxMessages?: number;
+}
+export declare const createMessageQueue: <TItem>({ callback, cache, interval, maxMessages }: Options<TItem>) => {
+    push: (message: TItem, bufferCallback: ErrorCallback) => void;
+    stop: () => void;
+};
+export {};

package/lib/src/queue.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessageQueue = void 0;
+const createMessageQueue = ({ callback, cache = [], interval = 1000, maxMessages = 10 }) => {
+    const sendMessages = (bufferCallback) => {
+        const messages = cache.splice(0, maxMessages);
+        if (messages.length === 0)
+            return;
+        return callback(messages, bufferCallback);
+    };
+    const push = (message, bufferCallback) => {
+        cache.push(message);
+        if (cache.length === maxMessages) {
+            sendMessages(bufferCallback);
+        }
+        else {
+            bufferCallback();
+        }
+    };
+    const intervalID = setInterval(sendMessages, interval);
+    const stop = () => clearInterval(intervalID);
+    return {
+        push,
+        stop
+    };
+};
+exports.createMessageQueue = createMessageQueue;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@efebia/pino-mongodb",
+  "version": "0.0.1",
+  "license": "MIT",
+  "dependencies": {
+    "mongodb": "^4.8.1",
+    "pino-abstract-transport": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "18",
+    "typescript": "^4.7.4"
+  },
+  "files": [
+    "/lib"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "main": "./lib"
+}