@orpc/trpc 1.6.6 → 1.6.8

package/dist/index.d.mts

@@ -1,2 +1,20 @@
+import { AsyncIteratorClass } from '@orpc/shared';
+import { AnyProcedure, AnyRouter, inferRouterContext } from '@trpc/server';
+import { inferRouterMeta } from '@trpc/server/unstable-core-do-not-import';
+import * as ORPC from '@orpc/server';
 
-export { };
+interface experimental_ORPCMeta extends ORPC.Route {
+}
+type experimental_ToORPCOutput<T> = T extends AsyncIterable<infer TData, infer TReturn, infer TNext> ? AsyncIteratorClass<TData, TReturn, TNext> : T;
+type experimental_ToORPCRouterResult<TContext extends ORPC.Context, TMeta extends ORPC.Meta, TRecord extends Record<string, any>> = {
+    [K in keyof TRecord]: TRecord[K] extends AnyProcedure ? ORPC.Procedure<TContext, object, ORPC.Schema<TRecord[K]['_def']['$types']['input'], unknown>, ORPC.Schema<unknown, experimental_ToORPCOutput<TRecord[K]['_def']['$types']['output']>>, object, TMeta> : TRecord[K] extends Record<string, any> ? experimental_ToORPCRouterResult<TContext, TMeta, TRecord[K]> : never;
+};
+/**
+ * Convert a tRPC router to an oRPC router.
+ *
+ * @warning You should set the `meta` type to `ORPCMeta` when creating your tRPC builder, to ensure OpenAPI features work correctly.
+ */
+declare function experimental_toORPCRouter<T extends AnyRouter>(router: T): experimental_ToORPCRouterResult<inferRouterContext<T>, inferRouterMeta<T>, T['_def']['record']>;
+
+export { experimental_toORPCRouter };
+export type { experimental_ORPCMeta, experimental_ToORPCOutput, experimental_ToORPCRouterResult };

package/dist/index.d.ts

@@ -1,2 +1,20 @@
+import { AsyncIteratorClass } from '@orpc/shared';
+import { AnyProcedure, AnyRouter, inferRouterContext } from '@trpc/server';
+import { inferRouterMeta } from '@trpc/server/unstable-core-do-not-import';
+import * as ORPC from '@orpc/server';
 
-export { };
+interface experimental_ORPCMeta extends ORPC.Route {
+}
+type experimental_ToORPCOutput<T> = T extends AsyncIterable<infer TData, infer TReturn, infer TNext> ? AsyncIteratorClass<TData, TReturn, TNext> : T;
+type experimental_ToORPCRouterResult<TContext extends ORPC.Context, TMeta extends ORPC.Meta, TRecord extends Record<string, any>> = {
+    [K in keyof TRecord]: TRecord[K] extends AnyProcedure ? ORPC.Procedure<TContext, object, ORPC.Schema<TRecord[K]['_def']['$types']['input'], unknown>, ORPC.Schema<unknown, experimental_ToORPCOutput<TRecord[K]['_def']['$types']['output']>>, object, TMeta> : TRecord[K] extends Record<string, any> ? experimental_ToORPCRouterResult<TContext, TMeta, TRecord[K]> : never;
+};
+/**
+ * Convert a tRPC router to an oRPC router.
+ *
+ * @warning You should set the `meta` type to `ORPCMeta` when creating your tRPC builder, to ensure OpenAPI features work correctly.
+ */
+declare function experimental_toORPCRouter<T extends AnyRouter>(router: T): experimental_ToORPCRouterResult<inferRouterContext<T>, inferRouterMeta<T>, T['_def']['record']>;
+
+export { experimental_toORPCRouter };
+export type { experimental_ORPCMeta, experimental_ToORPCOutput, experimental_ToORPCRouterResult };

package/dist/index.mjs

