@tstdl/base 0.93.86 → 0.93.89

package/test1.js

@@ -9,7 +9,7 @@ import { configurePostgresKeyValueStore, migratePostgresKeyValueStoreSchema } fr
 import { configurePostgresLock, migratePostgresLockSchema } from './lock/postgres/index.js';
 import { PrettyPrintLogFormatter, provideConsoleLogTransport } from './logger/index.js';
 import { configureOrm, injectRepository } from './orm/server/index.js';
-import { configurePostgresQueue, migratePostgresQueueSchema } from './queue/postgres/index.js';
+import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from './task-queue/postgres/index.js';
 import { migrateTestSchema } from './test/module.js';
 import { Test, testData } from './test/test.model.js';
 import { timedBenchmarkAsync } from './utils/benchmark.js';

package/test4.js

@@ -17,7 +17,7 @@ import { injectAsync } from './injector/inject.js';
 import { configureLocalMessageBus } from './message-bus/index.js';
 import { configureS3ObjectStorage } from './object-storage/index.js';
 import { configureOrm } from './orm/server/index.js';
-import { configurePostgresQueue } from './queue/postgres/module.js';
+import { configurePostgresTaskQueue } from './task-queue/postgres/module.js';
 import { boolean, positiveInteger, string } from './utils/config-parser.js';
 import { cancelableTimeout } from './utils/timing.js';
 const config = {
@@ -100,7 +100,7 @@ async function bootstrap() {
         fileUploadObjectStorageModule: 'document-uploads',
         filePreviewObjectStorageModule: 'document-previews',
     });
