@tstdl/base 0.92.86 → 0.92.88

package/pdf/utils.js

@@ -1,11 +1,136 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { TemporaryFile } from '../file/temporary-file.js';
 import { spawnCommand } from '../process/spawn.js';
+import { isString } from '../utils/type-guards.js';
 export async function getPdfPageCount(file) {
-    const process = await spawnCommand('qpdf', ['--show-npages', file]);
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const fileIsPath = isString(file);
+        const tmpFile = __addDisposableResource(env_1, fileIsPath ? await TemporaryFile.from(file) : undefined, true);
+        const path = fileIsPath ? file : tmpFile.path;
+        const process = await spawnCommand('qpdf', ['--show-npages', path]);
+        const { code } = await process.wait();
+        if (code != 0) {
+            const errorOutput = await process.readError();
+            throw new Error(errorOutput.trim());
+        }
+        const output = await process.readOutput();
+        return Number(output);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+}
+export async function mergePdfs(pdfs) {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const stack = __addDisposableResource(env_2, new AsyncDisposableStack(), true);
+        const resultFile = __addDisposableResource(env_2, TemporaryFile.create(), true);
+        const sourceFiles = await getPdfSourceFiles(pdfs, stack);
+        await pdfunite(sourceFiles, resultFile);
+        return await resultFile.read();
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            await result_2;
+    }
+}
+export async function mergePdfsStream(pdfs) {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const stack = __addDisposableResource(env_3, new AsyncDisposableStack(), true);
+        const resultFile = __addDisposableResource(env_3, TemporaryFile.create(), true);
+        const sourceFiles = await getPdfSourceFiles(pdfs, stack);
+        await pdfunite(sourceFiles, resultFile);
+        return resultFile.readStream();
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        const result_3 = __disposeResources(env_3);
+        if (result_3)
+            await result_3;
+    }
+}
+async function getPdfSourceFiles(pdfs, stack) {
+    return await Promise.all(pdfs.map(async (pdf) => {
+        if (isString(pdf)) {
+            return pdf;
+        }
+        const tmpFile = await TemporaryFile.from(pdf);
+        stack.use(tmpFile);
+        return tmpFile.path;
+    }));
+}
+async function pdfunite(sourceFiles, resultFile) {
+    const process = await spawnCommand('pdfunite', [...sourceFiles, resultFile.path]);
     const { code } = await process.wait();
     if (code != 0) {
         const errorOutput = await process.readError();
-        throw new Error(errorOutput.trim());
+        throw new Error(errorOutput);
     }
-    const output = await process.readOutput();
-    return Number(output);
 }

package/promise/lazy-promise.d.ts

@@ -4,8 +4,8 @@ export declare class LazyPromise<T> extends CustomPromise<T> {
     #private;
     readonly [Symbol.toStringTag] = "LazyPromise";
     constructor(executorOrPromiseProvider: PromiseExecutor<T> | (() => PromiseLike<T>));
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
-    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
     private execute;
 }

package/queue/postgres/module.d.ts

