@tstdl/base 0.93.175 → 0.93.177

package/api/server/middlewares/response-time.middleware.js

@@ -1,8 +1,5 @@
-import { round } from '../../../utils/math.js';
-import { Timer } from '../../../utils/timer.js';
 export async function responseTimeMiddleware({ response }, next) {
-    const timer = Timer.startNew();
+    const stop = response.serverTiming.start('total');
     await next();
-    const time = round(timer.milliseconds, 2);
-    response.headers.set('X-Response-Time', `${time}ms`);
+    stop();
 }

package/audit/auditor.js

@@ -235,7 +235,7 @@ __decorate([
 Auditor = Auditor_1 = __decorate([
     Injectable({
         providers: [
-            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(AuditModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) },
+            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(AuditModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) },
         ],
     })
 ], Auditor);

package/authentication/server/authentication.service.js

@@ -787,7 +787,7 @@ let AuthenticationService = AuthenticationService_1 = class AuthenticationServic
 AuthenticationService = AuthenticationService_1 = __decorate([
     Singleton({
         providers: [
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(AuthenticationModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(AuthenticationModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
         ],
     })
 ], AuthenticationService);

package/circuit-breaker/postgres/circuit-breaker.js

@@ -93,7 +93,7 @@ PostgresCircuitBreakerService = __decorate([
     Singleton({
         argumentIdentityProvider: (arg) => isString(arg) ? arg : arg.key,
         providers: [
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresCircuitBreakerModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresCircuitBreakerModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
         ],
     })
 ], PostgresCircuitBreakerService);

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

@@ -3,7 +3,7 @@ import { provide } from '../../../injector/injector.js';
 import { factoryProvider } from '../../../injector/provider.js';
 import { DatabaseConfig } from '../../../orm/server/index.js';
 import { DocumentManagementConfiguration } from '../module.js';
-export const documentManagementDatabaseConfigFactoryProvider = factoryProvider((_, context) => context.resolve(DocumentManagementConfiguration).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }));
+export const documentManagementDatabaseConfigFactoryProvider = factoryProvider((_, context) => context.resolve(DocumentManagementConfiguration).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }));
 export const documentManagementDatabaseConfigProvider = provide(DatabaseConfig, documentManagementDatabaseConfigFactoryProvider);
 export function DocumentManagementSingleton() {
     return Singleton({ providers: [documentManagementDatabaseConfigProvider] });

package/errors/format.d.ts

@@ -1,4 +1,4 @@
-import type { Record, UndefinableJson } from '../types/index.js';
+import type { ObjectLiteral, Record, UndefinableJson } from '../types/index.js';
 export type FormatErrorOptions = {
     /** Include error name in message */
     includeName?: boolean;
@@ -20,6 +20,11 @@ export type SerializedError = {
     cause?: SerializedError;
     aggregateErrors?: SerializedError[];
 };
+export type NonRecursiveSerializedError = Omit<SerializedError, 'extraInfo' | 'cause' | 'aggregateErrors'> & {
+    extraInfo?: ObjectLiteral | null | undefined;
+    cause?: ObjectLiteral;
+    aggregateErrors?: ObjectLiteral[];
+};
 export interface ErrorExtraInfo {
     /** Format extra data (without message and stack) as JSON */
     getExtraInfo(): UndefinableJson | undefined;

package/errors/format.js

@@ -29,7 +29,7 @@ export function serializeError(error, options = {}) {
             aggregateErrors = actualError.errors;
         }
         // Extract Extra Info
-        if (includeExtraInfo && isFunction(actualError.getExtraInfo)) {
+        if (includeExtraInfo && isFunction(actualError?.getExtraInfo)) {
             extraInfo = actualError.getExtraInfo();
         }
         // Isolate 'rest' properties via destructuring

package/http/index.d.ts

@@ -12,6 +12,7 @@ export * from './http-query.js';
 export * from './http-url-parameters.js';
 export * from './http-value-map.js';
 export * from './http.error.js';
+export * from './server-timing.js';
 export * from './server/index.js';
 export * from './tokens.js';
 export * from './types.js';

package/http/index.js

@@ -12,6 +12,7 @@ export * from './http-query.js';
 export * from './http-url-parameters.js';
 export * from './http-value-map.js';
 export * from './http.error.js';
+export * from './server-timing.js';
 export * from './server/index.js';
 export * from './tokens.js';
 export * from './types.js';

package/http/server/http-server-response.d.ts

@@ -3,6 +3,7 @@ import type { ServerSentEventsSource } from '../../sse/server-sent-events-source
 import type { Record } from '../../types/index.js';
 import type { HttpHeadersInput } from '../http-headers.js';
 import { HttpHeaders } from '../http-headers.js';
+import { ServerTiming } from '../server-timing.js';
 export type SetCookieObject = SetCookieOptions & {
     value: string;
 };
@@ -24,6 +25,7 @@ export type HttpServerResponseOptions = {
 export declare class HttpServerResponse {
     #private;
     readonly headers: HttpHeaders;
+    readonly serverTiming: ServerTiming;
     statusCode: number | undefined;
     statusMessage: string | undefined;
     get body(): HttpServerResponseBody | undefined;

package/http/server/http-server-response.js

@@ -2,10 +2,12 @@ import { formatSetCookie } from '../../cookie/cookie.js';
 import { objectEntries } from '../../utils/object/object.js';
 import { isDefined, isUndefined } from '../../utils/type-guards.js';
 import { HttpHeaders } from '../http-headers.js';
+import { ServerTiming } from '../server-timing.js';
 export class HttpServerResponse {
     #body;
     #bodyType;
     headers = new HttpHeaders();
+    serverTiming = new ServerTiming();
     statusCode;
     statusMessage;
     get body() {

package/http/server/node/node-http-server.js

@@ -141,6 +141,9 @@ function getResponder(httpResponse) {
     return respond;
 }
 function writeHeaders(response, httpResponse) {
+    if (response.serverTiming.hasMetrics) {
+        response.headers.set('Server-Timing', response.serverTiming.toString());
+    }
     for (const [name, value] of response.headers.normalizedEntries()) {
         httpResponse.setHeader(name, value);
     }

package/http/server-timing.d.ts

@@ -0,0 +1,31 @@
+export type ServerTimingMetric = {
+    name: string;
+    duration?: number;
+    description?: string;
+};
+export declare class ServerTiming {
+    #private;
+    /**
+     * Whether there are any metrics.
+     */
+    get hasMetrics(): boolean;
+    /**
+     * Add a metric to the server timing.
+     * @param name The name of the metric.
+     * @param duration The duration of the metric in milliseconds.
+     * @param description An optional description for the metric.
+     */
+    add(name: string, duration?: number, description?: string): void;
+    /**
+     * Start a timer for a metric.
+     * @param name The name of the metric.
+     * @param description An optional description for the metric.
+     * @returns A function to stop the timer and add the metric.
+     */
+    start(name: string, description?: string): () => void;
+    /**
+     * Format the metrics as a `Server-Timing` header value.
+     * @returns Comma-separated list of metrics.
+     */
+    toString(): string;
+}

package/http/server-timing.js

@@ -0,0 +1,47 @@
+import { round } from '../utils/math.js';
+import { Timer } from '../utils/timer.js';
+import { isDefined } from '../utils/type-guards.js';
+export class ServerTiming {
+    #metrics = [];
+    /**
+     * Whether there are any metrics.
+     */
+    get hasMetrics() {
+        return this.#metrics.length > 0;
+    }
+    /**
+     * Add a metric to the server timing.
+     * @param name The name of the metric.
+     * @param duration The duration of the metric in milliseconds.
+     * @param description An optional description for the metric.
+     */
+    add(name, duration, description) {
+        this.#metrics.push({ name, duration, description });
+    }
+    /**
+     * Start a timer for a metric.
+     * @param name The name of the metric.
+     * @param description An optional description for the metric.
+     * @returns A function to stop the timer and add the metric.
+     */
+    start(name, description) {
+        const timer = Timer.startNew();
+        return () => this.add(name, round(timer.milliseconds, 2), description);
+    }
+    /**
+     * Format the metrics as a `Server-Timing` header value.
+     * @returns Comma-separated list of metrics.
+     */
+    toString() {
+        return this.#metrics.map((metric) => {
+            let result = metric.name;
+            if (isDefined(metric.duration)) {
+                result += `;dur=${metric.duration}`;
+            }
+            if (isDefined(metric.description)) {
+                result += `;desc="${metric.description}"`;
+            }
+            return result;
+        }).join(', ');
+    }
+}

package/http/tests/server-timing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/http/tests/server-timing.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { ServerTiming } from '../server-timing.js';
+describe('ServerTiming', () => {
+    test('should be empty by default', () => {
+        const timing = new ServerTiming();
+        expect(timing.hasMetrics).toBe(false);
+        expect(timing.toString()).toBe('');
+    });
+    test('should add a simple metric', () => {
+        const timing = new ServerTiming();
+        timing.add('db');
+        expect(timing.hasMetrics).toBe(true);
+        expect(timing.toString()).toBe('db');
+    });
+    test('should add a metric with duration', () => {
+        const timing = new ServerTiming();
+        timing.add('db', 53.2);
+        expect(timing.toString()).toBe('db;dur=53.2');
+    });
+    test('should add a metric with duration and description', () => {
+        const timing = new ServerTiming();
+        timing.add('db', 53.2, 'Database Query');
+        expect(timing.toString()).toBe('db;dur=53.2;desc="Database Query"');
+    });
+    test('should add multiple metrics', () => {
+        const timing = new ServerTiming();
+        timing.add('cache', undefined, 'Cache Miss');
+        timing.add('db', 53.2);
+        timing.add('total', 123.45);
+        expect(timing.toString()).toBe('cache;desc="Cache Miss", db;dur=53.2, total;dur=123.45');
+    });
+    test('should use start/stop for metrics', async () => {
+        const timing = new ServerTiming();
+        const stop = timing.start('total');
+        await new Promise((resolve) => setTimeout(resolve, 11));
+        stop();
+        const result = timing.toString();
+        expect(result).toMatch(/total;dur=\d+\.\d+/);
+        const duration = Number.parseFloat(result.split('=')[1]);
+        expect(duration).toBeGreaterThanOrEqual(10);
+    });
+});

package/key-value-store/postgres/key-value-store.service.js

@@ -56,7 +56,7 @@ let PostgresKeyValueStore = class PostgresKeyValueStore extends Transactional {
 PostgresKeyValueStore = __decorate([
     Singleton({
         providers: [
-            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresKeyValueStoreModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) },
+            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresKeyValueStoreModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) },
         ],
     })
 ], PostgresKeyValueStore);

package/lock/postgres/provider.js

@@ -20,7 +20,7 @@ let PostgresLockProvider = class PostgresLockProvider extends LockProvider {
 PostgresLockProvider = __decorate([
     Singleton({
         providers: [
-            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresLockModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) },
+            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresLockModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) },
         ],
     })
 ], PostgresLockProvider);

package/mail/README.md

@@ -203,7 +203,7 @@ export class MarketingService {
         subject: 'Weekly Newsletter',
         content: { text: '...' },
       },
-      marketingConfig, // Override config
+      { clientConfig: marketingConfig },
     );
   }
 }

