effect-start 0.23.0 → 0.25.0

package/dist/bun/BunServerRequest.js

@@ -1,252 +0,0 @@
-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/BunSql.d.ts

@@ -1,4 +0,0 @@
-import * as Layer from "effect/Layer";
-import * as Sql from "../Sql.ts";
-export declare const layer: (config: Sql.SqlClientConfig) => Layer.Layer<Sql.SqlClient, Sql.SqlError>;
-export declare const layerMemory: Layer.Layer<Sql.SqlClient, Sql.SqlError>;

package/dist/bun/BunSql.js

@@ -1,81 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as FiberRef from "effect/FiberRef";
-import * as GlobalValue from "effect/GlobalValue";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Sql from "../Sql.js";
-const wrapError = (error) => new Sql.SqlError({
-    code: error?.code ?? "UNKNOWN",
-    message: error instanceof Error ? error.message : String(error),
-    cause: error,
-});
-const wrapQuery = (promise) => Effect.tryPromise({ try: () => promise, catch: wrapError });
-const makeValues = (obj, ...columns) => {
-    const items = Array.isArray(obj) ? obj : [obj];
-    const cols = columns.length > 0 ? columns : Object.keys(items[0]);
-    return { value: items, columns: cols };
-};
-const currentTransaction = GlobalValue.globalValue(Symbol.for("effect-start/BunSql/currentTransaction"), () => FiberRef.unsafeMake(Option.none()));
-const runQuery = (bunSql, strings, values) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    if (Option.isSome(txOpt)) {
-        return wrapQuery(txOpt.value.conn(strings, ...values));
-    }
-    return wrapQuery(bunSql(strings, ...values));
-});
-const runUnsafe = (bunSql, query, values) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    if (Option.isSome(txOpt)) {
-        return wrapQuery(txOpt.value.conn.unsafe(query, values));
-    }
-    return wrapQuery(bunSql.unsafe(query, values));
-});
-const makeWithTransaction = (bunSql) => (self) => Effect.uninterruptibleMask((restore) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    if (Option.isSome(txOpt)) {
-        const { conn, depth } = txOpt.value;
-        const name = `sp_${depth}`;
-        return Effect.gen(function* () {
-            yield* wrapQuery(conn.unsafe(`SAVEPOINT ${name}`));
-            const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ conn, depth: depth + 1 }))));
-            if (Exit.isSuccess(exit)) {
-                yield* wrapQuery(conn.unsafe(`RELEASE SAVEPOINT ${name}`));
-                return exit.value;
-            }
-            yield* wrapQuery(conn.unsafe(`ROLLBACK TO SAVEPOINT ${name}`)).pipe(Effect.orDie);
-            return yield* exit;
-        });
-    }
-    const runTx = (conn) => Effect.gen(function* () {
-        yield* wrapQuery(conn.unsafe("BEGIN"));
-        const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ conn, depth: 1 }))));
-        if (Exit.isSuccess(exit)) {
-            yield* wrapQuery(conn.unsafe("COMMIT"));
-            return exit.value;
-        }
-        yield* wrapQuery(conn.unsafe("ROLLBACK")).pipe(Effect.orDie);
-        return yield* exit;
-    });
-    return Effect.matchEffect(Effect.tryPromise({ try: () => bunSql.reserve(), catch: wrapError }), {
-        onFailure: () => runTx(bunSql),
-        onSuccess: (reserved) => Effect.ensuring(runTx(reserved), Effect.sync(() => reserved.release())),
-    });
-}));
-export const layer = (config) => Layer.scoped(Sql.SqlClient, Effect.acquireRelease(Effect.try({
-    try: () => {
-        const bunSql = new Bun.SQL(config);
-        return Object.assign((strings, ...values) => runQuery(bunSql, strings, values), {
-            unsafe: (query, values) => runUnsafe(bunSql, query, values),
-            values: makeValues,
-            withTransaction: makeWithTransaction(bunSql),
-            reserve: Effect.acquireRelease(Effect.tryPromise({ try: () => bunSql.reserve(), catch: wrapError }), (reserved) => Effect.sync(() => reserved.release())).pipe(Effect.map((reserved) => Object.assign((strings, ...values) => wrapQuery(reserved(strings, ...values)), {
-                unsafe: (query, values) => wrapQuery(reserved.unsafe(query, values)),
-                values: makeValues,
-            }))),
-            close: (options) => wrapQuery(bunSql.close(options)),
-        });
-    },
-    catch: wrapError,
-}), (client) => client.close().pipe(Effect.orDie)));
-export const layerMemory = layer({
-    adapter: "sqlite",
-    filename: ":memory:",
-});

