@tstdl/base 0.92.84 → 0.92.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.84",
+  "version": "0.92.86",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -17,14 +17,16 @@
     "pub": "npm run build:production && rm -vf dist/test* && rm -vrf dist/tools/ && npm publish dist/",
     "tsc:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch",
-    "generate:orm": "npm run generate:drizzle:document-management && npm run generate:drizzle:authentication && npm run generate:drizzle:mail",
-    "generate:drizzle:document-management": "drizzle-kit generate --config dist/document-management/server/drizzle.config.js",
-    "generate:drizzle:authentication": "drizzle-kit generate --config dist/authentication/server/drizzle.config.js",
-    "generate:drizzle:mail": "drizzle-kit generate --config dist/mail/drizzle.config.js",
-    "copy:orm": "npm run copy:document-management && npm run copy:authentication && npm run copy:mail",
-    "copy:document-management": "rm -rf ./dist/document-management/server/drizzle && cp -r ./source/document-management/server/drizzle ./dist/document-management/server/",
-    "copy:authentication": "rm -rf ./dist/authentication/server/drizzle && cp -r ./source/authentication/server/drizzle ./dist/authentication/server/",
-    "copy:mail": "rm -rf ./dist/mail/drizzle && cp -r ./source/mail/drizzle ./dist/mail/"
+    "generate:migration": "npm run generate:migration:document-management && npm run generate:migration:authentication && npm run generate:migration:mail && npm run generate:migration:queue",
+    "generate:migration:document-management": "drizzle-kit generate --config dist/document-management/server/drizzle.config.js",
+    "generate:migration:authentication": "drizzle-kit generate --config dist/authentication/server/drizzle.config.js",
+    "generate:migration:mail": "drizzle-kit generate --config dist/mail/drizzle.config.js",
+    "generate:migration:queue": "drizzle-kit generate --config dist/queue/postgres/drizzle.config.js",
+    "copy:orm": "npm run copy:orm:document-management && npm run copy:orm:authentication && npm run copy:orm:mail && npm run copy:orm:queue",
+    "copy:orm:document-management": "rm -rf ./dist/document-management/server/drizzle && cp -r ./source/document-management/server/drizzle ./dist/document-management/server/",
+    "copy:orm:authentication": "rm -rf ./dist/authentication/server/drizzle && cp -r ./source/authentication/server/drizzle ./dist/authentication/server/",
+    "copy:orm:mail": "rm -rf ./dist/mail/drizzle && cp -r ./source/mail/drizzle ./dist/mail/",
+    "copy:orm:queue": "rm -rf ./dist/queue/postgres/drizzle && cp -r ./source/queue/postgres/drizzle ./dist/queue/postgres/"
   },
   "exports": {
     "./tsconfig.json": "./tsconfig.json",
@@ -136,7 +138,7 @@
     "type-fest": "4.35"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "4.0",
+    "@stylistic/eslint-plugin": "4.1",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -162,7 +164,7 @@
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.6",
-    "drizzle-orm": "^0.39",
+    "drizzle-orm": "^0.40",
     "handlebars": "^4.7",
     "minio": "^8.0",
     "mjml": "^4.15",

package/process-shutdown.js

@@ -14,7 +14,6 @@ export function getShutdownSignal() {
     return getShutdownToken().signal;
 }
 let logger;
-// eslint-disable-next-line no-shadow
 export function setProcessShutdownLogger(shutdownLogger) {
     logger = shutdownLogger;
 }
@@ -49,7 +48,6 @@ export function initializeSignals() {
         }
     });
     for (const event of quitEvents) {
-        // eslint-disable-next-line @typescript-eslint/no-loop-func
         process.on(event, (...args) => {
             console.error(event, ...args);
             quitReason = args;
@@ -57,7 +55,6 @@ export function initializeSignals() {
         });
     }
     for (const quitSignal of quitSignals) {
-        // eslint-disable-next-line @typescript-eslint/no-loop-func
         process.on(quitSignal, (signal) => {
             logger.info(`${signal} received, quitting.`);
             requestShutdown();

package/queue/enqueue-batch.d.ts

@@ -13,4 +13,5 @@ export declare class QueueEnqueueBatch<T> implements QueueEnqueueBatchMethods<T>
     /** enqueues all added items */
     enqueue(returnJobs?: false): Promise<void>;
     enqueue(returnJobs: true): Promise<Job<T>[]>;
+    enqueue(returnJobs?: boolean): Promise<Job<T>[] | undefined>;
 }

package/queue/enqueue-batch.js

@@ -13,7 +13,7 @@ export class QueueEnqueueBatch {
     async enqueue(returnJobs) {
         const items = this.items;
         this.items = [];
-        const result = await this.queue.enqueueMany(items, returnJobs);
+        const result = await this.queue.enqueueMany(items, { returnJobs });
         return result;
     }
 }

package/queue/mongo/queue.d.ts

@@ -1,7 +1,7 @@
 import type { CancellationSignal } from '../../cancellation/index.js';
 import { Lock } from '../../lock/index.js';
 import { MessageBusProvider } from '../../message-bus/index.js';
-import type { EnqueueManyItem, EnqueueOptions, Job, JobTag } from '../../queue/index.js';
+import type { EnqueueManyItem, EnqueueManyOptions, EnqueueOneOptions, Job, JobTag } from '../../queue/index.js';
 import { Queue, type QueueConfig } from '../../queue/index.js';
 import { MongoJobRepository } from './mongo-job.repository.js';
 export declare class MongoQueue<T = unknown> extends Queue<T> {
@@ -12,9 +12,14 @@ export declare class MongoQueue<T = unknown> extends Queue<T> {
     private readonly maxTries;
     private readonly messageBus;
     constructor(repository: MongoJobRepository<T>, lock: Lock, messageBusProvider: MessageBusProvider, key: string, config?: QueueConfig);
-    enqueue(data: T, options?: EnqueueOptions): Promise<Job<T>>;
-    enqueueMany(items: EnqueueManyItem<T>[], returnJobs?: false): Promise<void>;
-    enqueueMany(items: EnqueueManyItem<T>[], returnJobs: true): Promise<Job<T>[]>;
+    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
+        returnJobs?: false;
+    }): Promise<void>;
+    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
+        returnJobs: true;
+    }): Promise<Job<T>[]>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<void | Job<T>[]>;
     has(id: string): Promise<boolean>;
     countByTag(tag: JobTag): Promise<number>;
     get(id: string): Promise<Job<T> | undefined>;

package/queue/mongo/queue.js

@@ -66,12 +66,12 @@ let MongoQueue = class MongoQueue extends Queue {
             : await this.repository.insertWithUniqueTagStrategy(newJob, uniqueTag);
         return toModelJob(job);
     }
-    async enqueueMany(items, returnJobs = false) {
+    async enqueueMany(items, options) {
         const now = currentTimestamp();
         const nonUnique = [];
         const keepOld = [];
         const takeNew = [];
-        for (const { data, tag = null, uniqueTag, priority = defaultJobPriority } of items) {
+        for (const { data, tag = null, priority = defaultJobPriority } of items) {
             const newMongoJob = {
                 queue: this.queueKey,
                 jobId: getNewId(),
@@ -83,7 +83,7 @@ let MongoQueue = class MongoQueue extends Queue {
                 lastDequeueTimestamp: 0,
                 batch: null
             };
-            switch (uniqueTag) {
+            switch (options?.uniqueTag) {
                 case undefined:
                     nonUnique.push(newMongoJob);
                     break;
@@ -102,7 +102,7 @@ let MongoQueue = class MongoQueue extends Queue {
             (keepOld.length > 0) ? this.repository.bulkInsertWithUniqueTagStrategy(keepOld, UniqueTagStrategy.KeepOld) : undefined,
             (takeNew.length > 0) ? this.repository.bulkInsertWithUniqueTagStrategy(takeNew, UniqueTagStrategy.TakeNew) : undefined
         ]);
-        if (returnJobs) {
+        if (options?.returnJobs == true) {
             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] } });
@@ -225,7 +225,7 @@ MongoQueue = __decorate([
                 if (isString(argument)) {
                     return provider.get(argument, defaultQueueConfig);
                 }
-                return provider.get(argument.key, { ...defaultQueueConfig, ...argument });
+                return provider.get(argument.name, { ...defaultQueueConfig, ...argument });
             }
         }
     }),
@@ -241,7 +241,6 @@ function toModelJob(mongoJob) {
     };
     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;

package/queue/postgres/drizzle/0000_zippy_moondragon.sql

@@ -0,0 +1,11 @@
+CREATE TABLE "queue"."job" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"queue" text NOT NULL,
+	"tag" text,
+	"priority" integer NOT NULL,
+	"enqueue_timestamp" timestamp with time zone NOT NULL,
+	"tries" integer NOT NULL,
+	"last_dequeue_timestamp" timestamp with time zone,
+	"data" jsonb NOT NULL,
+	CONSTRAINT "job_queue_tag_unique" UNIQUE("queue","tag")
+);

package/queue/postgres/drizzle/meta/0000_snapshot.json

@@ -0,0 +1,90 @@
+{
+  "id": "1a2e63a5-b780-4f4d-ae41-ce8369aa1cf0",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "queue.job": {
+      "name": "job",
+      "schema": "queue",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "queue": {
+          "name": "queue",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tag": {
+          "name": "tag",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enqueue_timestamp": {
+          "name": "enqueue_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tries": {
+          "name": "tries",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_dequeue_timestamp": {
+          "name": "last_dequeue_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "data": {
+          "name": "data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "job_queue_tag_unique": {
+          "name": "job_queue_tag_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "queue",
+            "tag"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/queue/postgres/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1740684120614,
+      "tag": "0000_zippy_moondragon",
+      "breakpoints": true
+    }
+  ]
+}

package/queue/postgres/drizzle.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("drizzle-kit").Config;
+export default _default;

package/queue/postgres/drizzle.config.js

@@ -0,0 +1,11 @@
+import { relative, resolve } from 'node:path';
+import { defineConfig } from 'drizzle-kit';
+export default defineConfig({
+    dialect: 'postgresql',
+    out: relative('./', resolve(__dirname, './drizzle/').replace('dist', 'source')),
+    schema: resolve(__dirname, './schemas.js'),
+    migrations: {
+        schema: 'queue',
+        table: '_migrations'
+    }
+});

package/queue/postgres/index.d.ts

@@ -0,0 +1,4 @@
+export * from './job.model.js';
+export * from './module.js';
+export * from './queue.js';
+export * from './queue.provider.js';

package/queue/postgres/index.js

@@ -0,0 +1,4 @@
+export * from './job.model.js';
+export * from './module.js';
+export * from './queue.js';
+export * from './queue.provider.js';

package/queue/postgres/job.model.d.ts

@@ -0,0 +1,13 @@
+import { EntityWithoutMetadata } from '../../orm/entity.js';
+import { Integer, Json, Timestamp } from '../../orm/index.js';
+import type { ObjectLiteral } from '../../types.js';
+import type { Job } from '../queue.js';
+export declare class PostgresJob<T extends ObjectLiteral = ObjectLiteral> extends EntityWithoutMetadata implements Job<T> {
+    queue: string;
+    tag: string | null;
+    priority: Integer;
+    enqueueTimestamp: Timestamp;
+    tries: Integer;
+    lastDequeueTimestamp: Timestamp | null;
+    data: Json<T>;
+}

package/queue/postgres/job.model.js

@@ -0,0 +1,55 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Table } from '../../orm/decorators.js';
+import { EntityWithoutMetadata } from '../../orm/entity.js';
+import { Integer, Json, Timestamp, Unique } from '../../orm/index.js';
+import { StringProperty } from '../../schema/index.js';
+let PostgresJob = class PostgresJob extends EntityWithoutMetadata {
+    queue;
+    tag;
+    priority;
+    enqueueTimestamp;
+    tries;
+    lastDequeueTimestamp;
+    data;
+};
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], PostgresJob.prototype, "queue", void 0);
+__decorate([
+    StringProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresJob.prototype, "tag", void 0);
+__decorate([
+    Integer(),
+    __metadata("design:type", Number)
+], PostgresJob.prototype, "priority", void 0);
+__decorate([
+    Timestamp(),
+    __metadata("design:type", Number)
+], PostgresJob.prototype, "enqueueTimestamp", void 0);
+__decorate([
+    Integer(),
+    __metadata("design:type", Number)
+], PostgresJob.prototype, "tries", void 0);
+__decorate([
+    Timestamp({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresJob.prototype, "lastDequeueTimestamp", void 0);
+__decorate([
+    Json(),
+    __metadata("design:type", Object)
+], PostgresJob.prototype, "data", void 0);
+PostgresJob = __decorate([
+    Table('job'),
+    Unique(['queue', 'tag'])
+], PostgresJob);
+export { PostgresJob };

package/queue/postgres/module.d.ts

@@ -0,0 +1,9 @@
+import { type DatabaseConfig } from '../../orm/server/index.js';
+export declare class PostgresQueueModuleConfig {
+    database?: DatabaseConfig;
+}
+/**
+ * configure mail module
+ */
+export declare function configurePostgresQueue(config: PostgresQueueModuleConfig, register?: boolean): void;
+export declare function migratePostgresQueueSchema(): Promise<void>;

package/queue/postgres/module.js

@@ -0,0 +1,29 @@
+import { inject } from '../../injector/index.js';
+import { Injector } from '../../injector/injector.js';
+import { Database, migrate } from '../../orm/server/index.js';
+import { QueueProvider } from '../provider.js';
+import { Queue } from '../queue.js';
+import { PostgresQueue } from './queue.js';
+import { PostgresQueueProvider } from './queue.provider.js';
+export class PostgresQueueModuleConfig {
+    database;
+}
+/**
+ * configure mail module
+ */
+export function configurePostgresQueue(config, register = true) {
+    Injector.register(PostgresQueueModuleConfig, { useValue: config });
+    if (register) {
+        Injector.registerSingleton(QueueProvider, { useToken: PostgresQueueProvider });
+        Injector.registerSingleton(Queue, { useToken: PostgresQueue });
+    }
+}
+export async function migratePostgresQueueSchema() {
+    const connection = inject(PostgresQueueModuleConfig, undefined, { optional: true })?.database?.connection;
+    const database = inject(Database, connection);
+    await migrate(database, {
+        migrationsSchema: 'queue',
+        migrationsTable: '_migrations',
+        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', '')
+    });
+}

package/queue/postgres/queue.d.ts

@@ -0,0 +1,28 @@
+import { CancellationSignal } from '../../cancellation/index.js';
+import type { ObjectLiteral } from '../../types.js';
+import { Queue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Job, type JobTag } from '../queue.js';
+export declare class PostgresQueue<T extends ObjectLiteral> extends Queue<T> {
+    #private;
+    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
+        returnJobs?: false;
+    }): Promise<void>;
+    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
+        returnJobs: true;
+    }): Promise<Job<T>[]>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | undefined>;
+    has(id: string): Promise<boolean>;
+    countByTag(tag: JobTag): Promise<number>;
+    get(id: string): Promise<Job<T> | undefined>;
+    getByTag(tag: JobTag): Promise<Job<T>[]>;
+    cancel(id: string): Promise<void>;
+    cancelMany(ids: string[]): Promise<void>;
+    cancelByTag(tag: JobTag): Promise<void>;
+    cancelByTags(tags: JobTag[]): Promise<void>;
+    dequeue(): Promise<Job<T> | undefined>;
+    dequeueMany(count: number): Promise<Job<T>[]>;
+    acknowledge(job: Job<T>): Promise<void>;
+    acknowledgeMany(jobs: Job<T>[]): Promise<void>;
+    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
+    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
+}

