@chidchanun/bcp 0.2.13 → 0.2.14

package/packages/client/src/testing.ts

@@ -0,0 +1,52 @@
+export {
+    createFakeClock,
+    createJobTestHarness,
+    createOutboxTestHarness,
+    createRealtimeTestHarness,
+    createRealtimeTestSocket,
+    createRouteTestHandler,
+    createSequenceIdFactory,
+    createTestApp,
+    createTestAuthSession,
+    createWorkflowTestHarness,
+    expectResponse,
+    readSseEvents,
+    runTestMiddleware,
+    withTestTransaction,
+} from "../../server/src/testing.js";
+
+export {
+    createTestFormData,
+    runTestPageAction,
+    runTestPageGuards,
+    runTestPageLoader,
+} from "../../server/src/testing-page.js";
+
+export type {
+    CreateTestAuthSessionOptions,
+    FakeClock,
+    JobTestHarness,
+    OutboxTestHarness,
+    ParsedSseEvent,
+    RealtimeTestConnection,
+    RealtimeTestHarness,
+    RealtimeTestSocket,
+    TestApp,
+    TestAppOptions,
+    TestAuthSession,
+    TestRequestHandler,
+    TestRequestOptions,
+    TestResponseExpectation,
+    TestRouteFunction,
+    TestRouteHandlerOptions,
+    TestRouteMethod,
+    TestRouteModule,
+    TestTransactionDatabase,
+    WorkflowTestHarness,
+} from "../../server/src/testing.js";
+
+export type {
+    TestPageActionOptions,
+    TestPageContextOptions,
+    TestPageGuardOptions,
+} from "../../server/src/testing-page.js";

package/packages/server/src/realtime.ts

@@ -1139,43 +1139,88 @@ export function createRealtimeSseResponse(
             options.keepAliveMs ?? 15_000,
             "SSE keepAliveMs"
         );
