@orpc/contract 0.0.0-next.bc564a6 → 0.0.0-next.bf323bf

package/dist/index.js

@@ -161,7 +161,7 @@ var oc = new ContractBuilder({
 });
 
 // src/error-orpc.ts
-import { isPlainObject } from "@orpc/shared";
+import { isObject } from "@orpc/shared";
 var COMMON_ORPC_ERROR_DEFS = {
   BAD_REQUEST: {
     status: 400,
@@ -271,11 +271,21 @@ var ORPCError = class _ORPCError extends Error {
       data: this.data
     };
   }
-  static fromJSON(json) {
-    return new _ORPCError(json.code, json);
+  static fromJSON(json, options) {
+    return new _ORPCError(json.code, {
+      ...options,
+      ...json
+    });
   }
   static isValidJSON(json) {
-    return isPlainObject(json) && "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
+    if (!isObject(json)) {
+      return false;
+    }
+    const validKeys = ["defined", "code", "status", "message", "data"];
+    if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+      return false;
+    }
+    return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
   }
 };
 
@@ -319,6 +329,12 @@ async function validateORPCError(map, error) {
   }
   return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
 }
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
+    message: "Internal server error",
+    cause: error
+  });
+}
 
 // src/client-utils.ts
 async function safe(promise) {
@@ -358,6 +374,82 @@ var ValidationError = class extends Error {
   }
 };
 
+// src/event-iterator.ts
+import { getEventMeta, isAsyncIteratorObject, isEventMetaContainer, withEventMeta } from "@orpc/server-standard";
+function mapEventIterator(iterator, maps) {
+  return async function* () {
+    try {
+      while (true) {
+        const { done, value } = await iterator.next();
+        let mappedValue = await maps.value(value, done);
+        if (mappedValue !== value) {
+          const meta = getEventMeta(value);
+          if (meta && isEventMetaContainer(mappedValue)) {
+            mappedValue = withEventMeta(mappedValue, meta);
+          }
+        }
+        if (done) {
+          return mappedValue;
+        }
+        yield mappedValue;
+      }
+    } catch (error) {
+      let mappedError = await maps.error(error);
+      if (mappedError !== error) {
+        const meta = getEventMeta(error);
+        if (meta && isEventMetaContainer(mappedError)) {
+          mappedError = withEventMeta(mappedError, meta);
+        }
+      }
+      throw mappedError;
+    } finally {
+      await iterator.return?.();
+    }
+  }();
+}
+var EVENT_ITERATOR_SCHEMA_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_SCHEMA");
+function eventIterator(yields, returns) {
+  return {
+    "~standard": {
+      [EVENT_ITERATOR_SCHEMA_SYMBOL]: { yields, returns },
+      vendor: "orpc",
+      version: 1,
+      validate(iterator) {
+        if (!isAsyncIteratorObject(iterator)) {
+          return { issues: [{ message: "Expect event source iterator", path: [] }] };
+        }
+        const mapped = mapEventIterator(iterator, {
+          async value(value, done) {
+            const schema = done ? returns : yields;
+            if (!schema) {
+              return value;
+            }
+            const result = await schema["~standard"].validate(value);
+            if (result.issues) {
+              throw new ORPCError("EVENT_ITERATOR_VALIDATION_FAILED", {
+                message: "Event source iterator validation failed",
+                cause: new ValidationError({
+                  issues: result.issues,
+                  message: "Event source iterator validation failed"
+                })
+              });
+            }
+            return result.value;
+          },
+          error: async (error) => error
+        });
+        return { value: mapped };
+      }
+    }
+  };
+}
+function getEventIteratorSchemaDetails(schema) {
+  if (schema === void 0) {
+    return void 0;
+  }
+  return schema["~standard"][EVENT_ITERATOR_SCHEMA_SYMBOL];
+}
+
 // src/schema.ts
 function type(...[map]) {
   return {
@@ -382,11 +474,14 @@ export {
   adaptContractRouter,
   adaptRoute,
   createORPCErrorConstructorMap,
+  eventIterator,
   fallbackContractConfig,
   fallbackORPCErrorMessage,
   fallbackORPCErrorStatus,
+  getEventIteratorSchemaDetails,
   isContractProcedure,
   isDefinedError,
+  mapEventIterator,
   mergeErrorMap,
   mergeMeta,
   mergePrefix,
@@ -395,6 +490,7 @@ export {
   oc,
   prefixRoute,
   safe,
+  toORPCError,
   type,
   unshiftTagRoute,
   validateORPCError

package/dist/src/client.d.ts

@@ -1,21 +1,22 @@
-import type { AbortSignal } from './types';
-export type ClientOptions<TClientContext> = {
+export type ClientContext = Record<string, any>;
+export type ClientOptions<TClientContext extends ClientContext> = {
     signal?: AbortSignal;
-} & (undefined extends TClientContext ? {
+    lastEventId?: string | undefined;
+} & (Record<never, never> extends TClientContext ? {
     context?: TClientContext;
 } : {
     context: TClientContext;
 });
-export type ClientRest<TClientContext, TInput> = [input: TInput, options: ClientOptions<TClientContext>] | (undefined extends TInput & TClientContext ? [] : never) | (undefined extends TClientContext ? [input: TInput] : never);
+export type ClientRest<TClientContext extends ClientContext, TInput> = [input: TInput, options: ClientOptions<TClientContext>] | (Record<never, never> extends TClientContext ? (undefined extends TInput ? [input?: TInput] : [input: TInput]) : never);
 export type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
     __error?: {
         type: TError;
     };
 };
-export interface Client<TClientContext, TInput, TOutput, TError extends Error> {
+export interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
     (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
 }
-export type NestedClient<TClientContext> = Client<TClientContext, any, any, any> | {
+export type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
     [k: string]: NestedClient<TClientContext>;
 };
 //# sourceMappingURL=client.d.ts.map

package/dist/src/error-orpc.d.ts

@@ -1,3 +1,4 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { ErrorMap, ErrorMapItem } from './error-map';
 import type { SchemaOutput } from './schema';
 export type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
@@ -94,15 +95,14 @@ export type ORPCErrorOptions<TData> = ErrorOptions & {
 } : {
     data: TData;
 });
-export type ORPCErrorOptionsRest<TData> = [options: ORPCErrorOptions<TData>] | (undefined extends TData ? [] : never);
 export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     readonly defined: boolean;
     readonly code: TCode;
     readonly status: number;
     readonly data: TData;
-    constructor(code: TCode, ...[options]: ORPCErrorOptionsRest<TData>);
+    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
     toJSON(): ORPCErrorJSON<TCode, TData>;
-    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>): ORPCError<TCode, TData>;
+    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
     static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
 }
 export type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;

package/dist/src/error-utils.d.ts

@@ -1,14 +1,15 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { ErrorMap, ErrorMapItem } from './error-map';
 import type { ORPCErrorCode, ORPCErrorOptions } from './error-orpc';
 import type { SchemaInput } from './schema';
 import { ORPCError } from './error-orpc';
 export declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
 export type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
-export type ORPCErrorConstructorMapItemRest<TData> = [options: ORPCErrorConstructorMapItemOptions<TData>] | (undefined extends TData ? [] : never);
-export type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: ORPCErrorConstructorMapItemRest<TInData>) => ORPCError<TCode, TInData>;
+export type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
 export type ORPCErrorConstructorMap<T extends ErrorMap> = {
     [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, SchemaInput<UInputSchema>> : never : never;
 };
 export declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
 export declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+export declare function toORPCError(error: unknown): ORPCError<any, any>;
 //# sourceMappingURL=error-utils.d.ts.map

package/dist/src/event-iterator.d.ts

@@ -0,0 +1,12 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Schema } from './schema';
+export declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncGenerator<TMap, TMap, TNext>;
+export declare function eventIterator<TYieldIn, TYieldOut, TReturnIn = unknown, TReturnOut = unknown>(yields: StandardSchemaV1<TYieldIn, TYieldOut>, returns?: StandardSchemaV1<TReturnIn, TReturnOut>): StandardSchemaV1<AsyncIteratorObject<TYieldIn, TReturnIn, void>, AsyncIteratorObject<TYieldOut, TReturnOut, void>>;
+export declare function getEventIteratorSchemaDetails(schema: Schema): undefined | {
+    yields: Schema;
+    returns: Schema;
+};
+//# sourceMappingURL=event-iterator.d.ts.map

package/dist/src/index.d.ts

@@ -8,6 +8,7 @@ export * from './error';
 export * from './error-map';
 export * from './error-orpc';
 export * from './error-utils';
+export * from './event-iterator';
 export * from './meta';
 export * from './procedure';
 export * from './procedure-client';
@@ -15,5 +16,4 @@ export * from './route';
 export * from './router';
 export * from './router-client';
 export * from './schema';
-export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/procedure-client.d.ts

@@ -1,6 +1,6 @@
-import type { Client } from './client';
+import type { Client, ClientContext } from './client';
 import type { ErrorFromErrorMap } from './error';
 import type { ErrorMap } from './error-map';
 import type { Schema, SchemaInput, SchemaOutput } from './schema';
-export type ContractProcedureClient<TClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+export type ContractProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
 //# sourceMappingURL=procedure-client.d.ts.map

package/dist/src/router-client.d.ts

@@ -1,7 +1,8 @@
+import type { ClientContext } from './client';
 import type { ContractProcedure } from './procedure';
 import type { ContractProcedureClient } from './procedure-client';
 import type { AnyContractRouter } from './router';
-export type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
+export type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext extends ClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
     [K in keyof TRouter]: TRouter[K] extends AnyContractRouter ? ContractRouterClient<TRouter[K], TClientContext> : never;
 };
 //# sourceMappingURL=router-client.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.0.0-next.bc564a6",
+  "version": "0.0.0-next.bf323bf",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,13 +29,14 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0-rc.0",
-    "@orpc/shared": "0.0.0-next.bc564a6"
+    "@orpc/server-standard": "^0.4.0",
+    "@standard-schema/spec": "^1.0.0",
+    "@orpc/shared": "0.0.0-next.bf323bf"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",
     "valibot": "1.0.0-beta.9",
-    "zod": "3.24.1"
+    "zod": "^3.24.1"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",

package/dist/src/types.d.ts

@@ -1,3 +0,0 @@
-import type { FindGlobalInstanceType } from '@orpc/shared';
-export type AbortSignal = FindGlobalInstanceType<'AbortSignal'>;
-//# sourceMappingURL=types.d.ts.map