-    configurePostgresQueue();
+    configurePostgresTaskQueue();
     configureLocalMessageBus();
     console.log('Configuring AI service');
     configureAiService({

package/unit-test/index.d.ts

@@ -0,0 +1 @@
+export * from './integration-setup.js';

package/unit-test/index.js

@@ -0,0 +1 @@
+export * from './integration-setup.js';

package/unit-test/integration-setup.d.ts

@@ -0,0 +1,55 @@
+import type { PoolConfig } from 'pg';
+import { type AuthenticationAncillaryService } from '../authentication/server/index.js';
+import { Injector } from '../injector/index.js';
+import { LogLevel } from '../logger/index.js';
+import { Database } from '../orm/server/index.js';
+import type { Type } from '../types/index.js';
+export type IntegrationTestOptions = {
+    dbConfig?: Partial<PoolConfig>;
+    orm?: {
+        schema?: string;
+    };
+    api?: {
+        baseUrl?: string;
+        port?: number;
+    };
+    logLevels?: Record<string, LogLevel>;
+    modules?: {
+        taskQueue?: boolean;
+        messageBus?: boolean;
+        circuitBreaker?: boolean;
+        rateLimiter?: boolean;
+        authentication?: boolean;
+        keyValueStore?: boolean;
+        audit?: boolean;
+        lock?: boolean;
+        signals?: boolean;
+        api?: boolean;
+        test?: boolean;
+        webServer?: boolean;
+    };
+    authenticationAncillaryService?: Type<AuthenticationAncillaryService>;
+};
+export type TestContext = {
+    injector: Injector;
+    database: Database;
+};
+/**
+ * Standard setup for integration tests.
+ */
+export declare function setupIntegrationTest(options?: IntegrationTestOptions): Promise<TestContext>;
+/**
+ * Helper to truncate specific tables in a schema.
+ * Useful in beforeEach() to reset state.
+ */
+export declare function truncateTables(database: Database, schema: string, tables: string[]): Promise<void>;
+/**
+ * Helper to delete data for a specific tenant from specific tables.
+ * Useful for parallel tests to avoid interference.
+ */
+export declare function clearTenantData(database: Database, schema: string, tables: string[], tenantId: string): Promise<void>;
+/**
+ * Helper to drop specific tables.
+ * Useful in beforeAll() cleanups.
+ */
+export declare function dropTables(database: Database, schema: string, tables: string[]): Promise<void>;

package/unit-test/integration-setup.js

@@ -0,0 +1,182 @@
+import { sql } from 'drizzle-orm';
+import { configureApiServer } from '../api/server/index.js';
+import { configureAudit, migrateAuditSchema } from '../audit/index.js';
+import { AuthenticationApiClient } from '../authentication/client/api.client.js';
+import { configureAuthenticationClient } from '../authentication/client/index.js';
+import { AuthenticationApiController, configureAuthenticationServer, migrateAuthenticationSchema } from '../authentication/server/index.js';
+import { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from '../circuit-breaker/postgres/module.js';
+import { configureUndiciHttpClientAdapter } from '../http/client/adapters/undici.adapter.js';
+import { configureHttpClient } from '../http/client/index.js';
+import { HttpServer } from '../http/server/index.js';
+import { configureNodeHttpServer } from '../http/server/node/module.js';
+import { Injector, runInInjectionContext } from '../injector/index.js';
+import { configurePostgresKeyValueStore, migratePostgresKeyValueStoreSchema } from '../key-value-store/postgres/module.js';
+import { configurePostgresLock, migratePostgresLockSchema } from '../lock/postgres/module.js';
+import { ConsoleLogTransport, DEFAULT_LOG_LEVEL, LogFormatter, LogLevel, LogManager, LogTransport, PrettyPrintLogFormatter } from '../logger/index.js';
+import { configureLocalMessageBus } from '../message-bus/index.js';
+import { configureWebServerModule, WebServerModule } from '../module/modules/web-server.module.js';
+import { configureOrm, Database } from '../orm/server/index.js';
+import { configurePostgresRateLimiter, migratePostgresRateLimiterSchema } from '../rate-limit/postgres/module.js';
+import { configureDefaultSignalsImplementation } from '../signals/implementation/configure.js';
+import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from '../task-queue/postgres/index.js';
+import * as configParser from '../utils/config-parser.js';
+import { objectEntries } from '../utils/object/object.js';
+import { isDefined } from '../utils/type-guards.js';
+/**
+ * Standard setup for integration tests.
+ */
+export async function setupIntegrationTest(options = {}) {
+    const injector = new Injector('TestInjector');
+    // 1. Logger Setup
+    injector.register(LogFormatter, { useToken: PrettyPrintLogFormatter });
+    injector.register(LogTransport, { useToken: ConsoleLogTransport });
+    injector.register(DEFAULT_LOG_LEVEL, { useValue: LogLevel.Warn });
+    const logManager = injector.resolve(LogManager);
+    logManager.setModuleLevel('Audit', LogLevel.Error);
+    if (isDefined(options.logLevels)) {
+        for (const [module, level] of objectEntries(options.logLevels)) {
+            logManager.setModuleLevel(module, level);
+        }
+    }
+    // 2. Database Config
+    const dbConfig = {
+        host: configParser.string('DATABASE_HOST', '127.0.0.1'),
+        port: configParser.positiveInteger('DATABASE_PORT', 5432),
+        user: configParser.string('DATABASE_USER', 'tstdl'),
+        password: configParser.string('DATABASE_PASS', 'wf7rq6glrk5jykne'),
+        database: configParser.string('DATABASE_NAME', 'tstdl'),
+        ...options.dbConfig,
+    };
+    // 4. Configure ORM
+    configureOrm({
+        repositoryConfig: { schema: options.orm?.schema ?? 'test' },
+        connection: dbConfig,
+        injector,
+    });
+    // 5. Database Resolution
+    // We resolve the DB here to allow for immediate schema operations below
+    const database = injector.resolve(Database);
+    await runMigrationSafely(database, async () => {
+        // 6. Schema Setup Helper
+        // Automatically create the schema if a specific one was requested
+        if (isDefined(options.orm?.schema)) {
+            await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(options.orm.schema)}`);
+        }
+        // 7. Optional Modules
+        if (options.modules?.messageBus ?? options.modules?.taskQueue ?? options.modules?.authentication ?? options.modules?.test) {
+            configureLocalMessageBus({ injector });
+        }
+        if (options.modules?.taskQueue) {
+            configurePostgresTaskQueue({ injector });
+            await runInInjectionContext(injector, migratePostgresTaskQueueSchema);
+        }
+        if (options.modules?.circuitBreaker ?? options.modules?.taskQueue) {
+            configurePostgresCircuitBreaker({ injector });
+            await runInInjectionContext(injector, migratePostgresCircuitBreaker);
+        }
+        if (options.modules?.rateLimiter ?? options.modules?.taskQueue) {
+            configurePostgresRateLimiter({ injector });
+            await runInInjectionContext(injector, migratePostgresRateLimiterSchema);
+        }
+        if (options.modules?.keyValueStore ?? options.modules?.authentication) {
+            configurePostgresKeyValueStore({ injector });
+            await runInInjectionContext(injector, migratePostgresKeyValueStoreSchema);
+        }
+        if (options.modules?.lock ?? options.modules?.authentication) {
+            configurePostgresLock({ injector });
+            await runInInjectionContext(injector, migratePostgresLockSchema);
+        }
+        if (options.modules?.signals ?? options.modules?.authentication ?? options.modules?.test) {
+            configureDefaultSignalsImplementation();
+        }
+        if (options.modules?.audit ?? options.modules?.authentication) {
+            configureAudit({ injector });
+            await runInInjectionContext(injector, migrateAuditSchema);
+        }
+        if (options.modules?.authentication) {
+            configureAuthenticationServer({
+                serviceOptions: { secret: 'test-secret' },
+                authenticationAncillaryService: options.authenticationAncillaryService,
+                injector,
+            });
+            await runInInjectionContext(injector, migrateAuthenticationSchema);
+        }
+        if (options.modules?.api ?? options.modules?.authentication) {
+            configureNodeHttpServer({ trustedProxiesCount: 0, injector });
+            configureApiServer({ controllers: [AuthenticationApiController], injector });
+            configureUndiciHttpClientAdapter({ injector });
+            configureAuthenticationClient({
+                authenticationApiClient: AuthenticationApiClient,
+                registerMiddleware: true,
+            }, injector);
+            if (options.modules?.webServer ?? options.modules?.api ?? options.modules?.authentication) {
+                const port = options.api?.port ?? 0;
+                configureWebServerModule({ port, injector });
+                const webServerModule = await injector.resolveAsync(WebServerModule);
+                const httpServer = await injector.resolveAsync(HttpServer);
+                void webServerModule.run();
+                // Wait for server to be listening
+                while (true) {
+                    try {
+                        if (isDefined(httpServer.port)) {
+                            break;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+                }
+                configureHttpClient({ baseUrl: options.api?.baseUrl ?? `http://localhost:${httpServer.port}`, injector });
+            }
+        }
+    });
+    return { injector, database };
+}
+/**
+ * Helper to run a migration safely with a database advisory lock to prevent race conditions.
+ */
+async function runMigrationSafely(database, migration) {
+    const lockId = 123456789; // Fixed lock ID for migrations
+    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
+    try {
+        await migration();
+    }
+    finally {
+        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
+    }
+}
+/**
+ * Helper to truncate specific tables in a schema.
+ * Useful in beforeEach() to reset state.
+ */
+export async function truncateTables(database, schema, tables) {
+    if (tables.length == 0) {
+        return;
+    }
+    // Using CASCADE to handle foreign keys automatically
+    for (const table of tables) {
+        await database.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier(table)} CASCADE`);
+    }
+}
+/**
+ * Helper to delete data for a specific tenant from specific tables.
+ * Useful for parallel tests to avoid interference.
+ */
+export async function clearTenantData(database, schema, tables, tenantId) {
+    if (tables.length == 0) {
+        return;
+    }
+    for (const table of tables) {
+        await database.execute(sql `DELETE FROM ${sql.identifier(schema)}.${sql.identifier(table)} WHERE tenant_id = ${tenantId}`);
+    }
+}
+/**
+ * Helper to drop specific tables.
+ * Useful in beforeAll() cleanups.
+ */
+export async function dropTables(database, schema, tables) {
+    for (const table of tables) {
+        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier(table)} CASCADE`);
+    }
+}

