@tstdl/base 0.93.137 → 0.93.138

package/api/client/client.js

@@ -13,7 +13,7 @@ import { toTitleCase } from '../../utils/string/title-case.js';
 import { isArray, isBlob, isDefined, isObject, isReadableStream, isString, isUint8Array, isUndefined } from '../../utils/type-guards.js';
 import { buildUrl } from '../../utils/url-builder.js';
 import { resolveValueOrProvider } from '../../utils/value-or-provider.js';
-import { normalizedApiDefinitionEndpointsEntries } from '../types.js';
+import { normalizedApiDefinition } from '../types.js';
 import { getFullApiEndpointResource } from '../utils.js';
 export const httpClientSymbol = Symbol('HttpClient for ApiClient');
 export const apiDefinitionSymbol = Symbol('ApiDefinition');
@@ -22,7 +22,8 @@ export function setDefaultApiClientOptions(options) {
     copyObjectProperties(options, defaultOptions);
 }
 export function compileClient(definition, options = defaultOptions) {
-    const { resource: path, endpoints } = definition;
+    const normalizedDefinition = normalizedApiDefinition(definition);
+    const { resource: path } = normalizedDefinition;
     const constructedApiName = toTitleCase(path[0] ?? '');
     const apiName = `${constructedApiName}ApiClient`;
     const api = {
@@ -31,10 +32,10 @@ export function compileClient(definition, options = defaultOptions) {
             [apiDefinitionSymbol];
             constructor(httpClientOrOptions) {
                 this[httpClientSymbol] = (httpClientOrOptions instanceof HttpClient) ? httpClientOrOptions : inject(HttpClient, httpClientOrOptions);
-                this[apiDefinitionSymbol] = definition;
+                this[apiDefinitionSymbol] = normalizedDefinition;
             }
             static getEndpointResource(endpoint, parameters) {
-                const resource = getFullApiEndpointResource({ api: definition, endpoint: resolveValueOrProvider(definition.endpoints[endpoint]), defaultPrefix: options.prefix });
+                const resource = getFullApiEndpointResource({ api: normalizedDefinition, endpoint: resolveValueOrProvider(normalizedDefinition.endpoints[endpoint]), defaultPrefix: options.prefix });
                 if (isUndefined(parameters)) {
                     return resource;
                 }
@@ -59,8 +60,7 @@ export function compileClient(definition, options = defaultOptions) {
             return new api(httpClient);
         },
     });
-    const endpointsEntries = normalizedApiDefinitionEndpointsEntries(endpoints);
-    for (const [name, endpoint] of endpointsEntries) {
+    for (const [name, endpoint] of objectEntries(normalizedDefinition.endpoints)) {
         const methods = isArray(endpoint.method) ? endpoint.method : [endpoint.method ?? 'GET'];
         let resource;
         const hasGet = methods.includes('GET');
@@ -84,7 +84,7 @@ export function compileClient(definition, options = defaultOptions) {
                 else {
                     requestOptions = args[0];
                 }
-                resource ??= getFullApiEndpointResource({ api: definition, endpoint, defaultPrefix: options.prefix });
+                resource ??= getFullApiEndpointResource({ api: normalizedDefinition, endpoint, defaultPrefix: options.prefix });
                 const context = { endpoint };
                 const method = (hasGet && isUndefined(parameters)) ? 'GET' : fallbackMethod;
                 if (endpoint.result == ServerSentEvents) {
@@ -99,7 +99,7 @@ export function compileClient(definition, options = defaultOptions) {
                     }
                     return getDataStream(this[httpClientSymbol].options.baseUrl, resource, endpoint, parameters, requestOptions);
                 }
-                if (context.endpoint.data?.[bustCache] == true || requestOptions?.bustCache == true) {
+                if ((endpoint.bustCache == true) || (requestOptions?.bustCache == true)) {
                     context[bustCache] = true;
                 }
                 const request = new HttpClientRequest({

package/api/client/tests/api-client.test.js

@@ -143,7 +143,7 @@ describe('ApiClient', () => {
             resource: 'features',
             endpoints: {
                 withCredentials: { method: 'GET', credentials: true },
-                withBustCache: { method: 'GET', data: { [bustCache]: true } },
+                withBustCache: { method: 'GET', bustCache: true },
             },
         });
         const mockHttpClient = Object.assign(Object.create(HttpClient.prototype), {

package/api/server/gateway.d.ts

@@ -4,7 +4,7 @@ import { HttpServerResponse, type HttpServerRequest } from '../../http/server/in
 import { resolveArgumentType, type Resolvable } from '../../injector/index.js';
 import type { Type } from '../../types/index.js';
 import { type AsyncMiddleware, type AsyncMiddlewareNext } from '../../utils/middleware.js';
-import { type ApiController, type ApiDefinition, type ApiEndpointDefinition, type ApiEndpointMethod, type ApiEndpointServerImplementation } from '../types.js';
+import { type ApiController, type ApiDefinition, type ApiEndpointMethod, type ApiEndpointServerImplementation, type NormalizedApiEndpoints } from '../types.js';
 import type { CorsMiddlewareOptions } from './middlewares/cors.middleware.js';
 import { type CsrfMiddlewareOptions } from './middlewares/index.js';
 export type ApiGatewayMiddlewareContext = {
@@ -39,7 +39,7 @@ export declare abstract class ApiGatewayOptions {
     defaultMaxBytes?: number;
 }
 export type GatewayEndpoint = {
-    definition: ApiEndpointDefinition;
+    definition: NormalizedApiEndpoints[string];
     implementation: ApiEndpointServerImplementation;
 };
 export type ApiItem = {

package/api/server/gateway.js

@@ -31,11 +31,11 @@ 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 { normalizedApiDefinition, normalizedApiDefinitionEndpointsEntries } from '../types.js';
 import { getFullApiEndpointResource } from '../utils.js';
 import { ApiRequestTokenProvider } from './api-request-token.provider.js';
 import { handleApiError } from './error-handler.js';
-import { allowedMethodsMiddleware, contentTypeMiddleware, corsMiddleware, csrfMiddleware, getCatchErrorMiddleware, responseTimeMiddleware } from './middlewares/index.js';
+import { allowedMethodsMiddleware, contentTypeMiddleware, corsMiddleware, csrfMiddleware, getCatchErrorMiddleware, responseTimeMiddleware, serverSentEventsMiddleware } from './middlewares/index.js';
 import { API_MODULE_OPTIONS } from './tokens.js';
 const defaultMaxBytes = 10 * mebibyte;
 export class ApiGatewayOptions {
@@ -87,10 +87,11 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
         }
     }
     registerApi(definition, implementation) {
-        for (const [name, endpointDefinition] of normalizedApiDefinitionEndpointsEntries(definition.endpoints)) {
+        const normalizedDefinition = normalizedApiDefinition(definition);
+        for (const [name, endpointDefinition] of normalizedApiDefinitionEndpointsEntries(normalizedDefinition.endpoints)) {
             const versionArray = isUndefined(endpointDefinition.version) ? [1] : toArray(endpointDefinition.version);
             for (const version of versionArray) {
-                const resource = getFullApiEndpointResource({ api: definition, endpoint: endpointDefinition, defaultPrefix: this.#prefix, explicitVersion: version });
+                const resource = getFullApiEndpointResource({ api: normalizedDefinition, endpoint: endpointDefinition, defaultPrefix: this.#prefix, explicitVersion: version });
                 const methods = isArray(endpointDefinition.method) ? endpointDefinition.method : [endpointDefinition.method ?? 'GET'];
                 if (methods.length == 0) {
                     throw new Error(`No method provided for resource ${resource}.`);
@@ -169,10 +170,11 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
             contentTypeMiddleware,
             this.#catchErrorMiddleware,
             corsMiddleware(this.#options.cors),
+            serverSentEventsMiddleware,
             csrfMiddleware(this.#options.csrf),
             allowedMethodsMiddleware,
             ...this.#middlewares,
-            async (context, next) => await this.endpointMiddleware(context, next)
+            async (context, next) => await this.endpointMiddleware(context, next),
         ];
         this.#composedMiddleware = composeAsyncMiddleware(middlewares);
     }

package/api/server/middlewares/content-type.middleware.js

@@ -1,4 +1,3 @@
-import { match, P } from 'ts-pattern';
 import { isDefined } from '../../../utils/type-guards.js';
 export async function contentTypeMiddleware(context, next) {
     await next();
@@ -6,11 +5,26 @@ export async function contentTypeMiddleware(context, next) {
     if (isDefined(response.headers.contentType)) {
         return;
     }
-    response.headers.contentType = match(response.body)
-        .with({ json: P.select(P.when(isDefined)) }, () => 'application/json; charset=utf-8')
-        .with({ text: P.select(P.nonNullable) }, () => 'text/plain; charset=utf-8')
-        .with({ buffer: P.select(P.nonNullable) }, () => 'application/octet-stream')
-        .with({ stream: P.select(P.nonNullable) }, () => 'application/octet-stream')
-        .with({ events: P.select(P.nonNullable) }, () => 'text/event-stream')
-        .otherwise(() => undefined);
+    const contentType = matchBodyType(response.bodyType);
+    if (isDefined(contentType)) {
+        response.headers.contentType = contentType;
+        if (response.bodyType == 'events') {
+            response.headers.setIfMissing('Cache-Control', 'no-cache');
+            response.headers.setIfMissing('Connection', 'keep-alive');
+        }
+    }
+}
+function matchBodyType(bodyType) {
+    switch (bodyType) {
+        case 'json':
+            return 'application/json; charset=utf-8';
+        case 'text':
+            return 'text/plain; charset=utf-8';
+        case 'buffer':
+        case 'stream':
+            return 'application/octet-stream';
+        case 'events':
+            return 'text/event-stream';
+    }
+    throw new Error(`Unsupported body type: ${bodyType}`);
 }

package/api/server/middlewares/index.d.ts

@@ -4,3 +4,4 @@ export * from './content-type.middleware.js';
 export * from './cors.middleware.js';
 export * from './csrf.middleware.js';
 export * from './response-time.middleware.js';
+export * from './server-sent-events.middleware.js';

package/api/server/middlewares/index.js

@@ -4,3 +4,4 @@ export * from './content-type.middleware.js';
 export * from './cors.middleware.js';
 export * from './csrf.middleware.js';
 export * from './response-time.middleware.js';
+export * from './server-sent-events.middleware.js';

package/api/server/middlewares/server-sent-events.middleware.d.ts

@@ -0,0 +1,7 @@
+import type { ApiGatewayMiddlewareContext, ApiGatewayMiddlewareNext } from '../gateway.js';
+/**
+ * Middleware that adds required CORS headers for SSE and cache busting.
+ * @param context Gateway context.
+ * @param next Next middleware.
+ */
+export declare function serverSentEventsMiddleware(context: ApiGatewayMiddlewareContext, next: ApiGatewayMiddlewareNext): Promise<void>;

package/api/server/middlewares/server-sent-events.middleware.js

@@ -0,0 +1,18 @@
+import { toArray } from '../../../utils/array/array.js';
+/**
+ * Middleware that adds required CORS headers for SSE and cache busting.
+ * @param context Gateway context.
+ * @param next Next middleware.
+ */
+export async function serverSentEventsMiddleware(context, next) {
+    await next();
+    if ((context.response.bodyType != 'events') || (context.request.method != 'OPTIONS')) {
+        return;
+    }
+    const existing = context.response.headers.tryGet('Access-Control-Allow-Headers');
+    const items = toArray(existing).flatMap((header) => header?.split(',') ?? []).map((header) => header.trim()).filter((header) => header.length > 0);
+    const headers = new Set(items);
+    headers.add('Cache-Control');
+    headers.add('Last-Event-ID');
+    context.response.headers.set('Access-Control-Allow-Headers', [...headers].join(', '));
+}

package/api/types.d.ts

@@ -5,9 +5,9 @@ import type { HttpHeaders, HttpHeadersObject, HttpRequestAuthorization } from '.
 import type { HttpServerRequest, HttpServerResponse } from '../http/server/index.js';
 import type { HttpMethod } from '../http/types.js';
 import type { SchemaOutput, SchemaTestable } from '../schema/index.js';
-import type { DataStream, DataStreamSource, DataStreamSourceOptions } from '../sse/index.js';
+import { DataStream, type DataStreamSource, type DataStreamSourceOptions } from '../sse/index.js';
 import type { ServerSentEventsSource } from '../sse/server-sent-events-source.js';
-import type { ServerSentEvents } from '../sse/server-sent-events.js';
+import { ServerSentEvents } from '../sse/server-sent-events.js';
 import type { NonUndefinable, OneOrMany, Record, ReturnTypeOrT } from '../types/index.js';
 import { type ValueOrProvider } from '../utils/value-or-provider.js';
 import type { ApiGatewayMiddlewareContext } from './server/index.js';
@@ -68,6 +68,13 @@ export type ApiEndpointDefinition = {
     description?: string;
     data?: Record;
     dataStream?: DataStreamSourceOptions<any>;
+    /**
+     * If true, it requests cache-busting (implementation dependent on adapter).
+     * Useful for example for Angular service workers.
+     *
+     * @default false
+     */
+    bustCache?: boolean;
     /**
      * If true, sets browsers fetch to { credentials: 'include' } and enables 'Access-Control-Allow-Credentials' header.
      *
@@ -88,11 +95,15 @@ export type ApiDefinition<Resource extends string = string, Endpoints extends Ap
     prefix?: string | null;
     endpoints: Endpoints;
 };
+export type NormalizedApiDefinition<T extends ApiDefinition = ApiDefinition> = Omit<T, 'endpoints'> & {
+    endpoints: NormalizedApiEndpoints<T>;
+};
 export type ApiEndpointKeys<T extends ApiDefinition> = Extract<keyof T['endpoints'], string>;
-export type NormalizedApiEndpoints<T extends ApiDefinition['endpoints']> = {
-    [P in keyof T]: ReturnTypeOrT<T[P]>;
+export type NormalizedApiEndpoints<T extends ApiDefinition = ApiDefinition> = {
+    [P in keyof T['endpoints']]: ReturnTypeOrT<T['endpoints'][P]>;
 };
-export type ApiEndpoint<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NormalizedApiEndpoints<T['endpoints']>[K];
+export type NormalizedApiEndpoint<T extends ApiDefinition = ApiDefinition> = NormalizedApiEndpoints<T>[keyof NormalizedApiEndpoints<T>];
+export type ApiEndpoint<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NormalizedApiEndpoints<T>[K];
 export type ApiEndpointParametersSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['parameters']>;
 export type ApiEndpointBodySchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['body']>;
 export type ApiEndpointResultSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['result']>;
@@ -162,5 +173,6 @@ export type ApiClientImplementation<T extends ApiDefinition = any> = {
 };
 export declare function defineApi<T extends ApiDefinition>(definition: T): T;
 export declare function resolveApiEndpointDataProvider<T>(request: HttpServerRequest, context: ApiGatewayMiddlewareContext, provider: ApiEndpointDataProvider<T>): Promise<T>;
-export declare function normalizedApiDefinitionEndpoints<T extends ApiDefinition['endpoints']>(apiDefinitionEndpoints: T): NormalizedApiEndpoints<T>;
+export declare function normalizedApiDefinition<T extends ApiDefinition>(apiDefinition: T): NormalizedApiDefinition<T>;
+export declare function normalizedApiDefinitionEndpoints<T extends ApiDefinition>(apiDefinitionEndpoints: T['endpoints']): NormalizedApiEndpoints<T>;
 export declare function normalizedApiDefinitionEndpointsEntries<T extends ApiDefinition['endpoints']>(apiDefinition: T): [keyof T, ApiEndpointDefinition][];

package/api/types.js

@@ -1,4 +1,6 @@
-import { objectEntries } from '../utils/object/object.js';
+import { DataStream } from '../sse/index.js';
+import { ServerSentEvents } from '../sse/server-sent-events.js';
+import { fromEntries, objectEntries } from '../utils/object/object.js';
 import { isFunction } from '../utils/type-guards.js';
 import { resolveValueOrProvider } from '../utils/value-or-provider.js';
 export function defineApi(definition) {
@@ -10,10 +12,22 @@ export async function resolveApiEndpointDataProvider(request, context, provider)
     }
     return provider;
 }
+export function normalizedApiDefinition(apiDefinition) {
+    return {
+        ...apiDefinition,
+        endpoints: normalizedApiDefinitionEndpoints(apiDefinition.endpoints),
+    };
+}
 export function normalizedApiDefinitionEndpoints(apiDefinitionEndpoints) {
     const entries = normalizedApiDefinitionEndpointsEntries(apiDefinitionEndpoints);
-    return Object.fromEntries(entries);
+    return fromEntries(entries);
 }
 export function normalizedApiDefinitionEndpointsEntries(apiDefinition) {
-    return objectEntries(apiDefinition).map(([key, def]) => [key, resolveValueOrProvider(def)]);
+    return objectEntries(apiDefinition).map(([key, def]) => {
+        const endpoint = { ...resolveValueOrProvider(def) };
+        if ((endpoint.result == DataStream) || (endpoint.result == ServerSentEvents)) {
+            endpoint.bustCache ??= true;
+        }
+        return [key, endpoint];
+    });
 }

package/authentication/client/authentication.service.d.ts

@@ -27,6 +27,7 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
     private readonly logger;
     private readonly disposeSignal;
     private clockOffset;
+    private initialized;
     private refreshLoopPromise;
     /**
      * Observable for authentication errors.

package/authentication/client/authentication.service.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Subject, filter, firstValueFrom, map, race, skip, timer } from 'rxjs';
+import { Subject, filter, firstValueFrom, map, race, skip, takeUntil, timer } from 'rxjs';
 import { CancellationSignal, CancellationToken } from '../../cancellation/token.js';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { ForbiddenError } from '../../errors/forbidden.error.js';
@@ -71,6 +71,7 @@ let AuthenticationClientService = class AuthenticationClientService {
     logger = inject(Logger, 'AuthenticationService');
     disposeSignal = inject(CancellationSignal).createChild();
     clockOffset = 0;
+    initialized = false;
     refreshLoopPromise;
     /**
      * Observable for authentication errors.
@@ -175,9 +176,15 @@ let AuthenticationClientService = class AuthenticationClientService {
      * @internal
      */
     initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
         this.loadToken();
-        this.tokenUpdateBus.messages$.subscribe((token) => this.token.set(token));
-        this.refreshLoopPromise = this.refreshLoop();
+        this.tokenUpdateBus.messages$
+            .pipe(takeUntil(this.disposeSignal))
+            .subscribe((token) => this.token.set(token));
+        this.refreshLoopPromise ??= this.refreshLoop();
     }
     /** @internal */
     async [Symbol.asyncDispose]() {
@@ -188,6 +195,9 @@ let AuthenticationClientService = class AuthenticationClientService {
      * Stops refresh loop and completes subjects.
      */
     async dispose() {
+        if (!this.initialized) {
+            return;
+        }
         this.disposeSignal.set();
         await this.refreshLoopPromise;
         this.errorSubject.complete();
@@ -230,6 +240,7 @@ let AuthenticationClientService = class AuthenticationClientService {
         }
         finally {
             // Always clear the local token, even if the server call fails.
+            this.forceRefreshToken.unset();
             this.setNewToken(undefined);
             this.loggedOutBus.publishAndForget();
         }
@@ -390,9 +401,7 @@ let AuthenticationClientService = class AuthenticationClientService {
                 const refreshBufferSeconds = calculateRefreshBufferSeconds(token);
                 const needsRefresh = forceRefresh || (now >= (token.exp - refreshBufferSeconds));
                 if (needsRefresh) {
-                    let lockAcquired = false;
-                    await this.lock.tryUse(undefined, async () => {
-                        lockAcquired = true;
+                    const lockResult = await this.lock.tryUse(undefined, async () => {
                         const currentToken = this.token();
                         const currentNow = this.estimatedServerTimestampSeconds();
                         const currentRefreshBufferSeconds = isDefined(currentToken) ? calculateRefreshBufferSeconds(currentToken) : 0;
@@ -400,15 +409,12 @@ let AuthenticationClientService = class AuthenticationClientService {
                         const stillNeedsRefresh = isDefined(currentToken) && (forceRefresh || (currentNow >= (currentToken.exp - currentRefreshBufferSeconds)));
                         if (stillNeedsRefresh) {
                             await this.refresh();
-                            if (forceRefresh && (this.token() == currentToken)) {
-                                this.forceRefreshToken.unset();
-                            }
                         }
-                        else if (forceRefresh && (this.token() != currentToken)) {
+                        if (forceRefresh && (this.token() != currentToken)) {
                             this.forceRefreshToken.unset();
                         }
                     });
-                    if (!lockAcquired) {
+                    if (!lockResult.success) {
                         // Lock held by another instance, wait 5 seconds or until token changes (Passive Sync)
                         const changeReason = await firstValueFrom(race([
                             timer(5000).pipe(map(() => 'timer')),
@@ -421,11 +427,12 @@ let AuthenticationClientService = class AuthenticationClientService {
                         continue;
                     }
                 }
-                const currentRefreshBufferSeconds = calculateRefreshBufferSeconds(token);
-                const delay = Math.min(maxRefreshDelay, ((this.token()?.exp ?? 0) - this.estimatedServerTimestampSeconds() - currentRefreshBufferSeconds) * millisecondsPerSecond);
+                const currentToken = this.token();
+                const currentRefreshBufferSeconds = isDefined(currentToken) ? calculateRefreshBufferSeconds(currentToken) : 0;
+                const delay = Math.min(maxRefreshDelay, ((currentToken?.exp ?? 0) - this.estimatedServerTimestampSeconds() - currentRefreshBufferSeconds) * millisecondsPerSecond);
                 const wakeUpSignals = [
                     this.disposeSignal,
-                    this.token$.pipe(filter((t) => t != token)),
+                    this.token$.pipe(filter((t) => t != currentToken)),
                 ];
                 if (!forceRefresh) {
                     wakeUpSignals.push(this.forceRefreshToken);
@@ -439,13 +446,11 @@ let AuthenticationClientService = class AuthenticationClientService {
             }
             catch (error) {
                 this.logger.error(error);
-                if (this.token() != iterationToken) {
-                    continue;
-                }
+                const currentToken = this.token();
                 await firstValueFrom(race([
                     timer(2500),
                     this.disposeSignal.set$,
-                    this.token$.pipe(filter((t) => t != iterationToken)),
+                    this.token$.pipe(filter((t) => t != currentToken)),
                     this.forceRefreshToken.set$.pipe(skip(this.forceRefreshToken.isSet ? 1 : 0)),
                 ]), { defaultValue: undefined });
             }

package/document-management/api/document-management.api.d.ts

@@ -38,12 +38,6 @@ export declare const documentManagementApiDefinition: {
                 parse<T>(eventSource: import("../../sse/index.js").ServerSentEvents): import("rxjs").Observable<T>;
             };
             credentials: true;
-            data: {
-                bustCache: boolean;
-            };
-            cors: {
-                accessControlAllowHeaders: string;
-            };
         };
         getDocumentRequestsTemplateData: {
             resource: string;
@@ -454,12 +448,6 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
                 parse<T>(eventSource: import("../../sse/index.js").ServerSentEvents): import("rxjs").Observable<T>;
             };
             credentials: true;
-            data: {
-                bustCache: boolean;
-            };
-            cors: {
-                accessControlAllowHeaders: string;
-            };
         };
         getDocumentRequestsTemplateData: {
             resource: string;

package/document-management/api/document-management.api.js

@@ -6,8 +6,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { compileClient } from '../../api/client/index.js';
 import { defineApi } from '../../api/index.js';
-import { defaultAccessControlAllowHeaders } from '../../api/utils.js';
-import { bustCache } from '../../http/tokens.js';
 import { ReplaceClass } from '../../injector/index.js';
 import { array, boolean, literal, number, object, optional, string } from '../../schema/index.js';
 import { DataStream } from '../../sse/index.js';
@@ -43,8 +41,6 @@ export const documentManagementApiDefinition = defineApi({
             parameters: getDataParametersSchema,
             result: (DataStream),
             credentials: true,
-            data: { [bustCache]: true },
-            cors: { accessControlAllowHeaders: `${defaultAccessControlAllowHeaders}, Cache-Control` },
         },
         getDocumentRequestsTemplateData: {
             resource: 'views/document-requests-template-data',

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

@@ -6,30 +6,29 @@ import { HttpHeaders } from '../http-headers.js';
 export type SetCookieObject = SetCookieOptions & {
     value: string;
 };
+export type HttpServerResponseBody = {
+    stream?: ReadableStream<Uint8Array>;
+    buffer?: Uint8Array;
+    text?: string;
+    json?: unknown;
+    events?: ServerSentEventsSource;
+};
+export type HttpServerResponseBodyType = 'stream' | 'buffer' | 'text' | 'json' | 'events' | 'none';
 export type HttpServerResponseOptions = {
     statusCode?: number | undefined;
     statusMessage?: string | undefined;
     headers?: HttpHeadersInput | HttpHeaders;
     cookies?: Record<string, SetCookieObject>;
-    body?: {
-        stream?: ReadableStream<Uint8Array>;
-        buffer?: Uint8Array;
-        text?: string;
-        json?: unknown;
-        events?: ServerSentEventsSource;
-    };
+    body?: HttpServerResponseBody;
 };
 export declare class HttpServerResponse {
+    #private;
     statusCode: number | undefined;
     statusMessage: string | undefined;
     headers: HttpHeaders;
-    body: undefined | {
-        stream?: ReadableStream<Uint8Array>;
-        buffer?: Uint8Array;
-        text?: string;
-        json?: unknown;
-        events?: ServerSentEventsSource;
-    };
+    get body(): HttpServerResponseBody | undefined;
+    set body(value: HttpServerResponseBody | undefined);
+    get bodyType(): HttpServerResponseBodyType;
     constructor(response?: HttpServerResponseOptions);
     static fromObject(options?: HttpServerResponseOptions): HttpServerResponse;
     static redirect(url: string, options?: HttpServerResponseOptions): HttpServerResponse;

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

@@ -1,12 +1,23 @@
 import { formatSetCookie } from '../../cookie/cookie.js';
 import { objectEntries } from '../../utils/object/object.js';
-import { isDefined } from '../../utils/type-guards.js';
+import { isDefined, isUndefined } from '../../utils/type-guards.js';
 import { HttpHeaders } from '../http-headers.js';
 export class HttpServerResponse {
+    #body;
+    #bodyType;
     statusCode;
     statusMessage;
     headers;
-    body;
+    get body() {
+        return this.#body;
+    }
+    set body(value) {
+        this.#body = value;
+        this.#bodyType = getBodyType(value);
+    }
+    get bodyType() {
+        return this.#bodyType;
+    }
     constructor(response = {}) {
         this.update(response);
     }
@@ -38,3 +49,24 @@ export class HttpServerResponse {
 export function redirect(url, options) {
     return HttpServerResponse.redirect(url, options);
 }
+function getBodyType(body) {
+    if (isUndefined(body)) {
+        return 'none';
+    }
+    if (isDefined(body.stream)) {
+        return 'stream';
+    }
+    if (isDefined(body.buffer)) {
+        return 'buffer';
+    }
+    if (isDefined(body.text)) {
+        return 'text';
+    }
+    if (isDefined(body.json)) {
+        return 'json';
+    }
+    if (isDefined(body.events)) {
+        return 'events';
+    }
+    return 'none';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.137",
+  "version": "0.93.138",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -181,7 +181,7 @@
     }
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "5.8",
+    "@stylistic/eslint-plugin": "5.9",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.7",
     "@types/mjml": "4.7",