@tstdl/base 0.92.85 → 0.92.87

package/orm/server/types.d.ts

@@ -3,7 +3,7 @@ import type { PgColumnBuilder, PgTableWithColumns } from 'drizzle-orm/pg-core';
 import type { CamelCase, ConditionalPick, SnakeCase } from 'type-fest';
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { Record } from '../../schema/index.js';
-import type { AbstractConstructor, UnionToIntersection } from '../../types.js';
+import type { UnionToIntersection } from '../../types.js';
 import type { Tagged } from '../../types/index.js';
 import type { OrmColumnReflectionData } from '../decorators.js';
 import type { EntityType } from '../entity.js';
@@ -23,11 +23,11 @@ export type ColumnDefinition = {
 export type TransformContext = {
     encryptionKey?: CryptoKey;
 };
-type Column<Name extends string, T> = null extends T ? ColumnBuilder<T, Name> : NotNull<ColumnBuilder<T, Name>>;
+type Column<Name extends string, T> = null extends T ? ColumnBuilder<Exclude<T, null>, Name> : NotNull<ColumnBuilder<T, Name>>;
 export type ColumnPrefix<T> = T extends Tagged<unknown, EmbeddedConfigTag, {
     prefix: infer Prefix;
 }> ? Prefix extends string ? Prefix : '' : '';
-export type PgTableFromType<S extends string, T extends AbstractConstructor, TableName extends string = T extends Required<EntityType> ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
+export type PgTableFromType<T extends EntityType = EntityType, S extends string = string, TableName extends string = T extends Required<EntityType> ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
     name: TableName;
     schema: S;
     columns: BuildColumns<TableName, {

package/orm/types.d.ts

@@ -1,11 +1,11 @@
 import type { $Type, HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
-import type { boolean, date, doublePrecision, integer, jsonb, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import type { boolean, doublePrecision, integer, jsonb, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, uuid } from 'drizzle-orm/pg-core';
 import { Array, Integer } from '../schema/index.js';
 import type { AbstractConstructor, EnumerationObject, EnumerationValue, ObjectLiteral, UnionToTuple } from '../types.js';
 import type { GetTagMetadata, HasTag, Tagged, UnwrapTagged } from '../types/index.js';
+import type { bytea, numericDate, timestamp } from './data-types/index.js';
 import { Check, Column, Embedded, Encrypted, Index, PrimaryKey, References, Unique } from './decorators.js';
 import { Json, NumericDate, Timestamp, Uuid } from './schemas/index.js';
-import type { bytea } from './server/data-types/index.js';
 export type ColumnTypeTag = 'column';
 export type EmbeddedConfigTag = 'embedded';
 export type IsPrimaryKey<T> = T extends Tagged<unknown, ColumnTypeTag, PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, ColumnTypeTag, DrizzleIsPrimaryKey<GetTagMetadata<T, ColumnTypeTag>>> : Tagged<T, ColumnTypeTag, DrizzleIsPrimaryKey<ColumnBuilder<T>>>;
@@ -16,14 +16,14 @@ export type Embedded<T = AbstractConstructor, P extends string = ''> = Tagged<T,
     prefix: P;
 }>;
 export type Array<T extends Tagged<ObjectLiteral, ColumnTypeTag, PgColumnBuilder<any>>> = Tagged<UnwrapTagged<T>[], ColumnTypeTag, ReturnType<GetTagMetadata<T, ColumnTypeTag>['array']>>;
-export type Json<T extends ObjectLiteral = ObjectLiteral> = Tagged<T, ColumnTypeTag, $Type<ReturnType<typeof jsonb>, T>>;
+export type Json<T> = Tagged<T, ColumnTypeTag, $Type<ReturnType<typeof jsonb>, T>>;
 export type Enum<T extends EnumerationObject> = Tagged<EnumerationValue<T>, ColumnTypeTag, EnumColumn<T>>;
 export type Text = Tagged<string, ColumnTypeTag, ReturnType<typeof text<string, [string, ...string[]]>>>;
 export type Uuid = Tagged<string, ColumnTypeTag, ReturnType<typeof uuid>>;
 export type Integer = Tagged<number, ColumnTypeTag, ReturnType<typeof integer>>;
 export type DoublePrecision = Tagged<number, ColumnTypeTag, ReturnType<typeof doublePrecision>>;
 export type Boolean = Tagged<number, ColumnTypeTag, ReturnType<typeof boolean>>;
-export type NumericDate = Tagged<number, ColumnTypeTag, ReturnType<typeof date>>;
+export type NumericDate = Tagged<number, ColumnTypeTag, ReturnType<typeof numericDate>>;
 export type Timestamp = Tagged<number, ColumnTypeTag, ReturnType<typeof timestamp>>;
 export type Bytea = Tagged<Uint8Array, ColumnTypeTag, ReturnType<typeof bytea>>;
 export type Encrypted<T> = Tagged<T, ColumnTypeTag, ReturnType<typeof bytea>>;

package/orm/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Entity } from './entity.js';
+export declare function getEntityMap<T extends Entity>(entities: T[]): Map<string, T>;
+export declare function getEntityIds<T extends Entity>(entities: T[]): string[];

package/orm/utils.js

@@ -0,0 +1,6 @@
+export function getEntityMap(entities) {
+    return new Map(entities.map((entity) => [entity.id, entity]));
+}
+export function getEntityIds(entities) {
+    return entities.map((entity) => entity.id);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.85",
+  "version": "0.92.87",
   "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",
@@ -127,16 +129,18 @@
     "./utils/string": "./utils/string/index.js"
   },
   "dependencies": {
-    "@google-cloud/storage": "7.15",
-    "@google-cloud/vertexai": "1.9",
-    "disposablestack": "1.1",
+    "@google-cloud/storage": "^7.15",
+    "@google-cloud/vertexai": "^1.9",
+    "disposablestack": "^1.1",
     "luxon": "^3.5",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.35"
+    "ts-pattern": "^5.6",
+    "type-fest": "^4.37"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "4.1",
+    "@biomejs/biome": "1.9",
+    "@stylistic/eslint-plugin": "4.2",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -145,17 +149,17 @@
     "@types/node": "22",
     "@types/nodemailer": "6.4",
     "@types/pg": "8.11",
-    "@typescript-eslint/eslint-plugin": "8.25",
+    "@typescript-eslint/eslint-plugin": "8.26",
     "concurrently": "9.1",
     "drizzle-kit": "0.30",
     "eslint": "9.21",
     "globals": "16.0",
     "tsc-alias": "1.8",
-    "typescript": "5.7"
+    "typescript": "5.8"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.17",
-    "@google/generative-ai": "^0.22",
+    "@google/generative-ai": "^0.23",
     "@tstdl/angular": "^0.92",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
@@ -166,13 +170,13 @@
     "handlebars": "^4.7",
     "minio": "^8.0",
     "mjml": "^4.15",
-    "mongodb": "^6.13",
+    "mongodb": "^6.14",
     "nodemailer": "^6.10",
     "pg": "^8.13",
     "playwright": "^1.50",
     "preact": "^10.26",
     "preact-render-to-string": "^6.5",
-    "undici": "^7.3",
+    "undici": "^7.4",
     "urlpattern-polyfill": "^10.0"
   },
   "peerDependenciesMeta": {

package/pdf/pdf.service.d.ts

@@ -92,7 +92,6 @@ export declare class PdfService implements Resolvable<PdfServiceArgument> {
      * @returns pdf bytes
      */
     renderTemplate(keyOrTemplate: string | PdfTemplate, templateContext?: object, options?: PdfServiceRenderOptions): Promise<Uint8Array>;
-    merge(pdfs: (string | Uint8Array)[]): Promise<Uint8Array>;
     private renderStream;
 }
 export declare function pdfTemplate(name: string, fields: {

package/pdf/pdf.service.js

@@ -12,62 +12,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { execFile as execFileCallback } from 'node:child_process';
-import { access, readFile, unlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { promisify } from 'node:util';
 import { BrowserContextController } from '../browser/browser-context-controller.js';
 import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';
@@ -80,8 +24,7 @@ import { finalizeStream } from '../utils/stream/finalize-stream.js';
 import { readableStreamFromPromise } from '../utils/stream/readable-stream-from-promise.js';
 import { readBinaryStream } from '../utils/stream/stream-reader.js';
 import { timeout } from '../utils/timing.js';
-import { isDefined, isString } from '../utils/type-guards.js';
-const execFile = promisify(execFileCallback);
+import { isDefined } from '../utils/type-guards.js';
 export class PdfServiceRenderOptions extends PdfRenderOptions {
     browserContext;
     locale;
@@ -196,43 +139,6 @@ let PdfService = class PdfService {
         const stream = this.renderTemplateStream(keyOrTemplate, templateContext, options);
         return readBinaryStream(stream);
     }
-    async merge(pdfs) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
-            const tmp = tmpdir();
-            const sourceFiles = await Promise.all(pdfs.map(async (pdf) => {
-                if (isString(pdf)) {
-                    return pdf;
-                }
-                const file = `${tmp}/${crypto.randomUUID()}.pdf`;
-                await writeFile(file, pdf);
-                stack.defer(async () => unlink(file));
-                return file;
-            }));
-            const resultFile = `${tmp}/${crypto.randomUUID()}.pdf`;
-            const resultPromise = execFile('pdfunite', [...sourceFiles, resultFile]);
-            const result = await resultPromise;
-            try {
-                await access(resultFile);
-                stack.defer(async () => unlink(resultFile));
-            }
-            catch { /* ignore */ }
-            if (resultPromise.child.exitCode != 0) {
-                throw new Error(result.stderr);
-            }
-            return readFile(resultFile);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
-        }
-    }
     renderStream(handler, options = {}) {
         return readableStreamFromPromise(async () => {
             const context = options.browserContext ?? await this.browserController.newContext({ locale: options.locale ?? this.defaultLocale });

package/pdf/utils.d.ts

@@ -1 +1,3 @@
-export declare function getPdfPageCount(file: string): Promise<number>;
+export declare function getPdfPageCount(file: string | Uint8Array | ReadableStream<Uint8Array>): Promise<number>;
+export declare function mergePdfs(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<Uint8Array>;
+export declare function mergePdfsStream(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<ReadableStream<Uint8Array>>;

package/pdf/utils.js

@@ -1,11 +1,136 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { TemporaryFile } from '../file/temporary-file.js';
 import { spawnCommand } from '../process/spawn.js';
+import { isString } from '../utils/type-guards.js';
 export async function getPdfPageCount(file) {
-    const process = await spawnCommand('qpdf', ['--show-npages', file]);
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const fileIsPath = isString(file);
+        const tmpFile = __addDisposableResource(env_1, fileIsPath ? await TemporaryFile.from(file) : undefined, true);
+        const path = fileIsPath ? file : tmpFile.path;
+        const process = await spawnCommand('qpdf', ['--show-npages', path]);
+        const { code } = await process.wait();
+        if (code != 0) {
+            const errorOutput = await process.readError();
+            throw new Error(errorOutput.trim());
+        }
+        const output = await process.readOutput();
+        return Number(output);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+}
+export async function mergePdfs(pdfs) {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const stack = __addDisposableResource(env_2, new AsyncDisposableStack(), true);
+        const resultFile = __addDisposableResource(env_2, TemporaryFile.create(), true);
+        const sourceFiles = await getPdfSourceFiles(pdfs, stack);
+        await pdfunite(sourceFiles, resultFile);
+        return await resultFile.read();
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            await result_2;
+    }
+}
+export async function mergePdfsStream(pdfs) {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const stack = __addDisposableResource(env_3, new AsyncDisposableStack(), true);
+        const resultFile = __addDisposableResource(env_3, TemporaryFile.create(), true);
+        const sourceFiles = await getPdfSourceFiles(pdfs, stack);
+        await pdfunite(sourceFiles, resultFile);
+        return resultFile.readStream();
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        const result_3 = __disposeResources(env_3);
+        if (result_3)
+            await result_3;
+    }
+}
+async function getPdfSourceFiles(pdfs, stack) {
+    return await Promise.all(pdfs.map(async (pdf) => {
+        if (isString(pdf)) {
+            return pdf;
+        }
+        const tmpFile = await TemporaryFile.from(pdf);
+        stack.use(tmpFile);
+        return tmpFile.path;
+    }));
+}
+async function pdfunite(sourceFiles, resultFile) {
+    const process = await spawnCommand('pdfunite', [...sourceFiles, resultFile.path]);
     const { code } = await process.wait();
     if (code != 0) {
         const errorOutput = await process.readError();
-        throw new Error(errorOutput.trim());
+        throw new Error(errorOutput);
     }
-    const output = await process.readOutput();
-    return Number(output);
 }

package/promise/lazy-promise.d.ts

@@ -4,8 +4,8 @@ export declare class LazyPromise<T> extends CustomPromise<T> {
     #private;
     readonly [Symbol.toStringTag] = "LazyPromise";
     constructor(executorOrPromiseProvider: PromiseExecutor<T> | (() => PromiseLike<T>));
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
-    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
     private execute;
 }

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": {}
+  }
+}