@tstdl/base 0.90.43 → 0.90.46

package/examples/api/basic-overview.js

@@ -38,11 +38,11 @@ const users = [
     { id: 3, name: 'Bob' }
 ];
 const usersApiDefinition = defineApi({
-    resource: 'users',
+    resource: 'users', // /api/:version/users
     endpoints: {
         load: {
-            method: 'GET',
-            resource: ':id',
+            method: 'GET', // GET is default
+            resource: ':id', // => /api/v1/users/:id
             version: 1,
             parameters: object({
                 id: number({ coerce: true })
@@ -54,7 +54,7 @@ const usersApiDefinition = defineApi({
         },
         delete: {
             method: 'DELETE',
-            resource: ':id',
+            resource: ':id', // => /api/v1/users/:id
             parameters: object({
                 id: number({ coerce: true })
             }),

package/examples/api/streaming.js

@@ -26,7 +26,7 @@ import { Agent } from 'undici';
 configureTstdl();
 const logger = getGlobalInjector().resolve(CORE_LOGGER);
 const streamingApiDefinition = defineApi({
-    resource: 'streams',
+    resource: 'streams', // /api/:version/users
     endpoints: {
         echo: {
             method: 'POST',

package/mail/clients/nodemailer.mail-client.d.ts

@@ -1,6 +1,5 @@
 import type { Disposable } from '../../disposable/disposable.js';
-import type { MailClientConfig } from '../mail.client.js';
-import { MailClient } from '../mail.client.js';
+import { MailClient, MailClientConfig } from '../mail.client.js';
 import type { MailData, MailSendResult } from '../models/index.js';
 export declare class NodemailerMailClient extends MailClient implements Disposable {
     #private;

package/mail/clients/nodemailer.mail-client.js

@@ -5,14 +5,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { createTransport } from 'nodemailer';
-import { Singleton, injectArgument } from '../../injector/index.js';
+import { Singleton, inject, injectArgument } from '../../injector/index.js';
 import { Injector } from '../../injector/injector.js';
 import { assertDefined, isUndefined } from '../../utils/type-guards.js';
-import { MailClient } from '../mail.client.js';
+import { MailClient, MailClientConfig } from '../mail.client.js';
 let NodemailerMailClient = class NodemailerMailClient extends MailClient {
     #stack = new DisposableStack();
     #transports = new Map();
-    #defaultClientConfig = injectArgument(this, { optional: true });
+    #defaultClientConfig = injectArgument(this, { optional: true }) ?? inject(MailClientConfig, undefined, { optional: true });
     [Symbol.dispose]() {
         this.#stack.dispose();
     }

package/mail/mail.service.d.ts

@@ -1,12 +1,8 @@
 import type { TypedOmit } from '../types.js';
-import type { MailClientConfig } from './mail.client.js';
+import { MailClientConfig } from './mail.client.js';
 import type { MailData, MailSendResult, MailTemplate } from './models/index.js';
 export declare class MailService {
-    private readonly mailClient;
-    private readonly templateService;
-    private readonly mailLogRepository;
-    private readonly defaultData;
-    private readonly logger;
+    #private;
     send(mailData: MailData, clientConfig?: MailClientConfig): Promise<MailSendResult>;
     /** @deprecated internal */
     send(mailData: MailData, clientConfig?: MailClientConfig, templateName?: string): Promise<MailSendResult>;

package/mail/mail.service.js

@@ -9,22 +9,24 @@ import { Logger } from '../logger/index.js';
 import { TemplateService } from '../templates/template.service.js';
 import { currentTimestamp } from '../utils/date-time.js';
 import { formatError } from '../utils/format-error.js';
-import { isDefined } from '../utils/type-guards.js';
-import { MailClient } from './mail.client.js';
+import { assertDefined, isDefined } from '../utils/type-guards.js';
+import { MailClient, MailClientConfig } from './mail.client.js';
 import { MailLogRepository } from './repositories/mail-log.repository.js';
 import { MAIL_DEFAULT_DATA } from './tokens.js';
 let MailService = class MailService {
-    mailClient = inject(MailClient);
-    templateService = inject(TemplateService);
-    mailLogRepository = inject(MailLogRepository, undefined, { optional: true });
-    defaultData = inject(MAIL_DEFAULT_DATA, undefined, { optional: true });
-    logger = inject(Logger, 'MailService');
+    #mailClient = inject(MailClient);
+    #templateService = inject(TemplateService);
+    #mailLogRepository = inject(MailLogRepository, undefined, { optional: true });
+    #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 : undefined;
+        const clientConfig = (typeof clientConfigOrTemplateName == 'object') ? clientConfigOrTemplateName : this.#defaultClientConfig;
         const templateName = (typeof clientConfigOrTemplateName == 'object') ? templateNameOrNothing : clientConfigOrTemplateName;
-        const data = { ...this.defaultData, ...mailData };
+        assertDefined(clientConfig, 'No mail client config provided.');
+        const data = { ...this.#defaultData, ...mailData };
         let mailLog;
-        if (isDefined(this.mailLogRepository)) {
+        if (isDefined(this.#mailLogRepository)) {
             const log = {
                 timestamp: currentTimestamp(),
                 template: templateName ?? null,
@@ -32,29 +34,29 @@ let MailService = class MailService {
                 sendResult: null,
                 errors: null
             };
-            mailLog = await this.mailLogRepository.insert(log);
+            mailLog = await this.#mailLogRepository.insert(log);
         }
         try {
-            const result = await this.mailClient.send(data, clientConfig);
+            const result = await this.#mailClient.send(data, clientConfig);
             if (isDefined(mailLog)) {
-                await this.mailLogRepository.patch(mailLog, { sendResult: result });
+                await this.#mailLogRepository.patch(mailLog, { sendResult: result });
             }
             return result;
         }
         catch (error) {
             try {
                 if (isDefined(mailLog)) {
-                    await this.mailLogRepository.patch(mailLog, { errors: [formatError(error)] });
+                    await this.#mailLogRepository.patch(mailLog, { errors: [formatError(error)] });
                 }
             }
             catch (logError) {
-                this.logger.error(logError);
+                this.#logger.error(logError);
             }
             throw error;
         }
     }
     async sendTemplate(keyOrTemplate, mailData, templateContext, clientConfig) {
-        const { name, fields: { subject, html, text } } = await this.templateService.render(keyOrTemplate, templateContext);
+        const { name, fields: { subject, html, text } } = await this.#templateService.render(keyOrTemplate, templateContext);
         const fullMailData = { ...mailData, subject, content: { html, text } };
         return this.send(fullMailData, clientConfig, name);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.43",
+  "version": "0.90.46",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -20,7 +20,6 @@
   },
   "exports": {
     "./tsconfig.json": "./tsconfig.json",
-
     ".": "./index.js",
     "./environment": "./environment.js",
     "./interfaces": "./interfaces.js",
@@ -30,7 +29,6 @@
     "./tokens": "./tokens.js",
     "./types": "./types.js",
     "./web-types": "./web-types.js",
-
     "./api": "./api/index.js",
     "./application": "./application/index.js",
     "./authentication": "./authentication/index.js",
@@ -109,8 +107,7 @@
     "disposablestack": "^1.1",
     "luxon": "^3.4",
     "reflect-metadata": "^0.1",
-    "rxjs": "^7.8",
-    "type-fest": "^4.7"
+    "rxjs": "^7.8"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -121,17 +118,18 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "6.11",
-    "@typescript-eslint/parser": "6.11",
+    "@typescript-eslint/eslint-plugin": "6.12",
+    "@typescript-eslint/parser": "6.12",
     "concurrently": "8.2",
     "esbuild": "0.19",
-    "eslint": "8.53",
+    "eslint": "8.54",
     "eslint-import-resolver-typescript": "3.6",
     "eslint-plugin-import": "2.29",
     "tsc-alias": "1.8",
+    "type-fest": "4.7",
     "typedoc": "0.25",
     "typedoc-plugin-missing-exports": "2.1",
-    "typescript": "5.2"
+    "typescript": "5.3"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.10",
@@ -146,9 +144,9 @@
     "koa": "^2.14",
     "minio": "^7.1",
     "mjml": "^4.14",
-    "mongodb": "^6.2",
+    "mongodb": "^6.3",
     "nodemailer": "^6.9",
-    "playwright": "^1.39",
+    "playwright": "^1.40",
     "preact": "^10.19",
     "preact-render-to-string": "^6.3",
     "undici": "^5.27",

package/rxjs/index.d.ts

@@ -4,6 +4,7 @@ export * from './media-query.js';
 export * from './mutation-observer.js';
 export * from './noop.js';
 export * from './performance-observer.js';
+export * from './reject-error.js';
 export * from './resize-observer.js';
 export * from './retry-backoff.js';
 export * from './slow-array.js';

package/rxjs/index.js

@@ -4,6 +4,7 @@ export * from './media-query.js';
 export * from './mutation-observer.js';
 export * from './noop.js';
 export * from './performance-observer.js';
+export * from './reject-error.js';
 export * from './resize-observer.js';
 export * from './retry-backoff.js';
 export * from './slow-array.js';

package/rxjs/reject-error.d.ts

@@ -0,0 +1,2 @@
+import type { MonoTypeOperatorFunction } from 'rxjs';
+export declare function rejectErrors<T>(): MonoTypeOperatorFunction<T>;

package/rxjs/reject-error.js

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+export function rejectErrors() {
+    return function rejectErrors(source) {
+        return new Observable((subscriber) => source.subscribe({
+            next: (value) => subscriber.next(value),
+            complete: () => subscriber.complete()
+        }));
+    };
+}

package/signals/pipe.d.ts

@@ -1,49 +1,30 @@
 import { type OperatorFunction } from 'rxjs';
-import type { Signal, ToSignalOptions } from './api.js';
-export type PipeOptions = Pick<ToSignalOptions, 'rejectErrors'>;
+import type { Signal } from './api.js';
 /**
  * As we need an synchronous value for the resulting signal and effect scheduling is async, it uses the source signals value as the initial value for the pipe.
  * This would normally result in double emission inside the pipe, but is mitigated by using {@link SignalPipeOptions.distinctUntilChanged}. Because of this, mutating source signals are not supported.
  * If you have an mutating signal or require more control for whatever reason, use {@link rawPipe} instead.
  */
 export declare function pipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
-export declare function pipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>, options: PipeOptions): Signal<A>;
 export declare function pipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;
-export declare function pipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, options: PipeOptions): Signal<B>;
 export declare function pipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
-export declare function pipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, options: PipeOptions): Signal<C>;
 export declare function pipe<T, A, B, C, D>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Signal<D>;
-export declare function pipe<T, A, B, C, D>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, options: PipeOptions): Signal<D>;
 export declare function pipe<T, A, B, C, D, E>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Signal<E>;
-export declare function pipe<T, A, B, C, D, E>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, options: PipeOptions): Signal<E>;
 export declare function pipe<T, A, B, C, D, E, F>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Signal<F>;
-export declare function pipe<T, A, B, C, D, E, F>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, options: PipeOptions): Signal<F>;
 export declare function pipe<T, A, B, C, D, E, F, G>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Signal<G>;
-export declare function pipe<T, A, B, C, D, E, F, G>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, options: PipeOptions): Signal<G>;
 export declare function pipe<T, A, B, C, D, E, F, G, H>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Signal<H>;
-export declare function pipe<T, A, B, C, D, E, F, G, H>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, options: PipeOptions): Signal<H>;
 export declare function pipe<T, A, B, C, D, E, F, G, H, I>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Signal<I>;
-export declare function pipe<T, A, B, C, D, E, F, G, H, I>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, options: PipeOptions): Signal<I>;
-export declare function pipe(source: Signal<unknown>, ...operatorsAndOptions: (OperatorFunction<unknown, unknown> | PipeOptions)[]): Signal<unknown>;
+export declare function pipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown>;
 /**
  * As we need an synchronous value for the resulting signal and effect scheduling is async, you have to provide an immediate value on subscription, for example via the `startWith` operator, otherwise an error is thrown.
  */
 export declare function rawPipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
-export declare function rawPipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>, options: PipeOptions): Signal<A>;
 export declare function rawPipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;
-export declare function rawPipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, options: PipeOptions): Signal<B>;
 export declare function rawPipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
-export declare function rawPipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, options: PipeOptions): Signal<C>;
 export declare function rawPipe<T, A, B, C, D>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Signal<D>;
-export declare function rawPipe<T, A, B, C, D>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, options: PipeOptions): Signal<D>;
 export declare function rawPipe<T, A, B, C, D, E>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Signal<E>;
-export declare function rawPipe<T, A, B, C, D, E>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, options: PipeOptions): Signal<E>;
 export declare function rawPipe<T, A, B, C, D, E, F>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Signal<F>;
-export declare function rawPipe<T, A, B, C, D, E, F>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, options: PipeOptions): Signal<F>;
 export declare function rawPipe<T, A, B, C, D, E, F, G>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Signal<G>;
-export declare function rawPipe<T, A, B, C, D, E, F, G>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, options: PipeOptions): Signal<G>;
 export declare function rawPipe<T, A, B, C, D, E, F, G, H>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Signal<H>;
-export declare function rawPipe<T, A, B, C, D, E, F, G, H>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, options: PipeOptions): Signal<H>;
 export declare function rawPipe<T, A, B, C, D, E, F, G, H, I>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Signal<I>;
-export declare function rawPipe<T, A, B, C, D, E, F, G, H, I>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, options: PipeOptions): Signal<I>;
-export declare function rawPipe(source: Signal<unknown>, ...operatorsAndOptions: (OperatorFunction<unknown, unknown> | PipeOptions)[]): Signal<unknown>;
+export declare function rawPipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown>;

package/signals/pipe.js

@@ -1,17 +1,11 @@
-/* eslint-disable @typescript-eslint/unified-signatures */
 import { distinctUntilChanged } from 'rxjs';
 import { startWithProvider } from '../rxjs/start-with-provider.js';
 import { untrack } from '../rxjs/untrack.js';
-import { isNotFunction } from '../utils/type-guards.js';
 import { toObservable, toSignal } from './api.js';
-export function pipe(source, ...operatorsAndOptions) {
-    return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operatorsAndOptions);
+export function pipe(source, ...operators) {
+    return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operators);
 }
-export function rawPipe(source, ...operatorsAndOptions) {
-    const last = operatorsAndOptions.at(-1);
-    const lastIsOptions = isNotFunction(last);
-    const options = lastIsOptions ? last : undefined;
-    const operators = (lastIsOptions ? operatorsAndOptions.slice(0, -1) : operatorsAndOptions);
+export function rawPipe(source, ...operators) {
     const piped = toObservable(source).pipe(...operators, untrack());
-    return toSignal(piped, { ...options, requireSync: true });
+    return toSignal(piped, { requireSync: true });
 }

package/utils/timing.js

@@ -21,7 +21,7 @@ export async function timeoutUntil(timestamp) {
 /** timeout for specified duration */
 export async function cancelableTimeout(milliseconds, cancelSignal) {
     return firstValueFrom(race([
-        timer(milliseconds).pipe(map(() => false)),
+        timer(milliseconds).pipe(map(() => false)), // eslint-disable-line @typescript-eslint/no-unsafe-argument
         cancelSignal.set$.pipe(map(() => true)) // eslint-disable-line @typescript-eslint/no-unsafe-argument
     ]));
 }