@tstdl/base 0.93.5 → 0.93.7

package/api/response.d.ts

@@ -1,5 +1,6 @@
+import type { Logger } from '../logger/logger.js';
+import type { Type, UndefinableJson } from '../types/index.js';
 import { type CustomError, type CustomErrorStatic } from '../errors/index.js';
-import type { UndefinableJson } from '../types/index.js';
 export type ErrorHandlerData = undefined | UndefinableJson;
 export type ErrorSerializer<T extends CustomError, TData extends ErrorHandlerData> = (error: T) => TData;
 export type ErrorDeserializer<T extends CustomError, TData extends ErrorHandlerData> = (data: TData, responseError: ResponseError) => T;
@@ -26,6 +27,10 @@ export declare function hasErrorHandler(typeOrResponseOrName: CustomErrorStatic
 export declare function getErrorStatusCode(error: CustomError, defaultStatusCode?: number): number;
 export declare function createErrorResponse(error: Error, details?: any): ErrorResponse;
 export declare function createErrorResponse(name: string, message: string, details?: any): ErrorResponse;
+export declare function logAndGetErrorResponse(logger: Logger, supressedErrors: Set<Type<Error>>, error: unknown): {
+    statusCode: number;
+    errorResponse: ErrorResponse;
+};
 export declare function parseErrorResponse(response: ErrorResponse, fallbackToGenericApiError?: true): Error;
 export declare function parseErrorResponse(response: ErrorResponse, fallbackToGenericApiError: false): Error | undefined;
 export declare function isErrorResponse(response: Response<any> | unknown): response is ErrorResponse;

package/api/response.js

@@ -1,5 +1,6 @@
 import { SecretRequirementsError } from '../authentication/errors/secret-requirements.error.js';
 import { SchemaError } from '../schema/schema.error.js';
+import { formatError } from '../utils/format-error.js';
 import { ApiError, BadRequestError, ForbiddenError, InvalidCredentialsError, 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';
@@ -60,6 +61,31 @@ export function createErrorResponse(errorOrName, message = '', details) {
     }
     return response;
 }
+export function logAndGetErrorResponse(logger, supressedErrors, error) {
+    if (error instanceof Error) {
+        const errorConstructor = error.constructor;
+        const supressed = supressedErrors.has(errorConstructor);
+        if (!supressed) {
+            logger.error(error);
+        }
+        if (hasErrorHandler(errorConstructor)) {
+            return {
+                statusCode: getErrorStatusCode(error),
+                errorResponse: createErrorResponse(error),
+            };
+        }
+        return {
+            statusCode: 500,
+            errorResponse: createErrorResponse('500', 'Internal Server Error'),
+        };
+    }
+    const formattedError = formatError(error, { includeStack: true, includeRest: 'if-no-extra-info', includeExtraInfo: true });
+    logger.error(formattedError);
+    return {
+        statusCode: 500,
+        errorResponse: createErrorResponse('500', 'Internal Server Error'),
+    };
+}
 export function parseErrorResponse(response, fallbackToGenericApiError = true) {
     const handler = errorHandlers.get(response.error.name);
     if (handler != undefined) {

package/api/server/error-handler.js

@@ -1,26 +1,7 @@
-import { formatError } from '../../utils/format-error.js';
-import { createErrorResponse, getErrorStatusCode, hasErrorHandler } from '../response.js';
+import { logAndGetErrorResponse } from '../response.js';
 export function handleApiError(error, response, supressedErrors, logger) {
-    if (error instanceof Error) {
-        const errorConstructor = error.constructor;
-        const supressed = supressedErrors.has(errorConstructor);
-        if (!supressed) {
-            logger.error(error);
-        }
-        if (hasErrorHandler(errorConstructor)) {
-            response.statusCode = getErrorStatusCode(error);
-            response.body = { json: createErrorResponse(error) };
-        }
-        else {
-            response.statusCode = 500;
-            response.body = { json: createErrorResponse('500', 'Internal Server Error') };
-        }
-    }
-    else {
-        const formattedError = formatError(error, { includeStack: true, includeRest: 'if-no-extra-info', includeExtraInfo: true });
-        logger.error(formattedError);
-        response.statusCode = 500;
-        response.body = { json: createErrorResponse('500', 'Internal Server Error') };
-    }
+    const { statusCode, errorResponse } = logAndGetErrorResponse(logger, supressedErrors, error);
+    response.statusCode = statusCode;
+    response.body = { json: errorResponse };
     return response;
 }

package/api/server/gateway.js

@@ -30,6 +30,7 @@ import { mapObjectValues } from '../../utils/object/object.js';
 import { deferThrow } from '../../utils/throw.js';
 import { isArray, isBlob, isDefined, isNotNull, isNotNullOrUndefined, isNull, isNullOrUndefined, isObject, isReadableStream, isUint8Array, isUndefined } from '../../utils/type-guards.js';
 import { mebibyte } from '../../utils/units.js';
+import { logAndGetErrorResponse } from '../response.js';
 import { normalizedApiDefinitionEndpointsEntries } from '../types.js';
 import { getFullApiEndpointResource } from '../utils.js';
 import { ApiRequestTokenProvider } from './api-request-token.provider.js';
@@ -220,7 +221,13 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
                 .when(isBlob, (value) => ({ stream: value.stream() }))
                 .when((isReadableStream), (stream) => ({ stream }))
                 .when((value) => value instanceof ServerSentEventsSource, (events) => ({ events }))
-                .when(() => (context.endpoint.definition.result == DataStream), (value) => ({ events: DataStreamSource.fromIterable(value).eventSource }))
+                .when(() => (context.endpoint.definition.result == DataStream), (value) => {
+                const errorFormatter = (error) => {
+                    const { errorResponse } = logAndGetErrorResponse(this.#logger, this.#supressedErrors, error);
+                    return errorResponse.error;
+                };
+                return ({ events: DataStreamSource.fromIterable(value, { errorFormatter }).eventSource });
+            })
                 .when(() => (context.endpoint.definition.result == String), (text) => ({ text: text }))
                 .otherwise((json) => ({ json }));
         }

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

@@ -9,6 +9,7 @@ var DocumentManagementService_1;
 import { and, eq } from 'drizzle-orm';
 import { union } from 'drizzle-orm/pg-core';
 import { Enumerable } from '../../../enumerable/index.js';
+import { BadRequestError } from '../../../errors/bad-request.error.js';
 import { inject } from '../../../injector/index.js';
 import { Logger } from '../../../logger/logger.js';
 import { Transactional, injectRepository, injectTransactional } from '../../../orm/server/index.js';
@@ -87,6 +88,9 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         }
     }
     async loadData(tenantId, collectionIds) {
+        if (collectionIds.length == 0) {
+            throw new BadRequestError('At least one collection ID must be provided to load document management data.');
+        }
         return await this.transaction(async (tx) => {
             const [collections, documentCollectionAssignments, requestAssignments, assignmentScopes, { categories, types }] = await Promise.all([
                 this.#documentCollectionService.repository.withTransaction(tx).loadManyByQuery({ tenantId, id: { $in: collectionIds } }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.5",
+  "version": "0.93.7",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/sse/data-stream-source.d.ts

@@ -1,10 +1,13 @@
+import type { UndefinableJson } from '../types/types.js';
 import type { AnyIterable } from '../utils/any-iterable-iterator.js';
 import { ServerSentEventsSource } from './server-sent-events-source.js';
+export type DataStreamErrorFormatter = (error: unknown) => UndefinableJson;
 export type DataStreamSourceOptions = {
     /**
      * Whether to send deltas (the changes) between the last and current data or always the full data.
      */
     delta?: boolean;
+    errorFormatter?: DataStreamErrorFormatter;
 };
 export declare class DataStreamSource<T> {
     #private;

package/sse/data-stream-source.js

@@ -15,11 +15,13 @@ const jsonDiffPatch = createDiffPatch({
 });
 export class DataStreamSource {
     #options;
+    #errorFormatter;
     eventSource = new ServerSentEventsSource();
     closed = this.eventSource.closed;
     #lastData;
     constructor(options = { delta: true }) {
         this.#options = options;
+        this.#errorFormatter = options.errorFormatter ?? defaultErrorFormatter;
     }
     static fromIterable(iterable, options) {
         const source = new DataStreamSource(options);
@@ -60,7 +62,10 @@ export class DataStreamSource {
         await this.eventSource.close();
     }
     async error(error) {
-        await tryIgnoreAsync(async () => await this.eventSource.sendJson({ name: 'error', data: createErrorResponse(error).error }));
+        await tryIgnoreAsync(async () => await this.eventSource.sendJson({ name: 'error', data: this.#errorFormatter(error) }));
         await tryIgnoreAsync(async () => await this.eventSource.close());
     }
 }
+function defaultErrorFormatter(error) {
+    return createErrorResponse(error).error;
+}