@forklaunch/implementation-worker-redis 0.2.2 → 0.3.0

package/lib/consumers/index.d.mts

@@ -0,0 +1,19 @@
+import { TtlCache } from '@forklaunch/core/cache';
+import { WorkerConsumer } from '@forklaunch/interfaces-worker/interfaces';
+import { WorkerEventEntity, WorkerProcessFunction, WorkerFailureHandler } from '@forklaunch/interfaces-worker/types';
+import { RedisWorkerOptions } from '../types/index.mjs';
+
+declare class RedisWorkerConsumer<EventEntity extends WorkerEventEntity, Options extends RedisWorkerOptions> implements WorkerConsumer<EventEntity> {
+    protected readonly queueName: string;
+    protected readonly cache: TtlCache;
+    protected readonly options: Options;
+    protected readonly processEvents: WorkerProcessFunction<EventEntity>;
+    protected readonly failureHandler: WorkerFailureHandler<EventEntity>;
+    constructor(queueName: string, cache: TtlCache, options: Options, processEvents: WorkerProcessFunction<EventEntity>, failureHandler: WorkerFailureHandler<EventEntity>);
+    private retrieveEvents;
+    private updateEvents;
+    peekEvents(): Promise<EventEntity[]>;
+    start(): Promise<void>;
+}
+
+export { RedisWorkerConsumer };

package/lib/consumers/index.d.ts

@@ -1,2 +1,19 @@
-export * from './redisWorker.consumer';
-//# sourceMappingURL=index.d.ts.map
+import { TtlCache } from '@forklaunch/core/cache';
+import { WorkerConsumer } from '@forklaunch/interfaces-worker/interfaces';
+import { WorkerEventEntity, WorkerProcessFunction, WorkerFailureHandler } from '@forklaunch/interfaces-worker/types';
+import { RedisWorkerOptions } from '../types/index.js';
+
+declare class RedisWorkerConsumer<EventEntity extends WorkerEventEntity, Options extends RedisWorkerOptions> implements WorkerConsumer<EventEntity> {
+    protected readonly queueName: string;
+    protected readonly cache: TtlCache;
+    protected readonly options: Options;
+    protected readonly processEvents: WorkerProcessFunction<EventEntity>;
+    protected readonly failureHandler: WorkerFailureHandler<EventEntity>;
+    constructor(queueName: string, cache: TtlCache, options: Options, processEvents: WorkerProcessFunction<EventEntity>, failureHandler: WorkerFailureHandler<EventEntity>);
+    private retrieveEvents;
+    private updateEvents;
+    peekEvents(): Promise<EventEntity[]>;
+    start(): Promise<void>;
+}
+
+export { RedisWorkerConsumer };

package/lib/consumers/index.js

@@ -1 +1,71 @@
-export * from './redisWorker.consumer';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// consumers/index.ts
+var consumers_exports = {};
+__export(consumers_exports, {
+  RedisWorkerConsumer: () => RedisWorkerConsumer
+});
+module.exports = __toCommonJS(consumers_exports);
+
+// consumers/redisWorker.consumer.ts
+var RedisWorkerConsumer = class {
+  constructor(queueName, cache, options, processEvents, failureHandler) {
+    this.queueName = queueName;
+    this.cache = cache;
+    this.options = options;
+    this.processEvents = processEvents;
+    this.failureHandler = failureHandler;
+  }
+  async retrieveEvents() {
+    const events = (await this.cache.dequeueBatchRecords(
+      this.queueName,
+      this.options.pageSize
+    )).filter((event) => event != null);
+    return events;
+  }
+  async updateEvents(events) {
+    await this.cache.enqueueBatchRecords(
+      this.queueName,
+      events.filter((event) => event != null && event.retryCount <= 3).map((event) => ({
+        ...event,
+        retryCount: event.retryCount + 1
+      }))
+    );
+  }
+  async peekEvents() {
+    const events = await this.cache.peekQueueRecords(
+      this.queueName,
+      this.options.pageSize
+    );
+    return events;
+  }
+  async start() {
+    setInterval(async () => {
+      const events = await this.retrieveEvents();
+      const failedEvents = await this.processEvents(events);
+      await this.failureHandler(failedEvents);
+      await this.updateEvents(failedEvents.map((event) => event.value));
+    }, this.options.interval);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisWorkerConsumer
+});

