@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

package/queue/mongo/queue.js

@@ -1,260 +1,283 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+"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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+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;
 };
-import { singleton } from '../../container/index.js';
-import { getNewId } from '../../database/id.js';
-import { Lock } from '../../lock/index.js';
-import { MessageBusProvider } from '../../message-bus/index.js';
-import { Queue, UniqueTagStrategy, defaultJobPriority, defaultQueueConfig } from '../../queue/index.js';
-import { Alphabet } from '../../utils/alphabet.js';
-import { backoffGenerator } from '../../utils/backoff.js';
-import { CancellationToken } from '../../utils/cancellation-token.js';
-import { currentTimestamp } from '../../utils/date-time.js';
-import { propertyNameOf } from '../../utils/object/property-name.js';
-import { getRandomString } from '../../utils/random.js';
-import { assertDefined, isString, isUndefined } from '../../utils/type-guards.js';
-import { MongoJobRepository } from './mongo-job.repository.js';
-import { MongoQueueProvider } from './queue.provider.js';
-const triesProperty = propertyNameOf((e) => e.tries);
-const lastDequeueTimestampProperty = propertyNameOf((e) => e.lastDequeueTimestamp);
-const enqueueTimestampProperty = propertyNameOf((e) => e.enqueueTimestamp);
-const priorityProperty = propertyNameOf((e) => e.priority);
-const batchProperty = propertyNameOf((e) => e.batch);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var queue_exports = {};
+__export(queue_exports, {
+  MongoQueue: () => MongoQueue
+});
+module.exports = __toCommonJS(queue_exports);
+var import_id = require("../../database/id.js");
+var import_decorators = require("../../injector/decorators.js");
+var import_lock = require("../../lock/index.js");
+var import_message_bus = require("../../message-bus/index.js");
+var import_queue = require("../../queue/index.js");
+var import_alphabet = require("../../utils/alphabet.js");
+var import_backoff = require("../../utils/backoff.js");
+var import_cancellation_token = require("../../utils/cancellation-token.js");
+var import_date_time = require("../../utils/date-time.js");
+var import_property_name = require("../../utils/object/property-name.js");
+var import_random = require("../../utils/random.js");
+var import_type_guards = require("../../utils/type-guards.js");
+var import_mongo_job_repository = require("./mongo-job.repository.js");
+var import_queue_provider = require("./queue.provider.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+const triesProperty = (0, import_property_name.propertyNameOf)((e) => e.tries);
+const lastDequeueTimestampProperty = (0, import_property_name.propertyNameOf)((e) => e.lastDequeueTimestamp);
+const enqueueTimestampProperty = (0, import_property_name.propertyNameOf)((e) => e.enqueueTimestamp);
+const priorityProperty = (0, import_property_name.propertyNameOf)((e) => e.priority);
+const batchProperty = (0, import_property_name.propertyNameOf)((e) => e.batch);
 const backoffOptions = {
-    strategy: 'exponential',
-    initialDelay: 100,
-    increase: 2,
-    maximumDelay: 5000
+  strategy: "exponential",
+  initialDelay: 100,
+  increase: 2,
+  maximumDelay: 5e3
 };
-export let MongoQueue = class MongoQueue extends Queue {
-    repository;
-    lock;
-    queueKey;
-    processTimeout;
-    maxTries;
-    messageBus;
-    constructor(repository, lock, messageBusProvider, key, config) {
-        super();
-        this.repository = repository;
-        this.lock = lock;
-        this.queueKey = key;
-        this.processTimeout = config?.processTimeout ?? defaultQueueConfig.processTimeout;
-        this.maxTries = config?.maxTries ?? defaultQueueConfig.maxTries;
-        this.messageBus = messageBusProvider.get(`MongoQueue:${repository.collection.collectionName}:${key}`);
-    }
-    async enqueue(data, options = {}) {
-        const { tag = null, uniqueTag, priority = defaultJobPriority } = options;
-        const newJob = {
-            queue: this.queueKey,
-            jobId: getNewId(),
-            tag,
-            priority,
-            data,
-            enqueueTimestamp: currentTimestamp(),
-            tries: 0,
-            lastDequeueTimestamp: 0,
-            batch: null
-        };
-        const job = (uniqueTag == undefined)
-            ? await this.repository.insert(newJob)
-            : await this.repository.insertWithUniqueTagStrategy(newJob, uniqueTag);
-        return toModelJob(job);
-    }
-    async enqueueMany(items, returnJobs = false) {
-        const now = currentTimestamp();
-        const nonUnique = [];
-        const keepOld = [];
-        const takeNew = [];
-        for (const { data, tag = null, uniqueTag, priority = defaultJobPriority } of items) {
-            const newMongoJob = {
-                queue: this.queueKey,
-                jobId: getNewId(),
-                tag,
-                priority,
-                data,
-                enqueueTimestamp: now,
-                tries: 0,
-                lastDequeueTimestamp: 0,
-                batch: null
-            };
-            switch (uniqueTag) {
-                case undefined:
-                    nonUnique.push(newMongoJob);
-                    break;
-                case UniqueTagStrategy.KeepOld:
-                    keepOld.push(newMongoJob);
-                    break;
-                case UniqueTagStrategy.TakeNew:
-                    takeNew.push(newMongoJob);
-                    break;
-                default:
-                    throw new Error('unsupported UniqueTagStrategy');
-            }
-        }
-        const [nonUniqueJobs] = await Promise.all([
-            (nonUnique.length > 0) ? this.repository.insertMany(nonUnique) : [],
-            (keepOld.length > 0) ? this.repository.bulkInsertWithUniqueTagStrategy(keepOld, UniqueTagStrategy.KeepOld) : undefined,
-            (takeNew.length > 0) ? this.repository.bulkInsertWithUniqueTagStrategy(takeNew, UniqueTagStrategy.TakeNew) : undefined
-        ]);
-        if (returnJobs) {
-            const keepOldTags = keepOld.map((job) => job.tag);
-            const takeNewTags = takeNew.map((job) => job.tag);
-            const uniqueTagJobs = await this.repository.loadManyByFilter({ queue: this.queueKey, tag: { $in: [...keepOldTags, ...takeNewTags] } });
-            return [...nonUniqueJobs, ...uniqueTagJobs].map(toModelJob);
-        }
-        return undefined;
-    }
-    async has(id) {
-        return this.repository.hasByFilter({ queue: this.queueKey, jobId: id });
-    }
-    async countByTag(tag) {
-        return this.repository.countByFilter({ queue: this.queueKey, tag });
-    }
-    async get(id) {
-        return this.repository.tryLoadByFilter({ queue: this.queueKey, jobId: id });
-    }
-    async getByTag(tag) {
-        return this.repository.loadManyByFilter({ queue: this.queueKey, tag });
-    }
-    async cancel(id) {
-        await this.repository.deleteByFilter({ queue: this.queueKey, jobId: id });
-    }
-    async cancelMany(ids) {
-        await this.repository.deleteManyByFilter({ queue: this.queueKey, jobId: { $in: ids } });
-    }
-    async cancelByTag(tag) {
-        await this.repository.deleteManyByFilter({ queue: this.queueKey, tag });
-    }
-    async cancelByTags(tags) {
-        await this.repository.deleteManyByFilter({ queue: this.queueKey, tag: { $in: tags } });
+let MongoQueue = class MongoQueue2 extends import_queue.Queue {
+  repository;
+  lock;
+  queueKey;
+  processTimeout;
+  maxTries;
+  messageBus;
+  constructor(repository, lock, messageBusProvider, key, config) {
+    super();
+    this.repository = repository;
+    this.lock = lock;
+    this.queueKey = key;
+    this.processTimeout = config?.processTimeout ?? import_queue.defaultQueueConfig.processTimeout;
+    this.maxTries = config?.maxTries ?? import_queue.defaultQueueConfig.maxTries;
+    this.messageBus = messageBusProvider.get(`MongoQueue:${repository.collection.collectionName}:${key}`);
+  }
+  async enqueue(data, options = {}) {
+    const { tag = null, uniqueTag, priority = import_queue.defaultJobPriority } = options;
+    const newJob = {
+      queue: this.queueKey,
+      jobId: (0, import_id.getNewId)(),
+      tag,
+      priority,
+      data,
+      enqueueTimestamp: (0, import_date_time.currentTimestamp)(),
+      tries: 0,
+      lastDequeueTimestamp: 0,
+      batch: null
+    };
+    const job = uniqueTag == void 0 ? await this.repository.insert(newJob) : await this.repository.insertWithUniqueTagStrategy(newJob, uniqueTag);
+    return toModelJob(job);
+  }
+  async enqueueMany(items, returnJobs = false) {
+    const now = (0, import_date_time.currentTimestamp)();
+    const nonUnique = [];
+    const keepOld = [];
+    const takeNew = [];
+    for (const { data, tag = null, uniqueTag, priority = import_queue.defaultJobPriority } of items) {
+      const newMongoJob = {
+        queue: this.queueKey,
+        jobId: (0, import_id.getNewId)(),
+        tag,
+        priority,
+        data,
+        enqueueTimestamp: now,
+        tries: 0,
+        lastDequeueTimestamp: 0,
+        batch: null
+      };
+      switch (uniqueTag) {
+        case void 0:
+          nonUnique.push(newMongoJob);
+          break;
+        case import_queue.UniqueTagStrategy.KeepOld:
+          keepOld.push(newMongoJob);
+          break;
+        case import_queue.UniqueTagStrategy.TakeNew:
+          takeNew.push(newMongoJob);
+          break;
+        default:
+          throw new Error("unsupported UniqueTagStrategy");
+      }
     }
-    async dequeue() {
-        const { filter, update } = getDequeueFindParameters(this.queueKey, this.maxTries, this.processTimeout);
-        const job = await this.repository.baseRepository.tryLoadByFilterAndUpdate(filter, update, {
-            returnDocument: 'after',
-            sort: {
-                priority: 1,
-                enqueueTimestamp: 1,
-                lastDequeueTimestamp: 1,
-                tries: 1
-            }
-        });
-        return isUndefined(job) ? undefined : toModelJob(job);
+    const [nonUniqueJobs] = await Promise.all([
+      nonUnique.length > 0 ? this.repository.insertMany(nonUnique) : [],
+      keepOld.length > 0 ? this.repository.bulkInsertWithUniqueTagStrategy(keepOld, import_queue.UniqueTagStrategy.KeepOld) : void 0,
+      takeNew.length > 0 ? this.repository.bulkInsertWithUniqueTagStrategy(takeNew, import_queue.UniqueTagStrategy.TakeNew) : void 0
+    ]);
+    if (returnJobs) {
+      const keepOldTags = keepOld.map((job) => job.tag);
+      const takeNewTags = takeNew.map((job) => job.tag);
+      const uniqueTagJobs = await this.repository.loadManyByFilter({ queue: this.queueKey, tag: { $in: [...keepOldTags, ...takeNewTags] } });
+      return [...nonUniqueJobs, ...uniqueTagJobs].map(toModelJob);
     }
-    async dequeueMany(count) {
-        const batch = getRandomString(20, Alphabet.LowerUpperCaseNumbers);
-        await this.lock.use(10000, true, async () => {
-            const { filter } = getDequeueFindParameters(this.queueKey, this.maxTries, this.processTimeout, batch);
-            await this.repository.baseRepository.collection.aggregate([
-                { $match: filter },
-                {
-                    $sort: {
-                        [priorityProperty]: 1,
-                        [enqueueTimestampProperty]: 1,
-                        [lastDequeueTimestampProperty]: 1,
-                        [triesProperty]: 1
-                    }
-                },
-                { $limit: count },
-                {
-                    $merge: {
-                        into: this.repository.baseRepository.collection.collectionName,
-                        whenMatched: [
-                            {
-                                $set: {
-                                    [triesProperty]: { $add: [`$${triesProperty}`, 1] },
-                                    [lastDequeueTimestampProperty]: currentTimestamp(),
-                                    [batchProperty]: batch
-                                }
-                            }
-                        ],
-                        whenNotMatched: 'discard'
-                    }
+    return void 0;
+  }
+  async has(id) {
+    return this.repository.hasByFilter({ queue: this.queueKey, jobId: id });
+  }
+  async countByTag(tag) {
+    return this.repository.countByFilter({ queue: this.queueKey, tag });
+  }
+  async get(id) {
+    return this.repository.tryLoadByFilter({ queue: this.queueKey, jobId: id });
+  }
+  async getByTag(tag) {
+    return this.repository.loadManyByFilter({ queue: this.queueKey, tag });
+  }
+  async cancel(id) {
+    await this.repository.deleteByFilter({ queue: this.queueKey, jobId: id });
+  }
+  async cancelMany(ids) {
+    await this.repository.deleteManyByFilter({ queue: this.queueKey, jobId: { $in: ids } });
+  }
+  async cancelByTag(tag) {
+    await this.repository.deleteManyByFilter({ queue: this.queueKey, tag });
+  }
+  async cancelByTags(tags) {
+    await this.repository.deleteManyByFilter({ queue: this.queueKey, tag: { $in: tags } });
+  }
+  async dequeue() {
+    const { filter, update } = getDequeueFindParameters(this.queueKey, this.maxTries, this.processTimeout);
+    const job = await this.repository.baseRepository.tryLoadByFilterAndUpdate(filter, update, {
+      returnDocument: "after",
+      sort: {
+        priority: 1,
+        enqueueTimestamp: 1,
+        lastDequeueTimestamp: 1,
+        tries: 1
+      }
+    });
+    return (0, import_type_guards.isUndefined)(job) ? void 0 : toModelJob(job);
+  }
+  async dequeueMany(count) {
+    const batch = (0, import_random.getRandomString)(20, import_alphabet.Alphabet.LowerUpperCaseNumbers);
+    await this.lock.use(1e4, true, async () => {
+      const { filter } = getDequeueFindParameters(this.queueKey, this.maxTries, this.processTimeout, batch);
+      await this.repository.baseRepository.collection.aggregate([
+        { $match: filter },
+        {
+          $sort: {
+            [priorityProperty]: 1,
+            [enqueueTimestampProperty]: 1,
+            [lastDequeueTimestampProperty]: 1,
+            [triesProperty]: 1
+          }
+        },
+        { $limit: count },
+        {
+          $merge: {
+            into: this.repository.baseRepository.collection.collectionName,
+            whenMatched: [
+              {
+                $set: {
+                  [triesProperty]: { $add: [`$${triesProperty}`, 1] },
+                  [lastDequeueTimestampProperty]: (0, import_date_time.currentTimestamp)(),
+                  [batchProperty]: batch
                 }
-            ]).next();
-        });
-        const jobs = await this.repository.loadManyByFilter({ queue: this.queueKey, batch });
-        return jobs.map(toModelJob);
-    }
-    async acknowledge(job) {
-        return this.cancel(job.id);
-    }
-    async acknowledgeMany(jobs) {
-        const jobIds = jobs.map((job) => job.id);
-        return this.cancelMany(jobIds);
-    }
-    async *getConsumer(cancellationToken) {
-        const continueToken = CancellationToken.from(this.messageBus.allMessages$);
-        for await (const backoff of backoffGenerator(backoffOptions, cancellationToken)) {
-            const job = await this.dequeue();
-            if (job != undefined) {
-                yield job;
-            }
-            else {
-                backoff(continueToken);
-            }
+              }
+            ],
+            whenNotMatched: "discard"
+          }
         }
-        continueToken.complete();
+      ]).next();
+    });
+    const jobs = await this.repository.loadManyByFilter({ queue: this.queueKey, batch });
+    return jobs.map(toModelJob);
+  }
+  async acknowledge(job) {
+    return this.cancel(job.id);
+  }
+  async acknowledgeMany(jobs) {
+    const jobIds = jobs.map((job) => job.id);
+    return this.cancelMany(jobIds);
+  }
+  async *getConsumer(cancellationToken) {
+    const continueToken = import_cancellation_token.CancellationToken.from(this.messageBus.allMessages$);
+    for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationToken)) {
+      const job = await this.dequeue();
+      if (job != void 0) {
+        yield job;
+      } else {
+        backoff(continueToken);
+      }
     }
-    async *getBatchConsumer(size, cancellationToken) {
-        const continueToken = CancellationToken.from(this.messageBus.allMessages$);
-        for await (const backoff of backoffGenerator(backoffOptions, cancellationToken)) {
-            const jobs = await this.dequeueMany(size);
-            if (jobs.length > 0) {
-                yield jobs;
-            }
-            else {
-                backoff(continueToken);
-            }
-        }
-        continueToken.complete();
+    continueToken.complete();
+  }
+  async *getBatchConsumer(size, cancellationToken) {
+    const continueToken = import_cancellation_token.CancellationToken.from(this.messageBus.allMessages$);
+    for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationToken)) {
+      const jobs = await this.dequeueMany(size);
+      if (jobs.length > 0) {
+        yield jobs;
+      } else {
+        backoff(continueToken);
+      }
     }
+    continueToken.complete();
+  }
 };
 MongoQueue = __decorate([
-    singleton({
-        provider: {
-            useFactory: async (argument, context) => {
-                const provider = await context.resolveAsync(MongoQueueProvider);
-                assertDefined(argument, 'queue resolve argument is missing');
-                if (isString(argument)) {
-                    return provider.get(argument, defaultQueueConfig);
-                }
-                return provider.get(argument.key, { ...defaultQueueConfig, ...argument });
-            }
+  (0, import_decorators.Singleton)({
+    provider: {
+      useFactory: (argument, context) => {
+        const provider = context.resolve(import_queue_provider.MongoQueueProvider);
+        (0, import_type_guards.assertDefined)(argument, "queue resolve argument is missing");
+        if ((0, import_type_guards.isString)(argument)) {
+          return provider.get(argument, import_queue.defaultQueueConfig);
         }
-    }),
-    __metadata("design:paramtypes", [MongoJobRepository, Lock, MessageBusProvider, String, Object])
+        return provider.get(argument.key, { ...import_queue.defaultQueueConfig, ...argument });
+      }
+    }
+  }),
+  __metadata("design:paramtypes", [import_mongo_job_repository.MongoJobRepository, import_lock.Lock, import_message_bus.MessageBusProvider, String, Object])
 ], MongoQueue);
 function toModelJob(mongoJob) {
-    const job = {
-        id: mongoJob.jobId,
-        priority: mongoJob.priority,
-        tag: mongoJob.tag,
-        data: mongoJob.data
-    };
-    return job;
+  const job = {
+    id: mongoJob.jobId,
+    priority: mongoJob.priority,
+    tag: mongoJob.tag,
+    data: mongoJob.data
+  };
+  return job;
 }
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function getDequeueFindParameters(queueKey, maxTries, processTimeout, batch = null) {
-    const now = currentTimestamp();
-    const maximumLastDequeueTimestamp = now - processTimeout;
-    const filter = {
-        queue: queueKey,
-        tries: { $lt: maxTries },
-        lastDequeueTimestamp: { $lte: maximumLastDequeueTimestamp }
-    };
-    const update = {
-        $inc: { tries: 1 },
-        $set: {
-            lastDequeueTimestamp: now,
-            batch
-        }
-    };
-    return { filter, update };
+  const now = (0, import_date_time.currentTimestamp)();
+  const maximumLastDequeueTimestamp = now - processTimeout;
+  const filter = {
+    queue: queueKey,
+    tries: { $lt: maxTries },
+    lastDequeueTimestamp: { $lte: maximumLastDequeueTimestamp }
+  };
+  const update = {
+    $inc: { tries: 1 },
+    $set: {
+      lastDequeueTimestamp: now,
+      batch
+    }
+  };
+  return { filter, update };
 }

package/queue/mongo/queue.provider.d.ts

@@ -1,6 +1,6 @@
-import type { Injectable } from '../../container/index.js';
-import { resolveArgumentType } from '../../container/index.js';
 import type { CollectionArgument, MongoRepositoryConfig } from '../../database/mongo/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
+import { resolveArgumentType } from '../../injector/interfaces.js';
 import { LockProvider } from '../../lock/index.js';
 import { MessageBusProvider } from '../../message-bus/index.js';
 import type { QueueConfig } from '../../queue/index.js';
@@ -8,7 +8,7 @@ import { QueueProvider } from '../../queue/index.js';
 import type { MongoJob } from './job.js';
 import { MongoJobRepository } from './mongo-job.repository.js';
 import { MongoQueue } from './queue.js';
-export declare class MongoQueueProvider extends QueueProvider implements Injectable<CollectionArgument<MongoJob>> {
+export declare class MongoQueueProvider extends QueueProvider implements Resolvable<CollectionArgument<MongoJob>> {
     private readonly repository;
     private readonly lockProvider;
     private readonly messageBusProvider;