@loutrejs/loutre 0.5.0 → 0.7.0

package/dist/http/client.js

@@ -1,6 +1,5 @@
 import { SchemaValidationError, validateSchema, } from '../core/index.js';
-import { contractOfBinding } from '../core/contract-internal.js';
-import { parseHttpPath, } from './path.js';
+import { parseHttpPath } from './path.js';
 export class HttpClientResponseError extends Error {
     status;
     method;
@@ -15,13 +14,9 @@ export class HttpClientResponseError extends Error {
         this.name = 'HttpClientResponseError';
     }
 }
-export function createHttpClient(binding, transport) {
-    const contract = contractOfBinding(binding);
+export function createHttpClient(contract, transport) {
     const client = {};
-    for (const [procedureName, procedure] of Object.entries(contract.procedures)) {
-        const definition = httpDefinitionOf(procedure);
-        if (!definition)
-            continue;
+    for (const [procedureName, definition] of Object.entries(contract.routes)) {
         client[procedureName] = async (request = {}) => {
             const response = await transport({
                 method: definition.method,
@@ -29,24 +24,12 @@ export function createHttpClient(binding, transport) {
                 ...(request.query === undefined ? {} : { query: request.query }),
                 ...(request.headers === undefined ? {} : { headers: request.headers }),
                 ...(request.body === undefined ? {} : { body: request.body }),
-                ...(definition.request?.body === undefined
-                    ? {}
-                    : { contentType: definition.request.body.contentType }),
             });
             return decodeResponse(procedureName, definition, response);
         };
     }
     return Object.freeze(client);
 }
-function httpDefinitionOf(procedure) {
-    const protocol = procedure.protocols.http;
-    if (!protocol ||
-        protocol.protocol !== 'http' ||
-        !('definition' in protocol)) {
-        return undefined;
-    }
-    return protocol.definition;
-}
 function interpolatePath(path, params) {
     const segments = parseHttpPath(path);
     if (segments.length === 0)
@@ -72,11 +55,23 @@ async function decodeResponse(procedure, definition, response) {
     let lastValidationError;
     for (const candidate of candidates) {
         try {
-            const body = candidate.stream
-                ? validatedResponseStream(candidate.body, response.body, procedure, definition, response.status)
-                : await validateSchema(candidate.body, response.body);
-            const headers = candidate.headers
-                ? await validateSchema(candidate.headers, response.headers ?? {})
+            let body;
+            if (candidate.stream === 'server') {
+                if (!candidate.body)
+                    continue;
+                body = validatedResponseStream(candidate.body, response.body, procedure, definition, response.status);
+            }
+            else if (candidate.body) {
+                body = await validateSchema(candidate.body, response.body);
+            }
+            else {
+                if (response.body !== undefined && response.body !== null)
+                    continue;
+                body = undefined;
+            }
+            const headerSchema = responseHeadersSchema(candidate.headers);
+            const headers = headerSchema
+                ? await validateSchema(headerSchema, response.headers ?? {})
                 : (response.headers ?? {});
             return Object.freeze({ status: response.status, body, headers });
         }
@@ -88,6 +83,22 @@ async function decodeResponse(procedure, definition, response) {
     }
     throw new HttpClientResponseError(response.status, definition.method, definition.path, procedure, `${target} returned a response that does not match its Contract`, lastValidationError ? { cause: lastValidationError } : undefined);
 }
+function responseHeadersSchema(headers) {
+    if (isStandardSchema(headers))
+        return headers;
+    if (isResponseHeadersWithDefaults(headers))
+        return headers.schema;
+    return undefined;
+}
+function isStandardSchema(value) {
+    return typeof value === 'object' && value !== null && '~standard' in value;
+}
+function isResponseHeadersWithDefaults(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'schema' in value &&
+        isStandardSchema(value.schema));
+}
 function validatedResponseStream(schema, value, procedure, definition, status) {
     const target = describeHttpTarget(definition, procedure);
     if (!isAsyncIterable(value)) {
@@ -121,15 +132,18 @@ export function fetchHttpTransport(options) {
         appendQuery(url.searchParams, request.query);
         const headers = new Headers(options.headers);
         appendHeaders(headers, request.headers);
-        if (request.contentType && !headers.has('content-type')) {
-            headers.set('content-type', request.contentType);
+        const contentType = headers.get('content-type') ?? undefined;
+        const body = request.body === undefined
+            ? undefined
+            : encodeBody(request.body, contentType);
+        if (body instanceof FormData &&
+            normalizeMediaType(contentType) === 'multipart/form-data') {
+            headers.delete('content-type');
         }
         const response = await fetchImplementation(url, {
             method: request.method,
             headers,
-            ...(request.body === undefined
-                ? {}
-                : { body: encodeBody(request.body, request.contentType) }),
+            ...(body === undefined ? {} : { body }),
         });
         return {
             status: response.status,
@@ -191,7 +205,8 @@ function encodeBody(body, contentType) {
     return body;
 }
 async function decodeFetchBody(response) {
-    if (response.status === 204 ||
+    if (response.body === null ||
+        response.status === 204 ||
         response.status === 205 ||
         response.status === 304) {
         return undefined;
@@ -217,16 +232,25 @@ async function* decodeServerSentEvents(stream) {
     const decoder = new TextDecoder();
     let buffer = '';
     let completed = false;
+    let pendingCarriageReturn = false;
+    const appendDecoded = (value, final) => {
+        let decoded = pendingCarriageReturn ? `\r${value}` : value;
+        pendingCarriageReturn = false;
+        if (!final && decoded.endsWith('\r')) {
+            pendingCarriageReturn = true;
+            decoded = decoded.slice(0, -1);
+        }
+        buffer += normalizeEventStreamNewlines(decoded);
+    };
     try {
         while (true) {
             const next = await reader.read();
             if (next.done) {
                 completed = true;
-                buffer += decoder.decode();
+                appendDecoded(decoder.decode(), true);
                 break;
             }
-            buffer += decoder.decode(next.value, { stream: true });
-            buffer = normalizeEventStreamNewlines(buffer);
+            appendDecoded(decoder.decode(next.value, { stream: true }), false);
             let boundary = buffer.indexOf('\n\n');
             while (boundary >= 0) {
                 const event = buffer.slice(0, boundary);
@@ -241,16 +265,6 @@ async function* decodeServerSentEvents(stream) {
                 boundary = buffer.indexOf('\n\n');
             }
         }
-        buffer = normalizeEventStreamNewlines(buffer).trim();
-        if (buffer.length > 0) {
-            const data = buffer
-                .split('\n')
-                .filter((line) => line.startsWith('data:'))
-                .map((line) => line.slice('data:'.length).trimStart())
-                .join('\n');
-            if (data.length > 0)
-                yield JSON.parse(data);
-        }
     }
     finally {
         if (!completed)

package/dist/http/cors-internal.d.ts

@@ -0,0 +1,29 @@
+export type CorsOrigin = string | readonly string[] | ((origin: string) => boolean | Promise<boolean>);
+export interface CorsPolicyOptions {
+    readonly origin?: CorsOrigin;
+    readonly allowMethods?: readonly string[];
+    readonly allowHeaders?: readonly string[];
+    readonly exposeHeaders?: readonly string[];
+    readonly credentials?: boolean;
+    readonly maxAge?: number;
+}
+export type CorsPolicy = Readonly<{
+    origin: {
+        readonly kind: 'wildcard';
+    } | {
+        readonly kind: 'exact';
+        readonly origins: ReadonlySet<string>;
+    } | {
+        readonly kind: 'predicate';
+        readonly predicate: (origin: string) => boolean | Promise<boolean>;
+    };
+    allowMethods: readonly string[] | undefined;
+    allowHeaders: readonly string[] | undefined;
+    exposeHeaders: readonly string[];
+    credentials: boolean;
+    maxAge: number | undefined;
+}>;
+export declare function normalizeCorsPolicy(options: CorsPolicyOptions): CorsPolicy;
+export declare function registerCorsPolicy(middleware: object, policy: CorsPolicy): void;
+export declare function createCorsActualResponseHeaders(middlewares: readonly object[], request: Request): Promise<Headers | undefined>;
+export declare function createCorsPreflightResponseHeaders(middlewares: readonly object[], request: Request, targetMethod: string): Promise<Headers | undefined>;

package/dist/http/cors-internal.js

@@ -0,0 +1,160 @@
+const policies = new WeakMap();
+const httpToken = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+export function normalizeCorsPolicy(options) {
+    const credentials = options.credentials ?? false;
+    return Object.freeze({
+        origin: normalizeOrigin(options.origin ?? '*', credentials),
+        allowMethods: options.allowMethods === undefined
+            ? undefined
+            : normalizeTokens(options.allowMethods, 'allowMethods', true),
+        allowHeaders: options.allowHeaders === undefined
+            ? undefined
+            : normalizeTokens(options.allowHeaders, 'allowHeaders', false),
+        exposeHeaders: normalizeTokens(options.exposeHeaders ?? [], 'exposeHeaders', false),
+        credentials,
+        maxAge: normalizeMaxAge(options.maxAge),
+    });
+}
+export function registerCorsPolicy(middleware, policy) {
+    policies.set(middleware, policy);
+}
+export async function createCorsActualResponseHeaders(middlewares, request) {
+    const policy = corsPolicyOfMiddlewares(middlewares);
+    if (!policy)
+        return undefined;
+    const origin = request.headers.get('origin');
+    const headers = new Headers();
+    if (policy.origin.kind !== 'wildcard')
+        appendVary(headers, 'Origin');
+    if (origin === null)
+        return headers;
+    await applyOrigin(headers, policy, origin);
+    if (!headers.has('access-control-allow-origin'))
+        return headers;
+    if (policy.credentials) {
+        headers.set('access-control-allow-credentials', 'true');
+    }
+    if (policy.exposeHeaders.length > 0) {
+        headers.set('access-control-expose-headers', policy.exposeHeaders.join(', '));
+    }
+    return headers;
+}
+export async function createCorsPreflightResponseHeaders(middlewares, request, targetMethod) {
+    const policy = corsPolicyOfMiddlewares(middlewares);
+    if (!policy)
+        return undefined;
+    const headers = new Headers();
+    appendVary(headers, 'Access-Control-Request-Method');
+    const origin = request.headers.get('origin');
+    if (origin === null)
+        return headers;
+    await applyOrigin(headers, policy, origin);
+    if (!headers.has('access-control-allow-origin'))
+        return headers;
+    if (policy.credentials) {
+        headers.set('access-control-allow-credentials', 'true');
+    }
+    const methods = policy.allowMethods ?? [targetMethod.toUpperCase()];
+    if (methods.length > 0) {
+        headers.set('access-control-allow-methods', methods.join(', '));
+    }
+    if (policy.allowHeaders === undefined) {
+        const requested = request.headers.get('access-control-request-headers');
+        if (requested !== null && requested.trim().length > 0) {
+            headers.set('access-control-allow-headers', requested);
+            appendVary(headers, 'Access-Control-Request-Headers');
+        }
+    }
+    else if (policy.allowHeaders.length > 0) {
+        headers.set('access-control-allow-headers', policy.allowHeaders.join(', '));
+    }
+    if (policy.maxAge !== undefined) {
+        headers.set('access-control-max-age', String(policy.maxAge));
+    }
+    return headers;
+}
+function corsPolicyOfMiddlewares(middlewares) {
+    let found;
+    for (const middleware of middlewares) {
+        const policy = policies.get(middleware);
+        if (policy)
+            found = policy;
+    }
+    return found;
+}
+async function applyOrigin(headers, policy, origin) {
+    if (policy.origin.kind === 'wildcard') {
+        headers.set('access-control-allow-origin', '*');
+        return;
+    }
+    appendVary(headers, 'Origin');
+    const allowed = policy.origin.kind === 'exact'
+        ? policy.origin.origins.has(origin)
+        : await policy.origin.predicate(origin);
+    if (allowed)
+        headers.set('access-control-allow-origin', origin);
+}
+function normalizeOrigin(origin, credentials) {
+    if (typeof origin === 'function') {
+        return Object.freeze({ kind: 'predicate', predicate: origin });
+    }
+    const origins = typeof origin === 'string' ? [origin] : [...origin];
+    if (origins.length === 0) {
+        return Object.freeze({ kind: 'exact', origins: new Set() });
+    }
+    for (const value of origins) {
+        if (value.length === 0 || containsControlCharacter(value)) {
+            throw new TypeError('CORS origin cannot be empty or contain control characters');
+        }
+    }
+    if (origins.includes('*')) {
+        if (credentials) {
+            throw new TypeError('CORS origin cannot be a wildcard when credentials are enabled');
+        }
+        return Object.freeze({ kind: 'wildcard' });
+    }
+    return Object.freeze({
+        kind: 'exact',
+        origins: new Set(origins),
+    });
+}
+function containsControlCharacter(value) {
+    for (const character of value) {
+        const code = character.charCodeAt(0);
+        if (code <= 0x1f || code === 0x7f)
+            return true;
+    }
+    return false;
+}
+function normalizeTokens(values, option, uppercase) {
+    return Object.freeze(values.map((value) => {
+        const token = value.trim();
+        if (!httpToken.test(token)) {
+            throw new TypeError(`CORS ${option} contains an invalid HTTP token`);
+        }
+        return uppercase ? token.toUpperCase() : token;
+    }));
+}
+function normalizeMaxAge(maxAge) {
+    if (maxAge === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(maxAge) || maxAge < 0) {
+        throw new TypeError('CORS maxAge must be a non-negative safe integer');
+    }
+    return maxAge;
+}
+function appendVary(headers, value) {
+    const current = headers.get('vary');
+    if (current === null) {
+        headers.set('vary', value);
+        return;
+    }
+    const values = current
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (!values.some((item) => item.toLowerCase() === value.toLowerCase())) {
+        values.push(value);
+    }
+    headers.set('vary', values.join(', '));
+}

package/dist/http/cors.d.ts

@@ -1,5 +1,6 @@
-import { type LayerDescriptor, type PipelineItem } from '../core/index.js';
-export type CorsOrigin = string | readonly string[] | ((origin: string) => boolean | Promise<boolean>);
+import { type CorsOrigin } from './cors-internal.js';
+import type { HttpExecutionResult, HttpMiddlewareContext } from './extension.js';
+export type { CorsOrigin } from './cors-internal.js';
 export interface CorsOptions {
     readonly origin?: CorsOrigin;
     readonly allowMethods?: readonly string[];
@@ -9,9 +10,5 @@ export interface CorsOptions {
     readonly maxAge?: number;
     readonly name?: string;
 }
-export interface CorsLayerDescriptor extends LayerDescriptor<readonly [], readonly [], never, readonly [], string, 'framework', readonly [], object> {
-    readonly role: 'framework';
-}
-export declare function cors(options?: CorsOptions): CorsLayerDescriptor;
-export declare function createCorsActualResponseHeaders(pipeline: readonly PipelineItem[], request: Request): Promise<Headers | undefined>;
-export declare function createCorsPreflightResponseHeaders(pipeline: readonly PipelineItem[], request: Request, targetMethod: string): Promise<Headers | undefined>;
+export declare function cors(options?: CorsOptions): import("../core/generic-layer.js").GenericLayer<HttpMiddlewareContext, {}, HttpExecutionResult>;
+export type CorsLayerDescriptor = ReturnType<typeof cors>;

package/dist/http/cors.js

@@ -1,171 +1,13 @@
-import { childPipelineOf, layer, layerDefinitionOf, } from '../core/index.js';
-const policies = new WeakMap();
-const httpToken = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+import { defineLayer } from '../core/index.js';
+import { normalizeCorsPolicy, registerCorsPolicy, } from './cors-internal.js';
 export function cors(options = {}) {
-    const policy = normalizeCorsOptions(options);
-    const descriptor = layer({
+    const policy = normalizeCorsPolicy(options);
+    const middleware = defineLayer({
         name: options.name ?? 'cors',
-        role: 'framework',
-        factory: () => async (_ctx, next) => {
+        factory: () => async (_context, next) => {
             await next();
         },
     });
-    policies.set(descriptor, policy);
-    return descriptor;
-}
-export async function createCorsActualResponseHeaders(pipeline, request) {
-    const policy = corsPolicyOfPipeline(pipeline);
-    if (!policy)
-        return undefined;
-    const origin = request.headers.get('origin');
-    const headers = new Headers();
-    if (policy.origin.kind !== 'wildcard')
-        appendVary(headers, 'Origin');
-    if (origin === null)
-        return headers;
-    await applyOrigin(headers, policy, origin);
-    if (!headers.has('access-control-allow-origin'))
-        return headers;
-    if (policy.credentials) {
-        headers.set('access-control-allow-credentials', 'true');
-    }
-    if (policy.exposeHeaders.length > 0) {
-        headers.set('access-control-expose-headers', policy.exposeHeaders.join(', '));
-    }
-    return headers;
-}
-export async function createCorsPreflightResponseHeaders(pipeline, request, targetMethod) {
-    const policy = corsPolicyOfPipeline(pipeline);
-    if (!policy)
-        return undefined;
-    const headers = new Headers();
-    appendVary(headers, 'Access-Control-Request-Method');
-    const origin = request.headers.get('origin');
-    if (origin === null)
-        return headers;
-    await applyOrigin(headers, policy, origin);
-    if (!headers.has('access-control-allow-origin'))
-        return headers;
-    if (policy.credentials) {
-        headers.set('access-control-allow-credentials', 'true');
-    }
-    const methods = policy.allowMethods ?? [targetMethod.toUpperCase()];
-    if (methods.length > 0) {
-        headers.set('access-control-allow-methods', methods.join(', '));
-    }
-    if (policy.allowHeaders === undefined) {
-        const requested = request.headers.get('access-control-request-headers');
-        if (requested !== null && requested.trim().length > 0) {
-            headers.set('access-control-allow-headers', requested);
-            appendVary(headers, 'Access-Control-Request-Headers');
-        }
-    }
-    else if (policy.allowHeaders.length > 0) {
-        headers.set('access-control-allow-headers', policy.allowHeaders.join(', '));
-    }
-    if (policy.maxAge !== undefined) {
-        headers.set('access-control-max-age', String(policy.maxAge));
-    }
-    return headers;
-}
-function corsPolicyOfPipeline(pipeline) {
-    let found;
-    const visit = (items) => {
-        for (const item of items) {
-            if (item.kind !== 'layer')
-                continue;
-            const definition = layerDefinitionOf(item);
-            const policy = policies.get(definition);
-            if (policy)
-                found = policy;
-            const child = childPipelineOf(item);
-            if (child)
-                visit(child);
-        }
-    };
-    visit(pipeline);
-    return found;
-}
-async function applyOrigin(headers, policy, origin) {
-    if (policy.origin.kind === 'wildcard') {
-        headers.set('access-control-allow-origin', '*');
-        return;
-    }
-    appendVary(headers, 'Origin');
-    const allowed = policy.origin.kind === 'exact'
-        ? policy.origin.origins.has(origin)
-        : await policy.origin.predicate(origin);
-    if (allowed)
-        headers.set('access-control-allow-origin', origin);
-}
-function normalizeCorsOptions(options) {
-    const origin = normalizeOrigin(options.origin ?? '*', options.credentials ?? false);
-    return Object.freeze({
-        origin,
-        allowMethods: options.allowMethods === undefined
-            ? undefined
-            : normalizeTokens(options.allowMethods, 'allowMethods', true),
-        allowHeaders: options.allowHeaders === undefined
-            ? undefined
-            : normalizeTokens(options.allowHeaders, 'allowHeaders', false),
-        exposeHeaders: normalizeTokens(options.exposeHeaders ?? [], 'exposeHeaders', false),
-        credentials: options.credentials ?? false,
-        maxAge: normalizeMaxAge(options.maxAge),
-    });
-}
-function normalizeOrigin(origin, credentials) {
-    if (typeof origin === 'function') {
-        return Object.freeze({ kind: 'predicate', predicate: origin });
-    }
-    const origins = typeof origin === 'string' ? [origin] : [...origin];
-    if (origins.length === 0) {
-        return Object.freeze({ kind: 'exact', origins: new Set() });
-    }
-    for (const value of origins) {
-        if (value.length === 0 || /[\u0000-\u001f\u007f]/.test(value)) {
-            throw new TypeError('CORS origin cannot be empty or contain control characters');
-        }
-    }
-    if (origins.includes('*')) {
-        if (credentials) {
-            throw new TypeError('CORS origin cannot be a wildcard when credentials are enabled');
-        }
-        return Object.freeze({ kind: 'wildcard' });
-    }
-    return Object.freeze({
-        kind: 'exact',
-        origins: new Set(origins),
-    });
-}
-function normalizeTokens(values, option, uppercase) {
-    return Object.freeze(values.map((value) => {
-        const token = value.trim();
-        if (!httpToken.test(token)) {
-            throw new TypeError(`CORS ${option} contains an invalid HTTP token`);
-        }
-        return uppercase ? token.toUpperCase() : token;
-    }));
-}
-function normalizeMaxAge(maxAge) {
-    if (maxAge === undefined)
-        return undefined;
-    if (!Number.isSafeInteger(maxAge) || maxAge < 0) {
-        throw new TypeError('CORS maxAge must be a non-negative safe integer');
-    }
-    return maxAge;
-}
-function appendVary(headers, value) {
-    const current = headers.get('vary');
-    if (current === null) {
-        headers.set('vary', value);
-        return;
-    }
-    const values = current
-        .split(',')
-        .map((item) => item.trim())
-        .filter(Boolean);
-    if (!values.some((item) => item.toLowerCase() === value.toLowerCase())) {
-        values.push(value);
-    }
-    headers.set('vary', values.join(', '));
+    registerCorsPolicy(middleware, policy);
+    return middleware;
 }