package/mail/drizzle/0001_married_tarantula.sql

@@ -0,0 +1,12 @@
+CREATE OR REPLACE FUNCTION mail.map_errors_to_jsonb(text_array text[])
+RETURNS jsonb AS $$
+  SELECT COALESCE(jsonb_agg(jsonb_build_object('message', err)), '[]'::jsonb)
+  FROM unnest(text_array) AS err;
+$$ LANGUAGE sql IMMUTABLE;
+
+ALTER TABLE "mail"."log"
+  ALTER COLUMN "errors" SET DATA TYPE jsonb
+  USING mail.map_errors_to_jsonb("errors");
+
+ALTER TABLE "mail"."log" ALTER COLUMN "errors" SET NOT NULL;
+DROP FUNCTION mail.map_errors_to_jsonb(text[]);

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

@@ -0,0 +1,69 @@
+{
+  "id": "c74f667f-8acf-42e7-ad58-3aea45df3743",
+  "prevId": "0c48afa4-9ab0-4965-a93e-05a6c1b88e58",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "mail.log": {
+      "name": "log",
+      "schema": "mail",
+      "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
+        },
+        "template": {
+          "name": "template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "data": {
+          "name": "data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "send_result": {
+          "name": "send_result",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "errors": {
+          "name": "errors",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/mail/drizzle/meta/_journal.json

@@ -8,6 +8,13 @@
       "when": 1771240070681,
       "tag": "0000_numerous_the_watchers",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1774305325041,
+      "tag": "0001_married_tarantula",
+      "breakpoints": true
     }
   ]
 }

