@moku-labs/worker 0.1.0

package/dist/index.mjs

@@ -0,0 +1,491 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as defineDurableObject, c as coreConfig, d as stagePlugin, i as durableObjectsPlugin, l as createCore, n as queuesPlugin, o as d1Plugin, r as kvPlugin, s as bindingsPlugin, t as storagePlugin, u as createPlugin$1 } from "./storage-bL-U_fkA.mjs";
+import { envPlugin, logPlugin } from "@moku-labs/common";
+//#region src/plugins/server/api.ts
+/**
+* Builds the `app.server.*` surface the consumer's Worker default export reads.
+*
+* @param ctx - Plugin context: config, compiled state table, emit, require, has.
+* @returns The server API object with `handle` and `scheduled` methods.
+* @example
+* ```typescript
+* // Wired in index.ts as: api: ctx => createServerApi(ctx)
+* const serverApi = createServerApi(ctx);
+* const response = await serverApi.handle(request, env, exec);
+* ```
+*/
+const createServerApi = (ctx) => {
+	/**
+	* Route one HTTP request and return its `Response` (or 404 Not Found).
+	*
+	* Allocates a fresh `RequestContext` on the call stack carrying the
+	* per-request `env` — never stored on state (SB4). Response flows through
+	* the return value, not `emit` (F8; spec/07 §1).
+	*
+	* @param request - The incoming Cloudflare `Request`.
+	* @param env - Per-request Cloudflare bindings; threaded on the stack, never stored.
+	* @param exec - `ExecutionContext` for `waitUntil` / `passThroughOnException`.
+	* @returns The matched handler's `Response`, or `404 Not Found`.
+	* @example
+	* ```typescript
+	* const res = await serverApi.handle(new Request("https://example.com/"), env, exec);
+	* ```
+	*/
+	const handle = async (request, env, exec) => {
+		const url = new URL(request.url);
+		const requestId = crypto.randomUUID();
+		const startTime = Date.now();
+		ctx.emit("request:start", {
+			method: request.method,
+			path: url.pathname,
+			requestId
+		});
+		const match = ctx.state.match(request.method, url.pathname);
+		if (!match) return new Response("Not Found", { status: 404 });
+		ctx.emit("server:matched", {
+			path: url.pathname,
+			method: request.method
+		});
+		const rc = {
+			request,
+			env,
+			exec,
+			params: match.params,
+			url,
+			require: ctx.require,
+			has: ctx.has
+		};
+		const response = await match.endpoint.handler(rc);
+		ctx.emit("request:end", {
+			method: request.method,
+			path: url.pathname,
+			status: response.status,
+			ms: Date.now() - startTime
+		});
+		return response;
+	};
+	/**
+	* Cron entry. Dispatches the `ScheduledController` through the same endpoint
+	* table as `handle` and **awaits** the matched handler so Cloudflare does not
+	* kill the isolate before the work finishes.
+	*
+	* Awaited API method — not `emit` — because the Worker must `await` cron work
+	* (F8; spec/07 §3). The `env` is threaded on the stack, never stored on state (SB4).
+	*
+	* @param controller - Cloudflare `ScheduledController` (`cron`, `scheduledTime`).
+	* @param env - Per-request Cloudflare bindings; threaded, never stored.
+	* @param exec - `ExecutionContext` for `waitUntil` / `passThroughOnException`.
+	* @returns Resolves after all matched cron work completes (or immediately if no match).
+	* @example
+	* ```typescript
+	* await serverApi.scheduled(controller, env, exec);
+	* ```
+	*/
+	const scheduled = async (controller, env, exec) => {
+		const match = ctx.state.match("ALL", controller.cron);
+		if (!match) return;
+		const cronUrl = new URL(`https://cron/${controller.cron}`);
+		const rc = {
+			request: new Request(cronUrl.href),
+			env,
+			exec,
+			params: match.params,
+			url: cronUrl,
+			require: ctx.require,
+			has: ctx.has
+		};
+		await match.endpoint.handler(rc);
+	};
+	return {
+		handle,
+		scheduled
+	};
+};
+//#endregion
+//#region src/plugins/server/helpers.ts
+/**
+* Produce an `Endpoint` value from a path, method, and handler.
+*
+* @param path - Endpoint path string.
+* @param method - HTTP method literal or `"ALL"`.
+* @param handler - The function invoked when this endpoint matches.
+* @returns An `Endpoint` value object.
+* @example
+* ```typescript
+* makeEndpoint("/api", "GET", handler); // { path: "/api", method: "GET", handler }
+* ```
+*/
+const makeEndpoint = (path, method, handler) => ({
+	path,
+	method,
+	handler
+});
+/**
+* Build a typed `Endpoint`. `{name}` → required param; `{name?}` → optional param.
+*
+* PURE factory (spec/03 §1): no ctx, no lifecycle, no side effects; safe to run
+* before `createApp`. Each verb method (`get`, `post`, …, `all`) returns the
+* truthful Endpoint value — `method: "ALL"` is never used as a `"get"` sentinel.
+*
+* @param path - Endpoint path, optionally with `{name}` / `{name?}` params.
+* @returns A builder whose verb methods each return a typed `Endpoint`.
+* @example
+* ```typescript
+* endpoint("/api/data/{lang?}").get(({ params }) =>
+*   Response.json({ lang: params.lang ?? "en" })
+* );
+* ```
+*/
+const endpoint = (path) => ({
+	/**
+	* Build a GET endpoint bound to this path.
+	*
+	* @param handler - The handler invoked when a GET request matches.
+	* @returns A GET `Endpoint`.
+	* @example
+	* ```typescript
+	* endpoint("/health").get(() => new Response("ok"));
+	* ```
+	*/
+	get: (handler) => makeEndpoint(path, "GET", handler),
+	/**
+	* Build a POST endpoint bound to this path.
+	*
+	* @param handler - The handler invoked when a POST request matches.
+	* @returns A POST `Endpoint`.
+	* @example
+	* ```typescript
+	* endpoint("/users").post(({ request }) => Response.json({ created: true }, { status: 201 }));
+	* ```
+	*/
+	post: (handler) => makeEndpoint(path, "POST", handler),
+	/**
+	* Build a PUT endpoint bound to this path.
+	*
+	* @param handler - The handler invoked when a PUT request matches.
+	* @returns A PUT `Endpoint`.
+	* @example
+	* ```typescript
+	* endpoint("/users/{id}").put(({ params }) => Response.json({ updated: params.id }));
+	* ```
+	*/
+	put: (handler) => makeEndpoint(path, "PUT", handler),
+	/**
+	* Build a PATCH endpoint bound to this path.
+	*
+	* @param handler - The handler invoked when a PATCH request matches.
+	* @returns A PATCH `Endpoint`.
+	* @example
+	* ```typescript
+	* endpoint("/users/{id}").patch(({ params }) => Response.json({ patched: params.id }));
+	* ```
+	*/
+	patch: (handler) => makeEndpoint(path, "PATCH", handler),
+	/**
+	* Build a DELETE endpoint bound to this path.
+	*
+	* @param handler - The handler invoked when a DELETE request matches.
+	* @returns A DELETE `Endpoint`.
+	* @example
+	* ```typescript
+	* endpoint("/users/{id}").delete(() => new Response(null, { status: 204 }));
+	* ```
+	*/
+	delete: (handler) => makeEndpoint(path, "DELETE", handler),
+	/**
+	* Build a HEAD endpoint bound to this path.
+	*
+	* @param handler - The handler invoked when a HEAD request matches.
+	* @returns A HEAD `Endpoint`.
+	* @example
+	* ```typescript
+	* endpoint("/health").head(() => new Response(null, { status: 200 }));
+	* ```
+	*/
+	head: (handler) => makeEndpoint(path, "HEAD", handler),
+	/**
+	* Build an OPTIONS endpoint bound to this path.
+	*
+	* @param handler - The handler invoked when an OPTIONS request matches.
+	* @returns An OPTIONS `Endpoint`.
+	* @example
+	* ```typescript
+	* endpoint("/api").options(() => new Response(null, { headers: { Allow: "GET, POST" } }));
+	* ```
+	*/
+	options: (handler) => makeEndpoint(path, "OPTIONS", handler),
+	/**
+	* Build an ALL-method endpoint bound to this path (matches any verb).
+	*
+	* @param handler - The handler invoked when any request method matches.
+	* @returns An ALL-method `Endpoint`.
+	* @example
+	* ```typescript
+	* endpoint("0 * * * *").all(async () => new Response("cron done"));
+	* ```
+	*/
+	all: (handler) => makeEndpoint(path, "ALL", handler)
+});
+//#endregion
+//#region src/plugins/server/state.ts
+/** Specificity weight for a literal path segment. */
+const LITERAL_WEIGHT = 2;
+/** Specificity weight for a required param segment `{name}`. */
+const REQUIRED_PARAM_WEIGHT = 1;
+/** Specificity weight for an optional param segment `{name?}`. */
+const OPTIONAL_PARAM_WEIGHT = 0;
+/**
+* Parse one path segment string into a typed `PathSegment`.
+*
+* `{name}` → required param; `{name?}` → optional param; anything else → literal.
+*
+* @param raw - A single path segment token (no leading slash).
+* @returns The parsed `PathSegment`.
+* @example
+* ```typescript
+* parseSegment("{id}")  // → { value: "id", param: true, optional: false }
+* parseSegment("{id?}") // → { value: "id", param: true, optional: true }
+* parseSegment("api")   // → { value: "api", param: false, optional: false }
+* ```
+*/
+const parseSegment = (raw) => {
+	if (raw.startsWith("{") && raw.endsWith("}")) {
+		const inner = raw.slice(1, -1);
+		if (inner.endsWith("?")) return {
+			value: inner.slice(0, -1),
+			param: true,
+			optional: true
+		};
+		return {
+			value: inner,
+			param: true,
+			optional: false
+		};
+	}
+	return {
+		value: raw,
+		param: false,
+		optional: false
+	};
+};
+/**
+* Compute the specificity weight for a single `PathSegment`.
+*
+* @param segment - The parsed segment to score.
+* @returns `2` for literal, `1` for required param, `0` for optional param.
+* @example
+* ```typescript
+* segmentWeight({ value: "api", param: false, optional: false }) // 2
+* segmentWeight({ value: "id",  param: true,  optional: false }) // 1
+* segmentWeight({ value: "q",   param: true,  optional: true  }) // 0
+* ```
+*/
+const segmentWeight = (segment) => {
+	if (!segment.param) return LITERAL_WEIGHT;
+	if (!segment.optional) return REQUIRED_PARAM_WEIGHT;
+	return OPTIONAL_PARAM_WEIGHT;
+};
+/**
+* Convert an `Endpoint` to its compiled form (parsed segments + specificity score).
+*
+* @param endpoint - The declarative endpoint value from config.
+* @returns A `CompiledEndpoint` ready for the matcher table.
+* @example
+* ```typescript
+* const compiled = compileEndpoint(endpoint("/api/{id}").get(handler));
+* // compiled.specificity === 3 (literal "api" = 2, required "{id}" = 1)
+* ```
+*/
+const compileEndpoint = (endpoint) => {
+	const segments = endpoint.path.split("/").filter(Boolean).map((part) => parseSegment(part));
+	return {
+		endpoint,
+		segments,
+		specificity: segments.reduce((total, segment) => total + segmentWeight(segment), 0)
+	};
+};
+/**
+* Try to match one compiled endpoint against a request method and split path tokens.
+*
+* Returns the extracted params map on success, or `undefined` if the endpoint
+* does not match. Uses `undefined` (not `null`) per the unicorn/no-null rule.
+*
+* @param compiled - A single compiled endpoint.
+* @param method - The request method string (e.g. `"GET"`).
+* @param tokens - The request path split into non-empty segments.
+* @returns Extracted params record on match, or `undefined` for no match.
+* @example
+* ```typescript
+* const compiled = compileEndpoint(endpoint("/users/{id}").get(handler));
+* tryMatchEndpoint(compiled, "GET", ["users", "42"]) // → { id: "42" }
+* tryMatchEndpoint(compiled, "POST", ["users"])      // → undefined
+* ```
+*/
+const tryMatchEndpoint = (compiled, method, tokens) => {
+	if (compiled.endpoint.method !== "ALL" && compiled.endpoint.method !== method) return;
+	const { segments } = compiled;
+	const mandatoryCount = segments.filter((segment) => !segment.optional).length;
+	if (tokens.length < mandatoryCount || tokens.length > segments.length) return;
+	const params = {};
+	for (const [index, segment] of segments.entries()) {
+		const token = tokens[index];
+		if (segment.param) if (token === void 0) {
+			if (!segment.optional) return void 0;
+			params[segment.value] = void 0;
+		} else params[segment.value] = token;
+		else if (token !== segment.value) return;
+	}
+	return params;
+};
+/**
+* Sort comparator placing higher-specificity endpoints first.
+* Tie-break: method-specific endpoints before `ALL` so explicit methods win.
+*
+* @param a - First compiled endpoint.
+* @param b - Second compiled endpoint.
+* @returns Negative, zero, or positive sort key.
+* @example
+* ```typescript
+* const a = compileEndpoint(endpoint("/api/{id}").get(handler));   // specificity 3
+* const b = compileEndpoint(endpoint("/api/{id?}").get(handler));  // specificity 2
+* [b, a].sort(bySpecificityDesc); // → [a, b] — higher specificity first
+* ```
+*/
+const bySpecificityDesc = (a, b) => {
+	const delta = b.specificity - a.specificity;
+	if (delta !== 0) return delta;
+	if (a.endpoint.method !== "ALL" && b.endpoint.method === "ALL") return -1;
+	if (a.endpoint.method === "ALL" && b.endpoint.method !== "ALL") return 1;
+	return 0;
+};
+/**
+* Find the best-matching compiled endpoint in the table for the given method + path.
+*
+* Iterates the table (assumed sorted high-to-low specificity) and returns the
+* first match. Internally re-sorts on every call so it is safe to call before
+* `onInit` compiles the table.
+*
+* @param table - The compiled endpoint table.
+* @param method - Request method string (e.g. `"GET"`, `"ALL"`).
+* @param tokens - Path split into non-empty string tokens.
+* @returns The match result, or `null` when no endpoint matches.
+* @example
+* ```typescript
+* const result = findBestMatch(state.table, "GET", ["api", "users"]);
+* ```
+*/
+const findBestMatch = (table, method, tokens) => {
+	const sorted = table.toSorted(bySpecificityDesc);
+	for (const compiled of sorted) {
+		const params = tryMatchEndpoint(compiled, method, tokens);
+		if (params !== void 0) return {
+			endpoint: compiled.endpoint,
+			params
+		};
+	}
+	return null;
+};
+/**
+* Compile and sort the endpoint table in-place.
+*
+* Called by `onInit` — the one-time per-isolate setup. Sorts `state.table` by
+* specificity (descending), validates that no endpoint path contains duplicate
+* `{param}` names, and sets `state.compiled = true` to guard re-entry.
+*
+* @param state - The mutable server state whose `table` should be compiled.
+* @throws {Error} With `[moku-worker]` prefix when a path has duplicate param names.
+* @example
+* ```typescript
+* // Called inside serverPlugin.onInit:
+* compileServerState(ctx.state);
+* ```
+*/
+const compileServerState = (state) => {
+	if (state.compiled) return;
+	state.table.sort(bySpecificityDesc);
+	for (const compiled of state.table) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const segment of compiled.segments) {
+			if (!segment.param) continue;
+			if (seen.has(segment.value)) throw new Error(`[moku-worker] endpoint path "${compiled.endpoint.path}" has duplicate param "{${segment.value}}".\n  Each {param} name in a path must be unique.`);
+			seen.add(segment.value);
+		}
+	}
+	state.compiled = true;
+};
+/**
+* Creates the initial (uncompiled) server state from a declarative endpoint list.
+*
+* Copies `endpoints` into a fresh mutable `CompiledEndpoint[]` — does NOT mutate
+* the frozen config array. Sets `compiled = false`; `onInit` calls
+* `compileServerState` to sort/validate and set `compiled = true`.
+*
+* The `match(method, path)` method is safe to call before `onInit` because
+* `findBestMatch` re-sorts on every invocation.
+*
+* @param endpoints - The frozen declarative endpoint table from `config.endpoints`.
+* @returns A fresh `ServerState` with `compiled = false`.
+* @example
+* ```typescript
+* const state = createServerState(config.endpoints);
+* const hit = state.match("GET", "/api/users");
+* ```
+*/
+const createServerState = (endpoints) => {
+	const table = endpoints.map((ep) => compileEndpoint(ep));
+	/**
+	* Match a method + pathname against the compiled table.
+	*
+	* @param method - Request method (or `"ALL"` for cron dispatch).
+	* @param path - Request URL pathname (or cron expression string).
+	* @returns Matched endpoint + extracted params, or `null` for no match.
+	* @example
+	* ```typescript
+	* state.match("GET", "/api/users");
+	* ```
+	*/
+	const match = (method, path) => {
+		return findBestMatch(table, method, path.split("/").filter(Boolean));
+	};
+	return {
+		table,
+		compiled: false,
+		match
+	};
+};
+/**
+* Standard tier — HTTP routing + request/scheduled dispatch over a compiled
+* endpoint table. Emits `server:matched` (per-plugin) plus global
+* `request:start` / `request:end` declared in `WorkerEvents`.
+*
+* @see README.md
+*/
+const serverPlugin = createPlugin$1("server", {
+	events: (register) => register.map({ "server:matched": "An endpoint matched a request" }),
+	depends: [bindingsPlugin],
+	config: { endpoints: [] },
+	createState: ({ config }) => createServerState(config.endpoints),
+	api: (ctx) => createServerApi(ctx),
+	onInit: (ctx) => {
+		compileServerState(ctx.state);
+	},
+	helpers: { endpoint }
+});
+//#endregion
+//#region src/plugins/d1/types.ts
+var types_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region src/plugins/durable-objects/types.ts
+var types_exports$1 = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region src/plugins/queues/types.ts
+var types_exports$2 = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region src/plugins/server/types.ts
+var types_exports$3 = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region src/plugins/storage/types.ts
+var types_exports$4 = /* @__PURE__ */ __exportAll({});
+const { createApp, createPlugin } = createCore(coreConfig, { plugins: [bindingsPlugin, serverPlugin] });
+//#endregion
+export { types_exports as D1, types_exports$1 as DurableObjects, types_exports$2 as Queues, types_exports$3 as Server, types_exports$4 as Storage, bindingsPlugin, createApp, createPlugin, d1Plugin, defineDurableObject, durableObjectsPlugin, endpoint, envPlugin, kvPlugin, logPlugin, queuesPlugin, serverPlugin, stagePlugin, storagePlugin };

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };