@tstdl/base 0.93.140 → 0.93.141

package/task-queue/postgres/module.js

@@ -1,12 +1,13 @@
 import { inject } from '../../injector/index.js';
 import { Injector } from '../../injector/injector.js';
-import { Database, migrate } from '../../orm/server/index.js';
+import { Database, migrate, registerDatabaseMigration } from '../../orm/server/index.js';
 import { TaskQueueProvider } from '../provider.js';
 import { TaskQueue } from '../task-queue.js';
 import { PostgresTaskQueue } from './task-queue.js';
 import { PostgresTaskQueueProvider } from './task-queue.provider.js';
 export class PostgresTaskQueueModuleConfig {
     database;
+    autoMigrate;
 }
 /**
  * configure queue module
@@ -16,6 +17,9 @@ export function configurePostgresTaskQueue({ injector, ...config } = {}) {
     targetInjector.register(PostgresTaskQueueModuleConfig, { useValue: config });
     targetInjector.registerSingleton(TaskQueueProvider, { useToken: PostgresTaskQueueProvider });
     targetInjector.registerSingleton(TaskQueue, { useToken: PostgresTaskQueue });
+    if (config.autoMigrate != false) {
+        registerDatabaseMigration('PostgresTaskQueue', migratePostgresTaskQueueSchema, { injector });
+    }
 }
 export async function migratePostgresTaskQueueSchema() {
     const connection = inject(PostgresTaskQueueModuleConfig, undefined, { optional: true })?.database?.connection;

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

@@ -1,16 +1,19 @@
-import { PostgresTask, PostgresTaskArchive } from './task.model.js';
+import { PostgresTask, PostgresTaskArchive, PostgresTaskDependency } from './task.model.js';
 export declare const taskQueueSchema: import("../../orm/server/index.js").DatabaseSchema<"task_queue">;
+export declare const taskDependencyType: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Schedule: "schedule";
+    readonly Complete: "complete";
+}>;
 export declare const taskStatus: import("../../orm/enums.js").PgEnumFromEnumeration<{
     readonly Pending: "pending";
     readonly Running: "running";
     readonly Completed: "completed";
     readonly Cancelled: "cancelled";
-    readonly Waiting: "waiting";
     readonly Dead: "dead";
-}>;
-export declare const dependencyJoinMode: import("../../orm/enums.js").PgEnumFromEnumeration<{
-    readonly And: "and";
-    readonly Or: "or";
+    readonly Waiting: "waiting";
+    readonly WaitingChildren: "waiting-children";
+    readonly Paused: "paused";
 }>;
 export declare const task: import("../../orm/server/types.js").PgTableFromType<typeof PostgresTask, "task_queue">;
 export declare const taskArchive: import("../../orm/server/types.js").PgTableFromType<typeof PostgresTaskArchive, "task_queue">;
+export declare const taskDependency: import("../../orm/server/types.js").PgTableFromType<typeof PostgresTaskDependency, "task_queue">;

package/task-queue/postgres/schemas.js

@@ -1,8 +1,9 @@
 import { databaseSchema } from '../../orm/server/index.js';
-import { DependencyJoinMode, TaskStatus } from '../task-queue.js';
-import { PostgresTask, PostgresTaskArchive } from './task.model.js';
+import { TaskDependencyType, TaskStatus } from '../task-queue.js';
+import { PostgresTask, PostgresTaskArchive, PostgresTaskDependency } from './task.model.js';
 export const taskQueueSchema = databaseSchema('task_queue');
+export const taskDependencyType = taskQueueSchema.getEnum(TaskDependencyType);
 export const taskStatus = taskQueueSchema.getEnum(TaskStatus);
-export const dependencyJoinMode = taskQueueSchema.getEnum(DependencyJoinMode);
 export const task = taskQueueSchema.getTable(PostgresTask);
 export const taskArchive = taskQueueSchema.getTable(PostgresTaskArchive);
+export const taskDependency = taskQueueSchema.getTable(PostgresTaskDependency);

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

@@ -103,13 +103,12 @@ export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = T
         fatal?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
-    triggerTagFanIn(tags: string[], options?: {
-        transaction?: Transaction;
-    }): Promise<void>;
     failMany(tasks: Task<Definitions>[], errors: unknown[], options?: {
         transaction?: Transaction;
     }): Promise<void>;
     private resolveDependencies;
+    private evaluateTaskStatus;
+    private transitionTask;
     maintenance(options?: {
         transaction?: Transaction;
     }): Promise<void>;
@@ -123,15 +122,6 @@ export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = T
         types?: Type[];
     }): AsyncIterableIterator<TaskOfType<Definitions, Type>>;
     private maintenanceLoop;
-    /**
-     * @internal for internal unit test use only
-     * @param options
-     * @returns
-     */
-    processPendingFanIn(options?: {
-        transaction?: Transaction;
-    }): Promise<number>;
-    private startSystemWorker;
     getBatchConsumer<Type extends TaskTypes<Definitions>>(size: number, cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
         types?: Type[];