wingbot-mongodb 4.2.7 → 4.2.9

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>;