wingbot-mongodb 4.2.6 → 4.2.8

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "wingbot-mongodb",
-  "version": "4.2.6",
+  "version": "4.2.8",
   "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,6 +176,10 @@ class BaseStorage {
         return e;
     }
 
+    /**
+     *
+     * @returns {Promise<import('mongodb').Collection<WithId<T>>>}
+     */
     preHeat () {
         return this._getCollection();
     }
@@ -172,7 +187,7 @@ class BaseStorage {
     /**
      * 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,7 +295,7 @@ class BaseStorage {
      *
      * @protected
      * @param {boolean} [forRead]
-     * @returns {Promise<import('mongodb').Collection<wingbotmongodb.WithId<T>>>}
+     * @returns {Promise<import('mongodb').Collection<WithId<T>>>}
      */
     async _getCollection (forRead = false) {
         if (this._collection === null) {
@@ -311,7 +326,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,188 @@
+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]
+     * @returns {Promise<import('mongodb').Collection<WithId<T>>>}
+     */
+    protected _getCollection(forRead?: 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>;

package/types/BotConfigStorage.d.ts

@@ -0,0 +1,74 @@
+export = BotConfigStorage;
+/**
+ * Storage for wingbot.ai conversation config
+ *
+ * @class
+ */
+declare class BotConfigStorage {
+    /**
+     *
+     * @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>;
+    /**
+     * Returns botUpdate API for wingbot
+     *
+     * @param {Function} [onUpdate] - async update handler function
+     * @param {Function|string[]} [acl] - acl configuration
+     * @returns {{updateBot:Function}}
+     */
+    api(onUpdate?: Function, acl?: Function | string[]): {
+        updateBot: Function;
+    };
+    /**
+     * Invalidates current configuration
+     *
+     * @returns {Promise}
+     */
+    invalidateConfig(): Promise<any>;
+    /**
+     * @returns {Promise<number>}
+     */
+    getConfigTimestamp(): Promise<number>;
+    /**
+     * @template T
+     * @param {T} newConfig
+     * @param {string} [id]
+     * @returns {Promise<T>}
+     */
+    updateConfig<T>(newConfig: T, id?: string): Promise<T>;
+    /**
+     *
+     * @param {string} id
+     * @param {object} newConfig
+     */
+    setConfig(id: string, newConfig: object): Promise<void>;
+    /**
+     * @param {string} [id]
+     * @returns {Promise<object | null>}
+     */
+    getConfig(id?: string): Promise<object | null>;
+}
+declare namespace BotConfigStorage {
+    export { BaseConfig, Db, Collection };
+}
+type BaseConfig = {
+    [key: string]: any;
+} & {
+    _id: string;
+};
+type Db = import("mongodb").Db;
+type Collection = import("mongodb").Collection<BaseConfig>;

package/types/BotTokenStorage.d.ts

@@ -0,0 +1,61 @@
+export = BotTokenStorage;
+/**
+ * @typedef {object} Token
+ * @prop {string} senderId
+ * @prop {string} pageId
+ * @prop {string} token
+ */
+/** @typedef {import('mongodb').Db} Db */
+/** @typedef {import('mongodb').Collection} Collection */
+/**
+ * Storage for webview tokens
+ *
+ * @class
+ */
+declare class BotTokenStorage {
+    /**
+     *
+     * @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} token
+     * @returns {Promise<Token|null>}
+     */
+    findByToken(token: string): Promise<Token | null>;
+    /**
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @param {{(): Promise<string>}} createToken
+     * @returns {Promise<Token|null>}
+     */
+    getOrCreateToken(senderId: string, pageId: string, createToken?: {
+        (): Promise<string>;
+    }): Promise<Token | null>;
+    _wait(ms: any): Promise<any>;
+}
+declare namespace BotTokenStorage {
+    export { Token, Db, Collection };
+}
+type Token = {
+    senderId: string;
+    pageId: string;
+    token: string;
+};
+type Db = import("mongodb").Db;
+type Collection = import("mongodb").Collection;

package/types/ChatLogStorage.d.ts

@@ -0,0 +1,66 @@
+export = ChatLogStorage;
+/** @typedef {import('mongodb').Db} Db */
+/**
+ * Storage for conversation logs
+ *
+ * @class
+ */
+declare class ChatLogStorage 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]
+     */
+    constructor(mongoDb: Db | {
+        (): Promise<Db>;
+    }, collectionName?: string, log?: {
+        error: Function;
+        log: Function;
+    }, isCosmo?: boolean, secret?: string | Promise<string>);
+    muteErrors: boolean;
+    _secret: string | Promise<string>;
+    /**
+     * Interate history
+     * all limits are inclusive
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @param {number} [limit]
+     * @param {number} [endAt] - iterate backwards to history
+     * @param {number} [startAt] - iterate forward to last interaction
+     * @returns {Promise<object[]>}
+     */
+    getInteractions(senderId: string, pageId: string, limit?: number, endAt?: number, startAt?: number): Promise<object[]>;
+    /**
+     * Log single event
+     *
+     * @param {string} senderId
+     * @param {object[]} responses - list of sent responses
+     * @param {object} request - event request
+     * @param {object} [metadata] - request metadata
+     * @returns {Promise}
+     */
+    log(senderId: string, responses?: object[], request?: object, metadata?: object): Promise<any>;
+    _storeLog(event: any): Promise<void>;
+    /**
+     * Log single event
+     *
+     * @method
+     * @name ChatLog#error
+     * @param {any} err - error
+     * @param {string} senderId
+     * @param {object[]} [responses] - list of sent responses
+     * @param {object} [request] - event request
+     * @param {object} [metadata] - request metadata
+     * @returns {Promise}
+     */
+    error(err: any, senderId: string, responses?: object[], request?: object, metadata?: object): Promise<any>;
+}
+declare namespace ChatLogStorage {
+    export { Db };
+}
+import BaseStorage = require("./BaseStorage");
+type Db = import("mongodb").Db;

package/types/NotificationsStorage.d.ts

@@ -0,0 +1,295 @@
+export = NotificationsStorage;
+declare class NotificationsStorage {
+    /**
+     *
+     * @param {mongodb.Db|{():Promise<mongodb.Db>}} mongoDb
+     * @param {string} collectionsPrefix
+     * @param {{error:Function,log:Function}} [log] - console like logger
+     * @param {boolean} isCosmo
+     */
+    constructor(mongoDb: mongodb.Db | {
+        (): Promise<mongodb.Db>;
+    }, collectionsPrefix?: string, log?: {
+        error: Function;
+        log: Function;
+    }, isCosmo?: boolean);
+    _mongoDb: mongodb.Db | (() => Promise<mongodb.Db>);
+    taksCollection: string;
+    campaignsCollection: string;
+    subscribtionsCollection: string;
+    _isCosmo: boolean;
+    _log: {
+        error: Function;
+        log: Function;
+    };
+    /**
+     * @type {Map<string,Promise<mongodb.Collection>>}
+     */
+    _collections: Map<string, Promise<mongodb.Collection>>;
+    _getOrCreateCollection(name: any): Promise<mongodb.Collection<mongodb.BSON.Document>>;
+    /**
+     * @param {string} collectionName
+     * @returns {Promise<mongodb.Collection>}
+     */
+    _getCollection(collectionName: string): Promise<mongodb.Collection>;
+    _ensureIndexes(collection: any, indexes: any): Promise<void>;
+    _doesNotSupportTextIndex: boolean;
+    /**
+     *
+     * @param {object} tasks
+     * @returns {Promise<Task[]>}
+     */
+    pushTasks(tasks: object): Promise<Task[]>;
+    _mapGenericObject(obj: any): any;
+    _mapCampaign(camp: any): any;
+    popTasks(limit: any, until?: number): Promise<any[]>;
+    /**
+     *
+     * @param {string} campaignId
+     * @param {boolean} [sentWithoutReaction]
+     * @param {string} [pageId]
+     */
+    getUnsuccessfulSubscribersByCampaign(campaignId: string, sentWithoutReaction?: boolean, pageId?: string): Promise<mongodb.BSON.Document[]>;
+    /**
+     * Return Task By Id
+     *
+     * @param {string} taskId
+     * @returns {Promise<Task|null>}
+     */
+    getTaskById(taskId: string): Promise<Task | null>;
+    /**
+     *
+     * @param {string} taskId
+     * @param {object} data
+     */
+    updateTask(taskId: string, data: object): Promise<any>;
+    /**
+     * Get last sent task from campaign
+     *
+     * @param {string} pageId
+     * @param {string} senderId
+     * @param {string} campaignId
+     * @returns {Promise<Task|null>}
+     */
+    getSentTask(pageId: string, senderId: string, campaignId: string): Promise<Task | null>;
+    /**
+     *
+     * @param {string} pageId
+     * @param {string} senderId
+     * @param {string[]} checkCampaignIds
+     * @returns {Promise<string[]>}
+     */
+    getSentCampagnIds(pageId: string, senderId: string, checkCampaignIds: string[]): Promise<string[]>;
+    /**
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @param {number} watermark
+     * @param {('read'|'delivery')} eventType
+     * @param {number} ts
+     * @returns {Promise<Task[]>}
+     */
+    updateTasksByWatermark(senderId: string, pageId: string, watermark: number, eventType: ("read" | "delivery"), ts?: number): Promise<Task[]>;
+    /**
+     *
+     * @param {object} campaign
+     * @param {object} [updateCampaign]
+     * @returns {Promise<Campaign>}
+     */
+    upsertCampaign(campaign: object, updateCampaign?: object): Promise<Campaign>;
+    /**
+     *
+     * @param {string} campaignId
+     * @returns {Promise}
+     */
+    removeCampaign(campaignId: string): Promise<any>;
+    /**
+     *
+     * @param {string} campaignId
+     * @param {object} increment
+     * @returns {Promise}
+     */
+    incrementCampaign(campaignId: string, increment?: object): Promise<any>;
+    /**
+     *
+     * @param {string} campaignId
+     * @param {object} data
+     * @returns {Promise<Campaign|null>}
+     */
+    updateCampaign(campaignId: string, data: object): Promise<Campaign | null>;
+    /**
+     *
+     * @param {number} [now]
+     * @returns {Promise<Campaign|null>}
+     */
+    popCampaign(now?: number): Promise<Campaign | null>;
+    /**
+     *
+     * @param {string} campaignId
+     * @returns {Promise<null|Campaign>}
+     */
+    getCampaignById(campaignId: string): Promise<null | Campaign>;
+    /**
+     *
+     * @param {string[]} campaignIds
+     * @returns {Promise<Campaign[]>}
+     */
+    getCampaignByIds(campaignIds: string[]): Promise<Campaign[]>;
+    /**
+     *
+     * @param {object} condition
+     * @param {number} [limit]
+     * @param {object} [lastKey]
+     * @returns {Promise<{data:Campaign[],lastKey:string}>}
+     */
+    getCampaigns(condition: object, limit?: number, lastKey?: object): Promise<{
+        data: Campaign[];
+        lastKey: string;
+    }>;
+    /**
+     *
+     * @param {SubscriptionData[]} subscriptionData
+     * @param {boolean} [onlyToKnown=false]
+     * @returns {Promise}
+     */
+    batchSubscribe(subscriptionData: SubscriptionData[], onlyToKnown?: boolean): Promise<any>;
+    /**
+     *
+     * @param {string|string[]} senderId
+     * @param {string} pageId
+     * @param {string} tag
+     * @param {boolean} [onlyToKnown]
+     * @returns {Promise}
+     */
+    subscribe(senderId: string | string[], pageId: string, tag: string, onlyToKnown?: boolean): Promise<any>;
+    /**
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @param {string} [tag]
+     * @returns {Promise<string[]>}
+     */
+    unsubscribe(senderId: string, pageId: string, tag?: string): Promise<string[]>;
+    _createSubscribtionsCondition(include: any, exclude: any, pageId?: any): {};
+    /**
+     *
+     * @param {string[]} include
+     * @param {string[]} exclude
+     * @param {string} [pageId]
+     * @returns {Promise<number>}
+     */
+    getSubscribtionsCount(include: string[], exclude: string[], pageId?: string): Promise<number>;
+    /**
+     *
+     * @param {string[]} include
+     * @param {string[]} exclude
+     * @param {number} limit
+     * @param {string} [pageId]
+     * @param {*} lastKey
+     * @returns {Promise<{data: Target[], lastKey: string }>}
+     */
+    getSubscribtions(include: string[], exclude: string[], limit: number, pageId?: string, lastKey?: any): Promise<{
+        data: Target[];
+        lastKey: string;
+    }>;
+    /**
+     * @param {string} senderId
+     * @param {string} pageId
+     * @returns {Promise<Subscription[]>}
+     */
+    getSenderSubscriptions(senderId: string, pageId: string): Promise<Subscription[]>;
+    /**
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @returns {Promise<string[]>}
+     */
+    getSenderSubscribtions(senderId: string, pageId: string): Promise<string[]>;
+    getTags(pageId?: any): Promise<{
+        tag: any;
+        subscribtions: any;
+    }[]>;
+}
+declare namespace NotificationsStorage {
+    export { Target, Subscribtion, Campaign, Task, Subscription, SubscriptionData };
+}
+import mongodb = require("mongodb");
+type Target = {
+    senderId: string;
+    pageId: string;
+    meta?: {
+        [key: string]: object;
+    };
+};
+type Subscribtion = {
+    senderId: string;
+    pageId: string;
+    subs: string[];
+};
+type Campaign = {
+    id: string;
+    /**
+     * Tatgeting
+     */
+    name: string;
+    include: string[];
+    /**
+     * Stats
+     */
+    exclude: string[];
+    sent: number;
+    succeeded: number;
+    failed: number;
+    unsubscribed: number;
+    delivery: number;
+    read: number;
+    notSent: number;
+    leaved: number;
+    /**
+     * Interaction
+     */
+    queued: number;
+    action: string;
+    /**
+     * Setup
+     */
+    data?: object;
+    sliding: boolean;
+    slide: number;
+    slideRound: number;
+    active: boolean;
+    in24hourWindow: boolean;
+    startAt: number;
+};
+type Task = {
+    id: string;
+    pageId: string;
+    senderId: string;
+    campaignId: string;
+    enqueue: number;
+    read?: number;
+    delivery?: number;
+    sent?: number;
+    insEnqueue?: number;
+    /**
+     * - user reacted
+     */
+    reaction?: boolean;
+    /**
+     * - time the event was not sent because user left
+     */
+    leaved?: number;
+};
+type Subscription = {
+    tag: string;
+    meta: object;
+};
+type SubscriptionData = {
+    pageId: string;
+    senderId: string;
+    tags: string[];
+    remove?: boolean;
+    meta?: {
+        [key: string]: object;
+    };
+};

package/types/StateStorage.d.ts

@@ -0,0 +1,97 @@
+export = StateStorage;
+/**
+ * @typedef {object} State
+ * @prop {string} senderId
+ * @prop {string} pageId
+ * @prop {object} state
+ */
+/**
+ * @typedef {object} StateCondition
+ * @prop {string} [search]
+ * @prop {string[]} [senderIds]
+ * @prop {string} [pageId]
+ */
+/** @typedef {import('mongodb').Db} Db */
+/**
+ * Storage for chat states
+ *
+ * @class
+ */
+declare class StateStorage extends BaseStorage<any> {
+    /**
+     *
+     * @param {Db|{():Promise<Db>}} mongoDb
+     * @param {string} collectionName
+     * @param {{error:Function,log:Function}} [log] - console like logger
+     * @param {boolean|number} isCosmo - boolean or number of failures in last 10min to kill app
+     */
+    constructor(mongoDb: Db | {
+        (): Promise<Db>;
+    }, collectionName?: string, log?: {
+        error: Function;
+        log: Function;
+    }, isCosmo?: boolean | number);
+    logCollisionsAsErrors: boolean;
+    /**
+     * Add custom indexing rule
+     *
+     * @param {object} index
+     * @param {object} options
+     * @param {string} options.name
+     * @deprecated
+     */
+    addCustomIndex(index: object, options: {
+        name: string;
+    }): void;
+    /**
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @returns {Promise<State|null>}
+     */
+    getState(senderId: string, pageId: string): Promise<State | null>;
+    /**
+     * Load state from database and lock it to prevent another reads
+     *
+     * @param {string} senderId - sender identifier
+     * @param {string} pageId - page identifier
+     * @param {object} [defaultState] - default state of the conversation
+     * @param {number} [timeout=300] - given default state
+     * @returns {Promise<object>} - conversation state
+     */
+    getOrCreateAndLock(senderId: string, pageId: string, defaultState?: object, timeout?: number): Promise<object>;
+    /**
+     *
+     * @param {StateCondition} condition
+     * @param {number} limit
+     * @param {string} lastKey
+     * @returns {Promise<{data:State[],lastKey:string}>}
+     */
+    getStates(condition?: StateCondition, limit?: number, lastKey?: string): Promise<{
+        data: State[];
+        lastKey: string;
+    }>;
+    _mapState(state: any): any;
+    /**
+     * Save the state to database
+     *
+     * @param {object} state - conversation state
+     * @returns {Promise<object>}
+     */
+    saveState(state: object): Promise<object>;
+}
+declare namespace StateStorage {
+    export { State, StateCondition, Db };
+}
+import BaseStorage = require("./BaseStorage");
+type State = {
+    senderId: string;
+    pageId: string;
+    state: object;
+};
+type StateCondition = {
+    search?: string;
+    senderIds?: string[];
+    pageId?: string;
+};
+type Db = import("mongodb").Db;

package/types/compact.d.ts

@@ -0,0 +1,53 @@
+export = compact;
+/**
+ * @param {Db} db
+ * @param {string} dbUrl
+ * @param {string} dbName
+ * @param {any} log
+ * @returns {Promise<{bytesFreed: number}>}
+ */
+declare function compact(db: Db, dbUrl: string, dbName: string, log?: any): Promise<{
+    bytesFreed: number;
+}>;
+declare namespace compact {
+    export { compactNode, getCompactableCollections, getReplicaSetNodes, Db };
+}
+/**
+ * Compacts all collections on a given replica set node
+ *
+ * @param {object} props
+ * @param {string} props.nodeUrl
+ * @param {boolean} [props.force]
+ * @param {string} props.dbUrl
+ * @param {string} props.dbName
+ * @param {string[]} props.collections
+ * @param {any} props.log
+ * @returns {Promise<{bytesFreed:number}>}
+ */
+declare function compactNode({ nodeUrl, collections, force, dbUrl, dbName, log }: {
+    nodeUrl: string;
+    force?: boolean;
+    dbUrl: string;
+    dbName: string;
+    collections: string[];
+    log: any;
+}): Promise<{
+    bytesFreed: number;
+}>;
+/** @typedef {import('mongodb').Db} Db */
+/**
+ * @param {Db} db
+ * @returns {Promise<string[]>}
+ */
+declare function getCompactableCollections(db: Db): Promise<string[]>;
+/**
+ * Returns host addresses of replica set nodes
+ *
+ * @param {Db} db
+ * @returns {Promise<{primary: string, secondaries: string[]}>}
+ */
+declare function getReplicaSetNodes(db: Db): Promise<{
+    primary: string;
+    secondaries: string[];
+}>;
+type Db = import("mongodb").Db;

package/types/defaultLogger.d.ts

@@ -0,0 +1,4 @@
+export function log(...args: any[]): void;
+export declare function error(...args: any[]): void;
+export declare function warn(...args: any[]): void;
+export { log as info, log as debug };

package/types/getNestedObjects.d.ts

@@ -0,0 +1,10 @@
+export = getNestedObjects;
+/**
+ *
+ * @param {any} obj
+ * @param {boolean} nested
+ * @param {string} [attr]
+ * @param {object} [ret]
+ * @returns {object}
+ */
+declare function getNestedObjects(obj: any, nested: boolean, attr?: string, ret?: object): object;

package/types/main.d.ts

@@ -0,0 +1,9 @@
+import BaseStorage = require("./BaseStorage");
+import StateStorage = require("./StateStorage");
+import BotTokenStorage = require("./BotTokenStorage");
+import ChatLogStorage = require("./ChatLogStorage");
+import BotConfigStorage = require("./BotConfigStorage");
+import AttachmentCache = require("./AttachmentCache");
+import NotificationsStorage = require("./NotificationsStorage");
+import AuditLogStorage = require("./AuditLogStorage");
+export { BaseStorage, StateStorage, BotTokenStorage, ChatLogStorage, BotConfigStorage, AttachmentCache, NotificationsStorage, AuditLogStorage };

package/types/tokenFactory.d.ts

@@ -0,0 +1,5 @@
+export = tokenFactory;
+/**
+ * @returns {Promise.<string>}
+ */
+declare function tokenFactory(): Promise<string>;

package/baseStorage.d.ts

@@ -1,50 +0,0 @@
-'use strict';
-
-declare namespace wingbotmongodb {
-
-    type Collection<T> = import('mongodb').Collection<T>;
-    type Db = import('mongodb').Db;
-    type CreateIndexesOptions = import('mongodb').CreateIndexesOptions;
-    type ObjectId = import('mongodb').ObjectId;
-    export interface Logger {
-        log: {(...any): void}
-        error: {(...any): void}
-    }
-
-    export type WithId<T extends object> = T & { _id: ObjectId };
-
-    export class BaseStorage<T = {}> {
-
-        constructor (
-            mongoDb: Db|{():Promise<Db>},
-            collectionName: string,
-            log?: Logger,
-            isCosmo?: boolean
-        )
-
-        _getCollection (forRead?: boolean): Promise<Collection<WithId<T>>>
-
-        public addFixtureDoc (...any: T)
-
-        public addIndex (index: object, options: CreateIndexesOptions)
-
-        protected _id (id: string): ObjectId
-
-        protected _expandObjectToSet (
-            attr: string|null,
-            obj: {[key: string]: any},
-            nested?: boolean
-        ): {[key: string]: any}
-
-        protected _log: { log: Function, error: Function };
-
-        public preHeat(): Promise<void>
-
-        public drop (): Promise<void>
-
-        protected _catchNetworkIssues<I> (fn: {():I}): Promise<I>
-
-        protected _detectNetworkIssueException<E extends Error> (e: E): E
-    }
-
-}