package/lib/consumers/{redisWorker.consumer.js → index.mjs}

@@ -1,9 +1,5 @@
-export class RedisWorkerConsumer {
-  queueName;
-  cache;
-  options;
-  processEvents;
-  failureHandler;
+// consumers/redisWorker.consumer.ts
+var RedisWorkerConsumer = class {
   constructor(queueName, cache, options, processEvents, failureHandler) {
     this.queueName = queueName;
     this.cache = cache;
@@ -12,23 +8,19 @@ export class RedisWorkerConsumer {
     this.failureHandler = failureHandler;
   }
   async retrieveEvents() {
-    const events = (
-      await this.cache.dequeueBatchRecords(
-        this.queueName,
-        this.options.pageSize
-      )
-    ).filter((event) => event != null);
+    const events = (await this.cache.dequeueBatchRecords(
+      this.queueName,
+      this.options.pageSize
+    )).filter((event) => event != null);
     return events;
   }
   async updateEvents(events) {
     await this.cache.enqueueBatchRecords(
       this.queueName,
-      events
-        .filter((event) => event != null && event.retryCount <= 3)
-        .map((event) => ({
-          ...event,
-          retryCount: event.retryCount + 1
-        }))
+      events.filter((event) => event != null && event.retryCount <= 3).map((event) => ({
+        ...event,
+        retryCount: event.retryCount + 1
+      }))
     );
   }
   async peekEvents() {
@@ -46,4 +38,7 @@ export class RedisWorkerConsumer {
       await this.updateEvents(failedEvents.map((event) => event.value));
     }, this.options.interval);
   }
-}
+};
+export {
+  RedisWorkerConsumer
+};

package/lib/producers/index.d.mts

@@ -0,0 +1,15 @@
+import { TtlCache } from '@forklaunch/core/cache';
+import { WorkerProducer } from '@forklaunch/interfaces-worker/interfaces';
+import { WorkerEventEntity } from '@forklaunch/interfaces-worker/types';
+import { RedisWorkerOptions } from '../types/index.mjs';
+
+declare class RedisWorkerProducer<EventEntity extends WorkerEventEntity, Options extends RedisWorkerOptions> implements WorkerProducer<EventEntity> {
+    private readonly queueName;
+    private readonly cache;
+    private readonly options;
+    constructor(queueName: string, cache: TtlCache, options: Options);
+    enqueueJob(event: EventEntity): Promise<void>;
+    enqueueBatchJobs(events: EventEntity[]): Promise<void>;
+}
+
+export { RedisWorkerProducer };

package/lib/producers/index.d.ts

@@ -1,2 +1,15 @@
-export * from './redisWorker.producer';
-//# sourceMappingURL=index.d.ts.map
+import { TtlCache } from '@forklaunch/core/cache';
+import { WorkerProducer } from '@forklaunch/interfaces-worker/interfaces';
+import { WorkerEventEntity } from '@forklaunch/interfaces-worker/types';
+import { RedisWorkerOptions } from '../types/index.js';
+
+declare class RedisWorkerProducer<EventEntity extends WorkerEventEntity, Options extends RedisWorkerOptions> implements WorkerProducer<EventEntity> {
+    private readonly queueName;
+    private readonly cache;
+    private readonly options;
+    constructor(queueName: string, cache: TtlCache, options: Options);
+    enqueueJob(event: EventEntity): Promise<void>;
+    enqueueBatchJobs(events: EventEntity[]): Promise<void>;
+}
+
+export { RedisWorkerProducer };

package/lib/producers/index.js