package/dist/bun/BunVirtualFilesPlugin.d.ts

@@ -1,4 +0,0 @@
-import type { BunPlugin } from "bun";
-type VirtualFiles = Record<string, string>;
-export declare function make(files: VirtualFiles): BunPlugin;
-export {};

package/dist/bun/_BunEnhancedResolve.d.ts

@@ -1,45 +0,0 @@
-type ErrorWithDetail = Error & {
-    details?: string;
-};
-interface ResolveRequest {
-    path: string | false;
-    context?: object;
-    descriptionFilePath?: string;
-    descriptionFileRoot?: string;
-    descriptionFileData?: Record<string, unknown>;
-    relativePath?: string;
-    ignoreSymlinks?: boolean;
-    fullySpecified?: boolean;
-}
-interface ResolveContext {
-    contextDependencies?: {
-        add: (item: string) => void;
-    };
-    fileDependencies?: {
-        add: (item: string) => void;
-    };
-    missingDependencies?: {
-        add: (item: string) => void;
-    };
-    stack?: Set<string>;
-    log?: (str: string) => void;
-    yield?: (request: ResolveRequest) => void;
-}
-interface ResolveOptions {
-    extensions?: Array<string>;
-    mainFields?: Array<string | string[]>;
-    conditionNames?: Array<string>;
-    fileSystem?: unknown;
-    useSyncFileSystemCalls?: boolean;
-    modules?: string | string[];
-}
-export interface Resolver {
-    resolve(context: object, path: string, request: string, resolveContext: ResolveContext, callback: (err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest) => void): void;
-}
-export declare class CachedInputFileSystem {
-    constructor(_fileSystem: unknown, _duration: number);
-}
-export declare const ResolverFactory: {
-    createResolver(options: ResolveOptions): Resolver;
-};
-export {};

package/dist/bun/index.d.ts

@@ -1,5 +0,0 @@
-export * as BunChildProcessSpawner from "./BunChildProcessSpawner.ts";
-export * as BunBundle from "./BunBundle.ts";
-export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts";
-export * as BunRoute from "./BunRoute.ts";
-export * as BunServer from "./BunServer.ts";

package/dist/bundler/Bundle.d.ts

@@ -1,61 +0,0 @@
-import type { PubSub } from "effect";
-import { Context, Effect } from "effect";
-import * as Schema from "effect/Schema";
-export declare const BundleEntrypointMetaKey: unique symbol;
-export type BundleOutputMetaValue = {};
-/**
- * Generic shape describing a bundle across multiple bundlers
- * (like bun, esbuild & vite)
- */
-export declare const BundleManifestSchema: Schema.Struct<{
-    entrypoints: Schema.Record$<typeof Schema.String, typeof Schema.String>;
-    artifacts: Schema.Array$<Schema.Struct<{
-        path: typeof Schema.String;
-        type: typeof Schema.String;
-        size: typeof Schema.Number;
-        hash: Schema.optional<typeof Schema.String>;
-        imports: Schema.optional<Schema.Array$<Schema.Struct<{
-            path: typeof Schema.String;
-            kind: Schema.Literal<["import-statement", "require-call", "require-resolve", "dynamic-import", "import-rule", "url-token", "internal", "entry-point-run", "entry-point-build"]>;
-        }>>>;
-    }>>;
-}>;
-export type BundleManifest = typeof BundleManifestSchema.Type;
-export declare const BundleEvent: Schema.Union<[Schema.TaggedStruct<"Change", {
-    path: typeof Schema.String;
-}>, Schema.TaggedStruct<"BuildError", {
-    error: typeof Schema.String;
-}>]>;
-export type BundleEvent = typeof BundleEvent.Type;
-declare const IdPrefix = "effect-start/tags/";
-export type BundleKey = `${string}Bundle`;
-export type BundleId = `${typeof IdPrefix}${BundleKey}`;
-/**
- * Passed to bundle effects and within bundle runtime.
- * Used to expose artifacts via HTTP server and properly resolve
- * imports within the bundle.
- */
-export type BundleContext = BundleManifest & {
-    resolve: (url: string) => string | null;
-    getArtifact: (path: string) => Blob | null;
-    events?: PubSub.PubSub<BundleEvent>;
-};
-declare const BundleError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "BundleError";
-} & Readonly<A>;
-export declare class BundleError extends BundleError_base<{
-    message: string;
-    cause?: unknown;
-}> {
-}
-export declare const emptyBundleContext: BundleContext;
-export declare const handleBundleErrorSilently: (effect: Effect.Effect<BundleContext, BundleError>) => Effect.Effect<BundleContext, never>;
-export declare const Tag: <const T extends BundleKey>(name: T) => <Identifier>() => Context.TagClass<Identifier, `effect-start/tags/${string}Bundle`, BundleContext>;
-export type Tag = Context.Tag<BundleId, BundleContext>;
-declare const ClientBundle_base: Context.TagClass<ClientBundle, `effect-start/tags/${string}Bundle`, BundleContext>;
-export declare class ClientBundle extends ClientBundle_base {
-}
-declare const ServerBundle_base: Context.TagClass<ServerBundle, `effect-start/tags/${string}Bundle`, BundleContext>;
-export declare class ServerBundle extends ServerBundle_base {
-}
-export {};

