@gjermundgaraba/effect-actions 0.1.0-rc.1 → 0.1.0

package/dist/Action-CXsfTEhx.d.mts

@@ -1,54 +0,0 @@
-import { Effect, Schema } from "effect";
-declare namespace Action_d_exports {
-  export { Action, Any, Codec, Handler, McpOptions, Options, SchemaErrorPolicy, SchemaFailure, make };
-}
-type Codec = Schema.Codec<unknown, unknown, never, never>;
-/** Failed request decoding or successful-result encoding, independent of transport terminology. */
-interface SchemaFailure {
-  readonly phase: "input" | "output";
-  /** May contain sensitive values. Do not reflect it in public error messages. */
-  readonly cause: Schema.SchemaError;
-}
-/** Pure application-owned mapping, set on a group and applied by both adapters. */
-interface SchemaErrorPolicy<Errors extends ReadonlyArray<Codec>> {
-  readonly errors: Errors;
-  readonly map: (failure: SchemaFailure) => NoInfer<Errors[number]["Type"]>;
-}
-interface McpOptions {
-  readonly name?: string;
-  readonly readOnly?: boolean;
-  /** Defaults to `!readOnly`; the MCP spec only defines it for non-read-only tools. */
-  readonly destructive?: boolean;
-}
-interface Options<Input extends Codec, Output extends Codec, Errors extends ReadonlyArray<Codec>, Http extends boolean = boolean> {
-  readonly description: string;
-  /** Omit for an action without arguments. */
-  readonly input?: Input;
-  readonly success: Output;
-  /** One schema per declared failure; each keeps its own HTTP status annotation. Defaults to none. */
-  readonly errors?: Errors;
-  readonly http?: Http;
-  readonly mcp?: false | McpOptions;
-}
-/** A pure contract: schemas and transport metadata. Implementations are bound by `ActionGroup.implement`. */
-interface Action<Name extends string, Input extends Codec, Output extends Codec, Errors extends ReadonlyArray<Codec>, Http extends boolean = boolean> {
-  readonly name: Name;
-  readonly description: string;
-  readonly input: Input;
-  readonly success: Output;
-  readonly errors: Errors;
-  readonly http: Http;
-  readonly mcp: false | {
-    readonly name: string;
-    readonly readOnly: boolean;
-    readonly destructive: boolean;
-  };
-}
-type Any = Action<string, Codec, Codec, ReadonlyArray<Codec>>;
-/** Receives decoded input; may fail only with the declared errors. */
-type Handler<A extends Any, R = never> = (input: A["input"]["Type"]) => Effect.Effect<A["success"]["Type"], A["errors"][number]["Type"], R>;
-/** An empty object schema that also produces the object root MCP requires. */
-declare const NoInput: Schema.$Record<Schema.String, Schema.Never>;
-declare function make<const Name extends string, Input extends Codec = typeof NoInput, Output extends Codec = never, const Errors extends ReadonlyArray<Codec> = [], const Http extends boolean = true>(name: Name, options: Options<Input, Output, Errors, Http>): Action<Name, Input, Output, Errors, Http>;
-//#endregion
-export { Handler as a, SchemaErrorPolicy as c, __exportAll as d, Codec as i, SchemaFailure as l, Action_d_exports as n, McpOptions as o, Any as r, Options as s, Action as t, make as u };

package/dist/implementation-4Q2BESw5.mjs

