@tstdl/base 0.92.85 → 0.92.87

package/queue/postgres/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1740684120614,
+      "tag": "0000_zippy_moondragon",
+      "breakpoints": true
+    }
+  ]
+}

package/queue/postgres/drizzle.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("drizzle-kit").Config;
+export default _default;

package/queue/postgres/drizzle.config.js

@@ -0,0 +1,11 @@
+import { relative, resolve } from 'node:path';
+import { defineConfig } from 'drizzle-kit';
+export default defineConfig({
+    dialect: 'postgresql',
+    out: relative('./', resolve(__dirname, './drizzle/').replace('dist', 'source')),
+    schema: resolve(__dirname, './schemas.js'),
+    migrations: {
+        schema: 'queue',
+        table: '_migrations'
+    }
+});

package/queue/postgres/index.d.ts

@@ -0,0 +1,4 @@
+export * from './job.model.js';
+export * from './module.js';
+export * from './queue.js';
+export * from './queue.provider.js';

package/queue/postgres/index.js

@@ -0,0 +1,4 @@
+export * from './job.model.js';
+export * from './module.js';
+export * from './queue.js';
+export * from './queue.provider.js';

package/queue/postgres/job.model.d.ts

@@ -0,0 +1,13 @@
+import { EntityWithoutMetadata } from '../../orm/entity.js';
+import { Integer, Json, Timestamp } from '../../orm/index.js';
+import type { ObjectLiteral } from '../../types.js';
+import type { Job } from '../queue.js';
+export declare class PostgresJob<T extends ObjectLiteral = ObjectLiteral> extends EntityWithoutMetadata implements Job<T> {
+    queue: string;
+    tag: string | null;
+    priority: Integer;
+    enqueueTimestamp: Timestamp;
+    tries: Integer;
+    lastDequeueTimestamp: Timestamp | null;
+    data: Json<T>;
+}

package/queue/postgres/job.model.js

@@ -0,0 +1,55 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Table } from '../../orm/decorators.js';
+import { EntityWithoutMetadata } from '../../orm/entity.js';
+import { Integer, Json, Timestamp, Unique } from '../../orm/index.js';
+import { StringProperty } from '../../schema/index.js';
+let PostgresJob = class PostgresJob extends EntityWithoutMetadata {
+    queue;
+    tag;
+    priority;
+    enqueueTimestamp;
+    tries;
+    lastDequeueTimestamp;
+    data;
+};
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], PostgresJob.prototype, "queue", void 0);
+__decorate([
+    StringProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresJob.prototype, "tag", void 0);
+__decorate([
+    Integer(),
+    __metadata("design:type", Number)
+], PostgresJob.prototype, "priority", void 0);
+__decorate([
+    Timestamp(),
+    __metadata("design:type", Number)
+], PostgresJob.prototype, "enqueueTimestamp", void 0);
+__decorate([
+    Integer(),
+    __metadata("design:type", Number)
+], PostgresJob.prototype, "tries", void 0);
+__decorate([
+    Timestamp({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresJob.prototype, "lastDequeueTimestamp", void 0);
+__decorate([
+    Json(),
+    __metadata("design:type", Object)
+], PostgresJob.prototype, "data", void 0);
+PostgresJob = __decorate([
+    Table('job'),
+    Unique(['queue', 'tag'])
+], PostgresJob);
+export { PostgresJob };

package/queue/postgres/module.d.ts

@@ -0,0 +1,9 @@
+import { type DatabaseConfig } from '../../orm/server/index.js';
+export declare class PostgresQueueModuleConfig {
+    database?: DatabaseConfig;
+}
+/**
+ * configure mail module
+ */
+export declare function configurePostgresQueue(config?: PostgresQueueModuleConfig, register?: boolean): void;
+export declare function migratePostgresQueueSchema(): Promise<void>;

package/queue/postgres/module.js

@@ -0,0 +1,29 @@
+import { inject } from '../../injector/index.js';
+import { Injector } from '../../injector/injector.js';
+import { Database, migrate } from '../../orm/server/index.js';
+import { QueueProvider } from '../provider.js';
+import { Queue } from '../queue.js';
+import { PostgresQueue } from './queue.js';
+import { PostgresQueueProvider } from './queue.provider.js';
+export class PostgresQueueModuleConfig {
+    database;
+}
+/**
+ * configure mail module
+ */
+export function configurePostgresQueue(config, register = true) {
+    Injector.register(PostgresQueueModuleConfig, { useValue: config });
+    if (register) {
+        Injector.registerSingleton(QueueProvider, { useToken: PostgresQueueProvider });
+        Injector.registerSingleton(Queue, { useToken: PostgresQueue });
+    }
+}
+export async function migratePostgresQueueSchema() {
+    const connection = inject(PostgresQueueModuleConfig, undefined, { optional: true })?.database?.connection;
+    const database = inject(Database, connection);
+    await migrate(database, {
+        migrationsSchema: 'queue',
+        migrationsTable: '_migrations',
+        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', '')
+    });
+}

package/queue/postgres/queue.d.ts

@@ -0,0 +1,28 @@
+import { CancellationSignal } from '../../cancellation/index.js';
+import type { ObjectLiteral } from '../../types.js';
+import { Queue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Job, type JobTag } from '../queue.js';
+export declare class PostgresQueue<T extends ObjectLiteral> extends Queue<T> {
+    #private;
+    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
+        returnJobs?: false;
+    }): Promise<void>;
+    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
+        returnJobs: true;
+    }): Promise<Job<T>[]>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | undefined>;
+    has(id: string): Promise<boolean>;
+    countByTag(tag: JobTag): Promise<number>;
+    get(id: string): Promise<Job<T> | undefined>;
+    getByTag(tag: JobTag): Promise<Job<T>[]>;
+    cancel(id: string): Promise<void>;
+    cancelMany(ids: string[]): Promise<void>;
+    cancelByTag(tag: JobTag): Promise<void>;
+    cancelByTags(tags: JobTag[]): Promise<void>;
+    dequeue(): Promise<Job<T> | undefined>;
+    dequeueMany(count: number): Promise<Job<T>[]>;
+    acknowledge(job: Job<T>): Promise<void>;
+    acknowledgeMany(jobs: Job<T>[]): Promise<void>;
+    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
+    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
+}