@@ -1 +1,110 @@
+import { mapEventIterator } from '@orpc/client';
+import * as ORPC from '@orpc/server';
+import { isObject, isTypescriptObject } from '@orpc/shared';
+import { isTrackedEnvelope, TRPCError } from '@trpc/server';
+import { isAsyncIterable, getHTTPStatusCodeFromError } from '@trpc/server/unstable-core-do-not-import';
 
+function experimental_toORPCRouter(router) {
+  const result = {
+    ...lazyToORPCRouter(router._def.lazy),
+    ...recordToORPCRouterRecord(router._def.record)
+  };
+  return result;
+}
+function lazyToORPCRouter(lazies) {
+  const orpcRouter = {};
+  for (const key in lazies) {
+    const item = lazies[key];
+    orpcRouter[key] = ORPC.lazy(async () => {
+      const router = await item.ref();
+      return { default: experimental_toORPCRouter(router) };
+    });
+  }
+  return orpcRouter;
+}
+function recordToORPCRouterRecord(records) {
+  const orpcRouter = {};
+  for (const key in records) {
+    const item = records[key];
+    if (typeof item === "function") {
+      orpcRouter[key] = toORPCProcedure(item);
+    } else {
+      orpcRouter[key] = recordToORPCRouterRecord(item);
+    }
+  }
+  return orpcRouter;
+}
+function toORPCProcedure(procedure) {
+  return new ORPC.Procedure({
+    errorMap: {},
+    meta: procedure._def.meta ?? {},
+    inputValidationIndex: 0,
+    outputValidationIndex: 0,
+    route: procedure._def.meta ?? {},
+    middlewares: [],
+    inputSchema: toDisabledStandardSchema(procedure._def.inputs.at(-1)),
+    outputSchema: toDisabledStandardSchema(procedure._def.output),
+    handler: async ({ context, signal, path, input, lastEventId }) => {
+      try {
+        const trpcInput = lastEventId !== void 0 && (input === void 0 || isObject(input)) ? { ...input, lastEventId } : input;
+        const output = await procedure({
+          ctx: context,
+          signal,
+          path: path.join("."),
+          type: procedure._def.type,
+          input: trpcInput,
+          getRawInput: () => trpcInput
+        });
+        if (isAsyncIterable(output)) {
+          return mapEventIterator(output[Symbol.asyncIterator](), {
+            error: async (error) => error,
+            value: (value) => {
+              if (isTrackedEnvelope(value)) {
+                const [id, data] = value;
+                return ORPC.withEventMeta({
+                  id,
+                  data
+                }, {
+                  id
+                });
+              }
+              return value;
+            }
+          });
+        }
+        return output;
+      } catch (cause) {
+        if (cause instanceof TRPCError) {
+          throw new ORPC.ORPCError(cause.code, {
+            status: getHTTPStatusCodeFromError(cause),
+            message: cause.message,
+            cause
+          });
+        }
+        throw cause;
+      }
+    }
+  });
+}
+function toDisabledStandardSchema(schema) {
+  if (!isTypescriptObject(schema) || !("~standard" in schema) || !isTypescriptObject(schema["~standard"])) {
+    return void 0;
+  }
+  return new Proxy(schema, {
+    get: (target, prop) => {
+      if (prop === "~standard") {
+        return new Proxy(target["~standard"], {
+          get: (target2, prop2) => {
+            if (prop2 === "validate") {
+              return (value) => ({ value });
+            }
+            return Reflect.get(target2, prop2, target2);
+          }
+        });
+      }
+      return Reflect.get(target, prop, target);
+    }
+  });
+}
+
+export { experimental_toORPCRouter };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/trpc",
   "type": "module",
-  "version": "1.6.6",
+  "version": "1.6.8",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -28,9 +28,9 @@
     "@trpc/server": ">=11.4.2"
   },
   "dependencies": {
-    "@orpc/client": "1.6.6",
-    "@orpc/server": "1.6.6",
-    "@orpc/shared": "1.6.6"
+    "@orpc/client": "1.6.8",
+    "@orpc/server": "1.6.8",
+    "@orpc/shared": "1.6.8"
   },
   "devDependencies": {
     "@trpc/server": "^11.4.3",