@tstdl/base 0.93.101 → 0.93.103

package/notification/models/in-app-notification.model.js

@@ -16,6 +16,7 @@ let InAppNotification = class InAppNotification extends TenantBaseEntity {
     static entityName = 'InAppNotification';
     userId;
     logId;
+    // TODO: anpinnen?
     readTimestamp;
     archiveTimestamp;
 };

package/object-storage/s3/s3.object-storage-provider.d.ts

@@ -5,6 +5,10 @@ export declare class S3ObjectStorageProviderConfig {
      * S3 endpoint
      */
     endpoint: string;
+    /**
+     * S3 Region
+     */
+    region?: string;
     /**
      * S3 bucket, use a single bucket for all modules (which will become transparent key prefixes)
      *

package/object-storage/s3/s3.object-storage-provider.js

@@ -18,6 +18,10 @@ export class S3ObjectStorageProviderConfig {
      * S3 endpoint
      */
     endpoint;
+    /**
+     * S3 Region
+     */
+    region;
     /**
      * S3 bucket, use a single bucket for all modules (which will become transparent key prefixes)
      *
@@ -50,6 +54,7 @@ let S3ObjectStorageProvider = class S3ObjectStorageProvider extends ObjectStorag
         }
         this.client = new Client({
             endPoint: hostname,
+            region: config.region,
             port: (port.length > 0) ? parseInt(port, 10) : undefined,
             useSSL: protocol == 'https:',
             accessKey: config.accessKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.101",
+  "version": "0.93.103",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/task-queue/task-context.d.ts

@@ -2,7 +2,7 @@ import type { CancellationSignal, CancellationToken } from '../cancellation/inde
 import type { Logger } from '../logger/index.js';
 import type { Transaction } from '../orm/server/index.js';
 import { TaskQueue, type EnqueueManyItem, type EnqueueOptions } from './task-queue.js';
-import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TaskState, TaskTypes, TasksStates } from './types.js';
+import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TaskState, TaskTypes } from './types.js';
 export declare class TaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
     #private;
     constructor(queue: TaskQueue<Definitions>, task: TaskOfType<Definitions, Type>, signal: CancellationToken, logger: Logger);
@@ -43,16 +43,3 @@ export declare class TaskContext<Definitions extends TaskDefinitionMap, Type ext
         transaction?: Transaction;
     }): Promise<void>;
 }
-export declare class BatchTaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
-    #private;
-    constructor(queue: TaskQueue<Definitions>, tasks: TaskOfType<Definitions, Type>[], signal: CancellationToken, logger: Logger);
-    get tasks(): TaskOfType<Definitions, Type>[];
-    get signal(): CancellationSignal;
-    get logger(): Logger;
-    for<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>): TaskContext<Definitions, Type>;
-    checkpointAll(options?: {
-        progresses?: number[];
-        states?: TasksStates<TaskOfType<Definitions, Type>[]>;
-        transaction?: Transaction;
-    }): Promise<void>;
-}

package/task-queue/task-context.js

@@ -92,33 +92,3 @@ export class TaskContext {
         this.#signal.set();
     }
 }
-export class BatchTaskContext {
-    #queue;
-    #tasks;
-    #logger;
-    #signal;
-    constructor(queue, tasks, signal, logger) {
-        this.#queue = queue;
-        this.#tasks = tasks;
-        this.#signal = signal;
-        this.#logger = logger.fork('Batch');
-    }
-    get tasks() {
-        return this.#tasks;
-    }
-    get signal() {
-        return this.#signal.signal;
-    }
-    get logger() {
-        return this.#logger;
-    }
-    for(task) {
-        return new TaskContext(this.#queue, task, this.#signal, this.#logger);
-    }
-    async checkpointAll(options) {
-        const validIds = await this.#queue.touchMany(this.#tasks, options);
-        if (validIds.length < this.#tasks.length) {
-            this.#logger.warn(`${this.#tasks.length - validIds.length} tasks in batch lost their lease during checkpoint`);
-        }
-    }
-}

package/task-queue/task-queue.d.ts

@@ -6,7 +6,7 @@ import type { Transaction } from '../orm/server/transaction.js';
 import { Transactional } from '../orm/server/transactional.js';
 import type { OneOrMany, Record, UndefinableJson } from '../types/types.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
-import type { ProcessBatchWorker, ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TasksResults, TasksStates, TaskState, TaskTypes } from './types.js';
+import type { ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TasksResults, TasksStates, TaskState, TaskTypes } from './types.js';
 export declare class TaskProcessResult<Result = unknown> {
     readonly payload: TaskProcessResultPayload<Result>;
     private constructor();
@@ -299,16 +299,8 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
         types?: Type[];
         forceDequeue?: boolean;
     }, handler: ProcessWorker<Definitions, Type>): void;
-    processBatch<Type extends TaskTypes<Definitions>>({ batchSize, concurrency, cancellationSignal, types, forceDequeue }: {
-        batchSize?: number;
-        concurrency?: number;
-        cancellationSignal: CancellationSignal;
-        types?: Type[];
-        forceDequeue?: boolean;
-    }, handler: ProcessBatchWorker<Definitions, Type>): void;
     protected getTransactionalContextData(): QueueConfig & {
         namespace: string;
     };
     private processWorker;
-    private processBatchWorker;
 }

package/task-queue/task-queue.js

@@ -2,13 +2,12 @@ import { defineEnum } from '../enumeration/enumeration.js';
 import { inject, injectArgument } from '../injector/index.js';
 import { Logger } from '../logger/logger.js';
 import { Transactional } from '../orm/server/transactional.js';
-import { createArray } from '../utils/array/array.js';
 import { currentTimestamp } from '../utils/date-time.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 { millisecondsPerDay, millisecondsPerMinute, millisecondsPerSecond } from '../utils/units.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
-import { BatchTaskContext } from './task-context.js';
+import { TaskContext } from './task-context.js';
 export class TaskProcessResult {
     payload;
     constructor(payload) {
@@ -89,114 +88,64 @@ export class TaskQueue extends Transactional {
             void this.processWorker(cancellationSignal, handler, { types, forceDequeue });
         }
     }
-    processBatch({ batchSize = 10, concurrency = 1, cancellationSignal, types, forceDequeue }, handler) {
-        for (let i = 0; i < concurrency; i++) {
-            void this.processBatchWorker(batchSize, cancellationSignal, handler, { types, forceDequeue });
-        }
-    }
     getTransactionalContextData() {
         return this.config;
     }
     async processWorker(cancellationSignal, handler, options) {
-        await this.processBatchWorker(1, cancellationSignal, async (batchContext) => {
-            const task = batchContext.tasks[0];
-            const context = batchContext.for(task);
-            const result = await handler(context);
-            return [result];
-        }, options);
-    }
-    async processBatchWorker(size, cancellationSignal, handler, options) {
-        for await (const tasks of this.getBatchConsumer(size, cancellationSignal, options)) {
-            const batchToken = cancellationSignal.createChild();
-            const context = new BatchTaskContext(this, tasks, batchToken, this.logger);
-            let activeTaskIds = new Set(tasks.map((t) => t.id));
-            context.logger.verbose(`Processing batch of ${tasks.length}`);
+        for await (const task of this.getConsumer(cancellationSignal, options)) {
+            const taskToken = cancellationSignal.createChild();
+            const context = new TaskContext(this, task, taskToken, this.logger);
+            let isTaskActive = true;
+            context.logger.verbose(`Processing task`);
             void (async () => {
-                while (batchToken.isUnset) {
-                    await cancelableTimeout(Math.min(this.visibilityTimeout / 2, 5000), batchToken);
-                    if (batchToken.isSet) {
+                while (taskToken.isUnset) {
+                    await cancelableTimeout(Math.min(this.visibilityTimeout / 2, 5000), taskToken);
+                    if (taskToken.isSet) {
                         break;
                     }
                     try {
-                        const tasksToTouch = tasks.filter((t) => activeTaskIds.has(t.id));
-                        if (tasksToTouch.length > 0) {
-                            const touchedIds = await this.touchMany(tasksToTouch);
-                            if (touchedIds.length != tasksToTouch.length) {
-                                const lostCount = tasksToTouch.length - touchedIds.length;
-                                context.logger.warn(`Batch integrity compromised: ${lostCount} tasks lost lease. Aborting batch.`);
-                                activeTaskIds = new Set(touchedIds);
-                                batchToken.set();
-                            }
-                            else {
-                                activeTaskIds = new Set(touchedIds);
-                            }
-                        }
-                        if (activeTaskIds.size == 0 && batchToken.isUnset) {
-                            context.logger.warn(`All tasks in batch lost lease. Stopping worker.`);
-                            batchToken.set();
+                        const touchedTask = await this.touch(task);
+                        if (isUndefined(touchedTask)) {
+                            context.logger.warn(`Task lost lease. Aborting.`);
+                            isTaskActive = false;
+                            taskToken.set();
                         }
                     }
                     catch (error) {
-                        context.logger.error('Error touching tasks', error);
+                        context.logger.error('Error touching task', error);
                     }
                 }
             })();
             try {
-                if (batchToken.isSet) {
-                    throw new Error('Tasks cancelled before start');
+                if (taskToken.isSet) {
+                    throw new Error('Task cancelled before start');
                 }
-                const results = await handler(context);
-                if (isDefined(results)) {
-                    const completions = [];
-                    const failures = [];
-                    const reschedules = [];
-                    for (let i = 0; i < tasks.length; i++) {
-                        const task = tasks[i];
-                        const result = results[i];
-                        switch (result.payload.action) {
-                            case 'complete':
-                                completions.push({ task, result: result.payload.result });
-                                break;
-                            case 'fail':
-                                failures.push({ task, error: result.payload.error, fatal: result.payload.fatal });
-                                break;
-                            case 'reschedule':
-                                reschedules.push({ task, timestamp: result.payload.timestamp });
-                                break;
-                            default:
-                                throw new Error(`Unsupported task result action.`);
-                        }
-                    }
-                    if (completions.length > 0) {
-                        context.logger.verbose(`Completing ${completions.length} tasks`);
-                        await this.completeMany(completions.map((c) => c.task), { results: completions.map((c) => c.result) });
-                    }
-                    if (failures.length > 0) {
-                        context.logger.verbose(`Failing ${failures.length} tasks`);
-                        for (const item of failures) {
-                            await this.fail(item.task, item.error, { fatal: item.fatal });
-                        }
-                    }
-                    if (reschedules.length > 0) {
-                        context.logger.verbose(`Rescheduling ${reschedules.length} tasks`);
-                        const reschedulesByTimestamp = new Map();
-                        for (const item of reschedules) {
-                            const ids = reschedulesByTimestamp.get(item.timestamp) ?? [];
-                            ids.push(item.task.id);
-                            reschedulesByTimestamp.set(item.timestamp, ids);
-                        }
-                        for (const [timestamp, ids] of reschedulesByTimestamp) {
-                            await this.rescheduleMany(ids, timestamp);
-                        }
+                const result = await handler(context);
+                if (isDefined(result) && isTaskActive) {
+                    switch (result.payload.action) {
+                        case 'complete':
+                            context.logger.verbose(`Completing task`);
+                            await this.complete(task, { result: result.payload.result });
+                            break;
+                        case 'fail':
+                            context.logger.verbose(`Failing task`);
+                            await this.fail(task, result.payload.error, { fatal: result.payload.fatal });
+                            break;
+                        case 'reschedule':
+                            context.logger.verbose(`Rescheduling task`);
+                            await this.reschedule(task.id, result.payload.timestamp);
+                            break;
+                        default:
+                            throw new Error(`Unsupported task result action.`);
                     }
                 }
             }
             catch (error) {
-                context.logger.error('Error processing tasks', error);
-                await this.failMany(tasks, createArray(tasks.length, () => error));
+                context.logger.error('Error processing task', error);
+                await this.fail(task, error);
             }
             finally {
-                batchToken.set();
+                taskToken.set();
             }
         }
     }

package/task-queue/tests/worker.test.js

@@ -61,27 +61,6 @@ describe('Worker & Base Class Tests', () => {
         expect(updated?.tries).toBe(1);
         expect(updated?.error?.message).toBe('worker error');
     });
-    it('should process batch of tasks', async () => {
-        await queue.enqueueMany([
-            { type: 'batch', data: { v: 1 } },
-            { type: 'batch', data: { v: 2 } },
-            { type: 'batch', data: { v: 3 } },
-        ]);
-        const processedBatch = [];
-        const token = new CancellationToken();
-        queue.processBatch({ batchSize: 2, cancellationSignal: token }, async (context) => {
-            expect(context.tasks.length).toBeLessThanOrEqual(2);
-            context.tasks.forEach(t => processedBatch.push(t.data['v']));
-            return context.tasks.map(() => TaskProcessResult.Complete());
-        });
-        for (let i = 0; i < 20; i++) {
-            if (processedBatch.length === 3)
-                break;
-            await timeout(100);
-        }
-        token.set();
-        expect(processedBatch.sort()).toEqual([1, 2, 3]);
-    });
     it('should extend lease (heartbeat) during long processing', async () => {
         const task = await queue.enqueue('long', {});
         const token = new CancellationToken();

package/task-queue/types.d.ts

@@ -1,4 +1,4 @@
-import type { BatchTaskContext, TaskContext } from './task-context.js';
+import type { TaskContext } from './task-context.js';
 import type { Task, TaskProcessResult } from './task-queue.js';
 export type TaskDefinition<Data = unknown, State = unknown, Result = unknown> = {
     data: Data;
@@ -39,10 +39,3 @@ export interface ProcessWorker<Definitions extends TaskDefinitionMap, Type exten
      */
     (context: TaskContext<Definitions, Type>): TaskProcessResult<Definitions[Type]['result']> | Promise<TaskProcessResult<Definitions[Type]['result']>>;
 }
-export interface ProcessBatchWorker<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
-    /**
-     * A worker function that processes a batch of tasks.
-     * @param context The batch context providing tasks and helpers.
-     */
-    (context: BatchTaskContext<Definitions, Type>): TaskProcessResult<Definitions[Type]['result']>[] | Promise<TaskProcessResult<Definitions[Type]['result']>[]>;
-}