package/queue/postgres/queue.js

@@ -0,0 +1,147 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { and, asc, eq, inArray, isNull as isSqlNull, lt, lte, or, sql } from 'drizzle-orm';
+import { merge } from 'rxjs';
+import { CancellationSignal } from '../../cancellation/index.js';
+import { inject, injectArgument, provide, Singleton } from '../../injector/index.js';
+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 { 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';
+import { PostgresQueueModuleConfig } from './module.js';
+import { job } from './schemas.js';
+let PostgresQueue = class PostgresQueue extends Queue {
+    #repository = injectRepository(PostgresJob);
+    #config = injectArgument(this);
+    #processTimeout = (isString(this.#config) ? undefined : this.#config.processTimeout) ?? defaultQueueConfig.processTimeout;
+    #maxTries = (isString(this.#config) ? undefined : this.#config.maxTries) ?? defaultQueueConfig.maxTries;
+    #queueName = isString(this.#config) ? this.#config : this.#config.name;
+    #messageBus = inject((MessageBus), `PostgresQueue:${this.#queueName}`);
+    #keepOldUpdate = { id: sql `${job.id}` };
+    #takeNewUpdate = {
+        id: RANDOM_UUID,
+        queue: this.#queueName,
+        priority: sql `excluded.priority`,
+        tag: sql `excluded.tag`,
+        tries: 0,
+        enqueueTimestamp: TRANSACTION_TIMESTAMP,
+        lastDequeueTimestamp: null,
+        data: sql `excluded.data`
+    };
+    #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 }], { uniqueTag: options?.uniqueTag, returnJobs: true });
+        return jobs[0];
+    }
+    async enqueueMany(items, options) {
+        const newEntities = items.map((item) => ({
+            queue: this.#queueName,
+            priority: item.priority ?? 1000,
+            tag: item.tag ?? null,
+            tries: 0,
+            enqueueTimestamp: TRANSACTION_TIMESTAMP,
+            lastDequeueTimestamp: null,
+            data: item.data
+        }));
+        const update = (options?.uniqueTag == UniqueTagStrategy.TakeNew)
+            ? this.#takeNewUpdate
+            : this.#keepOldUpdate;
+        const jobs = await this.#repository.upsertMany(['queue', 'tag'], newEntities, update);
+        this.#messageBus.publishAndForget();
+        return jobs;
+    }
+    async has(id) {
+        return this.#repository.hasByQuery({ queue: this.#queueName, id });
+    }
+    async countByTag(tag) {
+        return this.#repository.countByQuery({ queue: this.#queueName, tag });
+    }
+    async get(id) {
+        return this.#repository.tryLoadByQuery({ queue: this.#queueName, id });
+    }
+    async getByTag(tag) {
+        return this.#repository.loadManyByQuery({ queue: this.#queueName, tag });
+    }
+    async cancel(id) {
+        await this.#repository.hardDeleteByQuery({ queue: this.#queueName, id });
+    }
+    async cancelMany(ids) {
+        await this.#repository.hardDeleteManyByQuery({ queue: this.#queueName, id: { $in: ids } });
+    }
+    async cancelByTag(tag) {
+        await this.#repository.hardDeleteByQuery({ queue: this.#queueName, tag });
+    }
+    async cancelByTags(tags) {
+        await this.#repository.hardDeleteManyByQuery({ queue: this.#queueName, tag: { $in: tags } });
+    }
+    async dequeue() {
+        const jobs = await this.dequeueMany(1);
+        if (jobs.length == 0) {
+            return undefined;
+        }
+        return jobs[0];
+    }
+    async dequeueMany(count) {
+        const rows = await this.#repository.session
+            .update(job)
+            .set(this.#dequeueUpdate)
+            .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)
+            .for('update')))
+            .returning();
+        return this.#repository.$mapManyToEntity(rows); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    }
+    async acknowledge(job) {
+        return this.cancel(job.id);
+    }
+    async acknowledgeMany(jobs) {
+        const ids = jobs.map((job) => job.id);
+        return this.cancelMany(ids);
+    }
+    async *getConsumer(cancellationSignal) {
+        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
+        while (cancellationSignal.isUnset) {
+            const job = await this.dequeue();
+            if (isDefined(job)) {
+                yield job;
+                continue;
+            }
+            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
+        }
+    }
+    async *getBatchConsumer(size, cancellationSignal) {
+        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
+        while (cancellationSignal.isUnset) {
+            const jobs = await this.dequeueMany(size);
+            if (jobs.length > 0) {
+                yield jobs;
+                continue;
+            }
+            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
+        }
+    }
+};
+PostgresQueue = __decorate([
+    Singleton({
+        providers: [
+            provide(EntityRepositoryConfig, { useValue: { schema: 'queue' } }),
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) })
+        ]
+    })
+], PostgresQueue);
+export { PostgresQueue };

