@tstdl/base 0.89.8 → 0.90.1

package/api/response.d.ts

@@ -1,4 +1,4 @@
-import type { CustomError, CustomErrorStatic } from '../error/index.js';
+import type { CustomError, CustomErrorStatic } from '../errors/index.js';
 import type { UndefinableJson } from '../types.js';
 export type ErrorHandlerData = undefined | UndefinableJson;
 export type ErrorSerializer<T extends CustomError, TData extends ErrorHandlerData> = (error: T) => TData;
@@ -22,14 +22,10 @@ export type ResponseError = {
     data?: ErrorHandlerData;
 };
 export declare function registerErrorHandler<T extends CustomError, TData extends ErrorHandlerData>(constructor: CustomErrorStatic<T>, statusCode: number, serializer: ErrorSerializer<T, TData>, deserializer: ErrorDeserializer<T, TData>): void;
-export declare function hasErrorHandler(constructor: CustomErrorStatic | ErrorResponse | string): boolean;
+export declare function hasErrorHandler(typeOrResponseOrName: CustomErrorStatic | ErrorResponse | string): boolean;
 export declare function getErrorStatusCode(error: CustomError, defaultStatusCode?: number): number;
-export declare function createResultResponse<T>(result: T): ResultResponse<T>;
 export declare function createErrorResponse(error: Error, details?: any): ErrorResponse;
 export declare function createErrorResponse(name: string, message: string, details?: any): ErrorResponse;
-export declare function parseResponse<T>(response: Response<T>): T;
 export declare function parseErrorResponse(response: ErrorResponse, fallbackToGenericApiError?: true): Error;
 export declare function parseErrorResponse(response: ErrorResponse, fallbackToGenericApiError: false): Error | undefined;
-export declare function isResultResponse<T = any>(response: Response<T> | unknown): response is ResultResponse<T>;
 export declare function isErrorResponse(response: Response<any> | unknown): response is ErrorResponse;
-export declare function isResponse<T = any>(obj: unknown): obj is Response<T>;

package/api/response.js

@@ -1,6 +1,6 @@
 import { SecretRequirementsError } from '../authentication/errors/secret-requirements.error.js';
 import { SchemaError } from '../schema/schema.error.js';
-import { ApiError, BadRequestError, ForbiddenError, InvalidTokenError, MaxBytesExceededError, MethodNotAllowedError, NotFoundError, NotImplementedError, NotSupportedError, UnauthorizedError, UnsupportedMediaTypeError } from '../error/index.js';
+import { ApiError, BadRequestError, ForbiddenError, InvalidTokenError, MaxBytesExceededError, MethodNotAllowedError, NotFoundError, NotImplementedError, NotSupportedError, UnauthorizedError, UnsupportedMediaTypeError } from '../errors/index.js';
 import { assertString, isDefined, isFunction, isObject, isString } from '../utils/type-guards.js';
 import { deserializeSchemaError, serializeSchemaError } from './default-error-handlers.js';
 const errorHandlers = new Map();
@@ -11,25 +11,19 @@ export function registerErrorHandler(constructor, statusCode, serializer, deseri
     }
     errorHandlers.set(constructor.errorName, { statusCode, serializer, deserializer });
 }