+    let closed = false;
+    let controller:
+        ReadableStreamDefaultController<Uint8Array> |
+        undefined;
+    let timer:
+        ReturnType<typeof setTimeout> |
+        undefined;
+    let unsubscribe:
+        () => void =
+        () => undefined;
+    let abortListener:
+        (() => void) |
+        undefined;
+
+    const cleanup = () => {
+        if (closed) {
+            return false;
+        }
+        closed = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        unsubscribe();
+        unsubscribe =
+            () => undefined;
+        if (
+            options.signal &&
+            abortListener
+        ) {
+            options.signal.removeEventListener(
+                "abort",
+                abortListener
+            );
+            abortListener = undefined;
+        }
+        return true;
+    };
+
+    const close = () => {
+        if (!cleanup()) {
+            return;
+        }
+        const currentController =
+            controller;
+        controller = undefined;
+        if (!currentController) {
+            return;
+        }
+        try {
+            currentController.close();
+        } catch {
+            // Stream may already be closed or cancelled by the runtime.
+        }
+    };
+
+    const write = (
+        value: string
+    ) => {
+        const currentController =
+            controller;
+        if (
+            closed ||
+            !currentController
+        ) {
+            return;
+        }
+        try {
+            currentController.enqueue(
+                encoder.encode(value)
+            );
+        } catch {
+            cleanup();
+            controller = undefined;
+        }
+    };
 
     const stream =
         new ReadableStream<Uint8Array>({
-            start(controller) {
-                let closed = false;
-                let timer:
-                    ReturnType<typeof setTimeout> |
-                    undefined;
-                let unsubscribe:
-                    () => void =
-                    () => undefined;
-
-                const close = () => {
-                    if (closed) {
-                        return;
-                    }
-                    closed = true;
-                    if (timer) {
-                        clearTimeout(timer);
-                    }
-                    unsubscribe();
-                    try {
-                        controller.close();
-                    } catch {
-                        // Stream may already be closed by the runtime.
-                    }
-                };
-
-                const write = (
-                    value: string
-                ) => {
-                    if (!closed) {
-                        controller.enqueue(
-                            encoder.encode(value)
-                        );
-                    }
-                };
+            start(streamController) {
+                controller =
+                    streamController;
 
                 if (retryMs !== undefined) {
                     write(
@@ -1211,11 +1256,13 @@ export function createRealtimeSseResponse(
                     write(
                         `: keep-alive ${Date.now()}\n\n`
                     );
-                    timer =
-                        setTimeout(
-                            keepAlive,
-                            keepAliveMs
-                        );
+                    if (!closed) {
+                        timer =
+                            setTimeout(
+                                keepAlive,
+                                keepAliveMs
+                            );
+                    }
                 };
                 timer =
                     setTimeout(
@@ -1224,19 +1271,26 @@ export function createRealtimeSseResponse(
                     );
 
                 if (options.signal) {
+                    abortListener =
+                        close;
                     if (options.signal.aborted) {
                         close();
                         return;
                     }
                     options.signal.addEventListener(
                         "abort",
-                        close,
+                        abortListener,
                         {
                             once: true,
                         }
                     );
                 }
             },
+
+            cancel() {
+                cleanup();
+                controller = undefined;
+            },
         });
 
     const headers =
@@ -1461,4 +1515,4 @@ function formatError(
     } catch {
         return String(error);
     }
-}
+}

package/packages/server/src/testing-page.ts

@@ -0,0 +1,274 @@
+import {
+    executePageActionFunction,
+    normalizePageActionMethod,
+    type PageAction,
+    type PageActionExecution,
+    type PageActionMethod,
+} from "./form-action.js";
+import {
+    executePageGuardFunctions,
+    type PageGuard,
+    type PageGuardData,
+    type PageGuardDefinition,
+    type PageGuardExecution,
+} from "./page-guard.js";
+import {
+    executePageLoaderFunction,
+    type PageLoader,
+    type PageLoaderExecution,
+} from "./page-loader.js";
+
+export interface TestPageContextOptions {
+    params?: Record<string, any>;
+    url?: string | URL;
+    guardData?: PageGuardData;
+    hasGuard?: boolean;
+}
+
+export interface TestPageGuardOptions
+extends Omit<
+    TestPageContextOptions,
+    "guardData" | "hasGuard"
+> {
+    label?: string;
+}
+
+export interface TestPageActionOptions
+extends TestPageContextOptions {
+    actionName?: string;
+    method?: PageActionMethod | string;
+    formData?: FormData;
+    fields?: Record<
+        string,
+        string | Blob | Array<string | Blob>
+    >;
+    label?: string;
+}
+
+export async function runTestPageLoader(
+    loader: PageLoader,
+    options: TestPageContextOptions = {}
+): Promise<PageLoaderExecution> {
+    assertFunction(
+        loader,
+        "page loader"
+    );
+
+    return executePageLoaderFunction(
+        loader,
+        {
+            ...(options.params ?? {}),
+        },
+        resolveTestPageUrl(
+            options.url
+        ),
+        "bcp/testing loader",
+        {
+            ...(options.guardData ?? {}),
+        },
+        options.hasGuard ??
+            Object.keys(
+                options.guardData ?? {}
+            ).length > 0
+    );
+}
+
+export async function runTestPageGuards(
+    guards:
+        | PageGuard
+        | PageGuard[]
+        | PageGuardDefinition[],
+    options: TestPageGuardOptions = {}
+): Promise<PageGuardExecution> {
+    const list =
+        Array.isArray(guards)
+            ? guards
+            : [guards];
+    const definitions:
+        PageGuardDefinition[] =
+        list.map(
+            (candidate, index) => {
+                if (
+                    typeof candidate === "object" &&
+                    candidate !== null &&
+                    "guard" in candidate
+                ) {
+                    const definition =
+                        candidate as PageGuardDefinition;
+                    assertFunction(
+                        definition.guard,
+                        `page guard ${index + 1}`
+                    );
+                    return {
+                        filePath:
+                            definition.filePath ||
+                            `${options.label ?? "bcp/testing guard"}#${index + 1}`,
+                        guard:
+                            definition.guard,
+                    };
+                }
+
+                assertFunction(
+                    candidate,
+                    `page guard ${index + 1}`
+                );
+
+                return {
+                    filePath:
+                        `${options.label ?? "bcp/testing guard"}#${index + 1}`,
+                    guard:
+                        candidate as PageGuard,
+                };
+            }
+        );
+
+    return executePageGuardFunctions(
+        definitions,
+        {
+            ...(options.params ?? {}),
+        },
+        resolveTestPageUrl(
+            options.url
+        )
+    );
+}
+
+export async function runTestPageAction(
+    action: PageAction,
+    options: TestPageActionOptions = {}
+): Promise<PageActionExecution> {
+    assertFunction(
+        action,
+        "page action"
+    );
+
+    if (
+        options.formData &&
+        options.fields
+    ) {
+        throw new TypeError(
+            "BCP Testing: page action test cannot specify both formData and fields."
+        );
+    }
+
+    const actionName =
+        normalizeText(
+            options.actionName ?? "action",
+            "page action name"
+        );
+    const method =
+        normalizePageActionMethod(
+            options.method ?? "POST"
+        );
+    const formData =
+        options.formData ??
+        createTestFormData(
+            options.fields ?? {}
+        );
+
+    return executePageActionFunction(
+        action,
+        actionName,
+        method,
+        formData,
+        {
+            ...(options.params ?? {}),
+        },
+        resolveTestPageUrl(
+            options.url
+        ),
+        {
+            ...(options.guardData ?? {}),
+        },
+        options.hasGuard ??
+            Object.keys(
+                options.guardData ?? {}
+            ).length > 0,
+        options.label ??
+            "bcp/testing actions"
+    );
+}
+
+export function createTestFormData(
+    fields: Record<
+        string,
+        string | Blob | Array<string | Blob>
+    > = {}
+): FormData {
+    const formData =
+        new FormData();
+
+    for (
+        const [name, rawValue]
+        of Object.entries(fields)
+    ) {
+        const values =
+            Array.isArray(rawValue)
+                ? rawValue
+                : [rawValue];
+
+        for (const value of values) {
+            formData.append(
+                name,
+                value
+            );
+        }
+    }
+
+    return formData;
+}
+
+function resolveTestPageUrl(
+    value?: string | URL
+): URL {
+    if (value instanceof URL) {
+        return new URL(
+            value.href
+        );
+    }
+
+    const candidate =
+        value ??
+        "http://bcp.test/";
+
+    try {
+        return new URL(
+            candidate
+        );
+    } catch {
+        return new URL(
+            String(candidate).replace(
+                /^\//,
+                ""
+            ),
+            "http://bcp.test/"
+        );
+    }
+}
+
+function assertFunction(
+    value: unknown,
+    label: string
+): asserts value is (...args: any[]) => unknown {
+    if (typeof value !== "function") {
+        throw new TypeError(
+            `BCP Testing: ${label} must be a function.`
+        );
+    }
+}
+
+function normalizeText(
+    value: unknown,
+    label: string
+): string {
+    const text =
+        String(value ?? "").trim();
+
+    if (!text) {
+        throw new TypeError(
+            `BCP Testing: ${label} must be a non-empty string.`
+        );
+    }
+
+    return text;
+}