@tstdl/base 0.93.91 → 0.93.93

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

@@ -0,0 +1,7 @@
+import { describe, expectTypeOf, test } from 'vitest';
+describe('TaskContext Type Definitions', () => {
+    test('TaskContext should infer types from definition map', () => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/task-queue/tests/task-union.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+import { describe, expectTypeOf, test } from 'vitest';
+describe('Task Discriminated Union', () => {
+    test('Task should be a discriminated union based on definition map', () => {
+        // Should be a union
+        expectTypeOf().toBeObject();
+        // Discrimination check
+        const task = {};
+        if (task.type == 'test-task') {
+            expectTypeOf(task.data).toEqualTypeOf();
+            expectTypeOf(task.state).toEqualTypeOf();
+            expectTypeOf(task.result).toEqualTypeOf();
+        }
+        else if (task.type == 'other-task') {
+            expectTypeOf(task.data).toEqualTypeOf();
+            expectTypeOf(task.result).toEqualTypeOf();
+        }
+    });
+});

package/task-queue/tests/typing.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import { describe, expectTypeOf, test } from 'vitest';
+describe('TaskQueue Type Definitions', () => {
+    test('TaskDefinition and TaskDefinitionMap should be defined', () => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+    });
+});

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

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
-import { TaskQueueProvider, TaskResult, TaskState } from '../../task-queue/index.js';
+import { TaskProcessResult, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../unit-test/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Worker & Base Class Tests', () => {
@@ -30,8 +30,8 @@ describe('Worker & Base Class Tests', () => {
         const processed = [];
         const token = new CancellationToken();
         queue.process({ cancellationSignal: token }, async (context) => {
-            processed.push(context.data.val);
-            return TaskResult.Complete();
+            processed.push(context.data['val']);
+            return TaskProcessResult.Complete();
         });
         // Wait until 2 tasks are processed
         for (let i = 0; i < 20; i++) {
@@ -45,8 +45,8 @@ describe('Worker & Base Class Tests', () => {
         expect(processed.length).toBe(2);
         const check1 = await queue.getTask(t1.id);
         const check2 = await queue.getTask(t2.id);
-        expect(check1?.status).toBe(TaskState.Completed);
-        expect(check2?.status).toBe(TaskState.Completed);
+        expect(check1?.status).toBe(TaskStatus.Completed);
+        expect(check2?.status).toBe(TaskStatus.Completed);
     });
     it('should handle errors in worker gracefully', async () => {
         const task = await queue.enqueue('fail', {});
@@ -57,7 +57,7 @@ describe('Worker & Base Class Tests', () => {
         await timeout(200);
         token.set();
         const updated = await queue.getTask(task.id);
-        expect(updated?.status).toBe(TaskState.Pending); // Should retry
+        expect(updated?.status).toBe(TaskStatus.Pending); // Should retry
         expect(updated?.tries).toBe(1);
         expect(updated?.error?.message).toBe('worker error');
     });
@@ -71,8 +71,8 @@ describe('Worker & Base Class Tests', () => {
         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(() => TaskResult.Complete());
+            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)
@@ -90,13 +90,13 @@ describe('Worker & Base Class Tests', () => {
             // Simulate long work > visibilityTimeout (500ms)
             await timeout(700);
             executed = true;
-            return TaskResult.Complete();
+            return TaskProcessResult.Complete();
         });
         await timeout(1000);
         token.set();
         expect(executed).toBe(true);
         const updated = await queue.getTask(task.id);
-        expect(updated?.status).toBe(TaskState.Completed);
+        expect(updated?.status).toBe(TaskStatus.Completed);
     });
     it('should handle TaskResult actions (Fail, Reschedule)', async () => {
         const tFail = await queue.enqueue('fail-action', {});
@@ -106,12 +106,12 @@ describe('Worker & Base Class Tests', () => {
         queue.process({ cancellationSignal: token }, async (context) => {
             processed.add(context.id);
             if (context.id === tFail.id) {
-                return TaskResult.Fail(new Error('explicit fail'));
+                return TaskProcessResult.Fail(new Error('explicit fail'));
             }
             if (context.id === tResched.id) {
-                return TaskResult.RescheduleBy(1000);
+                return TaskProcessResult.RescheduleBy(1000);
             }
-            return TaskResult.Complete();
+            return TaskProcessResult.Complete();
         });
         for (let i = 0; i < 20; i++) {
             if (processed.size === 2)
@@ -120,10 +120,10 @@ describe('Worker & Base Class Tests', () => {
         }
         token.set();
         const uFail = await queue.getTask(tFail.id);
-        expect(uFail?.status).toBe(TaskState.Pending); // Retry
+        expect(uFail?.status).toBe(TaskStatus.Pending); // Retry
         expect(uFail?.error?.message).toBe('explicit fail');
         const uResched = await queue.getTask(tResched.id);
-        expect(uResched?.status).toBe(TaskState.Pending);
+        expect(uResched?.status).toBe(TaskStatus.Pending);
         expect(uResched?.scheduleTimestamp).toBeGreaterThan(Date.now());
     });
     it('should exercise TaskContext methods', async () => {
@@ -150,7 +150,7 @@ describe('Worker & Base Class Tests', () => {
             const otherChildren = await context.spawnMany(otherQueue, [{ type: 'other', data: { x: 2 } }]);
             expect(otherChildren[0]?.parentId).toBe(task.id);
             executed = true;
-            return TaskResult.Complete();
+            return TaskProcessResult.Complete();
         });
         for (let i = 0; i < 20; i++) {
             if (executed)

package/task-queue/types.d.ts

@@ -0,0 +1,48 @@
+import type { BatchTaskContext, TaskContext } from './task-context.js';
+import type { Task, TaskProcessResult } from './task-queue.js';
+export type TaskDefinition<Data = unknown, State = unknown, Result = unknown> = {
+    data: Data;
+    state: State;
+    result: Result;
+};
+export type TaskDefinitionMap<Definition extends Record<string, TaskDefinition> = Record<string, TaskDefinition>> = Definition;
+export type TaskTypes<Definitions extends TaskDefinitionMap> = Extract<keyof Definitions, string>;
+export type TaskOfType<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> = string extends TaskTypes<Definitions> ? Task<Definitions> & {
+    type: Type;
+} : Extract<Task<Definitions>, {
+    type: Type;
+}>;
+export type TaskData<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> = Definitions[Type]['data'];
+export type TaskState<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> = Definitions[Type]['state'];
+export type TaskResult<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> = Definitions[Type]['result'];
+export type TasksResults<Tasks extends Task<any>[]> = {
+    [I in keyof Tasks]: Tasks[I] extends Task<infer Definitions> ? TaskResult<Definitions, Tasks[I]['type']> : never;
+};
+export type TasksStates<Tasks extends Task<any>[]> = {
+    [I in keyof Tasks]: Tasks[I] extends Task<infer Definitions> ? TaskState<Definitions, Tasks[I]['type']> : never;
+};
+export type TaskProcessResultPayload<Result> = {
+    action: 'complete';
+    result: Result | undefined;
+} | {
+    action: 'fail';
+    error: unknown;
+    fatal: boolean;
+} | {
+    action: 'reschedule';
+    timestamp: number;
+};
+export interface ProcessWorker<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
+    /**
+     * A worker function that processes a single task.
+     * @param context The task context providing data, logger, and orchestration helpers.
+     */
+    (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']>[]>;
+}

package/task-queue/types.js

@@ -0,0 +1 @@
+export {};