package/dist/bundler/BundleFiles.d.ts

@@ -1,13 +0,0 @@
-import * as FileSystem from "../FileSystem.ts";
-import * as Effect from "effect/Effect";
-import * as Bundle from "./Bundle.ts";
-/**
- * Exports a bundle to a file system under specified directory.
- */
-export declare const toFiles: (context: Bundle.BundleContext, outDir: string) => Effect.Effect<undefined, import("../PlatformError.ts").PlatformError | Bundle.BundleError, FileSystem.FileSystem>;
-/**
- * Loads a bundle from a directory and returns a Bundle.BundleContext.
- * Expects the directory to contain a manifest.json file and all the artifacts
- * referenced in the manifest.
- */
-export declare const fromFiles: (directory: string) => Effect.Effect<Bundle.BundleContext, Bundle.BundleError, FileSystem.FileSystem>;

package/dist/bundler/BundleHttp.d.ts

@@ -1,45 +0,0 @@
-import type * as HttpApp from "@effect/platform/HttpApp";
-import { RouteNotFound } from "@effect/platform/HttpServerError";
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
-import * as Effect from "effect/Effect";
-import * as Scope from "effect/Scope";
-import * as Bundle from "./Bundle.ts";
-/**
- * Handles all entrypoints automatically.
- * Serves HTML entrypoints without requiring explicit route definitions for each one.
- * Examples:
- *  index.html -> /
- *  contact.html -> /contact
- *  about/index.html -> /about
- */
-export declare function entrypoint(uri?: string): HttpApp.Default<RouteNotFound, Bundle.ClientBundle>;
-export declare function httpApp(opts?: {
-    urlPrefix?: string;
-}): HttpApp.Default<RouteNotFound, Scope.Scope | Bundle.ClientBundle>;
-export declare const toHttpApp: <E, R>(bundleTag: Effect.Effect<Bundle.BundleContext, E, R>, opts?: {
-    urlPrefix?: string;
-}) => Effect.Effect<HttpServerResponse.HttpServerResponse, RouteNotFound | E, HttpServerRequest.HttpServerRequest | R>;
-/**
- * Render HTML to a string.
- * Useful for SSR.
- */
-export declare function renderPromise(clientBundle: Bundle.Tag, render: (request: Request, resolve: (url: string) => string) => Promise<Response>): Effect.Effect<HttpServerResponse.HttpServerResponse, Bundle.BundleError, HttpServerRequest.HttpServerRequest | `effect-start/tags/${string}Bundle`>;
-/**
- * Exposes bundle assets via HTTP routes.
- * Serves bundle artifacts, manifest.json, and events endpoint at the specified path.
- */
-export declare function withAssets(opts?: {
-    path?: string;
-}): <E, R>(app: HttpApp.Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, RouteNotFound | E, HttpServerRequest.HttpServerRequest | Bundle.ClientBundle | R>;
-/**
- * @see {entrypoint}
- */
-export declare function withEntrypoints(): <E, R>(app: HttpApp.Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, HttpServerRequest.HttpServerRequest | Bundle.ClientBundle | R>;
-/**
- * Combines both withAssets and withEntrypoints.
- * Provides complete bundle HTTP functionality in a single function call.
- */
-export declare function withBundle(opts?: {
-    path?: string;
-}): <E, R>(app: HttpApp.Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, RouteNotFound | E, HttpServerRequest.HttpServerRequest | Bundle.ClientBundle | R>;