oxidejs 0.2.4 → 0.3.0

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,30 +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";
-//#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
-export { type ActionContext, type ExecutionContext, type OxidejsActionHeaders, type OxidejsActionTransport, type OxidejsOptions, type OxidejsPreset, type OxidejsWranglerOptions, type ResolvedOptions, action, useCtx, useEnv, useFetchCtx, useRequest };
+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,49 +1,108 @@
-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 tacho 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`). Not tacho `ctx`. `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);
-};
+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 });
+}
 /**
-* Marks a `*.server.ts` export as a remote RPC action. Runtime identity; the
-* second call signature adds the transport-only `{ signal }` argument.
+* 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) {
-	return 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, useCtx, useEnv, useFetchCtx, useRequest };
+export { ACTION_CALL, action, brandServerAction, useCtx, useEnv, useFetchCtx, useRequest, wrapClientRpc, wrapClientStreamRpc };