package/queue/postgres/queue.js

@@ -0,0 +1,149 @@
+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;
+};
+import { and, asc, eq, inArray, isNull as isSqlNull, lt, lte, or, sql } from 'drizzle-orm';
+import { merge } from 'rxjs';
+import { CancellationSignal } from '../../cancellation/index.js';
+import { inject, injectArgument, provide, Singleton } from '../../injector/index.js';
+import { MessageBus } from '../../message-bus/index.js';
+import { DatabaseConfig, EntityRepositoryConfig, injectRepository, interval, RANDOM_UUID, TRANSACTION_TIMESTAMP } from '../../orm/server/index.js';
+import { cancelableTimeout } from '../../utils/timing.js';
+import { isString } from '../../utils/type-guards.js';
+import { millisecondsPerSecond } from '../../utils/units.js';
+import { defaultQueueConfig, Queue, UniqueTagStrategy } from '../queue.js';
+import { PostgresJob } from './job.model.js';
+import { PostgresQueueModuleConfig } from './module.js';
+import { job } from './schemas.js';
+let PostgresQueue = class PostgresQueue extends Queue {
+    #repository = injectRepository(PostgresJob);
+    #config = injectArgument(this);
+    #processTimeout = (isString(this.#config) ? undefined : this.#config.processTimeout) ?? defaultQueueConfig.processTimeout;
+    #maxTries = (isString(this.#config) ? undefined : this.#config.maxTries) ?? defaultQueueConfig.maxTries;
+    #queueName = isString(this.#config) ? this.#config : this.#config.name;
+    #messageBus = inject((MessageBus), `PostgresQueue:${this.#queueName}`);
+    #keepOldUpdate = { id: sql `${job.id}` };
+    #takeNewUpdate = {
+        id: RANDOM_UUID,
+        queue: this.#queueName,
+        priority: sql `excluded.priority`,
+        tag: sql `excluded.tag`,
+        tries: 0,
+        enqueueTimestamp: TRANSACTION_TIMESTAMP,
+        lastDequeueTimestamp: null,
+        data: sql `excluded.data`
+    };
+    #dequeueQuery = and(eq(job.queue, this.#queueName), lt(job.tries, this.#maxTries), or(isSqlNull(job.lastDequeueTimestamp), lte(job.lastDequeueTimestamp, sql `${job.lastDequeueTimestamp} + ${interval(this.#processTimeout, 'milliseconds')}`)));
+    #dequeueUpdate = {
+        tries: sql `${job.tries} + 1`,
+        lastDequeueTimestamp: TRANSACTION_TIMESTAMP
+    };
+    async enqueue(data, options) {
+        const jobs = await this.enqueueMany([{ data, tag: options?.tag, priority: options?.priority }], { returnJobs: true });
+        return jobs[0];
+    }
+    async enqueueMany(items, options) {
+        const newEntities = items.map((item) => ({
+            queue: this.#queueName,
+            priority: item.priority ?? 1000,
+            tag: item.tag ?? null,
+            tries: 0,
+            enqueueTimestamp: TRANSACTION_TIMESTAMP,
+            lastDequeueTimestamp: null,
+            data: item.data
+        }));
+        const update = (options?.uniqueTag == UniqueTagStrategy.TakeNew)
+            ? this.#takeNewUpdate
+            : this.#keepOldUpdate;
+        const jobs = await this.#repository.upsertMany(['queue', 'tag'], newEntities, update);
+        this.#messageBus.publishAndForget();
+        return jobs;
+    }
+    async has(id) {
+        return this.#repository.hasByQuery({ queue: this.#queueName, id });
+    }
+    async countByTag(tag) {
+        return this.#repository.countByQuery({ queue: this.#queueName, tag });
+    }
+    async get(id) {
+        return this.#repository.tryLoadByQuery({ queue: this.#queueName, id });
+    }
+    async getByTag(tag) {
+        return this.#repository.loadManyByQuery({ queue: this.#queueName, tag });
+    }
+    async cancel(id) {
+        await this.#repository.hardDeleteByQuery({ queue: this.#queueName, id });
+    }
+    async cancelMany(ids) {
+        await this.#repository.hardDeleteManyByQuery({ queue: this.#queueName, id: { $in: ids } });
+    }
+    async cancelByTag(tag) {
+        await this.#repository.hardDeleteByQuery({ queue: this.#queueName, tag });
+    }
+    async cancelByTags(tags) {
+        await this.#repository.hardDeleteManyByQuery({ queue: this.#queueName, tag: { $in: tags } });
+    }
+    async dequeue() {
+        const jobs = await this.dequeueMany(1);
+        if (jobs.length == 0) {
+            return undefined;
+        }
+        return jobs[0];
+    }
+    async dequeueMany(count) {
+        const rows = await this.#repository.session
+            .update(job)
+            .set(this.#dequeueUpdate)
+            .where(inArray(job.id, this.#repository.session.select({ id: job.id })
+            .from(job)
+            .where(this.#dequeueQuery)
+            .orderBy(asc(job.priority), asc(job.enqueueTimestamp), asc(job.lastDequeueTimestamp), asc(job.tries))
+            .limit(count)))
+            .returning();
+        return this.#repository.$mapManyToEntity(rows); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    }
+    async acknowledge(job) {
+        return this.cancel(job.id);
+    }
+    async acknowledgeMany(jobs) {
+        const ids = jobs.map((job) => job.id);
+        return this.cancelMany(ids);
+    }
+    async *getConsumer(cancellationSignal) {
+        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
+        while (cancellationSignal.isUnset) {
+            const job = await this.dequeue();
+            if (job != undefined) {
+                yield job;
+            }
+            else {
+                const cancelled = await cancelableTimeout(5 * millisecondsPerSecond, continue$);
+                if (cancelled) {
+                    break;
+                }
+            }
+        }
+    }
+    async *getBatchConsumer(size, cancellationSignal) {
+        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
+        while (cancellationSignal.isUnset) {
+            const jobs = await this.dequeueMany(size);
+            if (jobs.length > 0) {
+                yield jobs;
+                continue;
+            }
+            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
+        }
+    }
+};
+PostgresQueue = __decorate([
+    Singleton({
+        providers: [
+            provide(EntityRepositoryConfig, { useValue: { schema: 'queue' } }),
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) })
+        ]
+    })
+], PostgresQueue);
+export { PostgresQueue };

