@ductape/sdk 0.0.4-v99 → 0.0.5

package/dist/index.d.ts

@@ -238,7 +238,7 @@ export { uploadBlobToCloud, downloadBlobFromCloud, deleteBlobFromCloud, listBlob
 export type { IStorageServiceConfig, IUploadOptions, IDownloadOptions, IDeleteOptions, IListFilesOptions, ISignedUrlOptions, IStorageResult, IDownloadResult, IDeleteResult as IStorageDeleteResult, IListFilesResult, ISignedUrlResult, IStorageDispatchOptions, IStorageDispatchResult, IStorageProviderConfig, IStorageFileInfo, } from './storage';
 export { SessionsService, SessionError } from './sessions';
 export type { ISessionServiceConfig, ICreateSessionOptions, IRefreshSessionOptions, IVerifySessionOptions, IRevokeSessionOptions, IListSessionsOptions, IDefineSessionOptions, ISessionResult, IVerifyResult, IListSessionsResult, ISessionInfo, ISessionSchema, ISessionSchemaField, ISessionContext, IDefinedSession, } from './sessions';
-export { CacheService, CacheError } from './cache';
+export { CacheService, CacheError, cacheLogger, CacheLogger } from './cache';
 export type { ICacheServiceConfig, ICacheValue, IFetchCacheValuesOptions, IFetchCacheValuesResult, IFetchCacheDashboardOptions, ICacheDashboardMetrics, IClearCacheValueOptions, IClearCacheValuesOptions, IClearCacheValuesResult, ISetCacheValueOptions, IGetCacheValueOptions, IDeleteCacheValueOptions, IDeleteCacheValuesOptions, IDeleteCacheValuesResult, } from './cache';
 export { BrokersService, BrokerError } from './brokers';
 export { RabbitMQService, KafkaService, SQSService, RedisService, GooglePubSubService, loadBrokerService, parseEventString, isValidSqsUrl, getSqsQueueUrl, } from './brokers';
@@ -285,6 +285,7 @@ export default class Ductape implements IDuctape {
     private _quotaService;
     private _fallbackService;
     private _healthcheckService;
+    private _brokersService;
     private loggerService;
     private importService;
     private environment;
@@ -297,6 +298,11 @@ export default class Ductape implements IDuctape {
     healthCheckWorker: any;
     healthCheckUpdaterWorker: any;
     private loadRedis;
+    /**
+     * Connect to Redis for caching purposes (lazy initialization)
+     * This is separate from monitor() which sets up job queues
+     */
+    private connectCacheRedis;
     constructor({ accessKey, env_type, redis_url }: IDuctapeInit);
     private loadBullMQ;
     /**
@@ -494,7 +500,7 @@ export default class Ductape implements IDuctape {
          * @param {IFetchUsersPayload} data - The user fetch payload.
          * @returns {Promise<any[]>} The users for the session.
          */
-        users: (product: string, data: IFetchUsersPayload) => Promise<import("./types").IFileURLPayload[]>;
+        users: (data: IFetchUsersPayload) => Promise<import("./types").IFileURLPayload[]>;
         /**
          * Deletes a product session by tag.
          * @param {string} product - The product tag.
@@ -560,6 +566,39 @@ export default class Ductape implements IDuctape {
             page?: number;
             limit?: number;
         }) => Promise<import("./sessions").IListSessionsResult>;
+        /**
+         * Fetches paginated session users.
+         * @param data - The fetch users payload.
+         * @returns The paginated list of session users.
+         */
+        fetchUsers: (data: {
+            product: string;
+            session: string;
+            env?: string;
+            page?: number;
+            limit?: number;
+        }) => Promise<import("./sessions").IFetchSessionUsersResult>;
+        /**
+         * Fetches detailed information for a specific session user.
+         * @param data - The fetch user details payload.
+         * @returns The user details with their sessions.
+         */
+        fetchUserDetails: (data: {
+            product: string;
+            session: string;
+            identifier: string;
+            env?: string;
+        }) => Promise<import("./sessions").ISessionUserDetails>;
+        /**
+         * Fetches session dashboard metrics.
+         * @param data - The fetch dashboard payload.
+         * @returns The dashboard metrics for the session.
+         */
+        fetchDashboard: (data: {
+            product: string;
+            session: string;
+            env?: string;
+        }) => Promise<import("./sessions").ISessionDashboardMetrics>;
     };
     /**
      * Quota-related operations for managing product quotas with weighted distribution.
@@ -942,6 +981,7 @@ export default class Ductape implements IDuctape {
         listFiles: (data: {
             product: string;
             env: string;
+            cache?: string;
             storage: string;
             prefix?: string;
             limit?: number;
@@ -1002,7 +1042,10 @@ export default class Ductape implements IDuctape {
              * });
              * @deprecated Use upload() instead for direct cloud storage operations
              */
-            save: (data: IStorageProcessorInput) => Promise<any>;
+            save: (data: IStorageProcessorInput) => Promise<{
+                process_id: string;
+                output: any;
+            }>;
             /**
              * Uploads a file to cloud storage.
              * @param {Object} data - The upload options.
@@ -1215,12 +1258,23 @@ export default class Ductape implements IDuctape {
          *   event: 'broker-tag:topic-tag',
          *   message: { orderId: '123', status: 'pending' }
          * });
+         * @example
+         * // With session token for user-context publishing
+         * await ductape.events.produce({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   event: 'broker-tag:topic-tag',
+         *   message: { orderId: '123', status: 'pending' },
+         *   session: 'session-token-from-sessions.start()'
+         * });
          */
         produce: (data: {
             product: string;
             env: string;
             event: string;
             message: Record<string, unknown>;
+            session?: string;
+            cache?: string;
         }) => Promise<import("./brokers").IPublishResult>;
         /**
          * consume to a message broker topic.
@@ -1266,6 +1320,107 @@ export default class Ductape implements IDuctape {
          * });
          */
         dispatch: (data: IPublishDispatchInput) => Promise<IDispatchResult>;
+        /**
+         * Messages namespace for broker message tracking and queries.
+         * All query methods decrypt message content before returning.
+         */
+        messages: {
+            /**
+             * Query broker messages with filtering and pagination.
+             * Messages are decrypted before returning.
+             */
+            query: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+                topicTag?: string;
+                producerTag?: string;
+                consumerTag?: string;
+                status?: string;
+                startDate?: string;
+                endDate?: string;
+                page?: number;
+                limit?: number;
+            }) => Promise<{
+                messages: any[];
+                total: number;
+                page: number;
+                limit: number;
+                hasMore: boolean;
+            }>;
+            /**
+             * Get broker producers with pagination.
+             */
+            getProducers: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+                topicTag?: string;
+                page?: number;
+                limit?: number;
+            }) => Promise<{
+                producers: any[];
+                total: number;
+                page: number;
+                limit: number;
+                hasMore: boolean;
+            }>;
+            /**
+             * Get broker consumers with pagination.
+             */
+            getConsumers: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+                topicTag?: string;
+                page?: number;
+                limit?: number;
+            }) => Promise<{
+                consumers: any[];
+                total: number;
+                page: number;
+                limit: number;
+                hasMore: boolean;
+            }>;
+            /**
+             * Get broker dead letters with pagination.
+             * Messages are decrypted before returning.
+             */
+            getDeadLetters: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+                topicTag?: string;
+                consumerTag?: string;
+                startDate?: string;
+                endDate?: string;
+                page?: number;
+                limit?: number;
+            }) => Promise<{
+                deadLetters: any[];
+                total: number;
+                page: number;
+                limit: number;
+                hasMore: boolean;
+            }>;
+            /**
+             * Get comprehensive broker message statistics.
+             */
+            getStats: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+            }) => Promise<any>;
+            /**
+             * Get broker dashboard overview data.
+             * Recent messages are decrypted before returning.
+             */
+            getDashboard: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+            }) => Promise<any>;
+        };
     };
     /**
      * Notification-related operations for managing product notifications.
@@ -1337,6 +1492,86 @@ export default class Ductape implements IDuctape {
              */
             update: (product: string, tag: string, data: Partial<IProductNotificationTemplate>) => Promise<void>;
         };