@@ -1,61 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-//#region src/internal/actions.ts
-/** Each namespace is checked by whoever owns it: a group, the routes, or the MCP tools. */
-const assertDistinct = (what, names) => {
-	const seen = /* @__PURE__ */ new Set();
-	for (const name of names) {
-		if (seen.has(name)) throw new Error(`Duplicate ${what}: ${name}`);
-		seen.add(name);
-	}
-};
-const served = (groups, serves) => groups.flatMap((group) => {
-	const actions = group.actions.filter(serves);
-	return actions.length === 0 ? [] : [{
-		group,
-		actions
-	}];
-});
-//#endregion
-//#region src/internal/implementation.ts
-let implementations = 0;
-/**
-* Opaque implementation value; only its type is public. `R` is required per
-* request, `EX`/`RX` describe handler acquisition at Layer build. Layer
-* memoization lets both adapters share one handler build per runtime.
-*/
-var Implementation = class Implementation {
-	group;
-	#handlers;
-	#layer;
-	constructor(group, handlers, layer) {
-		this.group = group;
-		this.#handlers = handlers;
-		this.#layer = layer;
-	}
-	static make(group, build) {
-		const handlers = Context.Service(`effect-actions/Handlers#${++implementations}`);
-		return new Implementation(group, handlers, Layer.effect(handlers, build));
-	}
-	/**
-	* Acquire exactly the implementations an adapter serves. Each resolves its
-	* own handlers, so records are never merged across implementations.
-	*/
-	static register(serving, make) {
-		const [first, ...rest] = serving;
-		if (first === void 0) return make([]);
-		const bound = Effect.all(serving.map(({ app, actions }) => Effect.map(app.#handlers, (handlers) => ({
-			group: app.group,
-			actions,
-			handle: (action) => {
-				const handle = handlers[action.name];
-				if (handle === void 0) throw new Error(`Missing handler: ${action.name}`);
-				const dispatch = handle;
-				const name = `${app.group.name}.${action.name}`;
-				return (input) => Effect.withSpan(Effect.suspend(() => dispatch(input)), name, { captureStackTrace: false });
-			}
-		}))));
-		return Layer.unwrap(Effect.map(bound, make)).pipe(Layer.provide(Layer.mergeAll(first.app.#layer, ...rest.map(({ app }) => app.#layer))));
-	}
-};
-//#endregion
-export { assertDistinct as n, served as r, Implementation as t };

package/dist/implementation-DTqp_0DW.d.mts

@@ -1,61 +0,0 @@
-import { c as SchemaErrorPolicy, i as Codec, n as Action_d_exports, r as Any } from "./Action-CXsfTEhx.mjs";
-import { Effect, Layer, Scope } from "effect";
-//#region src/internal/actions.d.ts
-/** The contract half of a group: what adapters and clients need, without `implement`. */
-interface Actions<Name extends string = string, A extends ReadonlyArray<Any> = ReadonlyArray<Any>, PolicyErrors extends ReadonlyArray<Codec> = ReadonlyArray<Codec>> {
-  readonly name: Name;
-  readonly actions: A;
-  /** How both transports answer failed decoding or encoding; their native behavior without one. */
-  readonly schemaError: SchemaErrorPolicy<PolicyErrors> | undefined;
-}
-/** The errors a group's policy may answer with, by lookup rather than a conditional type. */
-type PolicyError<G extends Actions> = NonNullable<G["schemaError"]>["errors"][number];
-/**
- * What one adapter serves of a group. Each adapter projects its groups once and
- * reads nothing else, so an action it does not serve cannot influence its
- * names, routes, clients, pairing or acquisition.
- */
-interface Served {
-  readonly group: Actions;
-  readonly actions: ReadonlyArray<Any>;
-}
-//#endregion
-//#region src/internal/implementation.d.ts
-/** Decoded action values after schema parsing, erased across actions at the adapter boundary. */
-type ErasedValue = Any["input"]["Type"];
-type Erased<R> = {
-  handle(input: ErasedValue): Effect.Effect<ErasedValue, ErasedValue, R>;
-}["handle"];
-type Handlers<R> = Readonly<Record<string, Erased<R>>>;
-type Dispatch = (input: ErasedValue) => Effect.Effect<ErasedValue, ErasedValue>;
-/** One acquired implementation and the actions its adapter serves. */
-interface Bound extends Served {
-  readonly handle: (action: Any) => Dispatch;
-}
-/**
- * Opaque implementation value; only its type is public. `R` is required per
- * request, `EX`/`RX` describe handler acquisition at Layer build. Layer
- * memoization lets both adapters share one handler build per runtime.
- */
-declare class Implementation<G extends Actions, R, EX, RX> {
-  #private;
-  /** Adapters pair an implementation with its contract by this identity. */
-  readonly group: G;
-  private constructor();
-  static make<G extends Actions, R, EX, RX>(group: G, build: Effect.Effect<Handlers<R>, EX, RX>): Implementation<G, R, EX, Exclude<RX, Scope.Scope>>;
-  /**
-   * Acquire exactly the implementations an adapter serves. Each resolves its
-   * own handlers, so records are never merged across implementations.
-   */
-  static register<R, EX, RX, Out, E, In>(serving: ReadonlyArray<{
-    readonly app: Implementation<Actions, R, EX, RX>;
-    readonly actions: ReadonlyArray<Any>;
-  }>, make: (apps: ReadonlyArray<Bound>) => Layer.Layer<Out, E, In>): Layer.Layer<Out, E | EX, In | RX>;
-}
-type AnyImplementation<G extends Actions = Actions> = Implementation<G, any, any, any>;
-/** Per-request requirements of one implementation, or of a union of them. */
-type RequestContext<App> = App extends Implementation<any, infer R, any, any> ? R : never;
-type BuildError<App> = App extends Implementation<any, any, infer EX, any> ? EX : never;
-type BuildContext<App> = App extends Implementation<any, any, any, infer RX> ? RX : never;
-//#endregion
-export { RequestContext as a, Implementation as i, BuildContext as n, Actions as o, BuildError as r, PolicyError as s, AnyImplementation as t };