wingbot-mongodb 4.2.7 → 4.2.9

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "wingbot-mongodb",
-  "version": "4.2.7",
+  "version": "4.2.9",
   "description": "MongoDB storage for wingbot.ai",
   "main": "src/main.js",
+  "types": "types/main.d.ts",
   "scripts": {
     "test": "npm run test:lint && npm run test:coverage && npm run test:coverage:threshold",
     "test:unit": "mocha ./test/**/*.js",
@@ -11,7 +12,9 @@
     "test:coverage": "nyc --reporter=html mocha ./test && nyc report",
     "test:coverage:threshold": "nyc check-coverage --lines 80 --functions 73 --branches 75",
     "test:lint": "eslint ./src/**/*.js ./bin/**/*.js ./test/**/*.js ",
-    "doc": "node ./bin/makeApiDoc.js"
+    "doc": "node ./bin/makeApiDoc.js",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
   },
   "repository": {
     "type": "git",
@@ -34,6 +37,7 @@
   },
   "homepage": "https://github.com/wingbotai/wingbot-mongodb#readme",
   "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.10",
     "cross-env": "^7.0.3",
     "eslint": "^8.28.0",
     "eslint-config-airbnb": "^19.0.4",
@@ -47,6 +51,7 @@
     "mocha": "^10.1.0",
     "mongodb": "^6.1.0",
     "nyc": "^15.1.0",