package/mail/index.d.ts

@@ -8,4 +8,5 @@ export * from './mail.client.js';
 export * from './mail.service.js';
 export * from './models/index.js';
 export * from './module.js';
+export * from './task-definitions.js';
 export * from './tokens.js';

package/mail/index.js

@@ -8,4 +8,5 @@ export * from './mail.client.js';
 export * from './mail.service.js';
 export * from './models/index.js';
 export * from './module.js';
+export * from './task-definitions.js';
 export * from './tokens.js';

package/mail/mail.service.d.ts

@@ -1,10 +1,27 @@
+import type { AfterResolveContext } from '../injector/index.js';
+import { afterResolve } from '../injector/index.js';
+import type { Transaction } from '../orm/server/transaction.js';
 import type { TypedOmit } from '../types/index.js';
 import { MailClientConfig } from './mail.client.js';
 import { type MailData, type MailSendResult, type MailTemplate } from './models/index.js';
+export type MailSendOptions = {
+    clientConfig?: MailClientConfig;
+    /** @internal */
+    templateName?: string;
+};
 export declare class MailService {
     #private;
-    send(mailData: MailData, clientConfig?: MailClientConfig): Promise<MailSendResult>;
-    /** @deprecated internal */
-    send(mailData: MailData, clientConfig?: MailClientConfig, templateName?: string): Promise<MailSendResult>;
-    sendTemplate<Context extends object>(keyOrTemplate: string | MailTemplate<Context>, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: Context, clientConfig?: MailClientConfig): Promise<MailSendResult>;
+    [afterResolve](_: unknown, { cancellationSignal }: AfterResolveContext): void;
+    send(mailData: MailData, options?: MailSendOptions): Promise<MailSendResult>;
+    sendTemplate<Context extends object>(keyOrTemplate: string | MailTemplate<Context>, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: Context, options?: MailSendOptions): Promise<MailSendResult>;
+    enqueue(mailData: MailData, options?: {
+        transaction?: Transaction;
+        priority?: number;
+        delay?: number;
+    }): Promise<void>;
+    enqueueTemplate<Context extends object>(keyOrTemplate: string | MailTemplate<Context>, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: Context, options?: {
+        transaction?: Transaction;
+        priority?: number;
+        delay?: number;
+    }): Promise<void>;
 }

