@seam-rpc/server 5.0.0 → 5.0.2

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { Result, ApiError, ApiErrorInterface } from "@seam-rpc/core";
+import { Result, ApiError } from "@seam-rpc/core";
 import EventEmitter from "events";
 import express, { Express, NextFunction, Request, RequestHandler, Response } from "express";
 import * as z from "zod";
-export { ApiError as RpcError };
+export { ApiError };
 export type { Result };
 type Simplify<T> = T extends File ? File : T extends object ? {
     [K in keyof T]: Simplify<T[K]>;
@@ -29,14 +29,14 @@ export interface SeamEvents {
     inputValidationError: [error: unknown, context: SeamErrorContext];
     outputValidationError: [error: unknown, context: SeamErrorContext];
 }
-type ProcedureHandler<Input extends ProcedureInput, Output extends ProcedureOutput> = (options: ProcedureOptions<Input>) => Result<z.infer<Output>, ApiError> | Promise<Result<z.infer<Output>, ApiError>>;
+type ProcedureHandler<Input extends ProcedureInput, Output extends ProcedureOutput> = (options: ProcedureOptions<Input>) => Result<z.infer<Output>, ApiError<any, any>> | Promise<Result<z.infer<Output>, ApiError<any, any>>>;
 interface ProcedureOptions<Input extends ProcedureInput> {
     input: Simplify<ProcedureInputData<Input>>;
     ctx: SeamContext;
 }
 type ProcedureInput = Record<string, z.ZodType>;
 type ProcedureOutput = z.ZodType;
-type ProcedureErrors = Record<string, z.ZodType | undefined>;
+type ProcedureErrors = Record<string, any | undefined>;
 type ProcedureInputData<T extends ProcedureInput> = {
     [K in keyof T]: z.infer<T[K]>;
 };
@@ -46,10 +46,12 @@ interface SeamProcedure<Input extends ProcedureInput = {}, Output extends Proced
     errors?: Errors;
     handler?: ProcedureHandler<Input, Output>;
 }
