effect-start 0.19.0 → 0.20.0

package/dist/bun/BunServerRequest.js

@@ -0,0 +1,252 @@
+import * as Cookies from "@effect/platform/Cookies";
+import * as Headers from "@effect/platform/Headers";
+import * as HttpApp from "@effect/platform/HttpApp";
+import * as HttpIncomingMessage from "@effect/platform/HttpIncomingMessage";
+import * as HttpServerError from "@effect/platform/HttpServerError";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as Socket from "@effect/platform/Socket";
+import * as UrlParams from "@effect/platform/UrlParams";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as FiberSet from "effect/FiberSet";
+import * as Inspectable from "effect/Inspectable";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+export class ServerRequestImpl extends Inspectable.Class {
+    [HttpServerRequest.TypeId];
+    [HttpIncomingMessage.TypeId];
+    source;
+    resolve;
+    url;
+    bunServer;
+    headersOverride;
+    remoteAddressOverride;
+    constructor(source, resolve, url, bunServer, headersOverride, remoteAddressOverride) {
+        super();
+        this[HttpServerRequest.TypeId] = HttpServerRequest.TypeId;
+        this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId;
+        this.source = source;
+        this.resolve = resolve;
+        this.url = url;
+        this.bunServer = bunServer;
+        this.headersOverride = headersOverride;
+        this.remoteAddressOverride = remoteAddressOverride;
+    }
+    toJSON() {
+        return HttpIncomingMessage.inspect(this, {
+            _id: "@effect/platform/HttpServerRequest",
+            method: this.method,
+            url: this.originalUrl,
+        });
+    }
+    modify(options) {
+        return new ServerRequestImpl(this.source, this.resolve, options.url ?? this.url, this.bunServer, options.headers ?? this.headersOverride, options.remoteAddress ?? this.remoteAddressOverride);
+    }
+    get method() {
+        return this.source.method.toUpperCase();
+    }
+    get originalUrl() {
+        return this.source.url;
+    }
+    get remoteAddress() {
+        return this.remoteAddressOverride
+            ? Option.some(this.remoteAddressOverride)
+            : Option.fromNullable(this.bunServer.requestIP(this.source)?.address);
+    }
+    get headers() {
+        this.headersOverride ??= Headers.fromInput(this.source.headers);
+        return this.headersOverride;
+    }
+    cachedCookies;
+    get cookies() {
+        if (this.cachedCookies) {
+            return this.cachedCookies;
+        }
+        return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? "");
+    }
+    get stream() {
+        return this.source.body
+            ? Stream.fromReadableStream(() => this.source.body, (cause) => new HttpServerError.RequestError({
+                request: this,
+                reason: "Decode",
+                cause,
+            }))
+            : Stream.fail(new HttpServerError.RequestError({
+                request: this,
+                reason: "Decode",
+                description: "can not create stream from empty body",
+            }));
+    }
+    textEffect;
+    get text() {
+        if (this.textEffect) {
+            return this.textEffect;
+        }
+        this.textEffect = Effect.runSync(Effect.cached(Effect.tryPromise({
+            try: () => this.source.text(),
+            catch: (cause) => new HttpServerError.RequestError({
+                request: this,
+                reason: "Decode",
+                cause,
+            }),
+        })));
+        return this.textEffect;
+    }
+    get json() {
+        return Effect.tryMap(this.text, {
+            try: (_) => JSON.parse(_),
+            catch: (cause) => new HttpServerError.RequestError({
+                request: this,
+                reason: "Decode",
+                cause,
+            }),
+        });
+    }
+    get urlParamsBody() {
+        return Effect.flatMap(this.text, (_) => Effect.try({
+            try: () => UrlParams.fromInput(new URLSearchParams(_)),
+            catch: (cause) => new HttpServerError.RequestError({
+                request: this,
+                reason: "Decode",
+                cause,
+            }),
+        }));
+    }
+    multipartEffect;
+    get multipart() {
+        if (this.multipartEffect) {
+            return this.multipartEffect;
+        }
+        this.multipartEffect = Effect.runSync(Effect.cached(Effect.die("Multipart not implemented")));
+        return this.multipartEffect;
+    }
+    get multipartStream() {
+        return Stream.die("Multipart stream not implemented");
+    }
+    arrayBufferEffect;
+    get arrayBuffer() {
+        if (this.arrayBufferEffect) {
+            return this.arrayBufferEffect;
+        }
+        this.arrayBufferEffect = Effect.runSync(Effect.cached(Effect.tryPromise({
+            try: () => this.source.arrayBuffer(),
+            catch: (cause) => new HttpServerError.RequestError({
+                request: this,
+                reason: "Decode",
+                cause,
+            }),
+        })));
+        return this.arrayBufferEffect;
+    }
+    get upgrade() {
+        return Effect.flatMap(Effect.all([
+            Deferred.make(),
+            Deferred.make(),
+            Effect.makeSemaphore(1),
+        ]), ([deferred, closeDeferred, semaphore]) => Effect.async((resume) => {
+            const success = this.bunServer.upgrade(this.source, {
+                data: {
+                    deferred,
+                    closeDeferred,
+                    buffer: [],
+                    run: wsDefaultRun,
+                },
+            });
+            if (!success) {
+                resume(Effect.fail(new HttpServerError.RequestError({
+                    request: this,
+                    reason: "Decode",
+                    description: "Not an upgradeable ServerRequest",
+                })));
+                return;
+            }
+            resume(Effect.map(Deferred.await(deferred), (ws) => {
+                const write = (chunk) => Effect.sync(() => {
+                    if (typeof chunk === "string") {
+                        ws.sendText(chunk);
+                    }
+                    else if (Socket.isCloseEvent(chunk)) {
+                        ws.close(chunk.code, chunk.reason);
+                    }
+                    else {
+                        ws.sendBinary(chunk);
+                    }
+                    return true;
+                });
+                const writer = Effect.succeed(write);
+                const runRaw = Effect.fnUntraced(function* (handler, opts) {
+                    const set = yield* FiberSet.make();
+                    const run = yield* FiberSet.runtime(set)();
+                    function runRawInner(data) {
+                        const result = handler(data);
+                        if (Effect.isEffect(result)) {
+                            run(result);
+                        }
+                    }
+                    ws.data.run = runRawInner;
+                    ws.data.buffer.forEach(runRawInner);
+                    ws.data.buffer.length = 0;
+                    if (opts?.onOpen)
+                        yield* opts.onOpen;
+                    return yield* FiberSet.join(set);
+                }, Effect.scoped, Effect.onExit((exit) => {
+                    ws.close(exit._tag === "Success" ? 1000 : 1011);
+                    return Effect.void;
+                }), Effect.raceFirst(Deferred.await(closeDeferred)), semaphore.withPermits(1));
+                const encoder = new TextEncoder();
+                const run = (handler, opts) => runRaw((data) => typeof data === "string"
+                    ? handler(encoder.encode(data))
+                    : handler(data), opts);
+                return Socket.Socket.of({
+                    [Socket.TypeId]: Socket.TypeId,
+                    run,
+                    runRaw,
+                    writer,
+                });
+            }));
+        }));
+    }
+}
+function wsDefaultRun(_) {
+    this.buffer.push(_);
+}
+export function makeResponse(request, response, runtime) {
+    const fields = {
+        headers: new globalThis.Headers(response.headers),
+        status: response.status,
+    };
+    if (!Cookies.isEmpty(response.cookies)) {
+        for (const header of Cookies.toSetCookieHeaders(response.cookies)) {
+            fields.headers.append("set-cookie", header);
+        }
+    }
+    if (response.statusText !== undefined) {
+        fields.statusText = response.statusText;
+    }
+    if (request.method === "HEAD") {
+        return new Response(undefined, fields);
+    }
+    const ejectedResponse = HttpApp.unsafeEjectStreamScope(response);
+    const body = ejectedResponse.body;
+    switch (body._tag) {
+        case "Empty": {
+            return new Response(undefined, fields);
+        }
+        case "Uint8Array":
+        case "Raw": {
+            if (body.body instanceof Response) {
+                for (const [key, value] of fields.headers.entries()) {
+                    body.body.headers.set(key, value);
+                }
+                return body.body;
+            }
+            return new Response(body.body, fields);
+        }
+        case "FormData": {
+            return new Response(body.formData, fields);
+        }
+        case "Stream": {
+            return new Response(Stream.toReadableStreamRuntime(body.stream, runtime), fields);
+        }
+    }
+}

