@orpc/contract 0.38.0 → 0.40.0

package/dist/index.js

@@ -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 isObject(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";
   }
 };
 
@@ -364,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 {
@@ -388,11 +474,14 @@ export {
   adaptContractRouter,
   adaptRoute,
   createORPCErrorConstructorMap,
+  eventIterator,
   fallbackContractConfig,
   fallbackORPCErrorMessage,
   fallbackORPCErrorStatus,
+  getEventIteratorSchemaDetails,
   isContractProcedure,
   isDefinedError,
+  mapEventIterator,
   mergeErrorMap,
   mergeMeta,
   mergePrefix,

package/dist/src/client.d.ts

@@ -1,6 +1,7 @@
 export type ClientContext = Record<string, any>;
 export type ClientOptions<TClientContext extends ClientContext> = {
     signal?: AbortSignal;
+    lastEventId?: string | undefined;
 } & (Record<never, never> extends TClientContext ? {
     context?: TClientContext;
 } : {

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

@@ -102,7 +102,7 @@ export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error
     readonly data: 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/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';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,8 +29,9 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0",
-    "@orpc/shared": "0.38.0"
+    "@orpc/server-standard": "^0.4.0",
+    "@standard-schema/spec": "^1.0.0",
+    "@orpc/shared": "0.40.0"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",