@zintrust/core 0.1.15 → 0.1.16

package/src/session/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/session/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC"}

package/src/session/index.js

@@ -0,0 +1 @@
+export { SessionManager } from './SessionManager.js';

package/src/templates/features/Queue.ts.tpl

@@ -1,6 +1,7 @@
 // TEMPLATE_START
 
-import { generateSecureJobId, Logger } from '@zintrust/core';
+import { generateSecureJobId } from '@common/uuid';
+import { Logger } from '@config/logger';
 
 export interface QueueJob {
   id: string;
@@ -19,7 +20,7 @@ export const Queue = Object.freeze({
    * Add a job to the queue
    */
   async add<T>(data: T): Promise<string> {
-    const id = await generateSecureJobId();
+    const id = generateSecureJobId();
     const job: QueueJob = {
       id,
       data,
@@ -43,4 +44,4 @@ export const Queue = Object.freeze({
   },
 });
 
-// TEMPLATE_END
+// TEMPLATE_END

package/src/templates/project/basic/config/FileLogWriter.ts.tpl

@@ -1,14 +1,15 @@
 /**
  * FileLogWriter (Node.js only)
- * Re-exports core FileLogWriter for optional use
+ *
+ * Provides best-effort file logging with daily + size-based rotation.
+ * This module imports Node built-ins and should be loaded only in Node environments.
  */
 
 import { ensureDirSafe } from '@zintrust/core';
+import { Env } from './env';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 
-import { Env } from './env';
-
 const getCwdSafe = (): string => {
   try {
     if (typeof process === 'undefined' || typeof process.cwd !== 'function') return '';

package/src/templates/project/basic/config/SecretsManager.ts.tpl

@@ -4,7 +4,7 @@
  * Supports: AWS Secrets Manager, Parameter Store, Cloudflare KV, Deno env
  */
 
-import { Logger } from '@zintrust/core';
+import { Logger } from './logger';
 import type {
   GetSecretOptions,
   SecretConfig,

package/src/templates/project/basic/config/broadcast.ts.tpl

@@ -5,7 +5,7 @@
  * Driver selection must be dynamic (tests may mutate process.env).
  */
 
-import { Env } from '@config/env';
+import { Env } from './env';
 import {
   BroadcastConfigInput,
   BroadcastDrivers,
@@ -14,7 +14,7 @@ import {
   PusherBroadcastDriverConfig,
   RedisBroadcastDriverConfig,
   RedisHttpsBroadcastDriverConfig,
-} from '@config/type';
+} from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const normalizeDriverName = (value: string): string => value.trim().toLowerCase();

package/src/templates/project/basic/config/cache.ts.tpl

@@ -4,8 +4,8 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@config/env';
-import { CacheConfigInput, CacheDriverConfig } from '@config/type';
+import { Env } from './env';
+import { CacheConfigInput, CacheDriverConfig } from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const getCacheDriver = (config: CacheConfigInput, name?: string): CacheDriverConfig => {

package/src/templates/project/basic/config/database.ts.tpl

@@ -4,8 +4,8 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@config/env';
-import { DatabaseConfigShape, DatabaseConnectionConfig, DatabaseConnections } from '@config/type';
+import { Env } from './env';
+import { DatabaseConfigShape, DatabaseConnectionConfig, DatabaseConnections } from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const hasOwn = (obj: Record<string, unknown>, key: string): boolean => {

package/src/templates/project/basic/config/features.ts.tpl

@@ -1,5 +1,5 @@
-import { Env } from '@zintrust/core';
-import { Logger } from '@zintrust/core';
+import { Env } from './env';
+import { Logger } from './logger';
 
 /**
  * Feature Flags State

package/src/templates/project/basic/config/logger.ts.tpl

@@ -3,8 +3,6 @@
  * Sealed namespace pattern - all exports through Logger namespace
  * Replaces console.* calls throughout the codebase
  */
-import { Logger } from '@zintrust/core';
-
 import { appConfig } from './app';
 import { Env } from './env';
 

package/src/templates/project/basic/config/logging/HttpLogger.ts.tpl

@@ -10,7 +10,7 @@
  */
 
 import { delay } from '@zintrust/core';
-import { Env } from '@zintrust/core';
+import { Env } from '../env';
 import { ErrorFactory } from '@zintrust/core';
 import { HttpClient } from '@zintrust/core';
 

package/src/templates/project/basic/config/logging/SlackLogger.ts.tpl

@@ -9,7 +9,7 @@
  *  - SLACK_LOG_BATCH_WINDOW_MS (default: 5000)
  */
 
-import { Env } from '@zintrust/core';
+import { Env } from '../env';
 import { ErrorFactory } from '@zintrust/core';
 import { HttpClient } from '@zintrust/core';
 

package/src/templates/project/basic/config/mail.ts.tpl

@@ -4,8 +4,8 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@config/env';
-import type { MailConfigInput, MailDriverConfig } from '@config/type';
+import { Env } from './env';
+import type { MailConfigInput, MailDriverConfig } from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const isMailDriverConfig = (value: unknown): value is MailDriverConfig => {

package/src/templates/project/basic/config/microservices.ts.tpl

@@ -4,7 +4,7 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@zintrust/core';
+import { Env } from './env';
 
 const microservicesConfigObj = {
   /**

package/src/templates/project/basic/config/middleware.ts.tpl

@@ -1,13 +1,10 @@
-import {
-  CsrfMiddleware,
-  ErrorHandlerMiddleware,
-  LoggingMiddleware,
-  RateLimiter,
-  SecurityMiddleware,
-  type Middleware,
-} from '@zintrust/core';
-
 import { MiddlewareConfigType } from './type';
+import { CsrfMiddleware } from '@zintrust/core';
+import { ErrorHandlerMiddleware } from '@zintrust/core';
+import { LoggingMiddleware } from '@zintrust/core';
+import type { Middleware } from '@zintrust/core';
+import { RateLimiter } from '@zintrust/core';
+import { SecurityMiddleware } from '@zintrust/core';
 
 const shared = Object.freeze({
   log: LoggingMiddleware.create(),

package/src/templates/project/basic/config/notification.ts.tpl

@@ -5,13 +5,13 @@
  * Driver selection must be dynamic (tests may mutate process.env).
  */
 
-import { Env } from '@config/env';
+import { Env } from './env';
 import type {
   KnownNotificationDriverConfig,
   NotificationConfigInput,
   NotificationDrivers,
   NotificationProviders,
-} from '@config/type';
+} from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const normalizeName = (value: string): string => value.trim().toLowerCase();

package/src/templates/project/basic/config/security.ts.tpl

@@ -16,10 +16,9 @@
  * security domains (e.g., different keys for different microservices).
  */
 
-import { Logger } from '@zintrust/core';
-
 import { appConfig } from './app';
 import { Env } from './env';
+import { Logger } from './logger';
 import { ErrorFactory } from '@zintrust/core';
 
 /**

package/src/templates/project/basic/config/storage.ts.tpl

@@ -4,8 +4,8 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@config/env';
-import type { StorageConfigRuntime, StorageDriverConfig, StorageDrivers } from '@config/type';
+import { Env } from './env';
+import type { StorageConfigRuntime, StorageDriverConfig, StorageDrivers } from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const hasOwn = <T extends object>(obj: T, key: PropertyKey): key is keyof T => {

package/src/templates/project/basic/config/type.ts.tpl

@@ -1,5 +1,5 @@
-import { Env } from '@config/env';
-import type { Middleware as MiddlewareFn } from '@middleware/MiddlewareStack';
+import { Env } from './env';
+import type { Middleware as MiddlewareFn } from '@zintrust/core';
 
 export type Environment =
   | 'development'

package/src/tools/broadcast/Broadcast.d.ts

@@ -3,6 +3,14 @@ type Broadcaster = Readonly<{
 }>;
 export declare const Broadcast: Readonly<{
     send(channel: string, event: string, data: unknown): Promise<unknown>;
+    broadcastNow(channel: string, event: string, data: unknown): Promise<unknown>;
+    BroadcastLater(channel: string, event: string, data: unknown, options?: {
+        queueName?: string;
+        timestamp?: number;
+    }): Promise<string>;
+    queue(queueName: string): Readonly<{
+        BroadcastLater: (channel: string, event: string, data: unknown, options?: {}) => Promise<string>;
+    }>;
     broadcaster(name?: string): Broadcaster;
 }>;
 export default Broadcast;

package/src/tools/broadcast/Broadcast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Broadcast.d.ts","sourceRoot":"","sources":["../../../../src/tools/broadcast/Broadcast.ts"],"names":[],"mappings":"AAQA,KAAK,WAAW,GAAG,QAAQ,CAAC;IAC1B,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3E,CAAC,CAAC;AAyDH,eAAO,MAAM,SAAS;kBACA,MAAM,SAAS,MAAM,QAAQ,OAAO;uBAKrC,MAAM,GAAG,WAAW;EAQvC,CAAC;AAEH,eAAe,SAAS,CAAC"}
+{"version":3,"file":"Broadcast.d.ts","sourceRoot":"","sources":["../../../../src/tools/broadcast/Broadcast.ts"],"names":[],"mappings":"AAQA,KAAK,WAAW,GAAG,QAAQ,CAAC;IAC1B,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3E,CAAC,CAAC;AAyDH,eAAO,MAAM,SAAS;kBACA,MAAM,SAAS,MAAM,QAAQ,OAAO;0BAM5B,MAAM,SAAS,MAAM,QAAQ,OAAO;4BAMrD,MAAM,SACR,MAAM,QACP,OAAO,YACJ;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;qBAepC,MAAM;kCAEa,MAAM,SAAS,MAAM,QAAQ,OAAO;;uBAKrD,MAAM,GAAG,WAAW;EAQvC,CAAC;AAEH,eAAe,SAAS,CAAC"}

package/src/tools/broadcast/Broadcast.js

@@ -49,6 +49,29 @@ export const Broadcast = Object.freeze({
         const config = await resolveBroadcasterConfig();
         return sendWithConfig(config, channel, event, data);
     },
+    // Alias for send() - explicit intent for immediate broadcast
+    async broadcastNow(channel, event, data) {
+        return this.send(channel, event, data);
+    },
+    // Queue broadcast for async processing
+    async BroadcastLater(channel, event, data, options = {}) {
+        const { queueName = 'broadcasts', timestamp = Date.now() } = options;
+        const { Queue } = await import('../queue/Queue.js');
+        const messageId = await Queue.enqueue(queueName, {
+            type: 'broadcast',
+            channel,
+            event,
+            data,
+            timestamp,
+            attempts: 0,
+        });
+        return messageId;
+    },
+    queue(queueName) {
+        return Object.freeze({
+            BroadcastLater: async (channel, event, data, options = {}) => Broadcast.BroadcastLater(channel, event, data, { ...options, queueName }),
+        });
+    },
     broadcaster(name) {
         return Object.freeze({
             send: async (channel, event, data) => {

package/src/tools/notification/Notification.d.ts

@@ -5,6 +5,16 @@
  */
 export declare const Notification: Readonly<{
     send: (recipient: string, message: string, options?: Record<string, unknown>) => Promise<unknown>;
+    NotifyNow: (recipient: string, message: string, options?: Record<string, unknown>) => Promise<unknown>;
+    NotifyLater(recipient: string, message: string, notifyOptions?: Record<string, unknown>, queueOptions?: {
+        queueName?: string;
+        timestamp?: number;
+    }): Promise<string>;
+    queue(queueName: string): Readonly<{
+        NotifyLater: (recipient: string, message: string, notifyOptions?: Record<string, unknown>, queueOptions?: {
+            timestamp?: number;
+        }) => Promise<string>;
+    }>;
     channel: (name: string) => Readonly<{
         send: (recipient: string, message: string, options?: Record<string, unknown>) => Promise<unknown>;
     }>;

package/src/tools/notification/Notification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Notification.d.ts","sourceRoot":"","sources":["../../../../src/tools/notification/Notification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,YAAY;;oBAEP,MAAM;0BAEM,MAAM,WAAW,MAAM,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;EAItF,CAAC;AAEH,eAAe,YAAY,CAAC"}
+{"version":3,"file":"Notification.d.ts","sourceRoot":"","sources":["../../../../src/tools/notification/Notification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,YAAY;;;2BAQV,MAAM,WACR,MAAM,kBACA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,iBACxB;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GACvD,OAAO,CAAC,MAAM,CAAC;qBAcD,MAAM;iCAGN,MAAM,WACR,MAAM,kBACA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,iBACxB;YAAE,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE;;oBAM1B,MAAM;0BAEM,MAAM,WAAW,MAAM,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;EAItF,CAAC;AAEH,eAAe,YAAY,CAAC"}

package/src/tools/notification/Notification.js

@@ -6,6 +6,27 @@
 import { NotificationService } from './Service.js';
 export const Notification = Object.freeze({
     send: NotificationService.send,
+    // Alias for send() - explicit intent for immediate notification
+    NotifyNow: NotificationService.send,
+    // Queue notification for async processing
+    async NotifyLater(recipient, message, notifyOptions = {}, queueOptions = {}) {
+        const { queueName = 'notifications', timestamp = Date.now() } = queueOptions;
+        const { Queue } = await import('../queue/Queue.js');
+        const messageId = await Queue.enqueue(queueName, {
+            type: 'notification',
+            recipient,
+            message,
+            options: notifyOptions,
+            timestamp,
+            attempts: 0,
+        });
+        return messageId;
+    },
+    queue(queueName) {
+        return Object.freeze({
+            NotifyLater: async (recipient, message, notifyOptions = {}, queueOptions = {}) => Notification.NotifyLater(recipient, message, notifyOptions, { ...queueOptions, queueName }),
+        });
+    },
     channel: (name) => Object.freeze({
         send: async (recipient, message, options) => NotificationService.sendVia(name, recipient, message, options),
     }),

package/src/workers/BroadcastWorker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * BroadcastWorker - Processes queued broadcasts
+ *
+ * This worker dequeues broadcast messages and sends them using the Broadcast service.
+ * Use with Queue.dequeue() in a background process or cron job.
+ */
+export declare const BroadcastWorker: Readonly<{
+    processOne: (queueName?: string, driverName?: string) => Promise<boolean>;
+    processAll: (queueName?: string, driverName?: string) => Promise<number>;
+    runOnce: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        maxItems?: number;
+    }) => Promise<number>;
+    startWorker: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        signal?: AbortSignal;
+    }) => Promise<number>;
+}>;
+export default BroadcastWorker;
+//# sourceMappingURL=BroadcastWorker.d.ts.map

package/src/workers/BroadcastWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BroadcastWorker.d.ts","sourceRoot":"","sources":["../../../src/workers/BroadcastWorker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,eAAO,MAAM,eAAe;0BAbrB,CAAC,oBAAoB,CAAC;0BAGf,CAAC,oBAAoB,CAAC;kBACnB,CAAC;iBAAiB,CAAC;kBAE3B,CAAC;gBACC,CAAA;;sBAGE,CAAC;iBAGP,CAAA;kBAAwB,CAAC;cAC3B,CAAC;;EAaJ,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/src/workers/BroadcastWorker.js

@@ -0,0 +1,24 @@
+/**
+ * BroadcastWorker - Processes queued broadcasts
+ *
+ * This worker dequeues broadcast messages and sends them using the Broadcast service.
+ * Use with Queue.dequeue() in a background process or cron job.
+ */
+import { createQueueWorker } from '../workers/createQueueWorker.js';
+import { Broadcast } from '../tools/broadcast/Broadcast.js';
+export const BroadcastWorker = Object.freeze({
+    ...createQueueWorker({
+        kindLabel: 'broadcast',
+        defaultQueueName: 'broadcasts',
+        maxAttempts: 3,
+        getLogFields: (payload) => ({
+            channel: payload.channel,
+            event: payload.event,
+            queuedAt: payload.timestamp,
+        }),
+        handle: async (payload) => {
+            await Broadcast.send(payload.channel, payload.event, payload.data);
+        },
+    }),
+});
+export default BroadcastWorker;

package/src/workers/NotificationWorker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * NotificationWorker - Processes queued notifications
+ *
+ * This worker dequeues notification messages and sends them using the Notification service.
+ * Use with Queue.dequeue() in a background process or cron job.
+ */
+export declare const NotificationWorker: Readonly<{
+    processOne: (queueName?: string, driverName?: string) => Promise<boolean>;
+    processAll: (queueName?: string, driverName?: string) => Promise<number>;
+    runOnce: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        maxItems?: number;
+    }) => Promise<number>;
+    startWorker: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        signal?: AbortSignal;
+    }) => Promise<number>;
+}>;
+export default NotificationWorker;
+//# sourceMappingURL=NotificationWorker.d.ts.map

package/src/workers/NotificationWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotificationWorker.d.ts","sourceRoot":"","sources":["../../../src/workers/NotificationWorker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,eAAO,MAAM,kBAAkB;0BAdyD,CAAC,oBACzE,CAAC;0BAGf,CAAC,oBAAoB,CAAC;kBACnB,CAAC;iBAAkB,CAAA;kBAAwB,CAAC;gBAEtC,CAAC;;sBAGV,CAAC;iBAAiB,CAAC;kBACZ,CAAC;cAGL,CAAC;;EAaJ,CAAC;AAEH,eAAe,kBAAkB,CAAC"}

package/src/workers/NotificationWorker.js

@@ -0,0 +1,23 @@
+/**
+ * NotificationWorker - Processes queued notifications
+ *
+ * This worker dequeues notification messages and sends them using the Notification service.
+ * Use with Queue.dequeue() in a background process or cron job.
+ */
+import { createQueueWorker } from '../workers/createQueueWorker.js';
+import { Notification } from '../tools/notification/Notification.js';
+export const NotificationWorker = Object.freeze({
+    ...createQueueWorker({
+        kindLabel: 'notification',
+        defaultQueueName: 'notifications',
+        maxAttempts: 3,
+        getLogFields: (payload) => ({
+            recipient: payload.recipient,
+            queuedAt: payload.timestamp,
+        }),
+        handle: async (payload) => {
+            await Notification.send(payload.recipient, payload.message, payload.options);
+        },
+    }),
+});
+export default NotificationWorker;

package/src/workers/createQueueWorker.d.ts

@@ -0,0 +1,24 @@
+type QueueWorker = {
+    processOne: (queueName?: string, driverName?: string) => Promise<boolean>;
+    processAll: (queueName?: string, driverName?: string) => Promise<number>;
+    runOnce: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        maxItems?: number;
+    }) => Promise<number>;
+    startWorker: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        signal?: AbortSignal;
+    }) => Promise<number>;
+};
+export type CreateQueueWorkerOptions<TPayload> = {
+    kindLabel: string;
+    defaultQueueName: string;
+    maxAttempts: number;
+    getLogFields: (payload: TPayload) => Record<string, unknown>;
+    handle: (payload: TPayload) => Promise<void>;
+};
+export declare function createQueueWorker<TPayload>(options: CreateQueueWorkerOptions<TPayload>): QueueWorker;
+export {};
+//# sourceMappingURL=createQueueWorker.d.ts.map

package/src/workers/createQueueWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createQueueWorker.d.ts","sourceRoot":"","sources":["../../../src/workers/createQueueWorker.ts"],"names":[],"mappings":"AAGA,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1E,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACzE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACtB,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAAC,QAAQ,IAAI;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7D,MAAM,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C,CAAC;AA4IF,wBAAgB,iBAAiB,CAAC,QAAQ,EACxC,OAAO,EAAE,wBAAwB,CAAC,QAAQ,CAAC,GAC1C,WAAW,CAOb"}

package/src/workers/createQueueWorker.js

@@ -0,0 +1,114 @@
+import { Logger } from '../config/logger.js';
+import { Queue } from '../tools/queue/Queue.js';
+const buildBaseLogFields = (message, getLogFields) => {
+    return {
+        messageId: message.id,
+        ...getLogFields(message.payload),
+    };
+};
+const createProcessOne = (options) => {
+    return async (queueName = options.defaultQueueName, driverName) => {
+        const message = await Queue.dequeue(queueName, driverName);
+        if (!message)
+            return false;
+        const baseLogFields = buildBaseLogFields(message, options.getLogFields);
+        // Check for delayed execution
+        const payload = message.payload;
+        const rawTimestamp = 'timestamp' in payload ? payload['timestamp'] : 0;
+        const timestamp = typeof rawTimestamp === 'number' ? rawTimestamp : 0;
+        if (timestamp > Date.now()) {
+            Logger.info(`${options.kindLabel} not due yet, re-queueing`, {
+                ...baseLogFields,
+                dueAt: new Date(timestamp).toISOString(),
+            });
+            // Re-queue original payload
+            await Queue.enqueue(queueName, message.payload, driverName);
+            await Queue.ack(queueName, message.id, driverName);
+            return false;
+        }
+        try {
+            Logger.info(`Processing queued ${options.kindLabel}`, baseLogFields);
+            await options.handle(message.payload);
+            await Queue.ack(queueName, message.id, driverName);
+            Logger.info(`${options.kindLabel} processed successfully`, baseLogFields);
+            return true;
+        }
+        catch (error) {
+            const attempts = message.attempts ?? 0;
+            Logger.error(`Failed to process ${options.kindLabel}`, {
+                ...baseLogFields,
+                error,
+                attempts,
+            });
+            if (attempts < options.maxAttempts) {
+                await Queue.enqueue(queueName, message.payload, driverName);
+                Logger.info(`${options.kindLabel} re-queued for retry`, {
+                    ...baseLogFields,
+                    attempts: attempts + 1,
+                });
+            }
+            await Queue.ack(queueName, message.id, driverName);
+            return false;
+        }
+    };
+};
+const createProcessAll = (defaultQueueName, processOne) => {
+    return async (queueName = defaultQueueName, driverName) => {
+        let processed = 0;
+        let hasMore = true;
+        while (hasMore) {
+            // eslint-disable-next-line no-await-in-loop
+            hasMore = await processOne(queueName, driverName);
+            if (hasMore)
+                processed++;
+        }
+        return processed;
+    };
+};
+const createRunOnce = (defaultQueueName, processOne) => {
+    return async (opts = {}) => {
+        const { queueName = defaultQueueName, driverName, maxItems } = opts;
+        let processed = 0;
+        if (maxItems === undefined) {
+            while (true) {
+                // eslint-disable-next-line no-await-in-loop
+                const didProcess = await processOne(queueName, driverName);
+                if (!didProcess)
+                    break;
+                processed++;
+            }
+            return processed;
+        }
+        for (let i = 0; i < maxItems; i++) {
+            // eslint-disable-next-line no-await-in-loop
+            const didProcess = await processOne(queueName, driverName);
+            if (!didProcess)
+                break;
+            processed++;
+        }
+        return processed;
+    };
+};
+const createStartWorker = (kindLabel, defaultQueueName, processOne) => {
+    return async (opts = {}) => {
+        const { queueName = defaultQueueName, driverName, signal } = opts;
+        Logger.info(`Starting ${kindLabel} worker (drain-until-empty)`, { queueName });
+        let processedCount = 0;
+        while (signal?.aborted !== true) {
+            // eslint-disable-next-line no-await-in-loop
+            const didProcess = await processOne(queueName, driverName);
+            if (!didProcess)
+                break;
+            processedCount++;
+        }
+        Logger.info(`${kindLabel} worker finished (queue drained)`, { queueName, processedCount });
+        return processedCount;
+    };
+};
+export function createQueueWorker(options) {
+    const processOne = createProcessOne(options);
+    const processAll = createProcessAll(options.defaultQueueName, processOne);
+    const runOnce = createRunOnce(options.defaultQueueName, processOne);
+    const startWorker = createStartWorker(options.kindLabel, options.defaultQueueName, processOne);
+    return Object.freeze({ processOne, processAll, runOnce, startWorker });
+}