@srpc.org/core 0.20.3

package/dist/server.d.ts

@@ -0,0 +1,146 @@
+import { Serializer, DecoratedProcedureRecord } from './shared.js';
+
+type ProcedureType<TContext> = (
+  ctx: TContext,
+  ...args: any[]
+) => Promise<any> | any;
+
+type Routes<TContext> = {
+    [key: string]: ProcedureType<TContext> | SRPC<TContext>;
+};
+type AnySRPC = SRPC<any>;
+type SrpcBaseOptions<TRouter extends AnySRPC> = {
+    router: TRouter;
+};
+declare class SRPC<TContext, TRoutes extends Routes<TContext> = {}> {
+    __context: TContext;
+    ipc: TRoutes;
+    constructor(routes?: TRoutes);
+    context<T>(): SRPC<T>;
+    router<T extends Routes<TContext>>(routes: T): SRPC<TContext, T>;
+}
+declare const initSRPC: () => SRPC<unknown>;
+
+declare const srpcFetchApi: <TRouter extends AnySRPC>({ router, endpoint, createContext, transformer: serializer, }: SrpcBaseOptions<TRouter> & {
+    createContext?: (req: Request) => Promise<TRouter["__context"]>;
+    transformer?: Serializer;
+    endpoint: string;
+}) => {
+    fetch: (req: Request) => Promise<Response>;
+};
+
+/**
+ * @module
+ *
+ * Server-side SRPC module for creating routers and handling RPC requests.
+ *
+ * This module provides the core server functionality including:
+ * - Router initialization and composition
+ * - Fetch API adapter for edge runtimes
+ * - Server-side procedure calling without HTTP
+ *
+ * @example
+ * ```typescript
+ * import { initSRPC, srpcFetchApi } from "@srpc/core/server";
+ *
+ * // Initialize and create router
+ * const s = initSRPC();
+ * const appRouter = s.router({
+ *   sayHello: async (_, name: string) => `Hello ${name}!`
+ * });
+ *
+ * // Create Fetch API handler
+ * const { fetch: handleRequest } = srpcFetchApi({
+ *   router: appRouter,
+ *   endpoint: "/api"
+ * });
+ * ```
+ */
+
+/**
+ * Creates a server-side caller for direct procedure invocation without HTTP.
+ *
+ * Useful for:
+ * - Calling procedures from server components
+ * - Server-side rendering (SSR)
+ * - Internal server-to-server communication
+ * - Testing procedures without HTTP overhead
+ *
+ * @template TRouter - The SRPC router type
+ *
+ * @param options - Configuration object
+ * @param options.router - The SRPC router to create a caller for
+ * @param options.createContext - Optional function to create context for calls
+ *
+ * @returns A type-safe caller proxy matching your router structure
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createSRPCCaller, initSRPC } from "@srpc/core/server";
+ *
+ * const s = initSRPC();
+ * const appRouter = s.router({
+ *   sayHello: async (_, name: string) => `Hello ${name}!`,
+ *   getUser: async (_, id: number) => ({ id, name: "John" })
+ * });
+ *
+ * const caller = createSRPCCaller({ router: appRouter });
+ *
+ * // Call procedures directly
+ * const greeting = await caller.sayHello("World"); // "Hello World!"
+ * const user = await caller.getUser(1); // { id: 1, name: "John" }
+ * ```
+ *
+ * @example With context
+ * ```typescript
+ * type Context = { db: Database; user?: User };
+ *
+ * const s = initSRPC().context<Context>();
+ * const appRouter = s.router({
+ *   getCurrentUser: async (ctx) => {
+ *     if (!ctx.user) throw new Error("Not authenticated");
+ *     return ctx.user;
+ *   },
+ *   getPosts: async (ctx) => {
+ *     return ctx.db.posts.findAll();
+ *   }
+ * });
+ *
+ * const caller = createSRPCCaller({
+ *   router: appRouter,
+ *   createContext: async () => ({
+ *     db: getDatabase(),
+ *     user: await getCurrentUser()
+ *   })
+ * });
+ *
+ * const posts = await caller.getPosts();
+ * ```
+ *
+ * @example In Next.js Server Components
+ * ```typescript
+ * // server/rpc.ts
+ * export const rpcCaller = createSRPCCaller({
+ *   router: appRouter,
+ *   createContext: async () => ({
+ *     db: getDatabase(),
+ *     user: await getServerSession()
+ *   })
+ * });
+ *
+ * // app/page.tsx
+ * import { rpcCaller } from "@/server/rpc";
+ *
+ * export default async function Page() {
+ *   const user = await rpcCaller.getCurrentUser();
+ *   return <div>Hello {user.name}</div>;
+ * }
+ * ```
+ */
+declare const createSRPCCaller: <TRouter extends AnySRPC>({ createContext, router, }: {
+    createContext?: () => Promise<TRouter["__context"]>;
+    router: TRouter;
+}) => DecoratedProcedureRecord<TRouter["ipc"]>;
+
+export { SRPC, createSRPCCaller, initSRPC, srpcFetchApi };
+export type { AnySRPC };