package/utils/patterns.d.ts

@@ -2,4 +2,7 @@
 export declare const numberPattern: RegExp;
 /** Pattern matching valid email addresses */
 export declare const mailPattern: RegExp;
+/** Pattern matching valid UUIDs */
+export declare const uuidPattern: RegExp;
 export declare function isEmail(value: string): boolean;
+export declare function isUuid(value: string): boolean;

package/utils/patterns.js

@@ -1,8 +1,13 @@
 /** Pattern matching valid JavaScript number literals including binary, octal and hexadecimal format but *not* Infinity and NaN */
 export const numberPattern = /^[+-]?(?:\d*\.?\d+|\d+\.?\d*|0[bB][01]+|0[xX][\da-fA-F]+|0[oO][0-7]+)$/u;
 /** Pattern matching valid email addresses */
-// eslint-disable-next-line no-control-regex, prefer-named-capture-group
+// eslint-disable-next-line prefer-named-capture-group
 export const mailPattern = /^(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/u;
+/** Pattern matching valid UUIDs */
+export const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
 export function isEmail(value) {
     return mailPattern.test(value);
 }
+export function isUuid(value) {
+    return uuidPattern.test(value);
+}

package/audit/drizzle/0001_previous_network.sql

@@ -1,2 +0,0 @@
-ALTER TABLE "audit"."event" ALTER COLUMN "actor" DROP NOT NULL;--> statement-breakpoint
-ALTER TABLE "audit"."event" ALTER COLUMN "network_path" DROP NOT NULL;

package/audit/drizzle/meta/0001_snapshot.json

@@ -1,195 +0,0 @@
-{
-  "id": "12d8d2c6-0f8e-4958-a036-cd42c36f2b1f",
-  "prevId": "8f6c87f8-1692-49bd-9bd4-09dc9d0bdcd4",
-  "version": "7",
-  "dialect": "postgresql",
-  "tables": {
-    "audit.event": {
-      "name": "event",
-      "schema": "audit",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "uuid",
-          "primaryKey": true,
-          "notNull": true,
-          "default": "gen_random_uuid()"
-        },
-        "timestamp": {
-          "name": "timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "tenant_id": {
-          "name": "tenant_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "correlation_id": {
-          "name": "correlation_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "module": {
-          "name": "module",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "action": {
-          "name": "action",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "outcome": {
-          "name": "outcome",
-          "type": "audit_outcome",
-          "typeSchema": "audit",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "severity": {
-          "name": "severity",
-          "type": "audit_severity",
-          "typeSchema": "audit",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "actor_type": {
-          "name": "actor_type",
-          "type": "actor_type",
-          "typeSchema": "audit",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "actor": {
-          "name": "actor",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "impersonator_type": {
-          "name": "impersonator_type",
-          "type": "actor_type",
-          "typeSchema": "audit",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "impersonator": {
-          "name": "impersonator",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "target_type": {
-          "name": "target_type",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "target_id": {
-          "name": "target_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "network_path": {
-          "name": "network_path",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "network_ip_address": {
-          "name": "network_ip_address",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "network_user_agent": {
-          "name": "network_user_agent",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "network_session_id": {
-          "name": "network_session_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "changes_before": {
-          "name": "changes_before",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "changes_after": {
-          "name": "changes_after",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "details": {
-          "name": "details",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    }
-  },
-  "enums": {
-    "audit.actor_type": {
-      "name": "actor_type",
-      "schema": "audit",
-      "values": [
-        "anonymous",
-        "system",
-        "api-key",
-        "user"
-      ]
-    },
-    "audit.audit_outcome": {
-      "name": "audit_outcome",
-      "schema": "audit",
-      "values": [
-        "pending",
-        "success",
-        "cancelled",
-        "failure",
-        "denied"
-      ]
-    },
-    "audit.audit_severity": {
-      "name": "audit_severity",
-      "schema": "audit",
-      "values": [
-        "info",
-        "warn",
-        "error",
-        "critical"
-      ]
-    }
-  },
-  "schemas": {},
-  "sequences": {},
-  "roles": {},
-  "policies": {},
-  "views": {},
-  "_meta": {
-    "columns": {},
-    "schemas": {},
-    "tables": {}
-  }
-}

package/queue/enqueue-batch.d.ts

@@ -1,17 +0,0 @@
-import type { EnqueueManyItem, EnqueueOptions, Task, Queue } from './queue.js';
-export interface QueueEnqueueBatchMethods<Data, State, Result> {
-    add(...args: Parameters<Queue<Data, State, Result>['enqueue']>): void;
-    enqueue(): ReturnType<Queue<Data, State, Result>['enqueueMany']>;
-}
-export declare class QueueEnqueueBatch<Data, State, Result> implements QueueEnqueueBatchMethods<Data, State, Result> {
-    private readonly queue;
-    /** added items */
-    items: EnqueueManyItem<Data>[];
-    constructor(queue: Queue<Data, State, Result>);
-    /** add data to items */
-    add(data: Data, options?: EnqueueOptions): void;
-    /** enqueues all added items */
-    enqueue(returnTasks?: false): Promise<void>;
-    enqueue(returnTasks: true): Promise<Task<Data, State, Result>[]>;
-    enqueue(returnTasks?: boolean): Promise<Task<Data, State, Result>[] | undefined>;
-}

package/queue/enqueue-batch.js

@@ -1,18 +0,0 @@
-export class QueueEnqueueBatch {
-    queue;
-    /** added items */
-    items;
-    constructor(queue) {
-        this.queue = queue;
-        this.items = [];
-    }
-    /** add data to items */
-    add(data, options) {
-        this.items.push({ data, ...options });
-    }
-    async enqueue(returnTasks) {
-        const items = this.items;
-        this.items = [];
-        return await this.queue.enqueueMany(items, { returnTasks });
-    }
-}

package/queue/postgres/drizzle/0000_zippy_moondragon.sql

@@ -1,11 +0,0 @@
-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/0001_certain_wild_pack.sql

@@ -1,2 +0,0 @@
-ALTER TABLE "queue"."job" DROP CONSTRAINT "job_queue_tag_unique";--> statement-breakpoint
-CREATE INDEX "job_queue_tag_idx" ON "queue"."job" USING btree ("queue","tag");

package/queue/postgres/drizzle/0002_dear_meggan.sql

@@ -1,2 +0,0 @@
-DROP INDEX "queue"."job_queue_tag_idx";--> statement-breakpoint
-ALTER TABLE "queue"."job" ADD CONSTRAINT "job_queue_tag_unique" UNIQUE("queue","tag");

package/queue/postgres/drizzle/0003_tricky_venom.sql

@@ -1,30 +0,0 @@
-CREATE TYPE "queue"."task_state" AS ENUM('pending', 'running', 'completed', 'cancelled', 'waiting', 'dead');--> statement-breakpoint
-CREATE TABLE "queue"."task" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"queue" text NOT NULL,
-	"status" "queue"."task_state" NOT NULL,
-	"tag" text,
-	"priority" integer NOT NULL,
-	"parent_id" uuid,
-	"lease" uuid,
-	"enqueue_timestamp" timestamp with time zone NOT NULL,
-	"schedule_timestamp" timestamp with time zone NOT NULL,
-	"start_timestamp" timestamp with time zone,
-	"expiration_timestamp" timestamp with time zone,
-	"lock_expiration_timestamp" timestamp with time zone,
-	"complete_timestamp" timestamp with time zone,
-	"tries" integer NOT NULL,
-	"progress" double precision NOT NULL,
-	"data" jsonb,
-	"state" jsonb,
-	"result" jsonb,
-	"error" jsonb,
-	CONSTRAINT "task_queue_tag_unique" UNIQUE("queue","tag")
-);
---> statement-breakpoint
-DROP TABLE "queue"."job" CASCADE;--> statement-breakpoint
-ALTER TABLE "queue"."task" ADD CONSTRAINT "task_parent_id_task_id_fk" FOREIGN KEY ("parent_id") REFERENCES "queue"."task"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-CREATE INDEX "task_parent_id_status_idx" ON "queue"."task" USING btree ("parent_id","status");--> statement-breakpoint
-CREATE INDEX "task_queue_complete_timestamp_idx" ON "queue"."task" USING btree ("queue","complete_timestamp");--> statement-breakpoint
-CREATE INDEX "task_queue_status_lock_expiration_timestamp_idx" ON "queue"."task" USING btree ("queue","status","lock_expiration_timestamp");--> statement-breakpoint
-CREATE INDEX "task_queue_status_priority_schedule_timestamp_idx" ON "queue"."task" USING btree ("queue","status","priority","schedule_timestamp");