-export function hasErrorHandler(constructor) {
-    const name = isFunction(constructor)
-        ? constructor.errorName
-        : isString(constructor)
-            ? constructor
-            : isErrorResponse(constructor)
-                ? constructor.error.name
+export function hasErrorHandler(typeOrResponseOrName) {
+    const name = isFunction(typeOrResponseOrName)
+        ? typeOrResponseOrName.errorName
+        : isString(typeOrResponseOrName)
+            ? typeOrResponseOrName
+            : isErrorResponse(typeOrResponseOrName)
+                ? typeOrResponseOrName.error.name
                 : undefined;
     return errorHandlers.has(name);
 }
 export function getErrorStatusCode(error, defaultStatusCode = 500) {
     return errorHandlers.get(error.name)?.statusCode ?? defaultStatusCode;
 }
-export function createResultResponse(result) {
-    const response = {
-        result
-    };
-    return response;
-}
 export function createErrorResponse(errorOrName, message = '', details) {
     let response;
     if (errorOrName instanceof Error) {
@@ -66,15 +60,6 @@ export function createErrorResponse(errorOrName, message = '', details) {
     }
     return response;
 }
-export function parseResponse(response) {
-    if (isResultResponse(response)) {
-        return response.result;
-    }
-    if (isErrorResponse(response)) {
-        throw parseErrorResponse(response);
-    }
-    throw new Error('Unsupported response.');
-}
 export function parseErrorResponse(response, fallbackToGenericApiError = true) {
     const handler = errorHandlers.get(response.error.name);
     if (handler != undefined) {
@@ -86,16 +71,8 @@ export function parseErrorResponse(response, fallbackToGenericApiError = true) {
     }
     return new ApiError(response);
 }
-export function isResultResponse(response) {
-    const hasResult = isObject(response) && isDefined(response.result);
-    return hasResult;
-}
 export function isErrorResponse(response) {
-    const hasError = isObject(response) && isDefined(response.error);
-    return hasError;
-}
-export function isResponse(obj) {
-    return (isResultResponse(obj) || isErrorResponse(obj));
+    return isObject(response) && isDefined(response.error);
 }
 registerErrorHandler(ApiError, 400, ({ response }) => response, (response) => new ApiError(response));
 registerErrorHandler(BadRequestError, 400, () => undefined, (_, error) => new BadRequestError(error.message));

package/api/server/gateway.js

@@ -11,9 +11,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import 'urlpattern-polyfill'; // eslint-disable-line import/no-unassigned-import
-import { BadRequestError } from '../../error/bad-request.error.js';
-import { NotFoundError } from '../../error/not-found.error.js';
-import { NotImplementedError } from '../../error/not-implemented.error.js';
+import { BadRequestError } from '../../errors/bad-request.error.js';
+import { NotFoundError } from '../../errors/not-found.error.js';
+import { NotImplementedError } from '../../errors/not-implemented.error.js';
 import { HttpServerResponse } from '../../http/server/index.js';
 import { InjectArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';

package/api/server/middlewares/allowed-methods.middleware.js

@@ -1,4 +1,4 @@
-import { MethodNotAllowedError } from '../../../error/method-not-allowed.error.js';
+import { MethodNotAllowedError } from '../../../errors/method-not-allowed.error.js';
 import { HttpServerResponse } from '../../../http/server/index.js';
 import { isUndefined } from '../../../utils/type-guards.js';
 export async function allowedMethodsMiddleware(request, next, context) {

package/authentication/client/authentication.service.js

@@ -13,12 +13,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Subject, filter, firstValueFrom, race, timer } from 'rxjs';
 import { CancellationToken } from '../../cancellation/token.js';
 import { disposeAsync } from '../../disposable/index.js';
-import { BadRequestError } from '../../error/bad-request.error.js';
-import { ForbiddenError } from '../../error/forbidden.error.js';
-import { InvalidTokenError } from '../../error/invalid-token.error.js';
-import { NotFoundError } from '../../error/not-found.error.js';
-import { NotSupportedError } from '../../error/not-supported.error.js';
-import { UnauthorizedError } from '../../error/unauthorized.error.js';
+import { BadRequestError } from '../../errors/bad-request.error.js';
+import { ForbiddenError } from '../../errors/forbidden.error.js';
+import { InvalidTokenError } from '../../errors/invalid-token.error.js';
+import { NotFoundError } from '../../errors/not-found.error.js';
+import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { UnauthorizedError } from '../../errors/unauthorized.error.js';
 import { Inject, Optional, Singleton, afterResolve, inject } from '../../injector/index.js';
 import { Lock } from '../../lock/index.js';
 import { Logger } from '../../logger/index.js';

package/authentication/errors/secret-requirements.error.d.ts

@@ -1,4 +1,4 @@
-import { CustomError } from '../../error/custom.error.js';
+import { CustomError } from '../../errors/custom.error.js';
 export declare class SecretRequirementsError extends CustomError {
     static readonly errorName = "SecretRequirementsError";
     constructor(message?: string);

package/authentication/errors/secret-requirements.error.js

@@ -1,4 +1,4 @@
-import { CustomError } from '../../error/custom.error.js';
+import { CustomError } from '../../errors/custom.error.js';
 export class SecretRequirementsError extends CustomError {
     static errorName = 'SecretRequirementsError';
     constructor(message = 'Secret requirements not met.') {

package/authentication/server/authentication.api-controller.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { apiController } from '../../api/server/index.js';
-import { UnauthorizedError } from '../../error/unauthorized.error.js';
+import { InvalidCredentialsError } from '../../errors/invalid-credentials.error.js';
 import { HttpServerResponse } from '../../http/server/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { authenticationApiDefinition } from '../authentication.api.js';
@@ -23,7 +23,7 @@ let AuthenticationApiController = class AuthenticationApiController {
     async token({ parameters }) {
         const authenticationResult = await this.authenticationService.authenticate(parameters.subject, parameters.secret);
         if (!authenticationResult.success) {
-            throw new UnauthorizedError('Invalid credentials.');
+            throw new InvalidCredentialsError();
         }
         const result = await this.authenticationService.getToken(authenticationResult.subject, parameters.data);
         return this.getTokenResponse(result);

package/authentication/server/authentication.service.js

@@ -10,8 +10,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { InvalidTokenError } from '../../error/invalid-token.error.js';
-import { NotImplementedError } from '../../error/not-implemented.error.js';
+import { InvalidTokenError } from '../../errors/invalid-token.error.js';
+import { NotImplementedError } from '../../errors/not-implemented.error.js';
 import { Inject, Optional, Singleton, afterResolve } from '../../injector/index.js';
 import { Alphabet } from '../../utils/alphabet.js';
 import { deriveBytesMultiple, importPbkdf2Key } from '../../utils/cryptography.js';

package/authentication/server/helper.js

@@ -1,5 +1,5 @@
-import { BadRequestError } from '../../error/bad-request.error.js';
-import { InvalidTokenError } from '../../error/invalid-token.error.js';
+import { BadRequestError } from '../../errors/bad-request.error.js';
+import { InvalidTokenError } from '../../errors/invalid-token.error.js';
 import { currentTimestampSeconds } from '../../utils/date-time.js';
 import { parseAndValidateJwtTokenString } from '../../utils/jwt.js';
 import { isArray, isDefined, isUndefined } from '../../utils/type-guards.js';

package/browser/module.js

@@ -1,5 +1,5 @@
 import { chromium, firefox, webkit } from 'playwright';
-import { NotSupportedError } from '../error/not-supported.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
 import { Injector } from '../injector/injector.js';
 import { copyObjectProperties, filterUndefinedObjectProperties } from '../utils/object/object.js';
 import { isDefined, isUndefined } from '../utils/type-guards.js';

package/cookie/cookie.js

@@ -1,4 +1,4 @@
-import { NotSupportedError } from '../error/not-supported.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
 import { trim } from '../utils/string/trim.js';
 import { isDefined, isNumber, isUndefined } from '../utils/type-guards.js';
 const sameSiteMap = {

package/data-structures/index-out-of-bounds.error.d.ts

@@ -1,4 +1,4 @@
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 export declare class IndexOutOfBoundsError extends CustomError {
     constructor({ index, count, size }: {
         index: number;

package/data-structures/index-out-of-bounds.error.js

@@ -1,4 +1,4 @@
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 import { isDefined } from '../utils/type-guards.js';
 export class IndexOutOfBoundsError extends CustomError {
     constructor({ index, count, size }) {

package/data-structures/sorted-array-list.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 var SortedArrayList_1;
 /* eslint-disable @typescript-eslint/member-ordering */
-import { NotImplementedError } from '../error/not-implemented.error.js';
+import { NotImplementedError } from '../errors/not-implemented.error.js';
 import { Serializable, serializable } from '../serializer/serializable.js';
 import { binarySearch, binarySearchFirst, binarySearchInsertionIndex, binarySearchLast } from '../utils/binary-search.js';
 import { compareByValue } from '../utils/comparison.js';

package/database/mongo/mongo-base.repository.js

@@ -1,4 +1,4 @@
-import { NotFoundError } from '../../error/not-found.error.js';
+import { NotFoundError } from '../../errors/not-found.error.js';
 import { objectKeys } from '../../utils/object/object.js';
 import { assertDefined, isNull, isNullOrUndefined } from '../../utils/type-guards.js';
 import { mongoDocumentFromMaybeNewEntity, toEntity, toMongoDocument, toMongoProjection, toNewEntity, toProjectedEntity } from './model/document.js';

package/disposable/async-disposer.js

@@ -1,6 +1,6 @@
 import { isDefined, isNullOrUndefined } from '../utils/type-guards.js';
 import { CancellationToken } from '../cancellation/token.js';
-import { MultiError } from '../error/multi.error.js';
+import { MultiError } from '../errors/multi.error.js';
 import { dispose, disposeAsync, isAsyncDisposable, isDisposable } from './disposable.js';
 const deferrerToken = Symbol('DeferrerToken');
 export class AsyncDisposer {

package/errors/errors.localization.d.ts

@@ -0,0 +1,43 @@
+import type { Localization, LocalizeItem } from '../text/localization.service.js';
+import type { ApiError } from './api.error.js';
+import type { BadRequestError } from './bad-request.error.js';
+import type { CustomErrorStatic } from './custom.error.js';
+import type { ForbiddenError } from './forbidden.error.js';
+import type { InvalidCredentialsError } from './invalid-credentials.error.js';
+import type { InvalidTokenError } from './invalid-token.error.js';
+import type { MaxBytesExceededError } from './max-bytes-exceeded.error.js';
+import type { MethodNotAllowedError } from './method-not-allowed.error.js';
+import type { NotFoundError } from './not-found.error.js';
+import type { NotImplementedError } from './not-implemented.error.js';
+import type { NotSupportedError } from './not-supported.error.js';
+import type { TimeoutError } from './timeout.error.js';
+import type { UnauthorizedError } from './unauthorized.error.js';
+export type ErrorsLocalizationEntries<T extends CustomErrorStatic[]> = {
+    [I in Extract<keyof T, number> as T[I]['errorName']]: {
+        header: LocalizeItem<InstanceType<T[I]>>;
+        message?: LocalizeItem<InstanceType<T[I]>>;
+    };
+};
+export type ErrorsLocalization<T extends CustomErrorStatic[] = CustomErrorStatic[]> = Localization<{
+    errors: ErrorsLocalizationEntries<T>;
+}>;
+type TstdlErrors = [
+    typeof ApiError,
+    typeof BadRequestError,
+    typeof ForbiddenError,
+    typeof InvalidCredentialsError,
+    typeof InvalidTokenError,
+    typeof MaxBytesExceededError,
+    typeof MethodNotAllowedError,
+    typeof NotFoundError,
+    typeof NotImplementedError,
+    typeof NotSupportedError,
+    typeof TimeoutError,
+    typeof UnauthorizedError
+];
+export declare const errorsLocalizationKeys: import("../text/localization.service.js").ProxyLocalizationKeys<{
+    errors: ErrorsLocalizationEntries<CustomErrorStatic<import("./custom.error.js").CustomError>[]>;
+}>;
+export declare const germanTstdlErrorsLocalization: ErrorsLocalization<TstdlErrors>;
+export declare const englishTstdlErrorsLocalization: ErrorsLocalization<TstdlErrors>;
+export {};

package/errors/errors.localization.js

@@ -0,0 +1,117 @@
+import { getLocalizationKeys } from '../text/localization.service.js';
+export const errorsLocalizationKeys = getLocalizationKeys();
+export const germanTstdlErrorsLocalization = {
+    language: { code: 'de', name: 'Deutsch' },
+    keys: {
+        errors: {
+            ApiError: {
+                header: 'API Fehler',
+                message: getErrorMessage
+            },
+            BadRequestError: {
+                header: 'Ungültige Anfrage',
+                message: getErrorMessage
+            },
+            ForbiddenError: {
+                header: 'Zugriff nicht erlaubt',
+                message: getErrorMessage
+            },
+            InvalidCredentialsError: {
+                header: 'Ungültige Zugangsdaten',
+                message: getErrorMessage
+            },
+            InvalidTokenError: {
+                header: 'Anmeldung abgelaufen oder ungültig',
+                message: getErrorMessage
+            },
+            MaxBytesExceededError: {
+                header: 'Daten größer als erlaubt',
+                message: getErrorMessage
+            },
+            MethodNotAllowedError: {
+                header: 'Anfrage nicht erlaubt',
+                message: getErrorMessage
+            },
+            NotFoundError: {
+                header: 'Nicht gefunden',
+                message: getErrorMessage
+            },
+            NotImplementedError: {
+                header: 'Funktion nicht implementiert',
+                message: getErrorMessage
+            },
+            NotSupportedError: {
+                header: 'Nicht unterstützt',
+                message: getErrorMessage
+            },
+            TimeoutError: {
+                header: 'Zeitüberschreitung',
+                message: getErrorMessage
+            },
+            UnauthorizedError: {
+                header: 'Unautorisiert',
+                message: getErrorMessage
+            }
+        }
+    },
+    enums: []
+};
+export const englishTstdlErrorsLocalization = {
+    language: { code: 'en', name: 'English' },
+    keys: {
+        errors: {
+            ApiError: {
+                header: 'API error',
+                message: getErrorMessage
+            },
+            BadRequestError: {
+                header: 'Bad Request',
+                message: getErrorMessage
+            },
+            ForbiddenError: {
+                header: 'Access forbidden',
+                message: getErrorMessage
+            },
+            InvalidCredentialsError: {
+                header: 'Invalid credentials',
+                message: getErrorMessage
+            },
+            InvalidTokenError: {
+                header: 'Login expired or invalid',
+                message: getErrorMessage
+            },
+            MaxBytesExceededError: {
+                header: 'Data larger than allowed',
+                message: getErrorMessage
+            },
+            MethodNotAllowedError: {
+                header: 'Request not allowed',
+                message: getErrorMessage
+            },
+            NotFoundError: {
+                header: 'Not found',
+                message: getErrorMessage
+            },
+            NotImplementedError: {
+                header: 'Function not implemented',
+                message: getErrorMessage
+            },
+            NotSupportedError: {
+                header: 'Not supported',
+                message: getErrorMessage
+            },
+            TimeoutError: {
+                header: 'Timeout',
+                message: getErrorMessage
+            },
+            UnauthorizedError: {
+                header: 'Unauthorized',
+                message: getErrorMessage
+            }
+        }
+    },
+    enums: []
+};
+function getErrorMessage(error) {
+    return `${error.message}`;
+}

package/{error → errors}/index.d.ts

@@ -8,7 +8,9 @@ export * from './assertion.error.js';
 export * from './bad-request.error.js';
 export * from './custom.error.js';
 export * from './details.error.js';
+export * from './errors.localization.js';
 export * from './forbidden.error.js';
+export * from './invalid-credentials.error.js';
 export * from './invalid-token.error.js';
 export * from './max-bytes-exceeded.error.js';
 export * from './method-not-allowed.error.js';

package/{error → errors}/index.js

@@ -8,7 +8,9 @@ export * from './assertion.error.js';
 export * from './bad-request.error.js';
 export * from './custom.error.js';
 export * from './details.error.js';
+export * from './errors.localization.js';
 export * from './forbidden.error.js';
+export * from './invalid-credentials.error.js';
 export * from './invalid-token.error.js';
 export * from './max-bytes-exceeded.error.js';
 export * from './method-not-allowed.error.js';

package/errors/invalid-credentials.error.d.ts

@@ -0,0 +1,5 @@
+import { CustomError } from './custom.error.js';
+export declare class InvalidCredentialsError extends CustomError {
+    static readonly errorName = "InvalidCredentialsError";
+    constructor(message?: string);
+}

package/errors/invalid-credentials.error.js

@@ -0,0 +1,7 @@
+import { CustomError } from './custom.error.js';
+export class InvalidCredentialsError extends CustomError {
+    static errorName = 'InvalidCredentialsError';
+    constructor(message = 'Invalid credentials.') {
+        super({ message });
+    }
+}

package/http/http-headers.js

@@ -1,4 +1,4 @@
-import { BadRequestError } from '../error/bad-request.error.js';
+import { BadRequestError } from '../errors/bad-request.error.js';
 import { numberPattern } from '../utils/patterns.js';
 import { isNotNumber, isNotString, isNullOrUndefined, isNumber, isString, isUndefined } from '../utils/type-guards.js';
 import { HttpValueMap } from './http-value-map.js';

package/http/http-value-map.js

@@ -1,4 +1,4 @@
-import { BadRequestError } from '../error/bad-request.error.js';
+import { BadRequestError } from '../errors/bad-request.error.js';
 import { toArray } from '../utils/array/array.js';
 import { isIterable } from '../utils/iterable-helpers/is-iterable.js';
 import { objectEntries } from '../utils/object/object.js';

package/http/http.error.d.ts

@@ -1,6 +1,6 @@
 import type { TypedOmit, UndefinableJson } from '../types.js';
 import type { ErrorExtraInfo } from '../utils/format-error.js';
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 import type { HttpClientRequest, HttpClientRequestObject, HttpClientResponse, HttpClientResponseObject } from './client/index.js';
 export declare enum HttpErrorReason {
     Unknown = "Unknown",

package/http/http.error.js

@@ -1,6 +1,6 @@
 import { propertyNameOf } from '../utils/object/property-name.js';
 import { isDefined, isNotString, isString } from '../utils/type-guards.js';
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 export var HttpErrorReason;
 (function (HttpErrorReason) {
     HttpErrorReason["Unknown"] = "Unknown";

package/http/utils.js

@@ -1,6 +1,6 @@
-import { MaxBytesExceededError } from '../error/max-bytes-exceeded.error.js';
-import { NotSupportedError } from '../error/not-supported.error.js';
-import { UnsupportedMediaTypeError } from '../error/unsupported-media-type.error.js';
+import { MaxBytesExceededError } from '../errors/max-bytes-exceeded.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
+import { UnsupportedMediaTypeError } from '../errors/unsupported-media-type.error.js';
 import { isAnyIterable } from '../utils/any-iterable-iterator.js';
 import { decompress, decompressStream } from '../utils/compression.js';
 import { decodeText, decodeTextStream } from '../utils/encoding.js';

package/injector/resolve.error.d.ts

@@ -1,4 +1,4 @@
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 import type { ResolveChain } from './resolve-chain.js';
 export declare class ResolveError extends CustomError {
     constructor(message: string, chain: ResolveChain, cause?: Error);

package/injector/resolve.error.js

@@ -1,4 +1,4 @@
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 import { isDefined } from '../utils/type-guards.js';
 export class ResolveError extends CustomError {
     constructor(message, chain, cause) {

package/openid-connect/oidc.service.js

@@ -10,8 +10,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { ForbiddenError } from '../error/forbidden.error.js';
-import { NotImplementedError } from '../error/not-implemented.error.js';
+import { ForbiddenError } from '../errors/forbidden.error.js';
+import { NotImplementedError } from '../errors/not-implemented.error.js';
 import { HttpClient } from '../http/client/index.js';
 import { HttpHeaders } from '../http/http-headers.js';
 import { Inject, Optional, Singleton } from '../injector/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.89.8",
+  "version": "0.90.1",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -44,7 +44,7 @@
     "./disposable": "./disposable/index.js",
     "./distributed-loop": "./distributed-loop/index.js",
     "./enumerable": "./enumerable/index.js",
-    "./error": "./error/index.js",
+    "./errors": "./errors/index.js",
     "./function": "./function/index.js",
     "./http": "./http/index.js",
     "./http/undici": "./http/client/adapters/undici.adapter.js",
@@ -134,14 +134,13 @@
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.10",
     "@koa/router": "^12.0",
-    "@tstdl/angular": "^0.89",
+    "@tstdl/angular": "^0.90",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.4",
     "handlebars": "^4.7",
-    "knex": "^2.5",
     "koa": "^2.14",
     "minio": "^7.1",
     "mjml": "^4.14",

package/reflection/decorator-data.js

@@ -1,4 +1,4 @@
-import { DetailsError } from '../error/details.error.js';
+import { DetailsError } from '../errors/details.error.js';
 import { isDefined, isFunction, isNumber, isObject, isUndefined } from '../utils/type-guards.js';
 import { getConstructor } from './utils.js';
 // eslint-disable-next-line max-lines-per-function

package/rpc/rpc-error.d.ts

@@ -1,4 +1,4 @@
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 export declare class RpcError extends CustomError {
     static readonly errorName = "RpcError";
     constructor(message: string, cause?: any);

package/rpc/rpc-error.js

@@ -1,4 +1,4 @@
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 import { formatError } from '../utils/format-error.js';
 import { isDefined, isObject } from '../utils/type-guards.js';
 export class RpcError extends CustomError {

package/rpc/rpc.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { NotImplementedError } from '../error/not-implemented.error.js';
+import { NotImplementedError } from '../errors/not-implemented.error.js';
 import { deserialize, registerSerializer, serialize } from '../serializer/index.js';
 import { hasOwnProperty } from '../utils/object/object.js';
 import { reflectMethods } from '../utils/proxy.js';

package/schema/schema.error.d.ts

@@ -1,5 +1,5 @@
-import type { CustomErrorOptions } from '../error/custom.error.js';
-import { CustomError } from '../error/custom.error.js';
+import type { CustomErrorOptions } from '../errors/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 import type { JsonPath } from '../json-path/index.js';
 import type { OneOrMany, TypedOmit, UndefinableJson } from '../types.js';
 import type { ErrorExtraInfo } from '../utils/format-error.js';

package/schema/schema.error.js

@@ -1,4 +1,4 @@
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 import { toArray } from '../utils/array/array.js';
 import { isArray, isDefined, isNotNullOrUndefined, isString } from '../utils/type-guards.js';
 import { getExpectString } from './schema.js';

package/search-index/elastic/search-index.js

@@ -1,5 +1,5 @@
-import { BadRequestError } from '../../error/bad-request.error.js';
-import { MultiError } from '../../error/multi.error.js';
+import { BadRequestError } from '../../errors/bad-request.error.js';
+import { MultiError } from '../../errors/multi.error.js';
 import { afterResolve } from '../../injector/interfaces.js';
 import { SearchIndex, SearchIndexError } from '../../search-index/index.js';
 import { decodeBase64, encodeBase64 } from '../../utils/base64.js';

package/search-index/error.d.ts

@@ -1,4 +1,4 @@
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 export declare class SearchIndexError extends CustomError {
     static readonly errorName = "SearchIndexError";
     readonly type: string;

package/search-index/error.js

@@ -1,4 +1,4 @@
-import { CustomError } from '../error/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
 import { isDefined } from '../utils/type-guards.js';
 export class SearchIndexError extends CustomError {
     static errorName = 'SearchIndexError';

package/sse/server-sent-events.js

@@ -1,4 +1,4 @@
-import { NotSupportedError } from '../error/not-supported.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
 import { distinctUntilChanged, filter, fromEvent, map, merge, ReplaySubject, share, shareReplay, startWith, takeUntil } from 'rxjs';
 export var ServerSentEventsState;
 (function (ServerSentEventsState) {

package/templates/providers/file.template-provider.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import * as path from 'node:path';
-import { BadRequestError } from '../../error/bad-request.error.js';
+import { BadRequestError } from '../../errors/bad-request.error.js';
 import { InjectArg, Singleton } from '../../injector/decorators.js';
 import { resolveArgumentType } from '../../injector/interfaces.js';
 import { Schema } from '../../schema/index.js';

package/templates/resolvers/file.template-resolver.js

@@ -12,7 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { BadRequestError } from '../../error/bad-request.error.js';
+import { BadRequestError } from '../../errors/bad-request.error.js';
 import { InjectArg, Singleton } from '../../injector/decorators.js';
 import { resolveArgumentType } from '../../injector/interfaces.js';
 import { Property } from '../../schema/index.js';

package/text/localization.service.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { DetailsError } from '../error/details.error.js';
+import { DetailsError } from '../errors/details.error.js';
 import { ResolveArg, Singleton } from '../injector/decorators.js';
 import { Logger } from '../logger/index.js';
 import { computed, signal, toObservable } from '../signals/api.js';

package/utils/async-iterable-helpers/parallel/for-each.js

@@ -1,5 +1,5 @@
 import { ObservableSet } from '../../../collections/observable/observable-set.js';
-import { MultiError } from '../../../error/multi.error.js';
+import { MultiError } from '../../../errors/multi.error.js';
 export async function parallelForEach(iterable, concurrency, func) {
     const running = new ObservableSet();
     const errors = [];

package/utils/compression.js

@@ -1,4 +1,4 @@
-import { NotSupportedError } from '../error/not-supported.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
 import { dynamicImport } from '../import.js';
 import { supportsReadableStream } from '../supports.js';
 import { isAsyncIterable } from './async-iterable-helpers/is-async-iterable.js';

package/utils/date-time.js

@@ -1,4 +1,4 @@
-import { NotSupportedError } from '../error/not-supported.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
 import { DateTime } from 'luxon';
 import { isDate, isNumber } from './type-guards.js';
 import { typeOf } from './type-of.js';

package/utils/encoding.js

@@ -1,4 +1,4 @@
-import { AssertionError } from '../error/assertion.error.js';
+import { AssertionError } from '../errors/assertion.error.js';
 import { createArray } from './array/array.js';
 import { toUint8Array } from './binary.js';
 import { isUndefined } from './type-guards.js';

package/utils/file-reader.js

@@ -1,4 +1,4 @@
-import { DetailsError } from '../error/details.error.js';
+import { DetailsError } from '../errors/details.error.js';
 export async function readAsText(blob, encoding) {
     return setup((reader) => reader.readAsText(blob, encoding));
 }

package/utils/helpers.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import { supportsNotification } from '../supports.js';
-import { DetailsError } from '../error/details.error.js';
+import { DetailsError } from '../errors/details.error.js';
 import { decycle } from './object/decycle.js';
 import { isDefined } from './type-guards.js';
 /**

package/utils/image.js

@@ -1,4 +1,4 @@
-import { AssertionError } from '../error/assertion.error.js';
+import { AssertionError } from '../errors/assertion.error.js';
 import { firstValueFrom, fromEvent, map, race, switchMap, throwError } from 'rxjs';
 import { FactoryMap } from './factory-map.js';
 import { assertNotNullPass, isFunction, isNull } from './type-guards.js';

package/utils/jwt.js

@@ -1,4 +1,4 @@
-import { InvalidTokenError } from '../error/invalid-token.error.js';
+import { InvalidTokenError } from '../errors/invalid-token.error.js';
 import { toArray } from './array/array.js';
 import { decodeBase64Url, encodeBase64Url } from './base64.js';
 import { importHmacKey, sign } from './cryptography.js';

package/utils/math.js

@@ -1,4 +1,4 @@
-import { NotSupportedError } from '../error/not-supported.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
 import { defaultRandomNumberGeneratorFn } from '../random/number-generator/random-number-generator-function.js';
 /**
  * Generate a random float in interval [min, max).

package/utils/stream/size-limited-stream.js

@@ -1,4 +1,4 @@
-import { MaxBytesExceededError } from '../../error/max-bytes-exceeded.error.js';
+import { MaxBytesExceededError } from '../../errors/max-bytes-exceeded.error.js';
 export function sizeLimitTransform(maxBytes, writableStrategy, readableStrategy) {
     let totalLength = 0;
     return new TransformStream({

package/utils/stream/stream-reader.js

@@ -1,4 +1,4 @@
-import { BadRequestError } from '../../error/bad-request.error.js';
+import { BadRequestError } from '../../errors/bad-request.error.js';
 import { isAnyIterable } from '../any-iterable-iterator.js';
 import { concatArrayBufferViews } from '../binary.js';
 import { isDefined } from '../type-guards.js';

package/utils/timing.js

@@ -1,5 +1,5 @@
 import { firstValueFrom, map, race, timer } from 'rxjs';
-import { TimeoutError } from '../error/timeout.error.js';
+import { TimeoutError } from '../errors/timeout.error.js';
 import { _throw } from './throw.js';
 import { resolveValueOrProvider } from './value-or-provider.js';
 /** timeout for specified duration */

package/utils/type-guards.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/restrict-template-expressions, max-statements-per-line, no-eq-null */
 import { supportsBlob, supportsReadableStream } from '../supports.js';
-import { AssertionError } from '../error/assertion.error.js';
+import { AssertionError } from '../errors/assertion.error.js';
 export function assert(condition, message = 'assertion failed') {
     if (!condition) {
         throw new AssertionError((typeof message == 'function') ? message() : message);