@tstdl/base 0.93.77 → 0.93.80

package/document-management/server/drizzle/meta/_journal.json

@@ -5,15 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1750253838549,
-      "tag": "0000_ordinary_pretty_boy",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "7",
-      "when": 1764857079867,
-      "tag": "0001_lyrical_wong",
+      "when": 1767826943882,
+      "tag": "0000_glamorous_lorna_dane",
       "breakpoints": true
     }
   ]

package/document-management/server/services/document-collection.service.js

@@ -26,13 +26,13 @@ let DocumentCollectionService = class DocumentCollectionService extends Transact
         }
         const loadIds = collectionsOrIds.filter((collection) => isString(collection));
         if (loadIds.length == 0) {
-            return this.#ancillaryService.resolveMetadata(collectionsOrIds);
+            return this.#ancillaryService.resolveMetadata(tenantId, collectionsOrIds);
         }
         const loadedCollections = await this.repository.loadManyByQuery({ tenantId, id: { $in: loadIds } });
         const collections = collectionsOrIds.map((collectionOrId) => isString(collectionOrId)
             ? assertDefinedPass(loadedCollections.find((collection) => collection.id == collectionOrId), `Could not load collection "${collectionOrId}".`)
             : collectionOrId);
-        return this.#ancillaryService.resolveMetadata(collections);
+        return this.#ancillaryService.resolveMetadata(tenantId, collections);
     }
     async resolveMetadataMap(tenantId, collectionsOrIds) {
         const names = await this.resolveMetadata(tenantId, collectionsOrIds);
@@ -63,7 +63,7 @@ let DocumentCollectionService = class DocumentCollectionService extends Transact
     }
     async assignDocument(document, collectionIds) {
         const values = toArray(collectionIds).map((collectionId) => ({ tenantId: document.tenantId, collectionId, documentId: document.id, archiveTimestamp: null }));
-        await this.#documentCollectionAssignmentRepository.withSession(this.session).upsertMany(['collectionId', 'documentId'], values);
+        await this.#documentCollectionAssignmentRepository.withSession(this.session).upsertMany(['tenantId', 'collectionId', 'documentId'], values);
     }
     async archiveDocument(document, collectionIds) {
         await this.#documentCollectionAssignmentRepository.withSession(this.session).updateManyByQuery({ tenantId: document.tenantId, collectionId: { $in: toArray(collectionIds) }, documentId: document.id, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });

package/document-management/server/services/document-management-ancillary.service.d.ts

@@ -6,5 +6,5 @@ export declare abstract class DocumentManagementAncillaryService {
      * @param collections An array of DocumentCollection entities.
      * @returns A promise that resolves to an array of DocumentCollectionMetadata, corresponding to the input collections.
      */
-    abstract resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
+    abstract resolveMetadata(tenantId: string, collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
 }

package/document-management/server/services/document-management.service.js

@@ -56,7 +56,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
      */
     async getRelevantDocumentCollectionIds(tenantId, documentId) {
         const directAssignments = this.#documentCollectionService.session.$with('directAssignments').as((qb) => qb
-            .select({ collectionId: documentCollectionAssignment.id })
+            .select({ collectionId: documentCollectionAssignment.collectionId })
             .from(documentCollectionAssignment)
             .where(and(eq(documentCollectionAssignment.tenantId, tenantId), eq(documentCollectionAssignment.documentId, documentId))));
         const requestAssignments = this.#documentRequestCollectionAssignmentRepository.session.$with('requestAssignments').as((qb) => qb

package/document-management/server/services/document-workflow.service.js

@@ -45,7 +45,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
         if (this.isInTransaction) {
             return;
         }
-        this.#queue.process({ concurrency: 5, cancellationSignal }, async (job) => await this.processWorkflowJob(job), this.#logger);
+        this.#queue.process({ concurrency: 5, cancellationSignal }, async (taskContext) => await this.processWorkflowJob(taskContext), this.#logger);
     }
     async loadLatestWorkflow(tenantId, documentId) {
         return await this.repository.loadByQuery({ tenantId, documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
@@ -90,8 +90,8 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
         await this.repository.update(id, { state, completeTimestamp: (state == DocumentWorkflowState.Completed) ? currentTimestamp() : undefined, failReason });
         this.#observationService.workflowChange(id, this.session);
     }
-    async processWorkflowJob(job) {
-        const workflow = await this.repository.load(job.data.workflowId);
+    async processWorkflowJob(task) {
+        const workflow = await this.repository.load(task.data.workflowId);
         this.#logger.verbose(`Processing workflow "${workflow.step}" for document "${workflow.documentId}"`);
         try {
             await this.setWorkflowState(workflow.id, DocumentWorkflowState.Running);
@@ -109,10 +109,10 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
             else {
                 await this.setWorkflowState(workflow.id, DocumentWorkflowState.Review);
             }
+            await task.acknowledge();
         }
         catch (error) {
-            const isLastTry = job.tries >= this.#queue.maxTries;
-            if (isLastTry) {
+            if (task.triesLeft == 0) {
                 await this.repository.update(workflow.id, { state: DocumentWorkflowState.Error });
                 this.#observationService.documentChange(workflow.id, this.session);
             }

package/document-management/server/services/document.service.d.ts

@@ -8,8 +8,6 @@ export declare class DocumentService extends Transactional {
     create(tenantId: string, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }: TypedOmit<CreateDocumentParameters, 'uploadId'>, contentSource: Uint8Array<ArrayBuffer> | ReadableStream<Uint8Array<ArrayBuffer>> | {
         uploadId: string;
         uploadKey: string;
-    }, { createUserId }: {
-        createUserId?: string;
     }): Promise<Document>;
     update(tenantId: string, id: string, update: Partial<Pick<Document, UpdatableDocumentProperties>> & {
         tags?: string[];

package/document-management/server/services/document.service.js

@@ -38,7 +38,7 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     #observationService = inject(DocumentManagementObservationService);
     #logger = inject(Logger, DocumentService_1.name);
     repository = injectRepository(Document);
-    async create(tenantId, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }, contentSource, { createUserId }) {
+    async create(tenantId, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }, contentSource) {
         const document = await this.transaction(async (tx) => {
             const isUpload = isNotUint8Array(contentSource) && isNotReadableStream(contentSource);
             const document = await this.repository.withTransaction(tx).insert({
@@ -51,7 +51,6 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
                 summary: summary ?? null,
                 approval: approval ?? DocumentApproval.Pending,
                 comment: comment ?? null,
-                createUserId: createUserId ?? null,
                 originalFileName: originalFileName ?? null,
                 mimeType: 'pending',
                 hash: 'pending',

package/document-management/service-models/enriched/enriched-document.view.d.ts

@@ -6,7 +6,7 @@ import { EnrichedDocumentAssignment } from './enriched-document-assignment.view.
 import type { EnrichedDocumentCategory } from './enriched-document-category.view.js';
 import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
 import type { EnrichedDocumentType } from './enriched-document-type.view.js';
-export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'assignment' | 'tagIds' | 'createUserId'> {
+export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'assignment' | 'tagIds'> {
     #private;
     readonly id: string;
     readonly tenantId: string;

package/examples/document-management/main.d.ts

@@ -2,7 +2,7 @@ import '../../polyfills.js';
 import { DocumentManagementAuthorizationService, type DocumentCollection, type DocumentCollectionMetadata } from '../../document-management/index.js';
 import { DocumentManagementAncillaryService } from '../../document-management/server/index.js';
 export declare class ExampleDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
-    resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[];
+    resolveMetadata(_tenantId: string, collections: DocumentCollection[]): DocumentCollectionMetadata[];
 }
 export declare class AllowAllDocumentManagementAuthorizationService extends DocumentManagementAuthorizationService {
     getTenantId(): string;

package/examples/document-management/main.js

@@ -54,7 +54,7 @@ const config = {
     },
 };
 let ExampleDocumentManagementAncillaryService = class ExampleDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
-    resolveMetadata(collections) {
+    resolveMetadata(_tenantId, collections) {
         return collections.map((collection) => ({ name: collection.metadata.attributes['name'] ?? collection.id.split('-')[0], group: null }));
     }
 };

package/logger/transports/console.d.ts

@@ -1,6 +1,6 @@
 import { type InjectionToken, type Resolvable, type resolveArgumentType } from '../../injector/index.js';
 import type { ProvidersItem } from '../../injector/injector.js';
-import type { LogFormatter, LogPayload } from '../formatter.js';
+import { LogFormatter, type LogPayload } from '../formatter.js';
 import { LogLevel } from '../level.js';
 import { LogTransport, LogTransportOptions } from '../transport.js';
 export declare class ConsoleLogTransportOptions extends LogTransportOptions {

package/logger/transports/console.js

@@ -6,6 +6,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/index.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { LogFormatter } from '../formatter.js';
 import { LogLevel } from '../level.js';
 import { LogTransport, LogTransportOptions, provideLogTransport } from '../transport.js';
 export class ConsoleLogTransportOptions extends LogTransportOptions {
@@ -20,7 +22,8 @@ const consoleLevelFuncMap = {
     [LogLevel.Trace]: 'debug',
 };
 let ConsoleLogTransport = class ConsoleLogTransport extends LogTransport {
-    #formatter = inject(injectArgument(this).formatter);
+    #argument = injectArgument(this, { optional: true });
+    #formatter = isDefined(this.#argument?.formatter) ? inject(this.#argument.formatter) : inject(LogFormatter);
     log(payload) {
         const message = this.#formatter.format(payload);
         const consoleFunc = consoleLevelFuncMap[payload.level];

package/message-bus/message-bus-base.js

@@ -28,7 +28,7 @@ export class MessageBusBase extends MessageBus {
     }
     async [Symbol.asyncDispose]() {
         if (this.disposeToken.isSet) {
-            throw new Error('MessageBus is disposed.');
+            return;
         }
         this.disposeToken.set();
         this.publishSubject.complete();

package/orm/server/drizzle/schema-converter.js

@@ -33,19 +33,10 @@ export function getColumnDefinitionsMap(table) {
     return table[columnDefinitionsMapSymbol];
 }
 export function _getDrizzleTableFromType(type, fallbackSchemaName) {
-    const metadata = reflectionRegistry.getMetadata(type);
-    assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
-    const tableReflectionDatas = [];
-    for (let currentMetadata = metadata; isNotNullOrUndefined(currentMetadata?.parent); currentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent)) {
-        const tableReflectionData = currentMetadata.data.tryGet('orm');
-        if (isDefined(tableReflectionData)) {
-            tableReflectionDatas.push(tableReflectionData);
-        }
-    }
+    const tableReflectionDatas = getTableReflectionDatas(type);
     const mergedTableReflectionData = tableReflectionDatas.reduceRight((merged, data) => ({ ...merged, ...data }), {});
-    const tableReflectionData = tableReflectionDatas[0];
     const schema = assertDefinedPass(mergedTableReflectionData.schema ?? fallbackSchemaName, 'Table schema not provided');
-    const tableName = tableReflectionData?.name ?? getDefaultTableName(type);
+    const tableName = getTableName(type);
     const dbSchema = getDbSchema(schema);
     const columnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName);
     const columnDefinitionsMap = new Map(columnDefinitions.map((column) => [column.objectPath.path, column]));
@@ -194,7 +185,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
                     const foreignTable = getDrizzleTableFromType(tenantReferenceData.target(), dbSchema.schemaName);
                     const nonTenantColumn = tenantReferenceData.targetColumn ?? 'id';
                     return foreignKey({
-                        name: getForeignKeyName(tableName, [nonTenantColumn]),
+                        name: getForeignKeyName(tableName, getTableName(tenantReferenceData.target()), [nonTenantColumn]),
                         columns: [getColumn(table, 'tenantId'), getColumn(table, columnDefinition.name)],
                         foreignColumns: [getColumn(foreignTable, 'tenantId'), getColumn(foreignTable, nonTenantColumn)],
                     });
@@ -204,7 +195,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
                 return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
                     const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
                     return foreignKey({
-                        name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
+                        name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, getTableName(foreignKeyData.target()), foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
                         columns: foreignKeyData.columns.map((column) => getColumn(table, column)),
                         foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable, column)),
                     });
@@ -227,6 +218,25 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     drizzleSchema[columnDefinitionsMapSymbol] = columnDefinitionsMap;
     return drizzleSchema;
 }
+function unwrapSchema(schema) {
+    let nullable = false;
+    let array = false;
+    let currentSchema = schema;
+    while (true) {
+        if ((currentSchema instanceof NullableSchema) || (currentSchema instanceof OptionalSchema)) {
+            nullable = true;
+            currentSchema = currentSchema.schema;
+        }
+        else if (currentSchema instanceof ArraySchema) {
+            array = true;
+            currentSchema = currentSchema.itemSchema;
+        }
+        else {
+            break;
+        }
+    }
+    return { schema: currentSchema, nullable, array };
+}
 function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath({ dollar: false }), prefix = '') {
     const metadata = reflectionRegistry.getMetadata(type);
     assertDefined(metadata, `Type ${type.name} does not have reflection metadata (path: ${path.toString()}).`);
@@ -269,23 +279,8 @@ function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath
     return entries;
 }
 function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, reflectionData, options, context) {
-    let nullable = false;
-    let array = false;
-    let baseSchema = propertySchema;
-    while (true) {
-        if ((baseSchema instanceof NullableSchema) || (baseSchema instanceof OptionalSchema)) {
-            nullable = true;
-            baseSchema = baseSchema.schema;
-        }
-        else if (baseSchema instanceof ArraySchema) {
-            array = true;
-            baseSchema = baseSchema.itemSchema;
-        }
-        else {
-            break;
-        }
-    }
-    let column = getPostgresBaseColumn(columnName, dbSchema, baseSchema, reflectionData, context);
+    const { schema, nullable, array } = unwrapSchema(propertySchema);
+    let column = getPostgresBaseColumn(columnName, dbSchema, schema, reflectionData, context);
     if (array) {
         column = column.array();
     }
@@ -371,8 +366,34 @@ function getIndexName(tableName, columnsOrBaseName, options) {
 function getUniqueName(tableName, columnsOrBaseName, options) {
     return getIdentifier(tableName, columnsOrBaseName, 'unique', options);
 }
-function getForeignKeyName(tableName, columnsOrBaseName, options) {
-    return getIdentifier(tableName, columnsOrBaseName, 'fkey', options);
+function getForeignKeyName(tableName, foreignTableName, columnsOrBaseName, options) {
+    const middle = isString(columnsOrBaseName) ? columnsOrBaseName : getColumnNames(columnsOrBaseName).join('_');
+    const identifier = `${getTablePrefix(tableName, options?.naming)}_${middle}_${getTablePrefix(foreignTableName, options?.naming)}_fkey`;
+    if (identifier.length > 63) {
+        if (options?.naming != 'abbreviated-table') {
+            return getForeignKeyName(tableName, foreignTableName, columnsOrBaseName, { naming: 'abbreviated-table' });
+        }
+        throw new Error(`Identifier "${identifier}" for table "${tableName}" is too long. Maximum length is 63 characters.`);
+    }
+    console.log(tableName, foreignTableName, columnsOrBaseName, 'Foreign key name:', identifier);
+    return identifier;
+}
+function getTableName(type) {
+    const tableReflectionDatas = getTableReflectionDatas(type);
+    const tableReflectionData = tableReflectionDatas[0];
+    return tableReflectionData?.name ?? getDefaultTableName(type);
+}
+function getTableReflectionDatas(type) {
+    const metadata = reflectionRegistry.getMetadata(type);
+    assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
+    const tableReflectionDatas = [];
+    for (let currentMetadata = metadata; isNotNullOrUndefined(currentMetadata?.parent); currentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent)) {
+        const tableReflectionData = currentMetadata.data.tryGet('orm');
+        if (isDefined(tableReflectionData)) {
+            tableReflectionDatas.push(tableReflectionData);
+        }
+    }
+    return tableReflectionDatas;
 }
 function getIdentifier(tableName, columnsOrBaseName, suffix, options) {
     const middle = isString(columnsOrBaseName) ? columnsOrBaseName : getColumnNames(columnsOrBaseName).join('_');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.77",
+  "version": "0.93.80",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -16,6 +16,7 @@
     "build:docs:watch": "typedoc --watch",
     "lint": "eslint --cache source/",
     "pub": "npm run build:production && npm run cleanup:dist && npm publish dist/",
+    "test": "vitest run",
     "tsc:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch",
     "cleanup:dist": "rm -vrf dist/tools/",
@@ -161,7 +162,7 @@
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
-    "undici": "^7.16",
+    "undici": "^7.18",
     "urlpattern-polyfill": "^10.1",
     "zod": "^3.25"
   },
@@ -187,7 +188,9 @@
     "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.51"
+    "typescript-eslint": "8.52",
+    "vite-tsconfig-paths": "6.0",
+    "vitest": "4.0"
   },
   "overrides": {
     "drizzle-kit": {

package/queue/enqueue-batch.d.ts

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

@@ -10,10 +10,9 @@ export class QueueEnqueueBatch {
     add(data, options) {
         this.items.push({ data, ...options });
     }
-    async enqueue(returnJobs) {
+    async enqueue(returnTasks) {
         const items = this.items;
         this.items = [];
-        const result = await this.queue.enqueueMany(items, { returnJobs });
-        return result;
+        return await this.queue.enqueueMany(items, { returnTasks });
     }
 }

package/queue/index.d.ts

@@ -1,3 +1,4 @@
 export * from './enqueue-batch.js';
 export * from './provider.js';
 export * from './queue.js';
+export * from './task-context.js';

package/queue/index.js

@@ -1,3 +1,4 @@
 export * from './enqueue-batch.js';
 export * from './provider.js';
 export * from './queue.js';
+export * from './task-context.js';

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

@@ -0,0 +1,30 @@
+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");