+    "typescript": "^5.9.3",
     "wingbot": "^3.46.3"
   },
   "peerDependencies": {

package/src/AttachmentCache.js

@@ -3,8 +3,14 @@
  */
 'use strict';
 
+/**
+ * @typedef {object} StoredAttachment
+ * @prop {string} _id
+ * @prop {number} attachmentId
+ */
+
 /** @typedef {import('mongodb').Db} Db */
-/** @typedef {import('mongodb').Collection} Collection */
+/** @typedef {import('mongodb').Collection<StoredAttachment>} Collection */
 
 /**
  * Cache storage for Facebook attachments
@@ -69,7 +75,7 @@ class AttachmentCache {
     async saveAttachmentId (url, attachmentId) {
         const c = await this._getCollection();
 
-        await c.replaceOne({ _id: url }, { _id: url, attachmentId }, { upsert: true });
+        await c.replaceOne({ _id: url }, { attachmentId }, { upsert: true });
     }
 
 }

package/src/BaseStorage.js

@@ -13,6 +13,17 @@ const getNestedObjects = require('./getNestedObjects');
 /** @typedef {import('mongodb').Document} Document */
 /** @typedef {import('mongodb').CreateIndexesOptions} CreateIndexesOptions */
 
+/**
+ * @template T=ObjectId
+ * @typedef {object} CustomIdentifier
+ * @prop {T} _id
+ */
+
+/**
+ * @template {object} T
+ * @typedef {T & CustomIdentifier<ObjectId>} WithId
+ */
+
 /**
  *
  * @template T
@@ -92,7 +103,7 @@ class BaseStorage {
         this._log = log;
 
         // eslint-disable-next-line max-len
-        /** @type {import('mongodb').Collection<wingbotmongodb.WithId<T>>|Promise<import('mongodb').Collection<wingbotmongodb.WithId<T>>>} */
+        /** @type {import('mongodb').Collection<WithId<T>>|Promise<import('mongodb').Collection<WithId<T>>>} */
         this._collection = null;
 
         this._indexes = [];
@@ -165,14 +176,18 @@ class BaseStorage {
         return e;
     }
 
+    /**
+     *
+     * @returns {Promise<import('mongodb').Collection<WithId<T>>>}
+     */
     preHeat () {
-        return this._getCollection();
+        return this._getCollection(false, true);
     }
 
     /**
      * Insert defalt document to DB
      *
-     * @param  {...T} objects
+     * @param  {...WithId<T>} objects
      */
     addFixtureDoc (...objects) {
         this._fixtures.push(...objects);
@@ -227,14 +242,14 @@ class BaseStorage {
     /**
      *
      * @param {string} name
-     * @returns {Promise<import('mongodb').Collection<wingbotmongodb.WithId<T>>>}
+     * @returns {Promise<import('mongodb').Collection<WithId<T>>>}
      */
     async _getOrCreateCollection (name) {
         const db = typeof this._mongoDb === 'function'
             ? await this._mongoDb()
             : this._mongoDb;
 
-        /** @type {import('mongodb').Collection<wingbotmongodb.WithId<T>>} */
+        /** @type {import('mongodb').Collection<WithId<T>>} */
         let collection;
 
         if (this._isCosmo) {
@@ -280,9 +295,10 @@ class BaseStorage {
      *
      * @protected
      * @param {boolean} [forRead]
-     * @returns {Promise<import('mongodb').Collection<wingbotmongodb.WithId<T>>>}
+     * @param {boolean} [forceIndexAwait=false]
+     * @returns {Promise<import('mongodb').Collection<WithId<T>>>}
      */
-    async _getCollection (forRead = false) {
+    async _getCollection (forRead = false, forceIndexAwait = false) {
         if (this._collection === null) {
             let c;
             try {
@@ -296,9 +312,11 @@ class BaseStorage {
             }
         }
 
+        const requiresIndexAwait = this._shouldWaitForIndex
+            && (!forRead || this._shouldIndexBeforeRead);
+
         if (this._indexing
-            && this._shouldWaitForIndex
-            && (!forRead || this._shouldIndexBeforeRead)) {
+            && (requiresIndexAwait || forceIndexAwait)) {
 
             const err = await this._indexing;
             this._indexing = false;
@@ -311,7 +329,7 @@ class BaseStorage {
     /**
      *
      * @param {object[]} indexes
-     * @param {import('mongodb').Collection<wingbotmongodb.WithId<T>>} collection
+     * @param {import('mongodb').Collection<WithId<T>>} collection
      * @returns {Promise}
      */
     async _ensureIndexes (indexes, collection) {

package/src/BotConfigStorage.js

@@ -11,8 +11,10 @@ try {
     // noop
 }
 
+/** @typedef {{ [key: string]: any } & { _id: string }} BaseConfig */
+
 /** @typedef {import('mongodb').Db} Db */
-/** @typedef {import('mongodb').Collection} Collection */
+/** @typedef {import('mongodb').Collection<BaseConfig>} Collection */
 
 const CONFIG_ID = 'config';
 

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "types",
+    "checkJs": true,
+    "strict": false, // Temporarily disable strict mode
+    "skipLibCheck": true, // Skip type checking for declaration files
+    "noImplicitAny": false, // Allow implicit 'any' types
+    "esModuleInterop": true, // Ensure compatibility with CommonJS modules
+    "resolveJsonModule": true // Allow importing JSON modules
+  },
+  "include": ["src/**/*.js"],
+  "typeRoots": ["./types", "./node_modules/@types"] // Include custom types
+}

package/types/AttachmentCache.d.ts

@@ -0,0 +1,55 @@
+export = AttachmentCache;
+/**
+ * @typedef {object} StoredAttachment
+ * @prop {string} _id
+ * @prop {number} attachmentId
+ */
+/** @typedef {import('mongodb').Db} Db */
+/** @typedef {import('mongodb').Collection<StoredAttachment>} Collection */
+/**
+ * Cache storage for Facebook attachments
+ *
+ * @class
+ */
+declare class AttachmentCache {
+    /**
+     *
+     * @param {Db|{():Promise<Db>}} mongoDb
+     * @param {string} collectionName
+     */
+    constructor(mongoDb: Db | {
+        (): Promise<Db>;
+    }, collectionName?: string);
+    _mongoDb: import("mongodb").Db | (() => Promise<Db>);
+    _collectionName: string;
+    /**
+     * @type {Collection}
+     */
+    _collection: Collection;
+    /**
+     * @returns {Promise<Collection>}
+     */
+    _getCollection(): Promise<Collection>;
+    /**
+     *
+     * @param {string} url
+     * @returns {Promise<number|null>}
+     */
+    findAttachmentByUrl(url: string): Promise<number | null>;
+    /**
+     *
+     * @param {string} url
+     * @param {number} attachmentId
+     * @returns {Promise}
+     */
+    saveAttachmentId(url: string, attachmentId: number): Promise<any>;
+}
+declare namespace AttachmentCache {
+    export { StoredAttachment, Db, Collection };
+}
+type StoredAttachment = {
+    _id: string;
+    attachmentId: number;
+};
+type Db = import("mongodb").Db;
+type Collection = import("mongodb").Collection<StoredAttachment>;

package/types/AuditLogStorage.d.ts

@@ -0,0 +1,231 @@
+export = AuditLogStorage;
+/**
+ * @typedef {object} TrackingEvent
+ * @prop {string} [type='audit']
+ * @prop {string} category
+ * @prop {string} action
+ * @prop {string} [label]
+ * @prop {object} [payload]
+ */
+/**
+ * @typedef {object} User
+ * @prop {string} [id]
+ * @prop {string} [senderId]
+ * @prop {string} [pageId]
+ * @prop {string} [jwt] - jwt to check the authorship
+ */
+/**
+ * @typedef {object} Meta
+ * @prop {string} [ip]
+ * @prop {string} [ua]
+ * @prop {string} [ro] - referrer || origin
+ */
+/**
+ * @typedef {object} LogEntry
+ * @prop {string} date - ISO date
+ * @prop {number} delta - time skew in ms if there was a write conflict
+ * @prop {string} [eventType='audit']
+ * @prop {string} category
+ * @prop {string} action
+ * @prop {string} [label]
+ * @prop {object} [payload]
+ * @prop {string} level - (Critical|Important|Debug)
+ * @prop {boolean} ok - signature matches
+ * @prop {number} seq - sequence number
+ * @prop {string} type - (Error|Warn|Info)
+ * @prop {User} user
+ * @prop {string} wid - workspace id
+ * @prop {Meta} meta
+ */
+/**
+ * JWT Verifier
+ *
+ * @callback JwtVerifier
+ * @param {string} token
+ * @param {string} userId
+ * @param {User} [user]
+ * @returns {Promise<boolean>}
+ */
+/**
+ * @typedef {object} AuditLogEntry
+ * @prop {string} date - ISO date
+ * @prop {string} [eventType='audit']
+ * @prop {string} category
+ * @prop {string} action
+ * @prop {string} [label]
+ * @prop {object} [payload]
+ * @prop {string} level - (Critical|Important|Debug)
+ * @prop {string} type - (Error|Warn|Info)
+ * @prop {User} user
+ * @prop {string} wid - workspace id
+ * @prop {Meta} meta
+ */
+/**
+ * Audit Log Callback
+ *
+ * @callback AuditLogCallback
+ * @param {AuditLogEntry} entry
+ * @returns {Promise}
+ */
+/** @typedef {import('mongodb').Db} Db */
+/** @typedef {import('mongodb').Collection} Collection */
+/**
+ * Storage for audit logs with signatures chain
+ */
+declare class AuditLogStorage extends BaseStorage<any> {
+    /**
+     *
+     * @param {Db|{():Promise<Db>}} mongoDb
+     * @param {string} collectionName
+     * @param {{error:Function,log:Function}} [log] - console like logger
+     * @param {boolean} [isCosmo]
+     * @param {string|Promise<string>} [secret]
+     * @param {string|Promise<string>} [jwtVerifier]
+     */
+    constructor(mongoDb: Db | {
+        (): Promise<Db>;
+    }, collectionName?: string, log?: {
+        error: Function;
+        log: Function;
+    }, isCosmo?: boolean, secret?: string | Promise<string>, jwtVerifier?: string | Promise<string>);
+    defaultWid: string;
+    muteErrors: boolean;
+    maxRetries: number;
+    _secret: string | Promise<string>;
+    LEVEL_CRITICAL: string;
+    LEVEL_IMPORTANT: string;
+    LEVEL_DEBUG: string;
+    TYPE_ERROR: string;
+    TYPE_WARN: string;
+    TYPE_INFO: string;
+    /**
+     * @type {JwtVerifier}
+     */
+    _jwtVerify: JwtVerifier;
+    /** @type {AuditLogCallback} */
+    callback: AuditLogCallback;
+    /**
+     * Add a log
+     *
+     * @param {TrackingEvent} event
+     * @param {User} user
+     * @param {Meta} [meta]
+     * @param {string} [wid] - workspace ID
+     * @param {string} [type]
+     * @param {string} [level]
+     * @param {Date} [date]
+     * @returns {Promise}
+     */
+    log(event: TrackingEvent, user?: User, meta?: Meta, wid?: string, type?: string, level?: string, date?: Date): Promise<any>;
+    /**
+     *
+     * @param {string} [wid] - workspace id
+     * @param {number} [fromSeq] - for paging
+     * @param {number} [limit]
+     * @returns {Promise<LogEntry[]>}
+     */
+    list(wid?: string, fromSeq?: number, limit?: number): Promise<LogEntry[]>;
+    _wait(ms: any): Promise<any>;
+    _storeWithRetry(secret: any, entry: any, delta?: number, i?: number): any;
+    _store(entry: any, secret: any): Promise<void>;
+}
+declare namespace AuditLogStorage {
+    export { TrackingEvent, User, Meta, LogEntry, JwtVerifier, AuditLogEntry, AuditLogCallback, Db, Collection };
+}
+import BaseStorage = require("./BaseStorage");
+type TrackingEvent = {
+    type?: string;
+    category: string;
+    action: string;
+    label?: string;
+    payload?: object;
+};
+type User = {
+    id?: string;
+    senderId?: string;
+    pageId?: string;
+    /**
+     * - jwt to check the authorship
+     */
+    jwt?: string;
+};
+type Meta = {
+    ip?: string;
+    ua?: string;
+    /**
+     * - referrer || origin
+     */
+    ro?: string;
+};
+type LogEntry = {
+    /**
+     * - ISO date
+     */
+    date: string;
+    /**
+     * - time skew in ms if there was a write conflict
+     */
+    delta: number;
+    eventType?: string;
+    category: string;
+    action: string;
+    label?: string;
+    payload?: object;
+    /**
+     * - (Critical|Important|Debug)
+     */
+    level: string;
+    /**
+     * - signature matches
+     */
+    ok: boolean;
+    /**
+     * - sequence number
+     */
+    seq: number;
+    /**
+     * - (Error|Warn|Info)
+     */
+    type: string;
+    user: User;
+    /**
+     * - workspace id
+     */
+    wid: string;
+    meta: Meta;
+};
+/**
+ * JWT Verifier
+ */
+type JwtVerifier = (token: string, userId: string, user?: User) => Promise<boolean>;
+type AuditLogEntry = {
+    /**
+     * - ISO date
+     */
+    date: string;
+    eventType?: string;
+    category: string;
+    action: string;
+    label?: string;
+    payload?: object;
+    /**
+     * - (Critical|Important|Debug)
+     */
+    level: string;
+    /**
+     * - (Error|Warn|Info)
+     */
+    type: string;
+    user: User;
+    /**
+     * - workspace id
+     */
+    wid: string;
+    meta: Meta;
+};
+/**
+ * Audit Log Callback
+ */
+type AuditLogCallback = (entry: AuditLogEntry) => Promise<any>;
+type Db = import("mongodb").Db;
+type Collection = import("mongodb").Collection;

package/types/BaseStorage.d.ts

@@ -0,0 +1,189 @@
+export = BaseStorage;
+/**
+ * @template T={} {Document}
+ */
+declare class BaseStorage<T> {
+    static netFailuresIntervalMs: number;
+    static netFailuresCount: number;
+    static _killing: any;
+    static _failStack: any[];
+    static killer: () => NodeJS.Timeout;
+    static networkFailureErrorNames: string[];
+    /**
+     *
+     * @param {Db|{():Promise<Db>}} mongoDb
+     * @param {string} collectionName
+     * @param {{error:Function,log:Function}} [log] - console like logger
+     * @param {boolean|number} [isCosmo]
+     * @example
+     *
+     * const { BaseStorage } = require('winbot-mongodb');
+     *
+     * class MyCoolDataStorage extends BaseStorage {
+     *
+     *     constructor (mongoDb, collectionName, log = undefined, isCosmo = false) {
+     *          super(mongoDb, collectionName, log, isCosmo);
+     *
+     *          this.addIndex({
+     *              foo: -1
+     *          }, {
+     *              name: 'foo_1'
+     *          });
+     *
+     *          this.addIndex({
+     *              bar: -1,
+     *              baz: 1
+     *          }, {
+     *              name: 'bar_-1_baz_1'
+     *          });
+     *     }
+     *
+     * }
+     */
+    constructor(mongoDb: Db | {
+        (): Promise<Db>;
+    }, collectionName: string, log?: {
+        error: Function;
+        log: Function;
+    }, isCosmo?: boolean | number);
+    _mongoDb: import("mongodb").Db | (() => Promise<Db>);
+    _collectionName: string;
+    _isCosmo: boolean;
+    _log: {
+        error: Function;
+        log: Function;
+    };
+    /** @type {import('mongodb').Collection<WithId<T>>|Promise<import('mongodb').Collection<WithId<T>>>} */
+    _collection: import("mongodb").Collection<WithId<T>> | Promise<import("mongodb").Collection<WithId<T>>>;
+    _indexes: any[];
+    ignoredSignatureKeys: string[];
+    _secret: any;
+    systemIndexes: string[];
+    _fixtures: any[];
+    _uniqueIndexFailed: boolean;
+    _indexing: any;
+    _shouldIndexBeforeRead: boolean;
+    _shouldWaitForIndex: boolean;
+    /**
+     *
+     * @template T
+     * @param {{():T}} fn
+     * @returns {Promise<T>}
+     */
+    _catchNetworkIssues<T_1>(fn: {
+        (): T_1;
+    }): Promise<T_1>;
+    /**
+     * @template {Error} T
+     * @param {T} e
+     * @returns {T}
+     */
+    _detectNetworkIssueException<T_1 extends Error>(e: T_1): T_1;
+    /**
+     *
+     * @returns {Promise<import('mongodb').Collection<WithId<T>>>}
+     */
+    preHeat(): Promise<import("mongodb").Collection<WithId<T>>>;
+    /**
+     * Insert defalt document to DB
+     *
+     * @param  {...WithId<T>} objects
+     */
+    addFixtureDoc(...objects: WithId<T>[]): void;
+    /**
+     * Add custom indexing rule
+     *
+     * @param {object} index
+     * @param {CreateIndexesOptions} options
+     */
+    addIndex(index: object, options: CreateIndexesOptions): void;
+    /**
+     * @example
+     * {
+     *   _id: ObjectId.isValid(id) ? new ObjectId(input) : input
+     * }
+     *
+     * @protected
+     * @param {string} id
+     * @returns {string|ObjectId}
+     */
+    protected _id(id: string): string | ObjectId;
+    /**
+     *
+     * @param {string|null} attr
+     * @param {{[key: string]: any}} obj
+     * @param {boolean} [nested]
+     * @returns {{[key: string]: any}}
+     */
+    _expandObjectToSet(attr: string | null, obj: {
+        [key: string]: any;
+    }, nested?: boolean): {
+        [key: string]: any;
+    };
+    /**
+     *
+     * @param {string} name
+     * @returns {Promise<import('mongodb').Collection<WithId<T>>>}
+     */
+    _getOrCreateCollection(name: string): Promise<import("mongodb").Collection<WithId<T>>>;
+    /**
+     * Returns the collection to operate with
+     *
+     * @protected
+     * @param {boolean} [forRead]
+     * @param {boolean} [forceIndexAwait=false]
+     * @returns {Promise<import('mongodb').Collection<WithId<T>>>}
+     */
+    protected _getCollection(forRead?: boolean, forceIndexAwait?: boolean): Promise<import("mongodb").Collection<WithId<T>>>;
+    /**
+     *
+     * @param {object[]} indexes
+     * @param {import('mongodb').Collection<WithId<T>>} collection
+     * @returns {Promise}
+     */
+    _ensureIndexes(indexes: object[], collection: import("mongodb").Collection<WithId<T>>): Promise<any>;
+    _checkExistingIndexes(collection: any): Promise<any>;
+    _checkFixtures(collection: any): Promise<any[]>;
+    /**
+     *
+     * @template T
+     * @protected
+     * @param {T} object
+     * @returns {Promise<T>}
+     */
+    protected _sign<T_1>(object: T_1): Promise<T_1>;
+    /**
+     *
+     * @protected
+     * @template T
+     * @param {T} object
+     * @returns {T}
+     */
+    protected _objectToSign<T_1>(object: T_1): T_1;
+    /**
+     *
+     * @template T
+     * @param {T} objToSign
+     * @param {string} secret
+     * @param {string} [previous]
+     * @returns {string}
+     */
+    _signWithSecret<T_1>(objToSign: T_1, secret: string, previous?: string): string;
+    /**
+     * Drop collection
+     *
+     * @returns {Promise}
+     */
+    drop(): Promise<any>;
+}
+declare namespace BaseStorage {
+    export { Db, Document, CreateIndexesOptions, CustomIdentifier, WithId };
+}
+import { ObjectId } from "mongodb";
+type Db = import("mongodb").Db;
+type Document = import("mongodb").Document;
+type CreateIndexesOptions = import("mongodb").CreateIndexesOptions;
+type CustomIdentifier<T> = {
+    _id: T;
+};
+type WithId<T extends unknown> = T & CustomIdentifier<ObjectId>;