+        /**
+         * Send a notification via the email channel only.
+         * @param options - Email options (product, env, notification, input, session?, cache?).
+         * @returns {Promise<any>} The result of the notification processing.
+         * @example
+         * await ductape.notifications.email.send({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'emails:order-confirmation',
+         *   input: { recipients: ['user@example.com'], subject: { orderId: '123' }, template: { ... } }
+         * });
+         */
+        email: {
+            send: (options: import("./notifications").IEmailOptions) => Promise<{
+                process_id: string;
+                output: {
+                    sent: boolean;
+                };
+            }>;
+        };
+        /**
+         * Send a notification via the push channel only.
+         * @param options - Push options (product, env, notification, input, session?, cache?).
+         * @returns {Promise<any>} The result of the notification processing.
+         * @example
+         * await ductape.notifications.push.send({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'alerts:welcome-message',
+         *   input: { device_tokens: ['token1'], title: { name: 'John' }, body: { message: 'Welcome!' }, data: {} }
+         * });
+         */
+        push: {
+            send: (options: import("./notifications").IPushOptions) => Promise<{
+                process_id: string;
+                output: {
+                    sent: boolean;
+                };
+            }>;
+        };
+        /**
+         * Send a notification via the SMS channel only.
+         * @param options - SMS options (product, env, notification, input, session?, cache?).
+         * @returns {Promise<any>} The result of the notification processing.
+         * @example
+         * await ductape.notifications.sms.send({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'sms:verification',
+         *   input: { recipients: ['+1234567890'], body: { code: '123456' } }
+         * });
+         */
+        sms: {
+            send: (options: import("./notifications").ISmsOptions) => Promise<{
+                process_id: string;
+                output: {
+                    sent: boolean;
+                };
+            }>;
+        };
+        /**
+         * Send a notification via the callback (webhook) channel only.
+         * @param options - Callback options (product, env, notification, input, session?, cache?).
+         * @returns {Promise<any>} The result of the notification processing.
+         * @example
+         * await ductape.notifications.callback.send({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'webhooks:order-created',
+         *   input: { body: { orderId: '123' }, headers: { 'X-Custom': 'value' }, query: {}, params: {} }
+         * });
+         */
+        callback: {
+            send: (options: import("./notifications").ICallbackOptions) => Promise<{
+                process_id: string;
+                output: {
+                    sent: boolean;
+                };
+            }>;
+        };
         /**
          * Sends a notification immediately using the notification processor.
          * @param {INotificationProcessorInput} data - The notification processor input.
@@ -1351,6 +1586,9 @@ export default class Ductape implements IDuctape {
          */
         send: (data: INotificationProcessorInput) => Promise<{
             process_id: string;
+            output: {
+                sent: boolean;
+            };
         }>;
         /**
          * Dispatches a notification to be sent as a scheduled job.
@@ -1378,6 +1616,48 @@ export default class Ductape implements IDuctape {
          * });
          */
         dispatch: (data: INotificationDispatchInput) => Promise<IDispatchResult>;
