@mpgd/bridge 0.1.0 → 0.2.0

package/dist/orpc.d.ts

@@ -0,0 +1,26 @@
+import type { StandardUrl } from '@orpc/client/standard';
+import { type RouterContractClient } from '@orpc/contract';
+import { type BridgeRequest, type BridgeResponse } from './index';
+export type BridgeRpcEndpoint = StandardUrl;
+export type BridgeRpcPrefix = `/${string}`;
+export declare const defaultBridgeRpcEndpoint = "/api/mpgd/rpc";
+export declare const bridgeRpcContract: {
+  request: import("@orpc/contract").ProcedureContract<import("@orpc/contract").Schema<BridgeRequest<unknown>, BridgeRequest<unknown>>, import("@orpc/contract").Schema<BridgeResponse, BridgeResponse>, object>;
+};
+export type BridgeRpcContract = typeof bridgeRpcContract;
+export type BridgeRpcClient = RouterContractClient<BridgeRpcContract>;
+export type BridgeRpcRequestHandler = (request: BridgeRequest) => BridgeResponse | Promise<BridgeResponse>;
+export type BridgeRpcRouter = ReturnType<typeof createBridgeRpcRouter>;
+export interface CreateBridgeOrpcClientInput {
+  readonly url?: BridgeRpcEndpoint;
+  readonly fetch?: typeof fetch;
+  readonly headers?: Record<string, string>;
+}
+export interface CreateBridgeRpcFetchHandlerOptions {
+  readonly prefix?: BridgeRpcPrefix;
+}
+export declare function createBridgeOrpcClient(input?: CreateBridgeOrpcClientInput): BridgeRpcClient;
+export declare function createBridgeRpcRouter(handleRequest: BridgeRpcRequestHandler): {
+  request: import("@orpc/server").ImplementedProcedure<import("@orpc/server").DefaultInitialContext & object, object, import("@orpc/contract").Schema<BridgeRequest<unknown>, BridgeRequest<unknown>>, import("@orpc/contract").Schema<BridgeResponse, BridgeResponse>, object>;
+};
+export declare function createBridgeRpcFetchHandler(router: BridgeRpcRouter, options?: CreateBridgeRpcFetchHandlerOptions): (request: Request) => Promise<Response>;

package/dist/orpc.js

@@ -0,0 +1,84 @@
+import { createORPCClient } from '@orpc/client';
+import { RPCLink } from '@orpc/client/fetch';
+import { oc, type as orpcType } from '@orpc/contract';
+import { implement } from '@orpc/server';
+import { RPCHandler } from '@orpc/server/fetch';
+import { assertBridgeRequest, createBridgeError, } from './index';
+export const defaultBridgeRpcEndpoint = '/api/mpgd/rpc';
+export const bridgeRpcContract = oc.router({
+    request: oc.input(orpcType()).output(orpcType()),
+});
+export function createBridgeOrpcClient(input = {}) {
+    const headers = input.headers;
+    const link = new RPCLink({
+        url: input.url ?? defaultBridgeRpcEndpoint,
+        ...(input.fetch === undefined ? {} : { fetch: input.fetch }),
+        ...(headers === undefined
+            ? {}
+            : {
+                headers: () => headers,
+            }),
+    });
+    return createORPCClient(link);
+}
+export function createBridgeRpcRouter(handleRequest) {
+    const contract = implement(bridgeRpcContract);
+    return contract.router({
+        request: contract.request.handler(({ input }) => {
+            let request;
+            try {
+                request = assertBridgeRequest(input);
+            }
+            catch (error) {
+                return createBridgeError(bridgeRequestIdFromInput(input), 'INVALID_BRIDGE_REQUEST', `Bridge RPC request failed runtime validation: ${errorMessage(error)}`, false);
+            }
+            return handleRequest(request);
+        }),
+    });
+}
+export function createBridgeRpcFetchHandler(router, options = {}) {
+    const rpcHandler = new RPCHandler(router);
+    const prefix = options.prefix ?? defaultBridgeRpcEndpoint;
+    return async (request) => {
+        try {
+            const result = await rpcHandler.handle(request, {
+                prefix,
+                context: {
+                    request,
+                },
+            });
+            if (!result.matched) {
+                return new Response('Not Found', {
+                    status: 404,
+                    headers: {
+                        'content-type': 'text/plain',
+                    },
+                });
+            }
+            return result.response;
+        }
+        catch (error) {
+            console.error('Bridge RPC internal error:', error);
+            return new Response(JSON.stringify({
+                error: 'BRIDGE_RPC_INTERNAL_ERROR',
+            }), {
+                status: 500,
+                headers: {
+                    'content-type': 'application/json',
+                },
+            });
+        }
+    };
+}
+function bridgeRequestIdFromInput(input) {
+    if (typeof input === 'object' && input !== null && 'id' in input) {
+        const id = input.id;
+        if (typeof id === 'string' && id.length > 0) {
+            return id;
+        }
+    }
+    return 'unknown';
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/bridge",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Typed native bridge protocol for mpgd platform adapters.",
   "license": "MIT",
   "repository": {
@@ -28,12 +28,19 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./orpc": {
+      "types": "./dist/orpc.d.ts",
+      "default": "./dist/orpc.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
+    "@orpc/client": "2.0.0-beta.14",
+    "@orpc/contract": "2.0.0-beta.14",
+    "@orpc/server": "2.0.0-beta.14",
     "typia": "rc"
   },
   "devDependencies": {
@@ -50,6 +57,6 @@
     "lint": "ttsc --noEmit",
     "format": "ttsc format",
     "fix": "ttsc fix",
-    "test": "cd ../.. && node tools/run-ttsx.mjs packages/bridge/src/bridge-protocol.test.ts"
+    "test": "cd ../.. && node tools/run-ttsx.mjs packages/bridge/src/bridge-protocol.test.ts && node tools/run-ttsx.mjs packages/bridge/src/orpc.test.ts"
   }
 }