package/dist/bun/index.d.ts

@@ -1,4 +1,4 @@
 export * as BunBundle from "./BunBundle.ts";
-export * as BunHttpServer from "./BunHttpServer.ts";
 export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts";
 export * as BunRoute from "./BunRoute.ts";
+export * as BunServer from "./BunServer.ts";

package/dist/bun/index.js

@@ -1,4 +1,4 @@
 export * as BunBundle from "./BunBundle.js";
-export * as BunHttpServer from "./BunHttpServer.js";
 export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.js";
 export * as BunRoute from "./BunRoute.js";
+export * as BunServer from "./BunServer.js";

package/dist/datastar/actions/fetch.d.ts

@@ -0,0 +1,30 @@
+import type { SignalFilterOptions } from "../engine.ts";
+export declare const STARTED = "started";
+export declare const FINISHED = "finished";
+export declare const ERROR = "error";
+export declare const RETRYING = "retrying";
+export declare const RETRIES_FAILED = "retries-failed";
+type ResponseOverrides = {
+    selector?: string;
+    mode?: string;
+    namespace?: string;
+    useViewTransition?: boolean;
+} | {
+    onlyIfMissing?: boolean;
+};
+export type FetchArgs = {
+    selector?: string;
+    headers?: Record<string, string>;
+    contentType?: "json" | "form";
+    filterSignals?: SignalFilterOptions;
+    openWhenHidden?: boolean;
+    payload?: any;
+    requestCancellation?: "auto" | "disabled" | AbortController;
+    responseOverrides?: ResponseOverrides;
+    retry?: "auto" | "error" | "always" | "never";
+    retryInterval?: number;
+    retryScaler?: number;
+    retryMaxWaitMs?: number;
+    retryMaxCount?: number;
+};
+export {};