-type ExtractResultError<T> = Awaited<T> extends Result<any, infer E> ? E : never;
-type ErrorUnionToMap<E> = {
-    [K in E extends ApiErrorInterface<any, infer Code> ? Code : never]: Extract<E, ApiErrorInterface<any, K>> extends ApiErrorInterface<infer Map, K> ? Map[K] : never;
-};
+type ExtractResultError<T> = Awaited<T> extends Result<any, undefined> ? never : Awaited<T> extends Result<any, infer E> ? E : never;
+type ErrorUnionToMap<T> = [
+    T
+] extends [never] ? {} : [T] extends [ApiError<infer ErrorMap, infer Code>] ? {
+    [K in Code]: ErrorMap[K];
+} : never;
 export type ProcedureBuilder<Input extends ProcedureInput = {}, Output extends ProcedureOutput = z.ZodUndefined, Errors extends ProcedureErrors = {}> = {
     _def: SeamProcedure<Input, Output, Errors>;
     input: <T extends ProcedureInput>(schema: T) => ProcedureBuilder<T, Output, Errors>;
@@ -69,24 +71,15 @@ export declare class SeamSpace extends EventEmitter<SeamEvents> {
     get jsonParser(): import("connect").NextHandleFunction;
     get fileHandler(): express.RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
 }
-type ErrorMapToUnion<E extends Record<string, any>> = {
-    [K in keyof E]: ApiError<{
-        [P in K]: E[K];
-    }, K>;
-}[keyof E];
-type ResultFromErrors<Data, Errors extends Record<string, any>> = {
-    ok: true;
-    data: Data;
-} | (ErrorMapToUnion<Errors> extends infer E ? E extends ApiError<any, any> ? {
-    ok: false;
-    error: E;
-} : never : never);
 type InferInput<P> = P extends ProcedureBuilder<infer I, any, any> ? {
     [K in keyof I]: I[K] extends z.ZodType ? z.infer<I[K]> : never;
 } : never;
 type InferOutput<P> = P extends ProcedureBuilder<any, infer O, any> ? O extends z.ZodType ? z.infer<O> : never : never;
-type InferErrors<P> = P extends ProcedureBuilder<any, any, infer E> ? E : never;
-type ProcedureToFn<P> = P extends ProcedureBuilder<any, any, any> ? (input: InferInput<P>) => Promise<ResultFromErrors<InferOutput<P>, InferErrors<P>>> : never;
-type RouterToClient<T> = {
-    [K in keyof T]: T[K] extends ProcedureBuilder<any, any, any> ? ProcedureToFn<T[K]> : RouterToClient<T[K]>;
+type InferErrors<P> = P extends ProcedureBuilder<any, any, infer E> ? [keyof E] extends [never] ? undefined : {
+    [K in keyof E]: ApiError<E, K>;
+}[keyof E] : never;
+export type RouterToClient<RouterList extends Record<string, Record<string, ProcedureBuilder<any, any, any>>>> = {
+    [R in keyof RouterList]: {
+        [P in keyof RouterList[R]]: (input: InferInput<RouterList[R][P]>) => Promise<Result<InferOutput<RouterList[R][P]>, InferErrors<RouterList[R][P]>>>;
+    };
 };

package/dist/index.js

@@ -3,7 +3,7 @@ import EventEmitter from "events";
 import express, { Router } from "express";
 import FormData from "form-data";
 import * as z from "zod";
-export { ApiError as RpcError };
+export { ApiError };
 ;
 export async function createSeamSpace(app, fileHandler) {
     if (!fileHandler) {

package/package.json

@@ -1,11 +1,8 @@
 {
   "name": "@seam-rpc/server",
-  "version": "5.0.0",
+  "version": "5.0.2",
   "main": "dist/index.js",
   "type": "module",
-  "bin": {
-    "srpc": "dist/bin/index.js"
-  },
   "types": "dist/index.d.ts",
   "files": [
     "dist"

package/dist/router.d.ts

@@ -1,14 +0,0 @@
-import { Router } from "express";
-import { ProcedureBuilderList, SeamSpace } from "./index.js";
-export declare class SeamRouter {
-    private seamSpace;
-    private _procedures;
-    private _router;
-    constructor(seamSpace: SeamSpace, name: string);
-    get router(): Router;
-    private runMiddleware;
-    private validateInput;
-    private validateOutput;
-    private validateData;
-    addProcedures(procedures: ProcedureBuilderList): void;
-}

package/dist/router.js

@@ -1,197 +0,0 @@
-import { extractFiles, injectFiles, ApiError } from "@seam-rpc/core";
-import { Router } from "express";
-import FormData from "form-data";
-import * as z from "zod";
-export class SeamRouter {
-    constructor(seamSpace, name) {
-        this.seamSpace = seamSpace;
-        this._procedures = {};
-        this._router = Router();
-        this._router.post("/:procName", async (req, res, next) => {
-            const procedure = this._procedures[req.params.procName];
-            if (!procedure || !procedure.handler)
-                return res.sendStatus(404);
-            let input;
-            let validatedInput = undefined;
-            let output = undefined;
-            let validatedOutput;
-            // Middleware
-            try {
-                input = await this.runMiddleware(req, res);
-            }
-            catch (err) {
-                console.error(err);
-                return res.status(415).send(String(err));
-            }
-            // Validate input
-            try {
-                validatedInput = this.validateInput(input, procedure.input);
-            }
-            catch (err) {
-                seamSpace.emit("inputValidationError", err, {
-                    routerName: name,
-                    procedureName: req.params.procName,
-                    input,
-                    validatedInput,
-                    output,
-                    validatedOutput,
-                    request: req,
-                    response: res,
-                    next,
-                });
-                res.sendStatus(400);
-                return;
-            }
-            // Call procedure
-            const ctx = {
-                request: req,
-                response: res,
-                next,
-            };
-            function toResError(error) {
-                if (error instanceof ApiError)
-                    return { isApiError: true, error: error.toJSON() };
-                else
-                    return { isApiError: false };
-            }
-            try {
-                output = await procedure.handler({ input: validatedInput, ctx, error: errorHandler });
-            }
-            catch (error) {
-                seamSpace.emit("apiError", error, {
-                    routerName: name,
-                    procedureName: req.params.procName,
-                    input,
-                    validatedInput,
-                    output,
-                    validatedOutput,
-                    request: req,
-                    response: res,
-                    next: () => { res.status(400).json(toResError(error)); return next(); },
-                });
-                return;
-            }
-            if (!output.ok) {
-                seamSpace.emit("apiError", output.error, {
-                    routerName: name,
-                    procedureName: req.params.procName,
-                    input,
-                    validatedInput,
-                    output,
-                    validatedOutput,
-                    request: req,
-                    response: res,
-                    next: () => { res.status(400).json(toResError(output.error)); return next(); },
-                });
-                return;
-            }
-            // Validate output
-            try {
-                validatedOutput = this.validateOutput(output, z.object({ ok: z.literal(true), data: procedure.output }).or(z.object({ ok: z.literal(false), error: z.any() })));
-            }
-            catch (err) {
-                seamSpace.emit("outputValidationError", err, {
-                    routerName: name,
-                    procedureName: req.params.procName,
-                    input,
-                    validatedInput,
-                    output,
-                    validatedOutput,
-                    request: req,
-                    response: res,
-                    next,
-                });
-                res.sendStatus(500);
-                return;
-            }
-            try {
-                const { json, files, paths } = extractFiles({ result: validatedOutput });
-                // Does not include file(s)
-                if (files.length === 0) {
-                    res.json(json);
-                    return;
-                }
-                // Includes file(s)
-                const form = new FormData();
-                form.append("json", JSON.stringify(json));
-                form.append("paths", JSON.stringify(paths));
-                for (let i = 0; i < files.length; i++) {
-                    const file = files[i];
-                    const buffer = Buffer.from(await file.arrayBuffer());
-                    form.append(`file-${i}`, buffer, {
-                        filename: file.name || `file-${i}`,
-                        contentType: file.type || "application/octet-stream",
-                    });
-                }
-                res.writeHead(200, form.getHeaders());
-                form.pipe(res);
-            }
-            catch (error) {
-                seamSpace.emit("internalError", error, {
-                    routerName: name,
-                    procedureName: req.params.procName,
-                    input,
-                    validatedInput,
-                    output,
-                    validatedOutput,
-                    request: req,
-                    response: res,
-                    next: next,
-                });
-                res.sendStatus(500); //.send({ error: String(error) });
-            }
-        });
-        seamSpace.app.use(name, this._router);
-    }
-    get router() {
-        return this._router;
-    }
-    async runMiddleware(req, res) {
-        const contentType = req.headers["content-type"] || "";
-        const runMiddleware = (middleware) => new Promise((resolve, reject) => middleware(req, res, err => (err ? reject(err) : resolve())));
-        if (contentType.startsWith("application/json")) {
-            await runMiddleware(this.seamSpace.jsonParser);
-        }
-        else if (contentType.startsWith("multipart/form-data")) {
-            await runMiddleware(this.seamSpace.fileHandler);
-        }
-        else {
-            throw new Error("Unsupported content type.");
-        }
-        if (contentType.startsWith("application/json"))
-            return req.body;
-        // multipart/form-data (already checked before)
-        let input = JSON.parse(req.body.json);
-        const paths = JSON.parse(req.body.paths);
-        const files = (req.files ?? []).map((file, index) => ({
-            path: paths[index],
-            file: new File([file.buffer], file.originalname, { type: file.mimetype }),
-        }));
-        injectFiles(input, files);
-        return input;
-    }
-    validateInput(input, inputSchema) {
-        return this.validateData(input, z.object(inputSchema));
-    }
-    validateOutput(output, procOutput) {
-        return this.validateData(output, procOutput);
-    }
-    validateData(data, schema) {
-        if (!schema) {
-            if (data)
-                throw new Error("Received data, but no data expected.");
-            return null;
-        }
-        if (!data)
-            throw new Error("No data was received, but data was expected.");
-        return schema.parse(data);
-    }
-    addProcedures(procedures) {
-        for (const proc in procedures) {
-            this._procedures[proc] = procedures[proc]._def;
-        }
-    }
-}
-const errorHandler = (code, ...args) => {
-    return new ApiError(code, args[0]);
-};