@@ -1 +1,45 @@
-export * from './redisWorker.producer';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// producers/index.ts
+var producers_exports = {};
+__export(producers_exports, {
+  RedisWorkerProducer: () => RedisWorkerProducer
+});
+module.exports = __toCommonJS(producers_exports);
+
+// producers/redisWorker.producer.ts
+var RedisWorkerProducer = class {
+  constructor(queueName, cache, options) {
+    this.queueName = queueName;
+    this.cache = cache;
+    this.options = options;
+  }
+  async enqueueJob(event) {
+    await this.cache.enqueueRecord(this.queueName, event);
+  }
+  async enqueueBatchJobs(events) {
+    console.log("Enqueuing batch jobs", events);
+    await this.cache.enqueueBatchRecords(this.queueName, events);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisWorkerProducer
+});

package/lib/producers/{redisWorker.producer.js → index.mjs}

@@ -1,7 +1,5 @@
-export class RedisWorkerProducer {
-  queueName;
-  cache;
-  options;
+// producers/redisWorker.producer.ts
+var RedisWorkerProducer = class {
   constructor(queueName, cache, options) {
     this.queueName = queueName;
     this.cache = cache;
@@ -11,7 +9,10 @@ export class RedisWorkerProducer {
     await this.cache.enqueueRecord(this.queueName, event);
   }
   async enqueueBatchJobs(events) {
-    console.log('Enqueuing batch jobs', events);
+    console.log("Enqueuing batch jobs", events);
     await this.cache.enqueueBatchRecords(this.queueName, events);
   }
-}
+};
+export {
+  RedisWorkerProducer
+};

package/lib/schemas/index.d.mts

@@ -0,0 +1,18 @@
+import * as _forklaunch_core_mappers from '@forklaunch/core/mappers';
+import * as zod from 'zod';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import * as _forklaunch_validator from '@forklaunch/validator';
+
+declare const RedisWorkerSchemas: <SchemaValidator extends _forklaunch_validator.AnySchemaValidator>(options: Record<string, unknown> & {
+    validator: SchemaValidator;
+}) => _forklaunch_core_mappers.SchemasByValidator<SchemaValidator, (options: Record<string, unknown>) => {
+    pageSize: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TBigInt, _sinclair_typebox.TDate]>, number>;
+    retries: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TBigInt, _sinclair_typebox.TDate]>, number>;
+    interval: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TBigInt, _sinclair_typebox.TDate]>, number>;
+}, (options: Record<string, unknown>) => {
+    pageSize: zod.ZodEffects<zod.ZodNumber, number, unknown>;
+    retries: zod.ZodEffects<zod.ZodNumber, number, unknown>;
+    interval: zod.ZodEffects<zod.ZodNumber, number, unknown>;
+}>;
+
+export { RedisWorkerSchemas };

package/lib/schemas/index.d.ts

@@ -1,2 +1,18 @@
-export * from './redisWorker.schema';
-//# sourceMappingURL=index.d.ts.map
+import * as _forklaunch_core_mappers from '@forklaunch/core/mappers';
+import * as zod from 'zod';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import * as _forklaunch_validator from '@forklaunch/validator';
+
+declare const RedisWorkerSchemas: <SchemaValidator extends _forklaunch_validator.AnySchemaValidator>(options: Record<string, unknown> & {
+    validator: SchemaValidator;
+}) => _forklaunch_core_mappers.SchemasByValidator<SchemaValidator, (options: Record<string, unknown>) => {
+    pageSize: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TBigInt, _sinclair_typebox.TDate]>, number>;
+    retries: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TBigInt, _sinclair_typebox.TDate]>, number>;
+    interval: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TBigInt, _sinclair_typebox.TDate]>, number>;
+}, (options: Record<string, unknown>) => {
+    pageSize: zod.ZodEffects<zod.ZodNumber, number, unknown>;
+    retries: zod.ZodEffects<zod.ZodNumber, number, unknown>;
+    interval: zod.ZodEffects<zod.ZodNumber, number, unknown>;
+}>;
+
+export { RedisWorkerSchemas };