package/mail/mail.service.js

@@ -4,45 +4,62 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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, inject, provide } from '../injector/index.js';
+import { sql } from 'drizzle-orm';
+import { serializeError } from '../errors/index.js';
+import { Singleton, afterResolve, inject, provide } from '../injector/index.js';
 import { Logger } from '../logger/index.js';
+import { buildJsonb } from '../orm/index.js';
 import { DatabaseConfig, injectRepository } from '../orm/server/index.js';
+import { TaskProcessResult, TaskQueue } from '../task-queue/task-queue.js';
 import { TemplateService } from '../templates/template.service.js';
 import { currentTimestamp } from '../utils/date-time.js';
-import { formatError } from '../errors/index.js';
 import { assertDefined } from '../utils/type-guards.js';
 import { MailClient, MailClientConfig } from './mail.client.js';
 import { MailLog } from './models/index.js';
+import { mailLog as mailLogTable } from './models/schemas.js';
 import { MailModuleConfig } from './module.js';
 import { MAIL_DEFAULT_DATA } from './tokens.js';
 let MailService = class MailService {
     #mailClient = inject(MailClient);
     #templateService = inject(TemplateService);
     #mailLogRepository = injectRepository(MailLog);
+    #taskQueue = inject((TaskQueue), 'mail');
     #defaultClientConfig = inject(MailClientConfig, undefined, { optional: true });
     #defaultData = inject(MAIL_DEFAULT_DATA, undefined, { optional: true });
     #logger = inject(Logger, 'MailService');
-    async send(mailData, clientConfigOrTemplateName, templateNameOrNothing) {
-        const clientConfig = (typeof clientConfigOrTemplateName == 'object') ? clientConfigOrTemplateName : this.#defaultClientConfig;
-        const templateName = (typeof clientConfigOrTemplateName == 'object') ? templateNameOrNothing : clientConfigOrTemplateName;
-        assertDefined(clientConfig, 'No mail client config provided.');
+    [afterResolve](_, { cancellationSignal }) {
+        this.#taskQueue.process({ cancellationSignal, types: ['send-email', 'send-template-email'] }, async (context) => {
+            if (context.type == 'send-email') {
+                await this.send(context.data);
+            }
+            else {
+                await this.sendTemplate(context.data.templateKey, context.data.mailData, context.data.templateContext);
+            }
+            return TaskProcessResult.Complete();
+        });
+    }
+    async send(mailData, options) {
+        const config = options?.clientConfig ?? this.#defaultClientConfig;
+        assertDefined(config, 'No mail client config provided.');
         const data = { ...this.#defaultData, ...mailData };
         let mailLog;
         mailLog = await this.#mailLogRepository.insert({
             timestamp: currentTimestamp(),
-            template: templateName ?? null,
+            template: options?.templateName ?? null,
             data,
             sendResult: null,
-            errors: null,
+            errors: [],
         });
         try {
-            const result = await this.#mailClient.send(data, clientConfig);
+            const result = await this.#mailClient.send(data, config);
             await this.#mailLogRepository.update(mailLog.id, { sendResult: result });
             return result;
         }
         catch (error) {
             try {
-                await this.#mailLogRepository.update(mailLog.id, { errors: [formatError(error)] });
+                await this.#mailLogRepository.update(mailLog.id, {
+                    errors: sql `${mailLogTable.errors} || ${buildJsonb([serializeError(error)])}`,
+                });
             }
             catch (logError) {
                 this.#logger.error(logError);
@@ -50,16 +67,30 @@ let MailService = class MailService {
             throw error;
         }
     }