package/queue/postgres/queue.provider.d.ts

@@ -0,0 +1,7 @@
+import { QueueProvider, type QueueConfig } from '../../queue/index.js';
+import type { ObjectLiteral } from '../../types.js';
+import { PostgresQueue } from './queue.js';
+export declare class PostgresQueueProvider extends QueueProvider {
+    #private;
+    get<T extends ObjectLiteral>(name: string, config?: QueueConfig): PostgresQueue<T>;
+}

package/queue/postgres/queue.provider.js

@@ -0,0 +1,21 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Singleton } from '../../injector/decorators.js';
+import { inject } from '../../injector/inject.js';
+import { Injector } from '../../injector/injector.js';
+import { QueueProvider } from '../../queue/index.js';
+import { PostgresQueue } from './queue.js';
+let PostgresQueueProvider = class PostgresQueueProvider extends QueueProvider {
+    #injector = inject(Injector);
+    get(name, config) {
+        return this.#injector.resolve((PostgresQueue), { ...config, name: name });
+    }
+};
+PostgresQueueProvider = __decorate([
+    Singleton()
+], PostgresQueueProvider);
+export { PostgresQueueProvider };

package/queue/postgres/schemas.d.ts

@@ -0,0 +1,3 @@
+import { PostgresJob } from './job.model.js';
+export declare const queueSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"queue">;
+export declare const job: import("../../orm/server/types.js").PgTableFromType<typeof PostgresJob, "queue">;

package/queue/postgres/schemas.js

@@ -0,0 +1,4 @@
+import { databaseSchema } from '../../orm/server/database-schema.js';
+import { PostgresJob } from './job.model.js';
+export const queueSchema = databaseSchema('queue');
+export const job = queueSchema.getTable(PostgresJob);

package/queue/provider.d.ts

@@ -1,4 +1,5 @@
+import type { ObjectLiteral } from '../types.js';
 import type { Queue, QueueConfig } from './queue.js';
 export declare abstract class QueueProvider {
-    abstract get<T>(key: string, config?: QueueConfig): Queue<T>;
+    abstract get<T extends ObjectLiteral>(key: string, config?: QueueConfig): Queue<T>;
 }

package/queue/queue.d.ts

@@ -1,7 +1,10 @@
 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 JobTag = string | number | null;
+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;
     /**
@@ -18,6 +21,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 +32,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>;
@@ -54,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/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/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/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/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>;