@lavoro/memory 0.3.0 → 0.4.0

package/build/index.d.ts

@@ -1,9 +1,29 @@
-import { QueueDriver, QueueConfig, WorkerOptions, QueueDriverConfig, ConfiguredDriver } from '@lavoro/core';
+import { QueueDriver, QueueConfig, WorkerOptions, QueueDriverConfig, QueueName, QueueDriverStopOptions, Job, Payload, ConfiguredDriver } from '@lavoro/core';
 import { LockFactory } from '@verrou/core';
+import * as fastq from 'fastq';
 
+type MemoryQueueDriverState = {
+    isPausing: boolean;
+    isStarted: boolean;
+    runningJobCount: number;
+};
 declare class MemoryQueueDriver extends QueueDriver {
+    protected queues: Map<string, fastq.queueAsPromised<any, any>>;
+    protected state: MemoryQueueDriverState;
     constructor(queueConfig: QueueConfig, options: Record<string, WorkerOptions>, config?: QueueDriverConfig);
     createLockProvider(): LockFactory;
+    /**
+     *
+     * @param fullyQualifiedJobName
+     */
+    private createWorker;
+    private runJob;
+    private processJob;
+    listen(queue: QueueName, options?: WorkerOptions): Promise<void>;
+    start(): Promise<void>;
+    private waitForQueues;
+    stop(options?: QueueDriverStopOptions): Promise<void>;
+    enqueue<T extends Job, P extends Payload<T>>(job: T, payload: P): Promise<void>;
 }
 /**
  * In-memory queue driver with no persistence

package/build/index.js

@@ -1,15 +1,224 @@
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __reflectGet = Reflect.get;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
 // src/index.ts
 import {
+  Job,
   QueueDriver
 } from "@lavoro/core";
 import { LockFactory } from "@verrou/core";
 import { memoryStore } from "@verrou/core/drivers/memory";
-var MemoryQueueDriver = class extends QueueDriver {
+import * as fastq from "fastq";
+var MemoryQueueDriver = class _MemoryQueueDriver extends QueueDriver {
   constructor(queueConfig, options, config = {}) {
     super(queueConfig, options, config);
+    __publicField(this, "queues", /* @__PURE__ */ new Map());
+    __publicField(this, "state", {
+      isPausing: false,
+      isStarted: false,
+      runningJobCount: 0
+    });
   }
   createLockProvider() {
-    return new LockFactory(memoryStore().factory());
+    this.lockFactory = new LockFactory(memoryStore().factory());
+    return this.lockFactory;
+  }
+  /**
+   *
+   * @param fullyQualifiedJobName
+   */
+  createWorker(fullyQualifiedJobName, options) {
+    return __async(this, null, function* () {
+      var _a;
+      const { concurrency = 1 } = options;
+      const { queue, name } = Job.parseName(fullyQualifiedJobName);
+      if (!((_a = this.config) == null ? void 0 : _a.worker) || concurrency === 0) {
+        this.logger.trace(
+          { connection: this.connection, queue, job: name },
+          "Queue worker is disabled - skipping"
+        );
+        return;
+      }
+      if (!this.queues.has(fullyQualifiedJobName)) {
+        const q = fastq.promise(
+          this,
+          this.runJob,
+          concurrency
+        );
+        q.pause();
+        this.queues.set(fullyQualifiedJobName, q);
+      }
+      this.logger.trace(
+        {
+          connection: this.connection,
+          queue,
+          job: name,
+          options
+        },
+        "Started worker"
+      );
+    });
+  }
+  runJob(data) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      this.state.runningJobCount++;
+      try {
+        yield this.processJob(data);
+      } catch (error) {
+        this.logger.error(
+          {
+            connection: this.connection,
+            job: (_a = data.job) == null ? void 0 : _a.name,
+            id: (_b = data.job) == null ? void 0 : _b.id,
+            err: error
+          },
+          "Job execution failed"
+        );
+        throw error;
+      } finally {
+        this.state.runningJobCount--;
+      }
+    });
+  }
+  processJob(data) {
+    return __async(this, null, function* () {
+      const { job, payload } = data;
+      yield this.process({
+        id: job.id,
+        fullyQualifiedName: job.fullyQualifiedName,
+        payload
+      });
+    });
+  }
+  listen(queue, options) {
+    return __async(this, null, function* () {
+      const mergedOptions = this.getMergedWorkerOptions(queue, options);
+      yield __superGet(_MemoryQueueDriver.prototype, this, "listen").call(this, queue, options);
+      for (const job of this.registeredJobs.values()) {
+        yield this.createWorker(Job.compileName(queue, job.name), mergedOptions);
+      }
+    });
+  }
+  start() {
+    return __async(this, null, function* () {
+      yield __superGet(_MemoryQueueDriver.prototype, this, "start").call(this);
+      this.state.isPausing = false;
+      this.state.isStarted = true;
+      for (const queue of this.queues.values()) {
+        queue.resume();
+      }
+      this.logger.trace(
+        { connection: this.connection, driver: "memory" },
+        "Queue driver started"
+      );
+    });
+  }
+  waitForQueues(queues, timeout) {
+    return __async(this, null, function* () {
+      this.state.isPausing = true;
+      for (const queue of queues) {
+        queue.pause();
+      }
+      const waitForIdleState = () => __async(this, null, function* () {
+        while (this.state.runningJobCount > 0) {
+          yield new Promise((r) => setTimeout(r, 100));
+        }
+      });
+      yield Promise.race([
+        waitForIdleState(),
+        new Promise(
+          (_, reject) => setTimeout(
+            () => reject(new Error("Graceful shutdown timeout reached")),
+            timeout
+          )
+        )
+      ]);
+    });
+  }
+  stop(options) {
+    return __async(this, null, function* () {
+      const { graceful = true, timeout = 3e4 } = options || {};
+      this.logger.trace(
+        { connection: this.connection, driver: "memory", graceful, timeout },
+        `Waiting for fastq to stop...`
+      );
+      const queues = Array.from(this.queues.values());
+      if (graceful) {
+        yield this.waitForQueues(queues, timeout);
+      }
+      for (const queue of queues) {
+        queue.pause();
+        queue.kill();
+      }
+      this.queues.clear();
+      this.state = {
+        isStarted: false,
+        isPausing: false,
+        runningJobCount: 0
+      };
+      this.logger.trace(
+        { connection: this.connection, driver: "memory" },
+        "Fastq stopped"
+      );
+      yield __superGet(_MemoryQueueDriver.prototype, this, "stop").call(this);
+      this.logger.trace(
+        { connection: this.connection, driver: "memory" },
+        "Queue driver stopped"
+      );
+    });
+  }
+  enqueue(job, payload) {
+    return __async(this, null, function* () {
+      if (!this.state.isStarted) {
+        throw new Error("Queue driver is not started");
+      }
+      if (this.state.isPausing) {
+        throw new Error(
+          "Queue driver is shutting down and cannot accept new jobs"
+        );
+      }
+      yield __superGet(_MemoryQueueDriver.prototype, this, "enqueue").call(this, job, payload);
+      this.logger.trace(
+        {
+          connection: this.connection,
+          queue: job.options.queue,
+          job: job.name
+        },
+        "Enqueuing job"
+      );
+      const q = this.queues.get(job.fullyQualifiedName);
+      if (!q) {
+        throw new Error(`No worker found for job: ${job.fullyQualifiedName}`);
+      }
+      q.push({ job, payload }).catch((error) => {
+        this.emit("job:error", error, job, payload);
+      });
+    });
   }
 };
 function memory(config) {

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  QueueDriver,\n  QueueDriverConfig,\n  ConfiguredDriver,\n  QueueConfig,\n  WorkerOptions,\n} from '@lavoro/core'\n\nimport { LockFactory } from '@verrou/core'\nimport { memoryStore } from '@verrou/core/drivers/memory'\n\nexport class MemoryQueueDriver extends QueueDriver {\n  constructor(\n    queueConfig: QueueConfig,\n    options: Record<string, WorkerOptions>,\n    config: QueueDriverConfig = {},\n  ) {\n    super(queueConfig, options, config)\n  }\n\n  public createLockProvider() {\n    return new LockFactory(memoryStore().factory())\n  }\n}\n\n/**\n * In-memory queue driver with no persistence\n * and distributed locking capabilities.\n */\nexport function memory(\n  config?: QueueDriverConfig,\n): ConfiguredDriver<MemoryQueueDriver, QueueDriverConfig> {\n  return {\n    constructor: MemoryQueueDriver,\n    config: config,\n  }\n}\n"],"mappings":";AAAA;AAAA,EACE;AAAA,OAKK;AAEP,SAAS,mBAAmB;AAC5B,SAAS,mBAAmB;AAErB,IAAM,oBAAN,cAAgC,YAAY;AAAA,EACjD,YACE,aACA,SACA,SAA4B,CAAC,GAC7B;AACA,UAAM,aAAa,SAAS,MAAM;AAAA,EACpC;AAAA,EAEO,qBAAqB;AAC1B,WAAO,IAAI,YAAY,YAAY,EAAE,QAAQ,CAAC;AAAA,EAChD;AACF;AAMO,SAAS,OACd,QACwD;AACxD,SAAO;AAAA,IACL,aAAa;AAAA,IACb;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  ConfiguredDriver,\n  Job,\n  Payload,\n  QueueConfig,\n  QueueDriver,\n  QueueDriverConfig,\n  QueueDriverStopOptions,\n  QueueName,\n  WorkerOptions,\n} from '@lavoro/core'\nimport { LockFactory } from '@verrou/core'\nimport { memoryStore } from '@verrou/core/drivers/memory'\nimport * as fastq from 'fastq'\nimport type { queueAsPromised } from 'fastq'\n\ntype MemoryQueueDriverState = {\n  isPausing: boolean\n  isStarted: boolean\n  runningJobCount: number\n}\n\nexport class MemoryQueueDriver extends QueueDriver {\n  protected queues = new Map<string, queueAsPromised>()\n\n  protected state: MemoryQueueDriverState = {\n    isPausing: false,\n    isStarted: false,\n    runningJobCount: 0,\n  }\n\n  constructor(\n    queueConfig: QueueConfig,\n    options: Record<string, WorkerOptions>,\n    config: QueueDriverConfig = {},\n  ) {\n    super(queueConfig, options, config)\n  }\n\n  public createLockProvider() {\n    this.lockFactory = new LockFactory(memoryStore().factory())\n    return this.lockFactory\n  }\n\n  /**\n   *\n   * @param fullyQualifiedJobName\n   */\n  private async createWorker(\n    fullyQualifiedJobName: string,\n    options: WorkerOptions,\n  ): Promise<void> {\n    const { concurrency = 1 } = options\n\n    const { queue, name } = Job.parseName(fullyQualifiedJobName)\n\n    if (!this.config?.worker || concurrency === 0) {\n      this.logger.trace(\n        { connection: this.connection, queue, job: name },\n        'Queue worker is disabled - skipping',\n      )\n\n      return\n    }\n\n    if (!this.queues.has(fullyQualifiedJobName)) {\n      const q: queueAsPromised<any> = fastq.promise(\n        this,\n        this.runJob,\n        concurrency,\n      )\n\n      q.pause()\n\n      this.queues.set(fullyQualifiedJobName, q)\n    }\n\n    this.logger.trace(\n      {\n        connection: this.connection,\n        queue,\n        job: name,\n        options,\n      },\n      'Started worker',\n    )\n  }\n\n  private async runJob(data: any): Promise<void> {\n    this.state.runningJobCount++\n\n    try {\n      await this.processJob(data)\n    } catch (error) {\n      this.logger.error(\n        {\n          connection: this.connection,\n          job: data.job?.name,\n          id: data.job?.id,\n          err: error,\n        },\n        'Job execution failed',\n      )\n      throw error\n    } finally {\n      this.state.runningJobCount--\n    }\n  }\n\n  private async processJob(data: any): Promise<void> {\n    const { job, payload }: { job: Job; payload: any } = data\n\n    await this.process({\n      id: job.id,\n      fullyQualifiedName: job.fullyQualifiedName,\n      payload,\n    })\n  }\n\n  public async listen(\n    queue: QueueName,\n    options?: WorkerOptions,\n  ): Promise<void> {\n    const mergedOptions = this.getMergedWorkerOptions(queue, options)\n    await super.listen(queue, options)\n    for (const job of this.registeredJobs.values()) {\n      await this.createWorker(Job.compileName(queue, job.name), mergedOptions)\n    }\n  }\n\n  public async start(): Promise<void> {\n    await super.start()\n\n    this.state.isPausing = false\n    this.state.isStarted = true\n\n    for (const queue of this.queues.values()) {\n      queue.resume()\n    }\n\n    this.logger.trace(\n      { connection: this.connection, driver: 'memory' },\n      'Queue driver started',\n    )\n  }\n\n  private async waitForQueues(\n    queues: fastq.queueAsPromised[],\n    timeout: number,\n  ) {\n    /**\n     * Mark the queue as pausing so it will not\n     * accept any new jobs once signaled to stop.\n     */\n    this.state.isPausing = true\n\n    for (const queue of queues) {\n      queue.pause()\n    }\n\n    const waitForIdleState = async () => {\n      while (this.state.runningJobCount > 0) {\n        await new Promise((r) => setTimeout(r, 100))\n      }\n    }\n\n    await Promise.race([\n      waitForIdleState(),\n      new Promise((_, reject) =>\n        setTimeout(\n          () => reject(new Error('Graceful shutdown timeout reached')),\n          timeout,\n        ),\n      ),\n    ])\n  }\n\n  public async stop(options?: QueueDriverStopOptions): Promise<void> {\n    const { graceful = true, timeout = 30000 } = options || {}\n\n    this.logger.trace(\n      { connection: this.connection, driver: 'memory', graceful, timeout },\n      `Waiting for fastq to stop...`,\n    )\n\n    const queues = Array.from(this.queues.values())\n\n    if (graceful) {\n      await this.waitForQueues(queues, timeout)\n    }\n\n    for (const queue of queues) {\n      queue.pause()\n      queue.kill()\n    }\n\n    this.queues.clear()\n\n    this.state = {\n      isStarted: false,\n      isPausing: false,\n      runningJobCount: 0,\n    }\n\n    this.logger.trace(\n      { connection: this.connection, driver: 'memory' },\n      'Fastq stopped',\n    )\n\n    await super.stop()\n\n    this.logger.trace(\n      { connection: this.connection, driver: 'memory' },\n      'Queue driver stopped',\n    )\n  }\n\n  public async enqueue<T extends Job, P extends Payload<T>>(\n    job: T,\n    payload: P,\n  ): Promise<void> {\n    if (!this.state.isStarted) {\n      throw new Error('Queue driver is not started')\n    }\n\n    if (this.state.isPausing) {\n      throw new Error(\n        'Queue driver is shutting down and cannot accept new jobs',\n      )\n    }\n\n    await super.enqueue(job, payload)\n\n    this.logger.trace(\n      {\n        connection: this.connection,\n        queue: job.options.queue,\n        job: job.name,\n      },\n      'Enqueuing job',\n    )\n\n    const q = this.queues.get(job.fullyQualifiedName)\n\n    if (!q) {\n      throw new Error(`No worker found for job: ${job.fullyQualifiedName}`)\n    }\n\n    q.push({ job, payload }).catch((error) => {\n      this.emit('job:error', error, job, payload)\n    })\n  }\n}\n\n/**\n * In-memory queue driver with no persistence\n * and distributed locking capabilities.\n */\nexport function memory(\n  config?: QueueDriverConfig,\n): ConfiguredDriver<MemoryQueueDriver, QueueDriverConfig> {\n  return {\n    constructor: MemoryQueueDriver,\n    config: config,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA,EAEE;AAAA,EAGA;AAAA,OAKK;AACP,SAAS,mBAAmB;AAC5B,SAAS,mBAAmB;AAC5B,YAAY,WAAW;AAShB,IAAM,oBAAN,MAAM,2BAA0B,YAAY;AAAA,EASjD,YACE,aACA,SACA,SAA4B,CAAC,GAC7B;AACA,UAAM,aAAa,SAAS,MAAM;AAbpC,wBAAU,UAAS,oBAAI,IAA6B;AAEpD,wBAAU,SAAgC;AAAA,MACxC,WAAW;AAAA,MACX,WAAW;AAAA,MACX,iBAAiB;AAAA,IACnB;AAAA,EAQA;AAAA,EAEO,qBAAqB;AAC1B,SAAK,cAAc,IAAI,YAAY,YAAY,EAAE,QAAQ,CAAC;AAC1D,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMc,aACZ,uBACA,SACe;AAAA;AAnDnB;AAoDI,YAAM,EAAE,cAAc,EAAE,IAAI;AAE5B,YAAM,EAAE,OAAO,KAAK,IAAI,IAAI,UAAU,qBAAqB;AAE3D,UAAI,GAAC,UAAK,WAAL,mBAAa,WAAU,gBAAgB,GAAG;AAC7C,aAAK,OAAO;AAAA,UACV,EAAE,YAAY,KAAK,YAAY,OAAO,KAAK,KAAK;AAAA,UAChD;AAAA,QACF;AAEA;AAAA,MACF;AAEA,UAAI,CAAC,KAAK,OAAO,IAAI,qBAAqB,GAAG;AAC3C,cAAM,IAAgC;AAAA,UACpC;AAAA,UACA,KAAK;AAAA,UACL;AAAA,QACF;AAEA,UAAE,MAAM;AAER,aAAK,OAAO,IAAI,uBAAuB,CAAC;AAAA,MAC1C;AAEA,WAAK,OAAO;AAAA,QACV;AAAA,UACE,YAAY,KAAK;AAAA,UACjB;AAAA,UACA,KAAK;AAAA,UACL;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA;AAAA,EAEc,OAAO,MAA0B;AAAA;AAxFjD;AAyFI,WAAK,MAAM;AAEX,UAAI;AACF,cAAM,KAAK,WAAW,IAAI;AAAA,MAC5B,SAAS,OAAO;AACd,aAAK,OAAO;AAAA,UACV;AAAA,YACE,YAAY,KAAK;AAAA,YACjB,MAAK,UAAK,QAAL,mBAAU;AAAA,YACf,KAAI,UAAK,QAAL,mBAAU;AAAA,YACd,KAAK;AAAA,UACP;AAAA,UACA;AAAA,QACF;AACA,cAAM;AAAA,MACR,UAAE;AACA,aAAK,MAAM;AAAA,MACb;AAAA,IACF;AAAA;AAAA,EAEc,WAAW,MAA0B;AAAA;AACjD,YAAM,EAAE,KAAK,QAAQ,IAAgC;AAErD,YAAM,KAAK,QAAQ;AAAA,QACjB,IAAI,IAAI;AAAA,QACR,oBAAoB,IAAI;AAAA,QACxB;AAAA,MACF,CAAC;AAAA,IACH;AAAA;AAAA,EAEa,OACX,OACA,SACe;AAAA;AACf,YAAM,gBAAgB,KAAK,uBAAuB,OAAO,OAAO;AAChE,YAAM,+CAAM,eAAN,MAAa,OAAO,OAAO;AACjC,iBAAW,OAAO,KAAK,eAAe,OAAO,GAAG;AAC9C,cAAM,KAAK,aAAa,IAAI,YAAY,OAAO,IAAI,IAAI,GAAG,aAAa;AAAA,MACzE;AAAA,IACF;AAAA;AAAA,EAEa,QAAuB;AAAA;AAClC,YAAM,+CAAM,cAAN,IAAY;AAElB,WAAK,MAAM,YAAY;AACvB,WAAK,MAAM,YAAY;AAEvB,iBAAW,SAAS,KAAK,OAAO,OAAO,GAAG;AACxC,cAAM,OAAO;AAAA,MACf;AAEA,WAAK,OAAO;AAAA,QACV,EAAE,YAAY,KAAK,YAAY,QAAQ,SAAS;AAAA,QAChD;AAAA,MACF;AAAA,IACF;AAAA;AAAA,EAEc,cACZ,QACA,SACA;AAAA;AAKA,WAAK,MAAM,YAAY;AAEvB,iBAAW,SAAS,QAAQ;AAC1B,cAAM,MAAM;AAAA,MACd;AAEA,YAAM,mBAAmB,MAAY;AACnC,eAAO,KAAK,MAAM,kBAAkB,GAAG;AACrC,gBAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,GAAG,CAAC;AAAA,QAC7C;AAAA,MACF;AAEA,YAAM,QAAQ,KAAK;AAAA,QACjB,iBAAiB;AAAA,QACjB,IAAI;AAAA,UAAQ,CAAC,GAAG,WACd;AAAA,YACE,MAAM,OAAO,IAAI,MAAM,mCAAmC,CAAC;AAAA,YAC3D;AAAA,UACF;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA;AAAA,EAEa,KAAK,SAAiD;AAAA;AACjE,YAAM,EAAE,WAAW,MAAM,UAAU,IAAM,IAAI,WAAW,CAAC;AAEzD,WAAK,OAAO;AAAA,QACV,EAAE,YAAY,KAAK,YAAY,QAAQ,UAAU,UAAU,QAAQ;AAAA,QACnE;AAAA,MACF;AAEA,YAAM,SAAS,MAAM,KAAK,KAAK,OAAO,OAAO,CAAC;AAE9C,UAAI,UAAU;AACZ,cAAM,KAAK,cAAc,QAAQ,OAAO;AAAA,MAC1C;AAEA,iBAAW,SAAS,QAAQ;AAC1B,cAAM,MAAM;AACZ,cAAM,KAAK;AAAA,MACb;AAEA,WAAK,OAAO,MAAM;AAElB,WAAK,QAAQ;AAAA,QACX,WAAW;AAAA,QACX,WAAW;AAAA,QACX,iBAAiB;AAAA,MACnB;AAEA,WAAK,OAAO;AAAA,QACV,EAAE,YAAY,KAAK,YAAY,QAAQ,SAAS;AAAA,QAChD;AAAA,MACF;AAEA,YAAM,+CAAM,aAAN,IAAW;AAEjB,WAAK,OAAO;AAAA,QACV,EAAE,YAAY,KAAK,YAAY,QAAQ,SAAS;AAAA,QAChD;AAAA,MACF;AAAA,IACF;AAAA;AAAA,EAEa,QACX,KACA,SACe;AAAA;AACf,UAAI,CAAC,KAAK,MAAM,WAAW;AACzB,cAAM,IAAI,MAAM,6BAA6B;AAAA,MAC/C;AAEA,UAAI,KAAK,MAAM,WAAW;AACxB,cAAM,IAAI;AAAA,UACR;AAAA,QACF;AAAA,MACF;AAEA,YAAM,+CAAM,gBAAN,MAAc,KAAK,OAAO;AAEhC,WAAK,OAAO;AAAA,QACV;AAAA,UACE,YAAY,KAAK;AAAA,UACjB,OAAO,IAAI,QAAQ;AAAA,UACnB,KAAK,IAAI;AAAA,QACX;AAAA,QACA;AAAA,MACF;AAEA,YAAM,IAAI,KAAK,OAAO,IAAI,IAAI,kBAAkB;AAEhD,UAAI,CAAC,GAAG;AACN,cAAM,IAAI,MAAM,4BAA4B,IAAI,kBAAkB,EAAE;AAAA,MACtE;AAEA,QAAE,KAAK,EAAE,KAAK,QAAQ,CAAC,EAAE,MAAM,CAAC,UAAU;AACxC,aAAK,KAAK,aAAa,OAAO,KAAK,OAAO;AAAA,MAC5C,CAAC;AAAA,IACH;AAAA;AACF;AAMO,SAAS,OACd,QACwD;AACxD,SAAO;AAAA,IACL,aAAa;AAAA,IACb;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lavoro/memory",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "In-memory queue driver for Lavoro",
   "author": "Aleksei Ivanov <contact@aleksei.dev>",
@@ -18,11 +18,14 @@
     "url": "https://github.com/lexuzieel/lavoro/issues"
   },
   "keywords": [
+    "worker",
     "queue",
+    "distributed",
+    "job",
+    "task",
+    "scheduler",
     "memory",
-    "in-memory",
-    "lavoro",
-    "driver"
+    "ephemeral"
   ],
   "exports": {
     ".": {
@@ -42,5 +45,8 @@
   "dependencies": {
     "@lavoro/core": "*",
     "@verrou/core": "^0.5.2"
+  },
+  "peerDependencies": {
+    "fastq": "^1.19.1"
   }
 }