@formadapter/orpc 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ludicrous
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# `@formadapter/orpc`
+
+Connect a FormAdapter form to an oRPC procedure without coupling the form to a
+router, transport, or UI adapter.
+
+```sh
+bun add @formadapter/orpc @orpc/client
+```
+
+## Client procedures
+
+`createORPCSubmission` returns a FormAdapter `onSubmit` handler. It sends the
+schema input from `SubmitContext` by default, not the transformed output passed
+as the first argument. That lets the server run the schema's transforms again
+at its trust boundary. The form's abort signal is forwarded through oRPC caller
+options.
+
+```tsx
+import { createORPCSubmission } from "@formadapter/orpc";
+
+<Account.Form onSubmit={createORPCSubmission(orpc.account.update)} />;
+```
+
+The procedure output is wrapped as `{ status: "success", data }`. A procedure
+that already returns a well-formed FormAdapter `SubmissionState` passes through
+unchanged.
+
+Use `mapInput` only when the form and procedure intentionally have different
+wire shapes. Caller options and oRPC context can be static values or per-submit
+factories:
+
+```ts
+const submit = createORPCSubmission(orpc.account.update, {
+  mapInput: (values) => ({ account: values }),
+  context: (_values, context) => ({ requestId: context.formData.get("requestId") }),
+  options: () => ({ lastEventId: currentEventId }),
+});
+```
+
+Unknown thrown values and server-side failures receive a safe generic message.
+Use `mapError` for application-specific errors; returning `undefined` falls
+through to the built-in mappings.
+
+## Typed form errors
+
+The package has no `@orpc/server` dependency. It exports a structural Standard
+Schema error declaration that can be installed once on an oRPC base builder:
+
+```ts
+import { FORM_SUBMISSION_ERROR_MAP } from "@formadapter/orpc";
+import { os } from "@orpc/server";
+
+const formProcedure = os.errors(FORM_SUBMISSION_ERROR_MAP);
+```
+
+In a handler, return the error through oRPC's generated constructor:
+
+```ts
+throw errors.FORM_SUBMISSION_FAILED({
+  data: submissionFailure({
+    fieldErrors: { email: ["That address is already registered."] },
+  }),
+});
+```
+
+`createORPCSubmission` maps that data directly into form state. It also maps
+oRPC's built-in `BAD_REQUEST` `{ issues }` payload, preserving nested and array
+Standard Schema paths.
+
+That `BAD_REQUEST` mapping is runtime fallback behavior, not a declared custom
+error. It works with oRPC's default input-validation payload. If an interceptor
+replaces or removes `data.issues`, use a typed custom error or `mapError` instead.
+
+## Actionable procedures
+
+Use `createORPCActionSubmission` for the tuple returned by `.actionable()`.
+This is separate because actionable procedures return JSON errors instead of
+throwing ordinary `ORPCError` instances and cannot accept an AbortSignal.
+Unexpected throws are deliberately re-thrown so framework redirects and
+not-found control flow continue to work.
+
+`@orpc/react`'s `createFormAction` is a different integration: it consumes
+bracket-notation `FormData` and returns no result state. FormAdapter uses its
+typed object submission path here so errors can be applied to the form.

package/dist/index.d.ts

