@tstdl/base 0.92.99 → 0.92.101

package/queue/postgres/job.model.js

@@ -7,9 +7,9 @@ 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);
 };
-import { Table } from '../../orm/decorators.js';
+import { Index, Table } from '../../orm/decorators.js';
 import { EntityWithoutMetadata } from '../../orm/entity.js';
-import { Integer, Json, Timestamp, Unique } from '../../orm/index.js';
+import { Integer, Json, Timestamp } from '../../orm/index.js';
 import { StringProperty } from '../../schema/index.js';
 let PostgresJob = class PostgresJob extends EntityWithoutMetadata {
     queue;
@@ -50,6 +50,6 @@ __decorate([
 ], PostgresJob.prototype, "data", void 0);
 PostgresJob = __decorate([
     Table('job'),
-    Unique(['queue', 'tag'])
+    Index(['queue', 'tag'])
 ], PostgresJob);
 export { PostgresJob };

package/queue/postgres/queue.d.ts

@@ -3,6 +3,8 @@ 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;
+    readonly processTimeout: number;
+    readonly maxTries: number;
     enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
     enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
         returnJobs?: false;
@@ -15,6 +17,7 @@ export declare class PostgresQueue<T extends ObjectLiteral> extends Queue<T> {
     countByTag(tag: JobTag): Promise<number>;
     get(id: string): Promise<Job<T> | undefined>;
     getByTag(tag: JobTag): Promise<Job<T>[]>;
+    getByTags(tags: JobTag[]): Promise<Job<T>[]>;
     cancel(id: string): Promise<void>;
     cancelMany(ids: string[]): Promise<void>;
     cancelByTag(tag: JobTag): Promise<void>;

package/queue/postgres/queue.js

@@ -12,7 +12,7 @@ import { MessageBus } from '../../message-bus/index.js';
 import { interval, RANDOM_UUID, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
 import { DatabaseConfig, EntityRepositoryConfig, injectRepository } from '../../orm/server/index.js';
 import { cancelableTimeout } from '../../utils/timing.js';
-import { isDefined, isString } from '../../utils/type-guards.js';
+import { isDefined, isString, isUndefined } from '../../utils/type-guards.js';
 import { millisecondsPerSecond } from '../../utils/units.js';
 import { defaultQueueConfig, Queue, UniqueTagStrategy } from '../queue.js';
 import { PostgresJob } from './job.model.js';
@@ -21,11 +21,11 @@ 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}` };
+    processTimeout = (isString(this.#config) ? undefined : this.#config.processTimeout) ?? defaultQueueConfig.processTimeout;
+    maxTries = (isString(this.#config) ? undefined : this.#config.maxTries) ?? defaultQueueConfig.maxTries;
     #takeNewUpdate = {
         id: RANDOM_UUID,
         queue: this.#queueName,
@@ -36,7 +36,7 @@ let PostgresQueue = class PostgresQueue extends Queue {
         lastDequeueTimestamp: null,
         data: sql `excluded.data`
     };
-    #dequeueQuery = and(eq(job.queue, this.#queueName), lt(job.tries, this.#maxTries), or(isSqlNull(job.lastDequeueTimestamp), lte(sql `${job.lastDequeueTimestamp} + ${interval(this.#processTimeout, 'milliseconds')}`, TRANSACTION_TIMESTAMP)));
+    #dequeueQuery = and(eq(job.queue, this.#queueName), lt(job.tries, this.maxTries), or(isSqlNull(job.lastDequeueTimestamp), lte(sql `${job.lastDequeueTimestamp} + ${interval(this.processTimeout, 'milliseconds')}`, TRANSACTION_TIMESTAMP)));
     #dequeueUpdate = {
         tries: sql `${job.tries} + 1`,
         lastDequeueTimestamp: TRANSACTION_TIMESTAMP
@@ -57,8 +57,12 @@ let PostgresQueue = class PostgresQueue extends Queue {
         }));
         const update = (options?.uniqueTag == UniqueTagStrategy.TakeNew)
             ? this.#takeNewUpdate
-            : this.#keepOldUpdate;
-        const jobs = await this.#repository.upsertMany(['queue', 'tag'], newEntities, update);
+            : (options?.uniqueTag == UniqueTagStrategy.KeepOld)
+                ? this.#keepOldUpdate
+                : undefined;
+        const jobs = isUndefined(update)
+            ? await this.#repository.insertMany(newEntities)
+            : await this.#repository.upsertMany(['queue', 'tag'], newEntities, update);
         this.#messageBus.publishAndForget();
         return jobs;
     }
@@ -74,6 +78,9 @@ let PostgresQueue = class PostgresQueue extends Queue {
     async getByTag(tag) {
         return this.#repository.loadManyByQuery({ queue: this.#queueName, tag });
     }
+    async getByTags(tags) {
+        return this.#repository.loadManyByQuery({ queue: this.#queueName, tag: { $in: tags } });
+    }
     async cancel(id) {
         await this.#repository.hardDeleteByQuery({ queue: this.#queueName, id });
     }

package/queue/queue.d.ts

@@ -14,6 +14,9 @@ export type Job<T> = {
     priority: number;
     tag: JobTag;
     data: T;
+    enqueueTimestamp: number;
+    lastDequeueTimestamp: number | null;
+    tries: number;
 };
 export declare const defaultJobPriority = 1000;
 export declare enum UniqueTagStrategy {
@@ -46,6 +49,8 @@ export type QueueArgument = string | (QueueConfig & {
 export declare const defaultQueueConfig: Required<QueueConfig>;
 export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
     readonly [resolveArgumentType]: QueueArgument;
+    abstract readonly processTimeout: number;
+    abstract readonly maxTries: number;
     batch(): QueueEnqueueBatch<T>;
     abstract enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
     abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
@@ -59,6 +64,7 @@ export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
     abstract countByTag(tag: JobTag): Promise<number>;
     abstract get(id: string): Promise<Job<T> | undefined>;
     abstract getByTag(tag: JobTag): Promise<Job<T>[]>;
+    abstract getByTags(tags: JobTag[]): Promise<Job<T>[]>;
     abstract cancel(id: string): Promise<void>;
     abstract cancelMany(ids: string[]): Promise<void>;
     abstract cancelByTag(tag: JobTag): Promise<void>;

package/utils/try-ignore.d.ts

@@ -3,7 +3,7 @@ export declare function tryIgnore<R>(fn: () => R): R;
 export declare function tryIgnore<R, F>(fn: () => R, fallback: F): R | F;
 export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R>;
 export declare function tryIgnoreAsync<R, F>(fn: () => Promise<R>, fallback: F): Promise<F>;
-export declare function tryIgnoreLog<R>(fn: () => R, logger: Logger): R;
-export declare function tryIgnoreLog<R, F>(fn: () => R, logger: Logger, fallback: F): R | F;
-export declare function tryIgnoreLogAsync<R>(fn: () => Promise<R>, logger: Logger): Promise<R>;
-export declare function tryIgnoreLogAsync<R, F>(fn: () => Promise<R>, logger: Logger, fallback: F): Promise<F>;
+export declare function tryIgnoreLog<R>(logger: Logger, fn: () => R): R;
+export declare function tryIgnoreLog<R, F>(logger: Logger, fn: () => R, fallback: F): R | F;
+export declare function tryIgnoreLogAsync<R>(logger: Logger, fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreLogAsync<R, F>(logger: Logger, fn: () => Promise<R>, fallback: F): Promise<F>;

package/utils/try-ignore.js

@@ -15,7 +15,7 @@ export async function tryIgnoreAsync(fn, fallback) {
         return fallback;
     }
 }
-export function tryIgnoreLog(fn, logger, fallback) {
+export function tryIgnoreLog(logger, fn, fallback) {
     try {
         return fn();
     }
@@ -24,7 +24,7 @@ export function tryIgnoreLog(fn, logger, fallback) {
         return fallback;
     }
 }
-export async function tryIgnoreLogAsync(fn, logger, fallback) {
+export async function tryIgnoreLogAsync(logger, fn, fallback) {
     try {
         const value = await fn();
         return value;