+        /**
+         * Fetches notification message logs (send history) with time filters. Secured via user auth.
+         * @param {Object} options - Query options.
+         * @param {string} [options.product_tag] - Product tag filter (e.g. ductape:rematch).
+         * @param {string} [options.env] - Environment slug filter (e.g. prd).
+         * @param {string} [options.notification_tag] - Notification event filter (e.g. rematch-notifications:order-placed).
+         * @param {string} [options.status] - Status filter: pending | sent | failed | reprocessing.
+         * @param {string} [options.type] - Type filter: email | push | sms | callback | notification.
+         * @param {string|Date} [options.start_date] - Start of time range (ISO string or Date).
+         * @param {string|Date} [options.end_date] - End of time range (ISO string or Date).
+         * @param {number} [options.page] - Page number (default 1).
+         * @param {number} [options.limit] - Page size (default 20).
+         * @returns {Promise<{ items: any[]; total: number; page: number; limit: number; hasMore: boolean }>}
+         * @example
+         * const { items, total, hasMore } = await ductape.notifications.getMessages({
+         *   product_tag: 'ductape:rematch',
+         *   env: 'prd',
+         *   start_date: new Date(Date.now() - 7 * 864e5).toISOString(),
+         *   end_date: new Date().toISOString(),
+         *   page: 1,
+         *   limit: 50,
+         * });
+         */
+        getMessages: (options: {
+            product_tag?: string;
+            product_id?: string;
+            env?: string;
+            notification_tag?: string;
+            status?: string;
+            type?: string;
+            process_id?: string;
+            start_date?: string | Date;
+            end_date?: string | Date;
+            page?: number;
+            limit?: number;
+        }) => Promise<{
+            items: any[];
+            total: number;
+            page: number;
+            limit: number;
+            hasMore: boolean;
+        }>;
     };
     /**
      * Database operations service.
@@ -2244,6 +2524,7 @@ export default class Ductape implements IDuctape {
             values: number[];
             metadata?: Record<string, unknown>;
             namespace?: string;
+            session?: string;
         }) => Promise<import("./vector").IUpsertVectorsResult>;
         /**
          * Fetch a single vector by ID.
@@ -3115,6 +3396,7 @@ export default class Ductape implements IDuctape {
             env?: string;
             page?: number;
             limit?: number;
+            expiryFilter?: "all" | "expiring" | "permanent" | "expired";
         }) => Promise<import("./cache").IFetchCacheValuesResult>;
         /**
          * Fetch cache dashboard metrics.
@@ -3689,7 +3971,7 @@ export default class Ductape implements IDuctape {
      */
     private createNewStorageService;
     /**
-     * Create a new BrokersService instance with authenticated config
+     * Get or create a BrokersService instance with authenticated config (cached)
      * @returns BrokersService instance
      */
     private createNewBrokersService;