@@ -0,0 +1,127 @@
+import { FailedSubmission, MaybePromise, StandardResult, SubmissionState, SuccessfulSubmission } from "@formadapter/core";
+
+//#region src/types.d.ts
+/** The structural callable shape shared by oRPC procedure clients. */
+type ORPCCallable = (...args: never[]) => unknown;
+type ClientArguments<Client extends ORPCCallable> = Client extends ((...args: infer Arguments) => unknown) ? Arguments : never;
+type SecondArgument<Arguments extends readonly unknown[]> = Arguments extends readonly [unknown, ...infer Rest] ? Rest[0] : never;
+type ClientResult<Client extends ORPCCallable> = Client extends ((...args: never[]) => infer Result) ? Result : never;
+type NonNever<Value, Fallback> = [Value] extends [never] ? Fallback : Value;
+/** The input accepted by an oRPC procedure client. */
+type ORPCClientInput<Client extends ORPCCallable> = ClientArguments<Client>[0];
+/** The resolved output returned by an oRPC procedure client. */
+type ORPCClientOutput<Client extends ORPCCallable> = Awaited<ClientResult<Client>>;
+/** The error recorded on oRPC's structurally typed PromiseWithError. */
+type ORPCClientError<Client extends ORPCCallable> = ClientResult<Client> extends {
+  readonly __error?: {
+    readonly type: infer ErrorType;
+  };
+} ? ErrorType : unknown;
+type InferredCallerOptions<Client extends ORPCCallable> = NonNullable<SecondArgument<ClientArguments<Client>>>;
+/** Caller options accepted by the client, excluding values controlled by this adapter. */
+type ORPCCallerOptions<Client extends ORPCCallable> = NonNever<InferredCallerOptions<Client> extends object ? Omit<InferredCallerOptions<Client>, "context" | "signal"> : never, Readonly<Record<never, never>>>;
+/** The per-call oRPC client context, if the client defines one. */
+type ORPCClientContext<Client extends ORPCCallable> = NonNever<InferredCallerOptions<Client> extends {
+  readonly context?: infer Context;
+} ? Context : never, Readonly<Record<never, never>>>;
+type ClientRequiresContext<Client extends ORPCCallable> = [InferredCallerOptions<Client>] extends [never] ? false : InferredCallerOptions<Client> extends {
+  readonly context: unknown;
+} ? true : false;
+/** The structural FormAdapter context supplied to an oRPC submission handler. */
+interface ORPCSubmitContext<Input> {
+  /** Prepared schema input before transforms. */
+  readonly input: Input;
+  readonly formData: FormData;
+  readonly signal: AbortSignal;
+}
+type DataFromSubmissionState<State> = State extends SuccessfulSubmission<infer Data> ? Data : never;
+/** Unwraps procedures that already return a shared SubmissionState. */
+type ORPCSubmissionData<Output> = [Output] extends [SubmissionState] ? DataFromSubmissionState<Output> : Output;
+type ORPCSubmissionHandler<Input, Values, Data> = (values: Values, context: ORPCSubmitContext<Input>) => Promise<SubmissionState<Data>>;
+type ORPCValueOrFactory<Value, Values, Input> = Value | ((values: Values, context: ORPCSubmitContext<Input>) => MaybePromise<Value>);
+interface ORPCErrorLike<Data = unknown> {
+  readonly code: string;
+  readonly data?: Data;
+  readonly defined?: boolean;
+  readonly message: string;
+  readonly status: number;
+}
+type ORPCErrorMapper<ErrorType, Values, Input, Data> = (error: ErrorType, values: Values, context: ORPCSubmitContext<Input>) => MaybePromise<SubmissionState<Data> | undefined>;
+interface ORPCSubmissionOptionsBase<Client extends ORPCCallable, Input, Values> {
+  /** Maps form values/context to the procedure input. Defaults to context.input. */
+  readonly mapInput?: (values: Values, context: ORPCSubmitContext<Input>) => MaybePromise<ORPCClientInput<Client>>;
+  /** Handles application-specific oRPC errors before the built-in mappings run. */
+  readonly mapError?: ORPCErrorMapper<ORPCClientError<Client>, Values, Input, ORPCSubmissionData<ORPCClientOutput<Client>>>;
+  /** Static caller options or a per-submit factory. Signal and context are managed separately. */
+  readonly options?: ORPCValueOrFactory<ORPCCallerOptions<Client>, Values, Input>;
+  /** Safe message used for unknown, malformed, and server-side failures. */
+  readonly unknownErrorMessage?: string;
+}
+type ORPCContextOption<Client extends ORPCCallable, Input, Values> = ClientRequiresContext<Client> extends true ? {
+  readonly context: ORPCValueOrFactory<ORPCClientContext<Client>, Values, Input>;
+} : {
+  readonly context?: ORPCValueOrFactory<ORPCClientContext<Client>, Values, Input>;
+};
+type ORPCSubmissionOptions<Client extends ORPCCallable, Input = ORPCClientInput<Client>, Values = unknown> = ORPCSubmissionOptionsBase<Client, Input, Values> & ORPCContextOption<Client, Input, Values>;
+type ORPCSubmissionOptionsRest<Client extends ORPCCallable, Input, Values> = ClientRequiresContext<Client> extends true ? [options: ORPCSubmissionOptions<Client, Input, Values>] : [options?: ORPCSubmissionOptions<Client, Input, Values>];
+/** JSON-safe error returned by an oRPC actionable procedure. */
+interface ORPCActionError<Data = unknown> extends ORPCErrorLike<Data> {
+  readonly defined: boolean;
+}
+type ORPCActionResult<Output, ErrorType extends ORPCErrorLike> = readonly [error: null, data: Output] | readonly [error: ErrorType, data: undefined];
+type ORPCAction<Input, Output, ErrorType extends ORPCErrorLike> = (input: Input) => PromiseLike<ORPCActionResult<Output, ErrorType>>;
+interface ORPCActionSubmissionOptions<ActionInput, Output, ErrorType extends ORPCErrorLike, Input = ActionInput, Values = unknown> {
+  readonly mapInput?: (values: Values, context: ORPCSubmitContext<Input>) => MaybePromise<ActionInput>;
+  readonly mapError?: ORPCErrorMapper<ErrorType, Values, Input, ORPCSubmissionData<Output>>;
+  readonly unknownErrorMessage?: string;
+}
+/** Minimal Standard Schema shape used by oRPC error data declarations. */
+interface ORPCStandardSchema<Input, Output = Input> {
+  readonly "~standard": {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly types?: {
+      readonly input: Input;
+      readonly output: Output;
+    };
+    readonly validate: (value: unknown) => StandardResult<Output>;
+  };
+}
+/**
+* Kept as an object type alias (rather than an interface) so it is assignable
+* to oRPC 1.x's open-ended `ErrorMap` without widening the known error code.
+*/
+type FormSubmissionErrorMap = {
+  readonly FORM_SUBMISSION_FAILED: {
+    readonly data: ORPCStandardSchema<FailedSubmission>;
+    readonly message: "Form submission failed";
+    readonly status: 422;
+  };
+};
+//#endregion
+//#region src/error-data.d.ts
+declare const FORM_SUBMISSION_FAILED_CODE: "FORM_SUBMISSION_FAILED";
+/** Runtime guard for error data sent through FORM_SUBMISSION_FAILED. */
+declare function isFormSubmissionFailureData(value: unknown): value is FailedSubmission;
+/** Standard Schema used for a typed oRPC FORM_SUBMISSION_FAILED error. */
+declare const formSubmissionFailureSchema: ORPCStandardSchema<FailedSubmission>;
+/** Reusable argument for `os.errors(FORM_SUBMISSION_ERROR_MAP)`. */
+declare const FORM_SUBMISSION_ERROR_MAP: FormSubmissionErrorMap;
+//#endregion
+//#region src/errors.d.ts
+declare const DEFAULT_ORPC_ERROR_MESSAGE = "Unable to submit the form. Please try again.";
+declare function isORPCErrorLike(value: unknown): value is ORPCErrorLike;
+declare function orpcErrorToSubmission(error: unknown, unknownErrorMessage?: string): SubmissionState | undefined;
+declare function unknownErrorToSubmission(error: unknown, unknownErrorMessage?: string): SubmissionState;
+//#endregion
+//#region src/submission.d.ts
+/** Adapts a normal oRPC procedure client to a FormAdapter onSubmit handler. */
+declare function createORPCSubmission<Client extends ORPCCallable, Input = ORPCClientInput<Client>, Values = unknown>(client: Client, ...[options]: ORPCSubmissionOptionsRest<Client, Input, Values>): ORPCSubmissionHandler<Input, Values, ORPCSubmissionData<ORPCClientOutput<Client>>>;
+/**
+* Adapts an oRPC `.actionable()` tuple to FormAdapter.
+* Unexpected throws are intentionally preserved for framework redirects/not-found control flow.
+*/
+declare function createORPCActionSubmission<ActionInput, Output, ErrorType extends ORPCErrorLike, Input = ActionInput, Values = unknown>(action: ORPCAction<ActionInput, Output, ErrorType>, options?: ORPCActionSubmissionOptions<ActionInput, Output, ErrorType, Input, Values>): ORPCSubmissionHandler<Input, Values, ORPCSubmissionData<Output>>;
+//#endregion
+export { DEFAULT_ORPC_ERROR_MESSAGE, FORM_SUBMISSION_ERROR_MAP, FORM_SUBMISSION_FAILED_CODE, type FormSubmissionErrorMap, type ORPCAction, type ORPCActionError, type ORPCActionResult, type ORPCActionSubmissionOptions, type ORPCCallable, type ORPCCallerOptions, type ORPCClientContext, type ORPCClientError, type ORPCClientInput, type ORPCClientOutput, type ORPCErrorLike, type ORPCErrorMapper, type ORPCStandardSchema, type ORPCSubmissionData, type ORPCSubmissionHandler, type ORPCSubmissionOptions, type ORPCSubmitContext, type ORPCValueOrFactory, createORPCActionSubmission, createORPCSubmission, formSubmissionFailureSchema, isFormSubmissionFailureData, isORPCErrorLike, orpcErrorToSubmission, unknownErrorToSubmission };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,139 @@
+import { isSubmissionState, issuePath, issuesToFieldErrors, submissionFailure, submissionSuccess } from "@formadapter/core";
+//#region src/error-data.ts
+const FORM_SUBMISSION_FAILED_CODE = "FORM_SUBMISSION_FAILED";
+/** Runtime guard for error data sent through FORM_SUBMISSION_FAILED. */
+function isFormSubmissionFailureData(value) {
+	try {
+		return isSubmissionState(value) && value.status === "error";
+	} catch {
+		return false;
+	}
+}
+function validateFailureData(value) {
+	return isFormSubmissionFailureData(value) ? { value } : { issues: [{ message: "Expected a FormAdapter failed submission." }] };
+}
+/** Standard Schema used for a typed oRPC FORM_SUBMISSION_FAILED error. */
+const formSubmissionFailureSchema = { "~standard": {
+	validate: validateFailureData,
+	vendor: "formadapter",
+	version: 1
+} };
+/** Reusable argument for `os.errors(FORM_SUBMISSION_ERROR_MAP)`. */
+const FORM_SUBMISSION_ERROR_MAP = { FORM_SUBMISSION_FAILED: {
+	data: formSubmissionFailureSchema,
+	message: "Form submission failed",
+	status: 422
+} };
+//#endregion
+//#region src/errors.ts
+const DEFAULT_ORPC_ERROR_MESSAGE = "Unable to submit the form. Please try again.";
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isPathSegment(value) {
+	try {
+		if (typeof value === "string" || typeof value === "number" || typeof value === "symbol") return true;
+		return isRecord(value) && "key" in value && (typeof value.key === "string" || typeof value.key === "number" || typeof value.key === "symbol");
+	} catch {
+		return false;
+	}
+}
+function isStandardIssue(value) {
+	try {
+		if (!isRecord(value) || typeof value.message !== "string") return false;
+		return value.path === void 0 || Array.isArray(value.path) && value.path.every(isPathSegment);
+	} catch {
+		return false;
+	}
+}
+function isORPCErrorLike(value) {
+	try {
+		return isRecord(value) && typeof value.code === "string" && typeof value.message === "string" && typeof value.status === "number" && Number.isFinite(value.status);
+	} catch {
+		return false;
+	}
+}
+function validationFailure(issues, fallbackMessage) {
+	const fieldIssues = issues.filter((issue) => issuePath(issue).length > 0);
+	const formErrors = issues.filter((issue) => issuePath(issue).length === 0).map((issue) => issue.message);
+	return submissionFailure({
+		errorKind: "validation",
+		fieldErrors: issuesToFieldErrors(fieldIssues),
+		formErrors: fieldIssues.length === 0 && formErrors.length === 0 ? [fallbackMessage] : formErrors
+	});
+}
+function issuesFromError(error) {
+	if (!isRecord(error.data) || !Array.isArray(error.data.issues)) return;
+	return error.data.issues.filter(isStandardIssue);
+}
+function orpcErrorToSubmission(error, unknownErrorMessage = DEFAULT_ORPC_ERROR_MESSAGE) {
+	try {
+		if (!isORPCErrorLike(error)) return void 0;
+		if (error.code === "FORM_SUBMISSION_FAILED" && isFormSubmissionFailureData(error.data)) return error.data;
+		const issues = error.code === "BAD_REQUEST" ? issuesFromError(error) : void 0;
+		if (issues) return validationFailure(issues, error.message || unknownErrorMessage);
+		if (error.status >= 400 && error.status < 500 && error.message.trim().length > 0) return submissionFailure({
+			errorKind: "business",
+			formErrors: [error.message]
+		});
+		return submissionFailure({
+			errorKind: "transport",
+			formErrors: [unknownErrorMessage]
+		});
+	} catch {
+		return;
+	}
+}
+function unknownErrorToSubmission(error, unknownErrorMessage = DEFAULT_ORPC_ERROR_MESSAGE) {
+	return orpcErrorToSubmission(error, unknownErrorMessage) ?? submissionFailure({
+		errorKind: "transport",
+		formErrors: [unknownErrorMessage]
+	});
+}
+//#endregion
+//#region src/submission.ts
+async function resolveValue(value, values, context) {
+	if (typeof value === "function") return await value(values, context);
+	return value;
+}
+function normalizeOutput(output) {
+	return isSubmissionState(output) ? output : submissionSuccess(output);
+}
+function safeCallerOptions(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	const result = { ...value };
+	delete result.context;
+	delete result.signal;
+	return result;
+}
+/** Adapts a normal oRPC procedure client to a FormAdapter onSubmit handler. */
+function createORPCSubmission(client, ...[options]) {
+	return async (values, context) => {
+		const input = options?.mapInput ? await options.mapInput(values, context) : context.input;
+		const suppliedOptions = await resolveValue(options?.options, values, context);
+		const suppliedContext = await resolveValue(options?.context, values, context);
+		const callerOptions = safeCallerOptions(suppliedOptions);
+		if (suppliedContext !== void 0) callerOptions.context = suppliedContext;
+		callerOptions.signal = context.signal;
+		try {
+			return normalizeOutput(await client(input, callerOptions));
+		} catch (error) {
+			return (options?.mapError ? await options.mapError(error, values, context) : void 0) ?? unknownErrorToSubmission(error, options?.unknownErrorMessage);
+		}
+	};
+}
+/**
+* Adapts an oRPC `.actionable()` tuple to FormAdapter.
+* Unexpected throws are intentionally preserved for framework redirects/not-found control flow.
+*/
+function createORPCActionSubmission(action, options = {}) {
+	return async (values, context) => {
+		const [error, output] = await action(options.mapInput ? await options.mapInput(values, context) : context.input);
+		if (error !== null) return (options.mapError ? await options.mapError(error, values, context) : void 0) ?? unknownErrorToSubmission(error, options.unknownErrorMessage);
+		return normalizeOutput(output);
+	};
+}
+//#endregion
+export { DEFAULT_ORPC_ERROR_MESSAGE, FORM_SUBMISSION_ERROR_MAP, FORM_SUBMISSION_FAILED_CODE, createORPCActionSubmission, createORPCSubmission, formSubmissionFailureSchema, isFormSubmissionFailureData, isORPCErrorLike, orpcErrorToSubmission, unknownErrorToSubmission };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["call"],"sources":["../src/error-data.ts","../src/errors.ts","../src/submission.ts"],"sourcesContent":["import { isSubmissionState } from \"@formadapter/core\";\nimport type { FailedSubmission, StandardResult } from \"@formadapter/core\";\n\nimport type {\n  FormSubmissionErrorMap,\n  ORPCStandardSchema,\n} from \"./types\";\n\nexport const FORM_SUBMISSION_FAILED_CODE = \"FORM_SUBMISSION_FAILED\" as const;\n\n/** Runtime guard for error data sent through FORM_SUBMISSION_FAILED. */\nexport function isFormSubmissionFailureData(\n  value: unknown,\n): value is FailedSubmission {\n  try {\n    return isSubmissionState(value) && value.status === \"error\";\n  } catch {\n    return false;\n  }\n}\n\nfunction validateFailureData(value: unknown): StandardResult<FailedSubmission> {\n  return isFormSubmissionFailureData(value)\n    ? { value }\n    : {\n        issues: [\n          {\n            message: \"Expected a FormAdapter failed submission.\",\n          },\n        ],\n      };\n}\n\n/** Standard Schema used for a typed oRPC FORM_SUBMISSION_FAILED error. */\nexport const formSubmissionFailureSchema: ORPCStandardSchema<FailedSubmission> = {\n  \"~standard\": {\n    validate: validateFailureData,\n    vendor: \"formadapter\",\n    version: 1,\n  },\n};\n\n/** Reusable argument for `os.errors(FORM_SUBMISSION_ERROR_MAP)`. */\nexport const FORM_SUBMISSION_ERROR_MAP: FormSubmissionErrorMap = {\n  FORM_SUBMISSION_FAILED: {\n    data: formSubmissionFailureSchema,\n    message: \"Form submission failed\",\n    status: 422,\n  },\n};\n","import {\n  issuePath,\n  issuesToFieldErrors,\n  submissionFailure,\n} from \"@formadapter/core\";\nimport type {\n  StandardIssue,\n  SubmissionState,\n} from \"@formadapter/core\";\n\nimport {\n  FORM_SUBMISSION_FAILED_CODE,\n  isFormSubmissionFailureData,\n} from \"./error-data\";\nimport type { ORPCErrorLike } from \"./types\";\n\nexport const DEFAULT_ORPC_ERROR_MESSAGE =\n  \"Unable to submit the form. Please try again.\";\n\nfunction isRecord(value: unknown): value is Readonly<Record<string, unknown>> {\n  return typeof value === \"object\" && value !== null;\n}\n\nfunction isPathSegment(value: unknown): boolean {\n  try {\n    if (\n      typeof value === \"string\" ||\n      typeof value === \"number\" ||\n      typeof value === \"symbol\"\n    ) {\n      return true;\n    }\n    return (\n      isRecord(value) &&\n      \"key\" in value &&\n      (typeof value.key === \"string\" ||\n        typeof value.key === \"number\" ||\n        typeof value.key === \"symbol\")\n    );\n  } catch {\n    return false;\n  }\n}\n\nfunction isStandardIssue(value: unknown): value is StandardIssue {\n  try {\n    if (!isRecord(value) || typeof value.message !== \"string\") return false;\n    return (\n      value.path === undefined ||\n      (Array.isArray(value.path) && value.path.every(isPathSegment))\n    );\n  } catch {\n    return false;\n  }\n}\n\nexport function isORPCErrorLike(value: unknown): value is ORPCErrorLike {\n  try {\n    return (\n      isRecord(value) &&\n      typeof value.code === \"string\" &&\n      typeof value.message === \"string\" &&\n      typeof value.status === \"number\" &&\n      Number.isFinite(value.status)\n    );\n  } catch {\n    return false;\n  }\n}\n\nfunction validationFailure(\n  issues: readonly StandardIssue[],\n  fallbackMessage: string,\n): SubmissionState {\n  const fieldIssues = issues.filter((issue) => issuePath(issue).length > 0);\n  const formErrors = issues\n    .filter((issue) => issuePath(issue).length === 0)\n    .map((issue) => issue.message);\n\n  return submissionFailure({\n    errorKind: \"validation\",\n    fieldErrors: issuesToFieldErrors(fieldIssues),\n    formErrors:\n      fieldIssues.length === 0 && formErrors.length === 0\n        ? [fallbackMessage]\n        : formErrors,\n  });\n}\n\nfunction issuesFromError(error: ORPCErrorLike): readonly StandardIssue[] | undefined {\n  if (!isRecord(error.data) || !Array.isArray(error.data.issues)) {\n    return undefined;\n  }\n  return error.data.issues.filter(isStandardIssue);\n}\n\nexport function orpcErrorToSubmission(\n  error: unknown,\n  unknownErrorMessage: string = DEFAULT_ORPC_ERROR_MESSAGE,\n): SubmissionState | undefined {\n  try {\n    if (!isORPCErrorLike(error)) return undefined;\n\n    if (\n      error.code === FORM_SUBMISSION_FAILED_CODE &&\n      isFormSubmissionFailureData(error.data)\n    ) {\n      return error.data;\n    }\n\n    const issues = error.code === \"BAD_REQUEST\"\n      ? issuesFromError(error)\n      : undefined;\n    if (issues) {\n      return validationFailure(issues, error.message || unknownErrorMessage);\n    }\n\n    if (\n      error.status >= 400 &&\n      error.status < 500 &&\n      error.message.trim().length > 0\n    ) {\n      return submissionFailure({\n        errorKind: \"business\",\n        formErrors: [error.message],\n      });\n    }\n\n    return submissionFailure({\n      errorKind: \"transport\",\n      formErrors: [unknownErrorMessage],\n    });\n  } catch {\n    return undefined;\n  }\n}\n\nexport function unknownErrorToSubmission(\n  error: unknown,\n  unknownErrorMessage: string = DEFAULT_ORPC_ERROR_MESSAGE,\n): SubmissionState {\n  return (\n    orpcErrorToSubmission(error, unknownErrorMessage) ??\n    submissionFailure({\n      errorKind: \"transport\",\n      formErrors: [unknownErrorMessage],\n    })\n  );\n}\n","import {\n  isSubmissionState,\n  submissionSuccess,\n} from \"@formadapter/core\";\nimport type {\n  SubmissionState,\n} from \"@formadapter/core\";\n\nimport { unknownErrorToSubmission } from \"./errors\";\nimport type {\n  ORPCAction,\n  ORPCActionSubmissionOptions,\n  ORPCCallable,\n  ORPCClientInput,\n  ORPCClientOutput,\n  ORPCErrorLike,\n  ORPCSubmissionData,\n  ORPCSubmissionHandler,\n  ORPCSubmissionOptionsRest,\n  ORPCSubmitContext,\n  ORPCValueOrFactory,\n} from \"./types\";\n\nasync function resolveValue<Value, Values, Input>(\n  value: ORPCValueOrFactory<Value, Values, Input> | undefined,\n  values: Values,\n  context: ORPCSubmitContext<Input>,\n): Promise<Value | undefined> {\n  if (typeof value === \"function\") {\n    return await (\n      value as (\n        currentValues: Values,\n        currentContext: typeof context,\n      ) => Value | PromiseLike<Value>\n    )(values, context);\n  }\n  return value;\n}\n\nfunction normalizeOutput<Output>(\n  output: Output,\n): SubmissionState<ORPCSubmissionData<Output>> {\n  return isSubmissionState(output)\n    ? (output as SubmissionState<ORPCSubmissionData<Output>>)\n    : submissionSuccess(output as ORPCSubmissionData<Output>);\n}\n\nfunction safeCallerOptions(value: unknown): Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    return {};\n  }\n  const result = { ...(value as Readonly<Record<string, unknown>>) };\n  delete result.context;\n  delete result.signal;\n  return result;\n}\n\n/** Adapts a normal oRPC procedure client to a FormAdapter onSubmit handler. */\nexport function createORPCSubmission<\n  Client extends ORPCCallable,\n  Input = ORPCClientInput<Client>,\n  Values = unknown,\n>(\n  client: Client,\n  ...[options]: ORPCSubmissionOptionsRest<Client, Input, Values>\n): ORPCSubmissionHandler<\n  Input,\n  Values,\n  ORPCSubmissionData<ORPCClientOutput<Client>>\n> {\n  return async (values, context) => {\n    const input = options?.mapInput\n      ? await options.mapInput(values, context)\n      : context.input;\n    const suppliedOptions = await resolveValue(\n      options?.options,\n      values,\n      context,\n    );\n    const suppliedContext = await resolveValue(\n      options?.context,\n      values,\n      context,\n    );\n    const callerOptions = safeCallerOptions(suppliedOptions);\n    if (suppliedContext !== undefined) {\n      callerOptions.context = suppliedContext;\n    }\n    callerOptions.signal = context.signal;\n\n    try {\n      const call = client as unknown as (\n        procedureInput: ORPCClientInput<Client>,\n        procedureOptions: Readonly<Record<string, unknown>>,\n      ) => unknown;\n      const output = (await call(\n        input as ORPCClientInput<Client>,\n        callerOptions,\n      )) as ORPCClientOutput<Client>;\n      return normalizeOutput(output);\n    } catch (error) {\n      const custom = options?.mapError\n        ? await options.mapError(\n            error as Parameters<NonNullable<typeof options.mapError>>[0],\n            values,\n            context,\n          )\n        : undefined;\n      return (\n        custom ??\n        (unknownErrorToSubmission(\n          error,\n          options?.unknownErrorMessage,\n        ) as SubmissionState<ORPCSubmissionData<ORPCClientOutput<Client>>>)\n      );\n    }\n  };\n}\n\n/**\n * Adapts an oRPC `.actionable()` tuple to FormAdapter.\n * Unexpected throws are intentionally preserved for framework redirects/not-found control flow.\n */\nexport function createORPCActionSubmission<\n  ActionInput,\n  Output,\n  ErrorType extends ORPCErrorLike,\n  Input = ActionInput,\n  Values = unknown,\n>(\n  action: ORPCAction<ActionInput, Output, ErrorType>,\n  options: ORPCActionSubmissionOptions<\n    ActionInput,\n    Output,\n    ErrorType,\n    Input,\n    Values\n  > = {},\n): ORPCSubmissionHandler<Input, Values, ORPCSubmissionData<Output>> {\n  return async (values, context) => {\n    const input = options.mapInput\n      ? await options.mapInput(values, context)\n      : context.input;\n    const [error, output] = await action(input as ActionInput);\n\n    if (error !== null) {\n      const custom = options.mapError\n        ? await options.mapError(error, values, context)\n        : undefined;\n      return (\n        custom ??\n        (unknownErrorToSubmission(\n          error,\n          options.unknownErrorMessage,\n        ) as SubmissionState<ORPCSubmissionData<Output>>)\n      );\n    }\n\n    return normalizeOutput(output as Output);\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@formadapter/orpc",
+  "version": "0.0.0",
+  "description": "Type-safe oRPC submissions for FormAdapter forms.",
+  "keywords": [
+    "forms",
+    "orpc",
+    "rpc",
+    "standard-schema",
+    "typescript"
+  ],
+  "homepage": "https://formadapter.com",
+  "bugs": {
+    "url": "https://github.com/ludicroushq/formadapter/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ludicroushq/formadapter.git",
+    "directory": "packages/orpc"
+  },
+  "license": "MIT",
+  "author": "ludicrous",
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@formadapter/core": "^0.0.0"
+  },
+  "peerDependencies": {
+    "@orpc/client": ">=1.14.0 <2.0.0"
+  },
+  "devDependencies": {
+    "@formadapter/react": "^0.0.0",
+    "@orpc/client": "1.14.7",
+    "@orpc/server": "1.14.7"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo .turbo",
+    "dev": "tsdown --watch",
+    "test": "vitest run --config vitest.config.ts",
+    "test:coverage": "vitest run --config vitest.config.ts --coverage",
+    "typecheck": "tsc --project tsconfig.json --noEmit"
+  }
+}