alchemy 2.0.0-beta.5 → 2.0.0-beta.50

package/lib/Cloudflare/Workers/Worker.d.ts

@@ -0,0 +1,588 @@
+import type * as cf from "@cloudflare/workers-types";
+import * as workers from "@distilled.cloud/cloudflare/workers";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { type MemoOptions } from "../../Build/Memo.ts";
+import * as Bundle from "../../Bundle/Bundle.ts";
+import type { InputProps } from "../../Input.ts";
+import { Platform, type Main, type PlatformProps } from "../../Platform.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import type { HyperdriveDevOrigin } from "../Hyperdrive/Hyperdrive.ts";
+import type { Providers } from "../Providers.ts";
+import { type Assets, type AssetsConfig, type AssetsProps } from "./Assets.ts";
+import { Request } from "./Request.ts";
+import type { WorkerBinding, WorkerBindingResource, WorkerBindings } from "./WorkerBinding.ts";
+import { type WorkerRuntimeContext } from "./WorkerRuntimeContext.ts";
+export declare const WorkerTypeId = "Cloudflare.Worker";
+export type WorkerTypeId = typeof WorkerTypeId;
+export declare const isWorker: <T>(value: T) => value is T & Worker;
+declare const WorkerEnvironment_base: Context.ServiceClass<WorkerEnvironment, "Cloudflare.Workers.WorkerEnvironment", Record<string, any>>;
+export declare class WorkerEnvironment extends WorkerEnvironment_base {
+}
+declare const WorkerExecutionContext_base: Context.ServiceClass<WorkerExecutionContext, "Cloudflare.Workers.WorkerExecutionContext", cf.ExecutionContext<unknown>>;
+export declare class WorkerExecutionContext extends WorkerExecutionContext_base {
+}
+export type WorkerEvent = Exclude<{
+    [type in keyof cf.ExportedHandler]: {
+        kind: "Cloudflare.Workers.WorkerEvent";
+        type: type;
+        input: Parameters<Exclude<cf.ExportedHandler[type], undefined>>[0];
+        env: Parameters<Exclude<cf.ExportedHandler[type], undefined>>[1];
+        context: Parameters<Exclude<cf.ExportedHandler[type], undefined>>[2];
+    };
+}[keyof cf.ExportedHandler], undefined>;
+export declare const isWorkerEvent: (value: any) => value is WorkerEvent;
+/**
+ * Assets configuration that includes a pre-computed hash.
+ * When hash is provided, it's used directly for diffing instead of computing from directory contents.
+ * This is useful when integrating with Build resources that produce a deterministic hash.
+ */
+export interface AssetsWithHash {
+    /**
+     * Path to the assets directory.
+     */
+    path: string;
+    /**
+     * Pre-computed hash of the assets. When provided, this hash is used for diffing
+     * to determine if the worker needs to be redeployed.
+     */
+    hash: string;
+    /**
+     * Optional assets configuration.
+     */
+    config?: AssetsConfig;
+}
+export interface WorkerObservability extends Exclude<workers.PutScriptRequest["metadata"]["observability"], undefined> {
+}
+export interface WorkerLimits extends Exclude<workers.PutScriptRequest["metadata"]["limits"], undefined> {
+}
+export type WorkerPlacement = Exclude<workers.PutScriptRequest["metadata"]["placement"], undefined>;
+export declare const ExportedHandlerMethods: ["fetch", "tail", "trace", "tailStream", "scheduled", "test", "email", "queue"];
+export type WorkerServices = Worker | Request | WorkerExecutionContext | WorkerEnvironment;
+export type WorkerShape = Main<WorkerServices>;
+export type WorkerEnv = Record<string, string | number | boolean | null | readonly unknown[] | {
+    readonly [key: string]: unknown;
+} | Redacted.Redacted<string>>;
+export type WorkerBindingProps = {
+    [bindingName in string]: WorkerBindingResource | Effect.Effect<WorkerBindingResource, any, any>;
+};
+type NormalizedBindings<Bindings extends WorkerBindingProps = {}, AssetsConfig extends WorkerAssetsConfig | undefined = undefined> = {
+    [B in keyof Bindings]: Bindings[B] extends Effect.Effect<infer T extends WorkerBindingResource, any, any> ? T extends Redacted.Redacted<infer T> | Config.Config<infer T> ? T : T : Extract<Bindings[B], WorkerBindingResource>;
+} & (undefined extends AssetsConfig ? {} : {
+    ASSETS: Assets;
+});
+export type WorkerAssetsConfig = string | AssetsProps | AssetsWithHash;
+export interface WorkerProps<Bindings extends WorkerBindingProps = any, Assets extends WorkerAssetsConfig | undefined = WorkerAssetsConfig | undefined> extends PlatformProps {
+    /**
+     * Worker name override. If omitted, Alchemy derives a deterministic physical
+     * name from the stack, stage, and logical ID.
+     */
+    name?: string;
+    /**
+     * Whether to enable a workers.dev URL for this worker
+     * @default true
+     */
+    url?: boolean;
+    /**
+     * Static assets to serve. Can be:
+     * - A string path to the assets directory
+     * - An AssetsProps object with directory and config
+     * - An object with path and hash (e.g., from a Build resource)
+     */
+    assets?: Assets;
+    subdomain?: {
+        enabled?: boolean;
+        previewsEnabled?: boolean;
+    };
+    /** @internal used by Cloudflare.Vite resource */
+    vite?: {
+        rootDir?: string;
+        memo?: MemoOptions;
+    };
+    logpush?: boolean;
+    /**
+     * Cloudflare Workers Observability settings. Controls Workers Logs
+     * (`logs`) and Workers Traces (`traces`), each with their own
+     * `enabled`, `headSamplingRate`, and `persist` toggles.
+     *
+     * If omitted, defaults to `{ enabled: true, logs: { enabled: true,
+     * invocationLogs: true } }`. Traces are off by default — opt in via
+     * `traces: { enabled: true, ... }`.
+     */
+    observability?: WorkerObservability;
+    tags?: string[];
+    /**
+     * Path to the Worker's entry module. Bundled with rolldown before
+     * upload. Mutually exclusive with {@link script} — provide exactly one.
+     */
+    main?: string;
+    /**
+     * Raw module source for the Worker. When provided, bundling is bypassed
+     * entirely and this string is uploaded as a single ESM module
+     * (`main.js`). Useful for tiny inline workers (tests, fixtures,
+     * one-offs) and any case where you've already produced the final
+     * bundle elsewhere. Mutually exclusive with {@link main}.
+     */
+    script?: string;
+    compatibility?: {
+        date?: string;
+        flags?: ("nodejs_compat" | "nodejs_als" | (string & {}))[];
+    };
+    limits?: WorkerLimits;
+    placement?: WorkerPlacement;
+    exports?: string[];
+    /**
+     * Environment variables and native Cloudflare Bindings to bind to
+     * the Worker. Accepts:
+     *
+     * - Resource references (R2 bucket, KV namespace, D1 database,
+     *   another Worker, Durable Object, etc.) — emitted as the
+     *   corresponding native binding.
+     * - `effect/Config` values (`Config.redacted`, `Config.string`,
+     *   `Config.number`, …) — resolved at deploy time and bound as
+     *   `secret_text` on Cloudflare regardless of the `Config`
+     *   constructor used. See
+     *   {@link https://v2.alchemy.run/concepts/secrets | Concepts › Secrets and Variables}.
+     * - Literal values — routed by shape: `Redacted<string>` →
+     *   `secret_text`, `string` → `plain_text`, anything else → `json`.
+     *
+     * In Effect-native Workers you can alternatively `yield*` a
+     * `Config` in the Init phase to register the binding implicitly;
+     * `env` is the only option for async (non-Effect) Workers.
+     */
+    env?: Bindings;
+    /**
+     * Cron expressions that trigger the Worker's scheduled handler.
+     *
+     * Pass an empty array to remove all Cron Triggers.
+     */
+    crons?: string[];
+    /**
+     * One or more custom hostnames (e.g. `"app.example.com"`) to bind to this
+     * Worker. The Cloudflare Zone is inferred from the hostname — the zone must
+     * already exist in the account.
+     */
+    domain?: string | string[];
+    /**
+     * Extra bundler options applied on top of the standard rolldown input/output
+     * options used to build this Worker. See {@link Bundle.BundleExtraOptions}.
+     */
+    build?: Bundle.BundleExtraOptions;
+    /**
+     * Options for the local dev server that runs this Worker under `alchemy dev`.
+     * Each Worker is served on its own port.
+     */
+    dev?: {
+        /**
+         * Host the local dev server binds to.
+         * @default "localhost"
+         */
+        host?: string;
+        /**
+         * Port the local dev server listens on. If the port is unavailable, the
+         * next free port is used unless {@link strictPort} is `true`.
+         * @default 1337
+         */
+        port?: number;
+        /**
+         * When `true`, fail instead of falling back to another port if {@link port}
+         * is already in use.
+         * @default false
+         */
+        strictPort?: boolean;
+    };
+}
+export type Worker<Bindings extends WorkerBindings = any> = Resource<WorkerTypeId, WorkerProps<Bindings>, {
+    workerId: string;
+    workerName: string;
+    logpush: boolean | undefined;
+    url: string | undefined;
+    tags: string[] | undefined;
+    durableObjectNamespaces: Record<string, string>;
+    accountId: string;
+    domains: string[];
+    crons: string[];
+    hash?: {
+        assets: string | undefined;
+        bundle: string | undefined;
+        input: string | undefined;
+    };
+}, {
+    bindings?: WorkerBinding[];
+    containers?: {
+        className: string;
+    }[];
+    crons?: string[];
+    hyperdrives?: Record<string, Required<HyperdriveDevOrigin>>;
+}, Providers>;
+/**
+ * A Cloudflare Worker host with deploy-time binding support and runtime export
+ * collection.
+ *
+ * A Worker follows a two-phase pattern. The outer `Effect.gen` runs at
+ * deploy time to bind resources (KV, R2, Durable Objects, etc.). It returns
+ * an object whose properties are the Worker's runtime handlers — `fetch` for
+ * HTTP requests and any additional RPC methods.
+ *
+ * ```typescript
+ * Effect.gen(function* () {
+ *   // Phase 1: bind resources (runs at deploy time)
+ *   const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
+ *
+ *   return {
+ *     // Phase 2: runtime handlers (runs on each request)
+ *     fetch: Effect.gen(function* () {
+ *       const value = yield* kv.get("key");
+ *       return HttpServerResponse.text(value ?? "not found");
+ *     }),
+ *   };
+ * })
+ * ```
+ *
+ * There are three ways to define a Worker, from simplest to most
+ * flexible. See the {@link https://alchemy.run/concepts/platform | Platform concept}
+ * page for the full explanation.
+ *
+ * - **Async** — plain `async fetch` handler, no Effect runtime in the bundle.
+ * - **Effect** — Effect implementation passed directly, single file.
+ * - **Layer** — class and `.make()` in a single file; Rolldown tree-shakes `.make()` from consumers.
+ *
+ * @section Async Workers
+ * You don't have to use Effect for your runtime code. If you create
+ * a Worker resource with `main` pointing at a file but provide no
+ * `Effect.gen` implementation, Alchemy bundles and deploys that file
+ * as-is. Your handler is a plain `async fetch` — no Effect runtime
+ * is included in the bundle.
+ *
+ * Use the `env` prop to declare which resources, `Config` values,
+ * and literal env vars are available at runtime, and
+ * `Cloudflare.InferEnv` to extract a fully typed `env` object from
+ * them.
+ *
+ * See the {@link https://alchemy.run/guides/async-worker | Async Workers Guide}
+ * for a comprehensive walkthrough of all binding types (R2, D1,
+ * Durable Objects, Assets, and more).
+ *
+ * @example Defining an async Worker in your stack
+ * ```typescript
+ * // alchemy.run.ts
+ * const db = yield* Cloudflare.D1Database("DB");
+ * const bucket = yield* Cloudflare.R2Bucket("Bucket");
+ *
+ * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
+ *
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   env: { db, bucket },
+ * });
+ * ```
+ *
+ * @example Writing the async handler
+ * ```typescript
+ * // src/worker.ts
+ * import type { WorkerEnv } from "../alchemy.run.ts";
+ *
+ * export default {
+ *   async fetch(request: Request, env: WorkerEnv) {
+ *     if (request.method === "GET") {
+ *       const object = await env.bucket.get("key");
+ *       return new Response(object?.body ?? null);
+ *     }
+ *     return new Response("Not Found", { status: 404 });
+ *   },
+ * };
+ * ```
+ *
+ * @section Effect Workers
+ * Pass the Effect implementation as the third argument. This is the
+ * simplest Effect-based approach — everything lives in one file.
+ * Convenient for standalone Workers that don't need to be referenced
+ * by other Workers.
+ *
+ * @example Worker Effect
+ * ```typescript
+ * export default class MyWorker extends Cloudflare.Worker<MyWorker>()(
+ *   "MyWorker",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     // init: bind resources
+ *     const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
+ *
+ *     return {
+ *       // runtime: use them
+ *       fetch: Effect.gen(function* () {
+ *         const value = yield* kv.get("key");
+ *         return HttpServerResponse.text(value ?? "not found");
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Worker Layer
+ * When two Workers need to reference each other (e.g. WorkerA calls
+ * WorkerB and vice versa), or you simply want optimal tree-shaking,
+ * define the Worker class separately from its `.make()` call. The
+ * class is a lightweight identifier; `.make()` provides the runtime
+ * implementation as an `export default`. Rolldown treats `.make()`
+ * as pure, so any Worker that imports the class to bind it will not
+ * pull in the `.make()` dependencies — the bundler tree-shakes
+ * them away entirely.
+ *
+ * The class and `.make()` can live in the same file. This is the
+ * same pattern used by `Container` and `DurableObjectNamespace`,
+ * and is recommended for any cross-Worker or cross-DO bindings.
+ *
+ * @example Worker Layer (class + .make() in one file)
+ * ```typescript
+ * // src/WorkerB.ts
+ * export default class WorkerB extends Cloudflare.Worker<WorkerB>()(
+ *   "WorkerB",
+ *   { main: import.meta.filename },
+ * ) {}
+ *
+ * export default WorkerB.make(
+ *   Effect.gen(function* () {
+ *     // init: bind resources
+ *     const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
+ *
+ *     return {
+ *       // runtime: use them
+ *       greet: (name: string) =>
+ *         Effect.gen(function* () {
+ *           yield* kv.put("last-greeted", name);
+ *           return `Hello ${name}`;
+ *         }),
+ *     };
+ *   }),
+ * );
+ * ```
+ *
+ * @example Binding a Worker Layer from another Worker
+ * ```typescript
+ * // src/WorkerA.ts — imports WorkerB; bundler tree-shakes .make()
+ * import WorkerB from "./WorkerB.ts";
+ *
+ * export default class WorkerA extends Cloudflare.Worker<WorkerA>()(
+ *   "WorkerA",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     const b = yield* Cloudflare.Worker.bind(WorkerB);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         return yield* b.greet("world");
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Configuration
+ * The props object controls compatibility flags, static assets, and
+ * build options. These are evaluated at deploy time.
+ *
+ * @example Enabling Node.js compatibility
+ * ```typescript
+ * {
+ *   main: import.meta.filename,
+ *   compatibility: {
+ *     flags: ["nodejs_compat"],
+ *     date: "2026-03-17",
+ *   },
+ * }
+ * ```
+ *
+ * @example Serving static assets
+ * ```typescript
+ * {
+ *   main: import.meta.filename,
+ *   assets: "./public",
+ * }
+ * ```
+ *
+ * @section Observability
+ * Cloudflare Workers Observability is on by default — `logs.enabled` and
+ * `logs.invocationLogs` are turned on if you don't pass an `observability`
+ * prop. Pass the prop yourself to tune sampling, enable persistence, or
+ * turn on the new `traces` channel (the same toggle the dashboard's
+ * Observability tab writes).
+ *
+ * Field names match the Cloudflare API (camelCased): `headSamplingRate`,
+ * `invocationLogs`, etc.
+ *
+ * @example Enabling logs and traces
+ * ```typescript
+ * {
+ *   main: import.meta.filename,
+ *   observability: {
+ *     enabled: true,
+ *     headSamplingRate: 1,
+ *     logs: {
+ *       enabled: true,
+ *       invocationLogs: true,
+ *       headSamplingRate: 1,
+ *       persist: true,
+ *     },
+ *     traces: {
+ *       enabled: true,
+ *       headSamplingRate: 1,
+ *       persist: true,
+ *     },
+ *   },
+ * }
+ * ```
+ *
+ * @section R2 Bucket
+ * Bind an R2 bucket in the init phase with `Cloudflare.R2Bucket.bind`.
+ * The returned handle exposes `get`, `put`, `delete`, and `list`
+ * methods you can call in your runtime handlers.
+ *
+ * @example Binding and using R2
+ * ```typescript
+ * // init
+ * const bucket = yield* Cloudflare.R2Bucket.bind(MyBucket);
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const request = yield* HttpServerRequest;
+ *     const key = request.url.split("/").pop()!;
+ *
+ *     if (request.method === "GET") {
+ *       const object = yield* bucket.get(key);
+ *       return object
+ *         ? HttpServerResponse.text(yield* object.text())
+ *         : HttpServerResponse.empty({ status: 404 });
+ *     }
+ *
+ *     yield* bucket.put(key, request.stream);
+ *     return HttpServerResponse.empty({ status: 201 });
+ *   }),
+ * };
+ * ```
+ *
+ * @section KV Namespace
+ * Bind a KV namespace with `Cloudflare.KVNamespace.bind`. KV provides
+ * eventually-consistent, low-latency key-value reads replicated
+ * globally across Cloudflare's edge.
+ *
+ * @example Binding and using KV
+ * ```typescript
+ * // init
+ * const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const value = yield* kv.get("my-key");
+ *     return HttpServerResponse.text(value ?? "not found");
+ *   }),
+ * };
+ * ```
+ *
+ * @section D1 Database
+ * Bind a D1 database with `Cloudflare.D1Connection.bind`. D1 is a
+ * serverless SQLite database — use `prepare` to build parameterized
+ * queries and `all`, `first`, or `run` to execute them.
+ *
+ * @example Binding and querying D1
+ * ```typescript
+ * // init
+ * const db = yield* Cloudflare.D1Connection.bind(MyDB);
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const results = yield* db
+ *       .prepare("SELECT * FROM users WHERE id = ?")
+ *       .bind(userId)
+ *       .all();
+ *     return yield* HttpServerResponse.json(results);
+ *   }),
+ * };
+ * ```
+ *
+ * @section Durable Objects
+ * Yield a `DurableObjectNamespace` class in the init phase to get a
+ * namespace handle. Call `getByName` or `getById` to get a typed RPC
+ * stub, then call its methods from your runtime handlers.
+ *
+ * @example Using a Durable Object
+ * ```typescript
+ * // init
+ * const counters = yield* Counter;
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const counter = counters.getByName("user-123");
+ *     const value = yield* counter.increment();
+ *     return HttpServerResponse.text(String(value));
+ *   }),
+ * };
+ * ```
+ *
+ * @section Containers
+ * Containers run long-lived processes alongside Durable Objects. Bind
+ * one with `Cloudflare.Container.bind` and start it with
+ * `Cloudflare.start`. You can call typed methods on the running
+ * container or make HTTP requests to its exposed ports.
+ *
+ * @example Binding and starting a Container
+ * ```typescript
+ * // init (inside a DurableObjectNamespace)
+ * const sandbox = yield* Cloudflare.Container.bind(Sandbox);
+ *
+ * return Effect.gen(function* () {
+ *   const container = yield* Cloudflare.start(sandbox, { enableInternet: true });
+ *
+ *   return {
+ *     exec: (cmd: string) => container.exec(cmd),
+ *     fetch: Effect.gen(function* () {
+ *       const { fetch } = yield* container.getTcpPort(3000);
+ *       const res = yield* fetch(HttpClientRequest.get("http://container/"));
+ *       return HttpServerResponse.fromClientResponse(res);
+ *     }),
+ *   };
+ * });
+ * ```
+ *
+ * @section Dynamic Workers
+ * `DynamicWorkerLoader` lets you spin up ephemeral Workers at runtime
+ * from inline JavaScript modules. This is useful for sandboxing
+ * user-provided code or running untrusted scripts in isolation.
+ *
+ * @example Loading a dynamic Worker
+ * ```typescript
+ * // init
+ * const loader = yield* Cloudflare.DynamicWorkerLoader("Loader");
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const worker = loader.load({
+ *       compatibilityDate: "2026-01-28",
+ *       mainModule: "worker.js",
+ *       modules: {
+ *         "worker.js": `export default {
+ *           async fetch(req) { return new Response("sandboxed"); }
+ *         }`,
+ *       },
+ *     });
+ *
+ *     const res = yield* worker.fetch(
+ *       HttpClientRequest.get("https://worker/"),
+ *     );
+ *     return HttpServerResponse.fromClientResponse(res);
+ *   }),
+ * };
+ * ```
+ */
+export declare const Worker: Platform<Worker, WorkerServices, WorkerShape, WorkerRuntimeContext> & {
+    <const Bindings extends WorkerBindingProps = {}, const Assets extends WorkerAssetsConfig | undefined = undefined, Req = never>(id: string, props: InputProps<WorkerProps<Bindings, Assets>> | Effect.Effect<InputProps<WorkerProps<Bindings, Assets>>, never, Req>): Effect.Effect<Worker<{
+        [binding in keyof NormalizedBindings<Bindings, Assets>]: NormalizedBindings<Bindings, Assets>[binding];
+    }>, never, Req | Providers>;
+};
+export declare const WorkerProvider: () => Layer.Layer<Provider.Provider<Worker<any>>, Config.ConfigError | import("effect/PlatformError").PlatformError | import("@distilled.cloud/cloudflare-runtime").SystemError, any>;
+export declare const LiveWorkerProvider: () => Layer.Layer<Provider.Provider<Worker<any>>, never, any>;
+export {};
+//# sourceMappingURL=Worker.d.ts.map

package/lib/Cloudflare/Workers/Worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/Worker.ts"],"names":[],"mappings":"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"}