@tstdl/base 0.92.85 → 0.92.86

package/queue/queue.d.ts

@@ -1,7 +1,7 @@
 import type { CancellationSignal } from '../cancellation/token.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import { QueueEnqueueBatch } from './enqueue-batch.js';
-export type JobTag = string | number | null;
+export type JobTag = string | null;
 export type Job<T> = {
     id: string;
     /**
@@ -18,6 +18,10 @@ export declare enum UniqueTagStrategy {
     TakeNew = 1
 }
 export type EnqueueOptions = {
+    tag?: JobTag;
+    priority?: number;
+};
+export type EnqueueOneOptions = {
     tag?: JobTag;
     uniqueTag?: UniqueTagStrategy;
     priority?: number;
@@ -25,21 +29,29 @@ export type EnqueueOptions = {
 export type EnqueueManyItem<T> = EnqueueOptions & {
     data: T;
 };
+export type EnqueueManyOptions = {
+    uniqueTag?: UniqueTagStrategy;
+    returnJobs?: boolean;
+};
 export type QueueConfig = {
     processTimeout?: number;
     maxTries?: number;
 };
 export type QueueArgument = string | (QueueConfig & {
-    key: string;
+    name: string;
 });
 export declare const defaultQueueConfig: Required<QueueConfig>;
 export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
     readonly [resolveArgumentType]: QueueArgument;
     batch(): QueueEnqueueBatch<T>;
-    abstract enqueue(data: T, options?: EnqueueOptions): Promise<Job<T>>;
-    abstract enqueueMany(items: EnqueueManyItem<T>[], returnJobs?: false): Promise<void>;
-    abstract enqueueMany(items: EnqueueManyItem<T>[], returnJobs: true): Promise<Job<T>[]>;
-    abstract enqueueMany(items: EnqueueManyItem<T>[], returnJobs?: boolean): Promise<void | Job<T>[]>;
+    abstract enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
+    abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
+        returnJobs?: false;
+    }): Promise<void>;
+    abstract enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
+        returnJobs: true;
+    }): Promise<Job<T>[]>;
+    abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | undefined>;
     abstract has(id: string): Promise<boolean>;
     abstract countByTag(tag: JobTag): Promise<number>;
     abstract get(id: string): Promise<Job<T> | undefined>;

package/schema/schemas/object.d.ts

@@ -29,7 +29,7 @@ export type OptionalProperties<T> = {
     } ? P : never;
 }[keyof T];
 export type ObjectSchemaPropertiesType<TP extends ObjectSchemaProperties> = SimplifyObject<{
-    [P in keyof PartialProperty<TP, OptionalProperties<TP>>]: SchemaOutput<TP[P]>;
+    -readonly [P in keyof PartialProperty<TP, OptionalProperties<TP>>]: SchemaOutput<TP[P]>;
 }>;
 export declare const tryGetSchemaFromReflection: typeof _tryGetSchemaFromReflection;
 export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {

package/utils/timing.d.ts

@@ -1,4 +1,5 @@
-import type { CancellationSignal } from '../cancellation/token.js';
+import { type Observable } from 'rxjs';
+import { CancellationSignal } from '../cancellation/token.js';
 import { type ValueOrProvider } from './value-or-provider.js';
 /** Timeout for specified duration */
 export declare function timeout(milliseconds?: number, options?: {
@@ -7,9 +8,9 @@ export declare function timeout(milliseconds?: number, options?: {
 /** Timeout until specified time */
 export declare function timeoutUntil(timestamp: number | Date): Promise<void>;
 /** Timeout for specified duration */
-export declare function cancelableTimeout(milliseconds: number, cancelSignal: CancellationSignal): Promise<boolean>;
+export declare function cancelableTimeout(milliseconds: number, cancelSignal: Observable<void> | CancellationSignal): Promise<boolean>;
 /** Timeout until specified time */
-export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: CancellationSignal): Promise<boolean>;
+export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: Observable<void> | CancellationSignal): Promise<boolean>;
 export declare function withTimeout<T>(milliseconds: number, promiseOrProvider: ValueOrProvider<Promise<T>>, options?: {
     errorMessage?: string;
 }): Promise<T>;

package/utils/timing.js

@@ -1,4 +1,5 @@
 import { firstValueFrom, map, race, timer } from 'rxjs';
+import { CancellationSignal } from '../cancellation/token.js';
 import { TimeoutError } from '../errors/timeout.error.js';
 import { _throw } from './throw.js';
 import { resolveValueOrProvider } from './value-or-provider.js';
@@ -20,9 +21,10 @@ export async function timeoutUntil(timestamp) {
 }
 /** Timeout for specified duration */
 export async function cancelableTimeout(milliseconds, cancelSignal) {
+    const observable = (cancelSignal instanceof CancellationSignal) ? cancelSignal.set$ : cancelSignal;
     return firstValueFrom(race([
         timer(milliseconds).pipe(map(() => false)),
-        cancelSignal.set$.pipe(map(() => true))
+        observable.pipe(map(() => true))
     ]));
 }
 /** Timeout until specified time */

package/document-management/models/schemas.d.ts

@@ -1,33 +0,0 @@
-import { DocumentCategory } from './document-category.model.js';
-import { DocumentCollectionDocument } from './document-collection-document.model.js';
-import { DocumentCollection } from './document-collection.model.js';
-import { DocumentFile } from './document-file.model.js';
-import { DocumentPropertyBooleanValue, DocumentPropertyDecimalValue, DocumentPropertyIntegerValue, DocumentPropertyTextValue } from './document-property-value.model.js';
-import { DocumentProperty } from './document-property.model.js';
-import { DocumentRequestCollection } from './document-request-collection.model.js';
-import { DocumentRequestFile } from './document-request-file.model.js';
-import { DocumentRequestTemplate } from './document-request-template.js';
-import { DocumentRequest } from './document-request.model.js';
-import { DocumentRequestsTemplate } from './document-requests-template.js';
-import { DocumentTypeProperty } from './document-type-property.model.js';
-import { DocumentType } from './document-type.model.js';
-import { Document } from './document.model.js';
-export declare const documentManagementSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"document_management">;
-export declare const dataType: import("drizzle-orm/pg-core").PgEnum<["boolean", "decimal", "text", "integer"]>;
-export declare const documentCategory: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentCategory>;
-export declare const documentCollectionDocument: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentCollectionDocument>;
-export declare const documentCollection: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentCollection>;
-export declare const documentFile: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentFile>;
-export declare const documentPropertyTextValue: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentPropertyTextValue>;
-export declare const documentPropertyIntegerValue: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentPropertyIntegerValue>;
-export declare const documentPropertyDecimalValue: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentPropertyDecimalValue>;
-export declare const documentPropertyBooleanValue: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentPropertyBooleanValue>;
-export declare const documentProperty: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentProperty>;
-export declare const documentRequestCollection: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequestCollection>;
-export declare const documentRequestFile: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequestFile>;
-export declare const documentRequestTemplate: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequestTemplate>;
-export declare const documentRequest: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequest>;
-export declare const documentRequestsTemplate: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequestsTemplate>;
-export declare const documentTypeProperty: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentTypeProperty>;
-export declare const documentType: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentType>;
-export declare const document: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof Document>;