oxidejs 0.2.3 → 0.3.0

package/dist/client-Bc4g9AEw.mjs

@@ -0,0 +1,145 @@
+import { Effect, Layer, Scope, Stream } from "effect";
+import { RpcClient, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { Socket } from "effect/unstable/socket";
+//#region src/rpc/stream.ts
+function asyncGenToStream(gen) {
+	return Stream.fromAsyncIterable(gen, (error) => error instanceof Error ? error : new Error(String(error)));
+}
+/**
+* Re-enter `run` for every generator pull so AsyncLocalStorage request context
+* stays available across yields (Effect may drain the stream after the outer ALS scope ends).
+*/
+function bindAsyncGenContext(gen, run) {
+	return {
+		next: (value) => run(() => gen.next(value)),
+		return: (value) => run(() => gen.return(value)),
+		throw: (error) => run(() => gen.throw(error)),
+		[Symbol.asyncIterator]() {
+			return this;
+		},
+		async [Symbol.asyncDispose]() {
+			await run(() => gen.return(void 0));
+		}
+	};
+}
+/** Create a generator inside `run`, then keep every subsequent pull inside `run`. */
+function asyncGenToStreamInContext(create, run) {
+	return asyncGenToStream(bindAsyncGenContext(run(create), run));
+}
+function streamToAsyncGen(stream) {
+	return Stream.toAsyncIterable(stream);
+}
+//#endregion
+//#region src/rpc/client.ts
+const clientCache = /* @__PURE__ */ new Map();
+let nextGroupId = 0;
+function cacheKey(group, options) {
+	const headerKey = options.headers ? Object.entries(options.headers).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join("&") : "";
+	let groupId = group.__oxideClientId;
+	if (groupId === void 0) {
+		groupId = ++nextGroupId;
+		group.__oxideClientId = groupId;
+	}
+	return `${groupId}|${options.transport ?? "http"}|${options.url}|${headerKey}`;
+}
+function httpLayer(options) {
+	const headers = options.headers;
+	return RpcClient.layerProtocolHttp({
+		url: options.url,
+		...headers ? { transformClient: (client) => HttpClient.mapRequest(client, (req) => {
+			for (const [key, value] of Object.entries(headers)) req = HttpClientRequest.setHeader(req, key, value);
+			return req;
+		}) } : {}
+	}).pipe(Layer.provide(RpcSerialization.layerNdJsonRpc()), Layer.provide(FetchHttpClient.layer));
+}
+function wsLayer(url) {
+	return RpcClient.layerProtocolSocket().pipe(Layer.provide(RpcSerialization.layerNdJsonRpc()), Layer.provide(Socket.layerWebSocket(url)), Layer.provide(Socket.layerWebSocketConstructorGlobal));
+}
+function clientLayer(options) {
+	return options.transport === "ws" ? wsLayer(options.url) : httpLayer(options);
+}
+function loadClient(group, options) {
+	return Effect.gen(function* () {
+		const scope = yield* Scope.make();
+		return yield* Scope.provide(scope)(RpcClient.make(group).pipe(Effect.provide(clientLayer(options))));
+	});
+}
+function isStreamResult(value) {
+	return Stream.isStream(value);
+}
+function isStreamTag(group, tag) {
+	const rpc = group.requests.get(tag);
+	if (!rpc?.successSchema) return false;
+	return RpcSchema.isStreamSchema(rpc.successSchema);
+}
+function streamToAsyncGenerator(stream, signal) {
+	const iterable = streamToAsyncGen(stream);
+	return (async function* () {
+		if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+		const iterator = iterable[Symbol.asyncIterator]();
+		const onAbort = () => {
+			iterator.return?.();
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			while (true) {
+				if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+				const next = await iterator.next();
+				if (next.done) return void 0;
+				yield next.value;
+			}
+		} finally {
+			signal?.removeEventListener("abort", onAbort);
+		}
+	})();
+}
+function callFlat(client, tag, args, callOpts) {
+	const caller = client[tag];
+	if (!caller) return Promise.reject(/* @__PURE__ */ new Error(`Unknown action ${tag}`));
+	const result = caller({ args }, callOpts);
+	if (isStreamResult(result)) return streamToAsyncGenerator(result, callOpts?.signal);
+	return Effect.runPromise(result, { signal: callOpts?.signal });
+}
+function nestClient(group, flat) {
+	const nested = {};
+	for (const tag of group.requests.keys()) {
+		const dot = tag.indexOf(".");
+		if (dot === -1) continue;
+		const mod = tag.slice(0, dot);
+		const name = tag.slice(dot + 1);
+		nested[mod] ??= {};
+		nested[mod][name] = (...args) => {
+			const opts = args.at(-1);
+			const hasSignal = opts && typeof opts === "object" && "signal" in opts && opts.signal instanceof AbortSignal && Object.keys(opts).length === 1;
+			const params = hasSignal ? args.slice(0, -1) : args;
+			return callFlat(flat, tag, params, hasSignal ? opts : void 0);
+		};
+	}
+	return nested;
+}
+function createClient(group, options) {
+	const key = cacheKey(group, options);
+	let entry = clientCache.get(key);
+	if (!entry) {
+		entry = { pending: Effect.runPromise(loadClient(group, options)).then((flat) => nestClient(group, flat)).catch((error) => {
+			clientCache.delete(key);
+			throw error;
+		}) };
+		clientCache.set(key, entry);
+	}
+	return new Proxy({}, { get(_target, mod) {
+		if (typeof mod !== "string") return void 0;
+		return new Proxy({}, { get(_inner, name) {
+			if (typeof name !== "string") return void 0;
+			if (isStreamTag(group, `${mod}.${name}`)) return (...args) => (async function* () {
+				const out = (await entry.pending)[mod]?.[name]?.(...args);
+				if (!out) throw new Error(`Unknown action ${mod}.${name}`);
+				yield* out;
+			})();
+			return (...args) => entry.pending.then((client) => client[mod]?.[name]?.(...args) ?? Promise.reject(/* @__PURE__ */ new Error(`Unknown action ${mod}.${name}`)));
+		} });
+	} });
+}
+//#endregion
+export { streamToAsyncGen as a, bindAsyncGenContext as i, asyncGenToStream as n, asyncGenToStreamInContext as r, createClient as t };

package/dist/context-C1UFQ0Zc.d.mts

@@ -0,0 +1,64 @@
+import * as Atom from "effect/unstable/reactivity/Atom";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+//#region src/action.d.ts
+declare const ACTION_CALL: unique symbol;
+type CallOptions = {
+  signal?: AbortSignal;
+};
+type ServerActionHandle<Args extends unknown[], A> = {
+  (...args: Args | [...Args, CallOptions]): Promise<A>;
+  set(...args: Args): Promise<A>;
+  bind(...args: Args): (...ev: unknown[]) => void;
+  with(...args: Args): (...ev: unknown[]) => void;
+  /** Last `AsyncResult` for this action's client atom (does not invoke RPC). */
+  readonly result: AsyncResult.AsyncResult<A, unknown>;
+  readonly atom: Atom.Atom<unknown>;
+  readonly $$atom: 1;
+};
+type StreamActionHandle<Args extends unknown[], Y, R = void> = {
+  (...args: Args | [...Args, CallOptions]): AsyncGenerator<Y, R, undefined>;
+  set(...args: Args): AsyncGenerator<Y, R, undefined>;
+  bind(...args: Args): (...ev: unknown[]) => void;
+  with(...args: Args): (...ev: unknown[]) => void;
+  readonly atom: undefined;
+  readonly $$atom: 1;
+};
+/** Attach an ilha server-island capture key to an action handle. */
+declare function brandServerAction<Args extends unknown[], A>(key: string, handle: ServerActionHandle<Args, A>): ServerActionHandle<Args, A>;
+/** Wrap an RPC caller as an `Atom.fn`-shaped client action handle. */
+declare function wrapClientRpc<Args extends unknown[], A>(rpc: (...args: Args | [...Args, CallOptions]) => Promise<A>): ServerActionHandle<Args, A>;
+/**
+ * Wrap a streaming RPC caller so the client handle returns an async generator
+ * (awaiting the underlying client lazily), not `Promise<AsyncGenerator>`.
+ */
+declare function wrapClientStreamRpc<Args extends unknown[], Y, R = void>(rpc: (...args: Args | [...Args, CallOptions]) => AsyncGenerator<Y, R, undefined>): StreamActionHandle<Args, Y, R>;
+/**
+ * Marks a `*.server.ts` export as a remote RPC action. On the server the
+ * underlying function runs locally; on the client the build replaces the module
+ * with an `Atom.fn`-shaped RPC handle (`set`, `bind`, `result`).
+ */
+declare function action<Args extends unknown[], Y, R = void>(fn: (...args: Args) => AsyncGenerator<Y, R, unknown>): StreamActionHandle<Args, Y, R>;
+declare function action<Args extends unknown[], Result>(fn: (...args: Args) => Result): ServerActionHandle<Args, Awaited<Result>>;
+//#endregion
+//#region src/context.d.ts
+type ExecutionContext = {
+  waitUntil?(promise: Promise<unknown>): void;
+  passThroughOnException?(): void;
+};
+/** RPC procedure request context. Starts as `{ req }` plus Worker extras. Middleware can add fields. */
+type ActionContext = {
+  req: Request;
+  env?: unknown;
+  fetchCtx?: ExecutionContext;
+  [key: string]: unknown;
+};
+/** Current RPC or host request context. Throws outside request handling. */
+declare function useCtx<C extends ActionContext = ActionContext>(): C;
+/** Current server `Request`. Available in actions, SSR, and frame renders. */
+declare function useRequest(): Request;
+/** Worker `env` from `fetch(request, env, ctx)`. `undefined` on the Node fetch preset. */
+declare function useEnv<E = unknown>(): E | undefined;
+/** Worker `ctx` from `fetch(request, env, ctx)` (`waitUntil`). `undefined` on Node. */
+declare function useFetchCtx(): ExecutionContext | undefined;
+//#endregion
+export { useFetchCtx as a, ServerActionHandle as c, brandServerAction as d, wrapClientRpc as f, useEnv as i, StreamActionHandle as l, ExecutionContext as n, useRequest as o, wrapClientStreamRpc as p, useCtx as r, ACTION_CALL as s, ActionContext as t, action as u };

package/dist/context-zrTZyYpF.mjs

@@ -0,0 +1,42 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/context.ts
+const ALS_KEY = Symbol.for("oxidejs.requestContext");
+const FETCH_KEY = Symbol.for("oxidejs.fetch");
+function als() {
+	const g = globalThis;
+	return g[ALS_KEY] ??= new AsyncLocalStorage();
+}
+function store() {
+	const current = als().getStore();
+	if (!current) throw new Error("oxidejs: request context is unavailable");
+	return current;
+}
+/** Current RPC or host request context. Throws outside request handling. */
+function useCtx() {
+	return store();
+}
+/** Current server `Request`. Available in actions, SSR, and frame renders. */
+function useRequest() {
+	return store().req;
+}
+/** Worker `env` from `fetch(request, env, ctx)`. `undefined` on the Node fetch preset. */
+function useEnv() {
+	return store().env;
+}
+/** Worker `ctx` from `fetch(request, env, ctx)` (`waitUntil`). `undefined` on Node. */
+function useFetchCtx() {
+	return store().fetchCtx;
+}
+function runWithRequest(req, fn, extra) {
+	return als().run({
+		...extra,
+		req
+	}, fn);
+}
+const HOOK_KEY = Symbol.for("oxidejs.runWithRequest");
+globalThis[HOOK_KEY] ??= (req, fn) => {
+	const extra = req[FETCH_KEY];
+	return runWithRequest(req, fn, extra);
+};
+//#endregion
+export { useRequest as a, useFetchCtx as i, useCtx as n, useEnv as r, runWithRequest as t };

package/dist/index.d.mts

@@ -1,36 +1,3 @@
+import { a as useFetchCtx, c as ServerActionHandle, d as brandServerAction, f as wrapClientRpc, i as useEnv, l as StreamActionHandle, n as ExecutionContext, o as useRequest, p as wrapClientStreamRpc, r as useCtx, s as ACTION_CALL, t as ActionContext, u as action } from "./context-C1UFQ0Zc.mjs";
 import { a as OxidejsWranglerOptions, i as OxidejsPreset, n as OxidejsActionTransport, o as ResolvedOptions, r as OxidejsOptions, t as OxidejsActionHeaders } from "./types-BM4NAnzy.mjs";
-import { UnpluginFactory } from "unplugin";
-//#region src/context.d.ts
-type ExecutionContext = {
-  waitUntil?(promise: Promise<unknown>): void;
-  passThroughOnException?(): void;
-};
-/** Tacho procedure `ctx`. Starts as `{ req }` plus Worker extras. Middleware can add fields. */
-type ActionContext = {
-  req: Request;
-  env?: unknown;
-  fetchCtx?: ExecutionContext;
-  [key: string]: unknown;
-};
-/** Current tacho or host request context. Throws outside request handling. */
-declare function useCtx<C extends ActionContext = ActionContext>(): C;
-/** Current server `Request`. Available in actions, SSR, and frame renders. */
-declare function useRequest(): Request;
-/** Worker `env` from `fetch(request, env, ctx)`. `undefined` on the Node fetch preset. */
-declare function useEnv<E = unknown>(): E | undefined;
-/** Worker `ctx` from `fetch(request, env, ctx)` (`waitUntil`). Not tacho `ctx`. `undefined` on Node. */
-declare function useFetchCtx(): ExecutionContext | undefined;
-/**
- * Marks a `*.server.ts` export as a remote RPC action. Runtime identity; the
- * second call signature adds the transport-only `{ signal }` argument.
- */
-declare function action<Args extends unknown[], Result>(fn: (...args: Args) => Result): typeof fn & ((...args: [...Args, options: {
-  signal?: AbortSignal;
-}]) => Result);
-//#endregion
-//#region src/index.d.ts
-declare const unpluginFactory: UnpluginFactory<OxidejsOptions | undefined>;
-declare const oxidejs: import("unplugin").UnpluginInstance<OxidejsOptions | undefined, boolean>;
-declare const vite: (options?: OxidejsOptions | undefined) => import("vite").Plugin<any> | import("vite").Plugin<any>[];
-//#endregion
-export { type ActionContext, type ExecutionContext, type OxidejsActionHeaders, type OxidejsActionTransport, type OxidejsOptions, type OxidejsPreset, type OxidejsWranglerOptions, type ResolvedOptions, action, oxidejs as default, oxidejs, unpluginFactory, useCtx, useEnv, useFetchCtx, useRequest, vite };
+export { ACTION_CALL, type ActionContext, type ExecutionContext, type OxidejsActionHeaders, type OxidejsActionTransport, type OxidejsOptions, type OxidejsPreset, type OxidejsWranglerOptions, type ResolvedOptions, type ServerActionHandle, type StreamActionHandle, action, brandServerAction, useCtx, useEnv, useFetchCtx, useRequest, wrapClientRpc, wrapClientStreamRpc };

package/dist/index.mjs

@@ -1,2 +1,108 @@
-import { a as useCtx, c as useRequest, i as action, n as unpluginFactory, o as useEnv, r as vite, s as useFetchCtx, t as oxidejs } from "./src-D-qdNVqg.mjs";
-export { action, oxidejs as default, oxidejs, unpluginFactory, useCtx, useEnv, useFetchCtx, useRequest, vite };
+import { a as useRequest, i as useFetchCtx, n as useCtx, r as useEnv } from "./context-zrTZyYpF.mjs";
+import * as Effect from "effect/Effect";
+import * as Atom from "effect/unstable/reactivity/Atom";
+import * as Registry from "effect/unstable/reactivity/AtomRegistry";
+//#region src/action.ts
+const ACTION_CALL = Symbol.for("ilha.actionCall");
+const ACTION_KEY = Symbol.for("oxidejs.actionKey");
+const AsyncGeneratorFunction = Object.getPrototypeOf(async function* () {}).constructor;
+let defaultRegistry;
+function registry() {
+	return defaultRegistry ??= Registry.make();
+}
+function isAsyncGeneratorFunction(fn) {
+	return typeof fn === "function" && fn instanceof AsyncGeneratorFunction;
+}
+function splitCallOptions(args) {
+	if (args.length === 0) return { args: [] };
+	const last = args[args.length - 1];
+	if (last && typeof last === "object" && "signal" in last && last.signal instanceof AbortSignal && Object.keys(last).length === 1) return {
+		args: args.slice(0, -1),
+		options: last
+	};
+	return { args };
+}
+function bindHandler(key, invoke, args) {
+	const handler = ((..._ev) => invoke(...args));
+	if (key) handler[ACTION_CALL] = {
+		k: key,
+		a: args
+	};
+	return handler;
+}
+function defineServerAction(atom, invoke, opts) {
+	const captureKey = opts?.captureKey;
+	const stripCallOptions = opts?.stripCallOptions ?? true;
+	const run = ((...allArgs) => {
+		if (!stripCallOptions) return Promise.resolve(invoke(...allArgs));
+		const { args } = splitCallOptions(allArgs);
+		return Promise.resolve(invoke(...args));
+	});
+	const set = (...args) => {
+		registry().set(atom, args);
+		return Promise.resolve(invoke(...args));
+	};
+	const bind = (...args) => {
+		return bindHandler(captureKey ?? run[ACTION_KEY], (...a) => void set(...a), args);
+	};
+	Object.assign(run, {
+		set,
+		bind,
+		with: bind,
+		atom,
+		$$atom: 1
+	});
+	Object.defineProperty(run, "result", {
+		enumerable: true,
+		get: () => registry().get(atom)
+	});
+	if (captureKey) run[ACTION_KEY] = captureKey;
+	return run;
+}
+function defineStreamAction(fn) {
+	const call = ((...allArgs) => {
+		const { args } = splitCallOptions(allArgs);
+		return fn(...args);
+	});
+	const deny = () => {
+		throw new Error("oxidejs: stream actions cannot be bound to DOM events");
+	};
+	Object.assign(call, {
+		set: call,
+		bind: deny,
+		with: deny,
+		atom: void 0,
+		$$atom: 1
+	});
+	return call;
+}
+/** Attach an ilha server-island capture key to an action handle. */
+function brandServerAction(key, handle) {
+	handle[ACTION_KEY] = key;
+	return handle;
+}
+/** Wrap an RPC caller as an `Atom.fn`-shaped client action handle. */
+function wrapClientRpc(rpc) {
+	const invoke = (...args) => Promise.resolve(rpc(...args));
+	return defineServerAction(Atom.make(Atom.fn((packed) => Effect.tryPromise({
+		try: () => invoke(...packed),
+		catch: (error) => error instanceof Error ? error : new Error(String(error))
+	}))), (...args) => invoke(...args), { stripCallOptions: false });
+}
+/**
+* Wrap a streaming RPC caller so the client handle returns an async generator
+* (awaiting the underlying client lazily), not `Promise<AsyncGenerator>`.
+*/
+function wrapClientStreamRpc(rpc) {
+	return defineStreamAction((...args) => rpc(...args));
+}
+function action(fn) {
+	if (isAsyncGeneratorFunction(fn)) return defineStreamAction(fn);
+	const invoke = (...args) => Promise.resolve(fn(...args));
+	return defineServerAction(Atom.make(Atom.fn((packed) => Effect.tryPromise({
+		try: () => invoke(...packed),
+		catch: (error) => error instanceof Error ? error : new Error(String(error))
+	}))), invoke);
+}
+//#endregion
+export { ACTION_CALL, action, brandServerAction, useCtx, useEnv, useFetchCtx, useRequest, wrapClientRpc, wrapClientStreamRpc };