@@ -5,5 +5,5 @@ export declare class PostgresQueueModuleConfig {
 /**
  * configure mail module
  */
-export declare function configurePostgresQueue(config: PostgresQueueModuleConfig, register?: boolean): void;
+export declare function configurePostgresQueue(config?: PostgresQueueModuleConfig, register?: boolean): void;
 export declare function migratePostgresQueueSchema(): Promise<void>;

package/queue/postgres/queue.js

@@ -11,7 +11,7 @@ import { inject, injectArgument, provide, Singleton } from '../../injector/index
 import { MessageBus } from '../../message-bus/index.js';
 import { DatabaseConfig, EntityRepositoryConfig, injectRepository, interval, RANDOM_UUID, TRANSACTION_TIMESTAMP } from '../../orm/server/index.js';
 import { cancelableTimeout } from '../../utils/timing.js';
-import { isString } from '../../utils/type-guards.js';
+import { isDefined, isString } from '../../utils/type-guards.js';
 import { millisecondsPerSecond } from '../../utils/units.js';
 import { defaultQueueConfig, Queue, UniqueTagStrategy } from '../queue.js';
 import { PostgresJob } from './job.model.js';
@@ -35,13 +35,13 @@ let PostgresQueue = class PostgresQueue extends Queue {
         lastDequeueTimestamp: null,
         data: sql `excluded.data`
     };
-    #dequeueQuery = and(eq(job.queue, this.#queueName), lt(job.tries, this.#maxTries), or(isSqlNull(job.lastDequeueTimestamp), lte(job.lastDequeueTimestamp, sql `${job.lastDequeueTimestamp} + ${interval(this.#processTimeout, 'milliseconds')}`)));
+    #dequeueQuery = and(eq(job.queue, this.#queueName), lt(job.tries, this.#maxTries), or(isSqlNull(job.lastDequeueTimestamp), lte(sql `${job.lastDequeueTimestamp} + ${interval(this.#processTimeout, 'milliseconds')}`, TRANSACTION_TIMESTAMP)));
     #dequeueUpdate = {
         tries: sql `${job.tries} + 1`,
         lastDequeueTimestamp: TRANSACTION_TIMESTAMP
     };
     async enqueue(data, options) {
-        const jobs = await this.enqueueMany([{ data, tag: options?.tag, priority: options?.priority }], { returnJobs: true });
+        const jobs = await this.enqueueMany([{ data, tag: options?.tag, priority: options?.priority }], { uniqueTag: options?.uniqueTag, returnJobs: true });
         return jobs[0];
     }
     async enqueueMany(items, options) {
@@ -96,11 +96,13 @@ let PostgresQueue = class PostgresQueue extends Queue {
         const rows = await this.#repository.session
             .update(job)
             .set(this.#dequeueUpdate)
-            .where(inArray(job.id, this.#repository.session.select({ id: job.id })
+            .where(inArray(job.id, this.#repository.session
+            .select({ id: job.id })
             .from(job)
             .where(this.#dequeueQuery)
             .orderBy(asc(job.priority), asc(job.enqueueTimestamp), asc(job.lastDequeueTimestamp), asc(job.tries))
-            .limit(count)))
+            .limit(count)
+            .for('update')))
             .returning();
         return this.#repository.$mapManyToEntity(rows); // eslint-disable-line @typescript-eslint/no-unsafe-argument
     }
@@ -115,15 +117,11 @@ let PostgresQueue = class PostgresQueue extends Queue {
         const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
         while (cancellationSignal.isUnset) {
             const job = await this.dequeue();
-            if (job != undefined) {
+            if (isDefined(job)) {
                 yield job;
+                continue;
             }
-            else {
-                const cancelled = await cancelableTimeout(5 * millisecondsPerSecond, continue$);
-                if (cancelled) {
-                    break;
-                }
-            }
+            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
         }
     }
     async *getBatchConsumer(size, cancellationSignal) {

package/queue/queue.d.ts

@@ -1,6 +1,9 @@
 import type { CancellationSignal } from '../cancellation/token.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import type { Logger } from '../logger/logger.js';
 import { QueueEnqueueBatch } from './enqueue-batch.js';
+export type ProcessWorker<T> = (job: Job<T>) => void | Promise<void>;
+export type ProcessBatchWorker<T> = (jobs: Job<T>[]) => void | Promise<void>;
 export type JobTag = string | null;
 export type Job<T> = {
     id: string;
@@ -66,4 +69,15 @@ export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
     abstract acknowledgeMany(jobs: Job<T>[]): Promise<void>;
     abstract getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
     abstract getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
+    process({ concurrency, cancellationSignal }: {
+        concurrency?: number;
+        cancellationSignal: CancellationSignal;
+    }, handler: ProcessWorker<T>, errorHandler?: Logger | ((error: unknown) => void | Promise<void>)): void;
+    processBatch({ batchSize, concurrency, cancellationSignal }: {
+        batchSize?: number;
+        concurrency?: number;
+        cancellationSignal: CancellationSignal;
+    }, handler: ProcessBatchWorker<T>, errorHandler?: Logger | ((error: unknown) => void | Promise<void>)): void;
+    private processWorker;
+    private processBatchWorker;
 }

package/queue/queue.js

@@ -1,3 +1,4 @@
+import { isDefined, isFunction } from '../utils/type-guards.js';
 import { millisecondsPerMinute } from '../utils/units.js';
 import { QueueEnqueueBatch } from './enqueue-batch.js';
 export const defaultJobPriority = 1000;
@@ -14,4 +15,46 @@ export class Queue {
     batch() {
         return new QueueEnqueueBatch(this);
     }
+    process({ concurrency = 1, cancellationSignal }, handler, errorHandler) {
+        const handleError = isFunction(errorHandler)
+            ? errorHandler
+            : isDefined(errorHandler)
+                ? (error) => errorHandler.error(error)
+                : undefined;
+        for (let i = 0; i < concurrency; i++) {
+            void this.processWorker(cancellationSignal, handler, handleError);
+        }
+    }
+    processBatch({ batchSize = 10, concurrency = 1, cancellationSignal }, handler, errorHandler) {
+        const handleError = isFunction(errorHandler)
+            ? errorHandler
+            : isDefined(errorHandler)
+                ? (error) => errorHandler.error(error)
+                : undefined;
+        for (let i = 0; i < concurrency; i++) {
+            void this.processBatchWorker(batchSize, cancellationSignal, handler, handleError);
+        }
+    }
+    async processWorker(cancellationSignal, handler, errorHandler) {
+        for await (const job of this.getConsumer(cancellationSignal)) {
+            try {
+                await handler(job);
+                await this.acknowledge(job);
+            }
+            catch (error) {
+                await errorHandler?.(error);
+            }
+        }
+    }
+    async processBatchWorker(size, cancellationSignal, handler, errorHandler) {
+        for await (const jobs of this.getBatchConsumer(size, cancellationSignal)) {
+            try {
+                await handler(jobs);
+                await this.acknowledgeMany(jobs);
+            }
+            catch (error) {
+                await errorHandler?.(error);
+            }
+        }
+    }
 }

package/utils/date-time.d.ts

@@ -42,13 +42,15 @@ export declare function timeObjectToNumericTime(time: Partial<TimeObject>): numb
 export declare function numericTimeToTimeObject(time: number): TimeObject;
 export declare function timestampToNumericDateAndTime(timestamp: number): NumericDateTime;
 export declare function numericDateToTimestamp(numericDate: number): number;
-export declare function numericDateToDate(numericDate: number): {
+export declare function numericDateToDate(numericDate: number): Date;
+export declare function numericDateToDateObject(numericDate: number): {
     year: number;
     month: number;
     day: number;
 };
 export declare function numericDateTimeToTimestamp({ date, time }: NumericDateTime): number;
-export declare function zonedDateObjectToDateTime(zonedDate: ZonedDateObject, units?: DateObjectUnits, options?: DateTimeJSOptions): DateTime;
+export declare function dateObjectToDateTime(dateObject: ZonedDateObject, units?: DateObjectUnits, options?: DateTimeJSOptions): DateTime;
+export declare function dateObjectToNumericDate(dateObject: DateObject): number;
 export declare function dateTimeToNumericDate(dateTime: DateTime): number;
 export declare function numericDateToDateTime(numericDate: number, units?: DateObjectUnits, options?: DateTimeJSOptions): DateTime;
 export declare function dateTimeToTime(dateTime: DateTime): number;

package/utils/date-time.js

@@ -74,7 +74,10 @@ export function numericDateToTimestamp(numericDate) {
 }
 export function numericDateToDate(numericDate) {
     const timestamp = numericDateToTimestamp(numericDate);
-    const date = new Date(timestamp);
+    return new Date(timestamp);
+}
+export function numericDateToDateObject(numericDate) {
+    const date = numericDateToDate(numericDate);
     return {
         year: date.getUTCFullYear(),
         month: date.getUTCMonth() + 1,
@@ -84,8 +87,12 @@ export function numericDateToDate(numericDate) {
 export function numericDateTimeToTimestamp({ date, time }) {
     return numericDateToTimestamp(date) + time;
 }
-export function zonedDateObjectToDateTime(zonedDate, units, options) {
-    return DateTime.fromObject({ ...zonedDate, ...units }, options);
+export function dateObjectToDateTime(dateObject, units, options) {
+    return DateTime.fromObject({ ...dateObject, ...units }, options);
+}
+export function dateObjectToNumericDate(dateObject) {
+    const dateTime = DateTime.fromObject({ ...dateObject }, { zone: 'UTC' });
+    return dateTimeToNumericDate(dateTime);
 }
 export function dateTimeToNumericDate(dateTime) {
     const timestamp = dateTime.toUTC(undefined, { keepLocalTime: true }).toMillis();

package/utils/format-error.js

@@ -2,7 +2,6 @@ import { unwrapError } from '../errors/utils.js';
 import { decycle } from './object/decycle.js';
 import { objectKeys } from './object/object.js';
 import { isDefined, isFunction, isUndefined } from './type-guards.js';
-// eslint-disable-next-line max-statements, complexity
 export function formatError(error, options = {}) {
     const { includeRest = 'if-no-extra-info', includeExtraInfo = true, includeStack = true } = options;
     let name;

package/utils/object/lazy-property.js

@@ -36,7 +36,6 @@ export function lazyProperty(object, propertyKey, initializer, descriptor = {})
         configurable
     });
 }
-// eslint-disable-next-line max-statements, max-lines-per-function
 export function lazyObject(initializers) {
     const object = {};
     for (const [key, value] of objectEntries(initializers)) {

package/utils/try-ignore.d.ts

@@ -1,2 +1,9 @@
-export declare function tryIgnore(fn: () => any): void;
-export declare function tryIgnoreAsync(fn: () => Promise<any>): Promise<void>;
+import type { Logger } from '../logger/logger.js';
+export declare function tryIgnore<R>(fn: () => R): R;
+export declare function tryIgnore<R, F>(fn: () => R, fallback: F): R | F;
+export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreAsync<R, F>(fn: () => Promise<R>, fallback: F): Promise<F>;
+export declare function tryIgnoreLog<R>(fn: () => R, logger: Logger): R;
+export declare function tryIgnoreLog<R, F>(fn: () => R, logger: Logger, fallback: F): R | F;
+export declare function tryIgnoreLogAsync<R>(fn: () => Promise<R>, logger: Logger): Promise<R>;
+export declare function tryIgnoreLogAsync<R, F>(fn: () => Promise<R>, logger: Logger, fallback: F): Promise<F>;

package/utils/try-ignore.js

@@ -1,12 +1,36 @@
-export function tryIgnore(fn) {
+export function tryIgnore(fn, fallback) {
     try {
-        fn();
+        return fn();
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function tryIgnoreAsync(fn, fallback) {
+    try {
+        const value = await fn();
+        return value;
+    }
+    catch {
+        return fallback;
     }
-    catch { /* ignore */ }
 }
-export async function tryIgnoreAsync(fn) {
+export function tryIgnoreLog(fn, logger, fallback) {
     try {
-        await fn();
+        return fn();
+    }
+    catch (error) {
+        logger.error(error);
+        return fallback;
+    }
+}
+export async function tryIgnoreLogAsync(fn, logger, fallback) {
+    try {
+        const value = await fn();
+        return value;
+    }
+    catch (error) {
+        logger.error(error);
+        return fallback;
     }
-    catch { /* ignore */ }
 }

package/document-management/models/document-index.model.d.ts

@@ -1,7 +0,0 @@
-import { Entity } from '../../orm/entity.js';
-import { Uuid } from '../../orm/types.js';
-export declare class DocumentIndex extends Entity {
-    documentId: Uuid;
-    summary: string;
-    tags: string[];
-}