-    async sendTemplate(keyOrTemplate, mailData, templateContext, clientConfig) {
+    async sendTemplate(keyOrTemplate, mailData, templateContext, options) {
         const { name, fields: { subject, html, text } } = await this.#templateService.render(keyOrTemplate, templateContext);
         const fullMailData = { ...mailData, subject, content: { html, text } };
-        return await this.send(fullMailData, clientConfig, name);
+        return await this.send(fullMailData, { ...options, templateName: name });
+    }
+    async enqueue(mailData, options) {
+        const data = { ...this.#defaultData, ...mailData };
+        await this.#taskQueue.enqueue('send-email', data, options);
+    }
+    async enqueueTemplate(keyOrTemplate, mailData, templateContext, options) {
+        if (typeof keyOrTemplate == 'string') {
+            await this.#taskQueue.enqueue('send-template-email', { templateKey: keyOrTemplate, mailData, templateContext }, options);
+        }
+        else {
+            const { fields: { subject, html, text } } = await this.#templateService.render(keyOrTemplate, templateContext);
+            const fullMailData = { ...mailData, subject, content: { html, text } };
+            await this.enqueue(fullMailData, options);
+        }
     }
 };
 MailService = __decorate([
     Singleton({
         providers: [
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(MailModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(MailModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
         ],
     })
 ], MailService);

package/mail/models/mail-log.model.d.ts

@@ -1,3 +1,4 @@
+import type { SerializedError } from '../../errors/format.js';
 import { BaseEntity, type Json, type Timestamp } from '../../orm/index.js';
 import type { MailData } from './mail-data.model.js';
 import type { MailSendResult } from './mail-send-result.model.js';
@@ -6,5 +7,5 @@ export declare class MailLog extends BaseEntity {
     template: string | null;
     data: Json<MailData>;
     sendResult: Json<MailSendResult> | null;
-    errors: string[] | null;
+    errors: Json<SerializedError[]>;
 }

package/mail/models/mail-log.model.js

@@ -33,7 +33,7 @@ __decorate([
     __metadata("design:type", Object)
 ], MailLog.prototype, "sendResult", void 0);
 __decorate([
-    StringProperty({ array: true, nullable: true }),
+    JsonProperty(),
     __metadata("design:type", Object)
 ], MailLog.prototype, "errors", void 0);
 MailLog = __decorate([

package/mail/task-definitions.d.ts

@@ -0,0 +1,20 @@
+import type { TaskDefinitionMap } from '../task-queue/types.js';
+import type { Record, TypedOmit } from '../types/index.js';
+import type { MailData } from './models/index.js';
+export type MailTemplateTaskData = {
+    templateKey: string;
+    mailData: TypedOmit<MailData, 'content' | 'subject'>;
+    templateContext?: Record<string>;
+};
+export type MailTaskDefinitions = TaskDefinitionMap<{
+    'send-email': {
+        data: MailData;
+        state: void;
+        result: void;
+    };
+    'send-template-email': {
+        data: MailTemplateTaskData;
+        state: void;
+        result: void;
+    };
+}>;

package/mail/task-definitions.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.175",
+  "version": "0.93.177",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,8 +152,8 @@
     "type-fest": "^5.5"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.1014",
-    "@aws-sdk/s3-request-presigner": "^3.1014",
+    "@aws-sdk/client-s3": "^3.1015",
+    "@aws-sdk/s3-request-presigner": "^3.1015",
     "@genkit-ai/google-genai": "^1.30",
     "@google-cloud/storage": "^7.19",
     "@toon-format/toon": "^2.1.0",

package/rate-limit/postgres/postgres-rate-limiter.js

@@ -56,7 +56,7 @@ PostgresRateLimiter = __decorate([
     Singleton({
         argumentIdentityProvider: JSON.stringify,
         providers: [
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresRateLimiterModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresRateLimiterModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
         ],
     })
 ], PostgresRateLimiter);