package/queue/postgres/queue.provider.d.ts

@@ -0,0 +1,7 @@
+import { QueueProvider, type QueueConfig } from '../../queue/index.js';
+import type { ObjectLiteral } from '../../types.js';
+import { PostgresQueue } from './queue.js';
+export declare class PostgresQueueProvider extends QueueProvider {
+    #private;
+    get<T extends ObjectLiteral>(name: string, config?: QueueConfig): PostgresQueue<T>;
+}

package/queue/postgres/queue.provider.js

@@ -0,0 +1,21 @@
+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;
+};
+import { Singleton } from '../../injector/decorators.js';
+import { inject } from '../../injector/inject.js';
+import { Injector } from '../../injector/injector.js';
+import { QueueProvider } from '../../queue/index.js';
+import { PostgresQueue } from './queue.js';
+let PostgresQueueProvider = class PostgresQueueProvider extends QueueProvider {
+    #injector = inject(Injector);
+    get(name, config) {
+        return this.#injector.resolve((PostgresQueue), { ...config, name: name });
+    }
+};
+PostgresQueueProvider = __decorate([
+    Singleton()
+], PostgresQueueProvider);
+export { PostgresQueueProvider };

package/queue/postgres/schemas.d.ts

@@ -0,0 +1,3 @@
+import { PostgresJob } from './job.model.js';
+export declare const queueSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"queue">;
+export declare const job: import("../../orm/server/types.js").PgTableFromType<typeof PostgresJob, "queue">;

package/queue/postgres/schemas.js

@@ -0,0 +1,4 @@
+import { databaseSchema } from '../../orm/server/database-schema.js';
+import { PostgresJob } from './job.model.js';
+export const queueSchema = databaseSchema('queue');
+export const job = queueSchema.getTable(PostgresJob);