package/dist/server.js

@@ -0,0 +1,262 @@
+import { _ } from '@swc/helpers/_/_class_private_field_loose_base';
+import { _ as _$1 } from '@swc/helpers/_/_class_private_field_loose_key';
+import { SRPCError, defaultSerializer, StatusCodeMap } from './shared.js';
+
+/**
+ * Used from trpc.io
+ */ const noop = ()=>{
+// noop
+};
+const freezeIfAvailable = (obj)=>{
+    if (Object.freeze) {
+        Object.freeze(obj);
+    }
+};
+function createInnerProxy(callback, path, memo) {
+    var _memo, _cacheKey;
+    const cacheKey = path.join(".");
+    (_memo = memo)[_cacheKey = cacheKey] ?? (_memo[_cacheKey] = new Proxy(noop, {
+        get (_obj, key) {
+            if (typeof key !== "string" || key === "then") {
+                // special case for if the proxy is accidentally treated
+                // like a PromiseLike (like in `Promise.resolve(proxy)`)
+                return undefined;
+            }
+            return createInnerProxy(callback, [
+                ...path,
+                key
+            ], memo);
+        },
+        apply (_1, _2, args) {
+            const lastOfPath = path[path.length - 1];
+            let opts = {
+                args,
+                path
+            };
+            // special handling for e.g. `trpc.hello.call(this, 'there')` and `trpc.hello.apply(this, ['there'])
+            if (lastOfPath === "call") {
+                opts = {
+                    args: args.length >= 2 ? [
+                        args[1]
+                    ] : [],
+                    path: path.slice(0, -1)
+                };
+            } else if (lastOfPath === "apply") {
+                opts = {
+                    args: args.length >= 2 ? args[1] : [],
+                    path: path.slice(0, -1)
+                };
+            } else if (lastOfPath === "toString") {
+                return path.slice(0, -1).join(".");
+            } else if (lastOfPath === "toJSON") {
+                return {
+                    path: path.slice(0, -1),
+                    pathString: path.slice(0, -1).join("."),
+                    __type: "SRPC"
+                };
+            }
+            freezeIfAvailable(opts.args);
+            freezeIfAvailable(opts.path);
+            return callback(opts);
+        }
+    }));
+    return memo[cacheKey];
+}
+/**
+ * Creates a proxy that calls the callback with the path and arguments
+ *
+ * @internal
+ */ const createRecursiveProxy = (callback)=>createInnerProxy(callback, [], Object.create(null));
+
+class SRPC {
+    context() {
+        return new SRPC();
+    }
+    router(routes) {
+        return new SRPC(routes);
+    }
+    constructor(routes){
+        if (routes) {
+            this.ipc = routes;
+        }
+    }
+}
+const initSRPC = ()=>{
+    return new SRPC();
+};
+var _router = /*#__PURE__*/ _$1("_router"), _options = /*#__PURE__*/ _$1("_options");
+class sRPC_API {
+    getRoute(path) {
+        const pathString = path.toString();
+        const value = _(this, _router)[_router].ipc[path];
+        if (value) {
+            return value;
+        }
+        if (pathString.includes(".")) {
+            let current = _(this, _router)[_router].ipc;
+            const pathParts = pathString.split(".");
+            for (const key of pathParts){
+                if (current && current instanceof SRPC) {
+                    current = current.ipc[key];
+                    continue;
+                } else if (current && typeof current === "object" && key in current) {
+                    current = current[key];
+                } else {
+                    current = null;
+                }
+            }
+            return current;
+        }
+        return _(this, _router)[_router].ipc[path];
+    }
+    async call(path, context, deserializedArgs) {
+        const route = this.getRoute(path);
+        if (typeof route !== "function") {
+            throw new SRPCError(`Route ${String(path)} not found`, "NOT_FOUND");
+        }
+        return route(context, ...deserializedArgs);
+    }
+    constructor(options){
+        Object.defineProperty(this, _router, {
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _options, {
+            writable: true,
+            value: void 0
+        });
+        _(this, _router)[_router] = options.router;
+        _(this, _options)[_options] = options;
+    }
+}
+
+const srpcFetchApi = ({ router, endpoint, createContext, transformer: serializer = defaultSerializer })=>{
+    const api = new sRPC_API({
+        router
+    });
+    return {
+        fetch: async (req)=>{
+            const url = new URL(req.url);
+            const context = await createContext?.(req);
+            const path = url.pathname.replace(`${endpoint}/`, "");
+            const body = await req.text();
+            const deserializedArgs = serializer.deserialize(body);
+            try {
+                const data = await api.call(path, context, deserializedArgs);
+                return new Response(serializer.serialize(data), {
+                    headers: {
+                        "Content-Type": "application/json"
+                    }
+                });
+            } catch (error) {
+                if (error instanceof SRPCError) {
+                    return new Response(serializer.serialize(error), {
+                        status: StatusCodeMap[error.code],
+                        headers: {
+                            "Content-Type": "application/json"
+                        }
+                    });
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(error);
+                return new Response(serializer.serialize(new SRPCError(message, "INTERNAL_SERVER_ERROR")), {
+                    status: 500,
+                    headers: {
+                        "Content-Type": "application/json"
+                    }
+                });
+            }
+        }
+    };
+};
+
+/**
+ * Creates a server-side caller for direct procedure invocation without HTTP.
+ *
+ * Useful for:
+ * - Calling procedures from server components
+ * - Server-side rendering (SSR)
+ * - Internal server-to-server communication
+ * - Testing procedures without HTTP overhead
+ *
+ * @template TRouter - The SRPC router type
+ *
+ * @param options - Configuration object
+ * @param options.router - The SRPC router to create a caller for
+ * @param options.createContext - Optional function to create context for calls
+ *
+ * @returns A type-safe caller proxy matching your router structure
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createSRPCCaller, initSRPC } from "@srpc/core/server";
+ *
+ * const s = initSRPC();
+ * const appRouter = s.router({
+ *   sayHello: async (_, name: string) => `Hello ${name}!`,
+ *   getUser: async (_, id: number) => ({ id, name: "John" })
+ * });
+ *
+ * const caller = createSRPCCaller({ router: appRouter });
+ *
+ * // Call procedures directly
+ * const greeting = await caller.sayHello("World"); // "Hello World!"
+ * const user = await caller.getUser(1); // { id: 1, name: "John" }
+ * ```
+ *
+ * @example With context
+ * ```typescript
+ * type Context = { db: Database; user?: User };
+ *
+ * const s = initSRPC().context<Context>();
+ * const appRouter = s.router({
+ *   getCurrentUser: async (ctx) => {
+ *     if (!ctx.user) throw new Error("Not authenticated");
+ *     return ctx.user;
+ *   },
+ *   getPosts: async (ctx) => {
+ *     return ctx.db.posts.findAll();
+ *   }
+ * });
+ *
+ * const caller = createSRPCCaller({
+ *   router: appRouter,
+ *   createContext: async () => ({
+ *     db: getDatabase(),
+ *     user: await getCurrentUser()
+ *   })
+ * });
+ *
+ * const posts = await caller.getPosts();
+ * ```
+ *
+ * @example In Next.js Server Components
+ * ```typescript
+ * // server/rpc.ts
+ * export const rpcCaller = createSRPCCaller({
+ *   router: appRouter,
+ *   createContext: async () => ({
+ *     db: getDatabase(),
+ *     user: await getServerSession()
+ *   })
+ * });
+ *
+ * // app/page.tsx
+ * import { rpcCaller } from "@/server/rpc";
+ *
+ * export default async function Page() {
+ *   const user = await rpcCaller.getCurrentUser();
+ *   return <div>Hello {user.name}</div>;
+ * }
+ * ```
+ */ const createSRPCCaller = ({ createContext, router })=>{
+    return createRecursiveProxy(async ({ path, args })=>{
+        const api = new sRPC_API({
+            router
+        });
+        const context = await createContext?.();
+        return api.call(path.join("."), context, args);
+    });
+};
+
+export { SRPC, createSRPCCaller, initSRPC, srpcFetchApi };