@seam-rpc/server 4.3.21 → 5.0.0

package/dist/index.js

@@ -1,14 +1,10 @@
-import { extractFiles, injectFiles, RpcError } from "@seam-rpc/core";
+import { extractFiles, injectFiles, ApiError } from "@seam-rpc/core";
 import EventEmitter from "events";
 import express, { Router } from "express";
 import FormData from "form-data";
 import * as z from "zod";
-export { RpcError };
+export { ApiError as RpcError };
 ;
-;
-const errorHandler = (code, ...args) => {
-    return new RpcError(code, args[0]);
-};
 export async function createSeamSpace(app, fileHandler) {
     if (!fileHandler) {
         let multer;
@@ -37,202 +33,189 @@ function createProcedureBuilder(definition = {}) {
             ...definition,
             output: schema,
         }),
-        errors: errors => createProcedureBuilder({
-            ...definition,
-            errors
-        }),
-        handler: handler => createProcedureBuilder({
+        handler: (handler) => createProcedureBuilder({
             ...definition,
-            handler
+            handler,
         }),
     };
 }
-export class SeamRouter {
-    constructor(seamSpace, path) {
-        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, {
-                    routerPath: path,
-                    procedureName: req.params.procName,
-                    input,
-                    validatedInput,
-                    output,
-                    validatedOutput,
-                    request: req,
-                    response: res,
-                    next,
-                });
-                res.sendStatus(400);
-                return;
-            }
-            // Call procedure
-            const ctx = {
+function defineSeamRouter(seamSpace, path, seamRouterBuilder) {
+    const router = Router();
+    router.post("/:procName", async (req, res, next) => {
+        const procedure = seamRouterBuilder[req.params.procName]._def;
+        if (!procedure || !procedure.handler)
+            return res.sendStatus(404);
+        let input;
+        let validatedInput = undefined;
+        let output = undefined;
+        let validatedOutput;
+        // Middleware
+        try {
+            input = await runMiddleware(seamSpace, req, res);
+        }
+        catch (err) {
+            console.error(err);
+            return res.status(415).send(String(err));
+        }
+        // Validate input
+        try {
+            validatedInput = validateInput(input, procedure.input);
+        }
+        catch (err) {
+            seamSpace.emit("inputValidationError", err, {
+                routerPath: path,
+                procedureName: req.params.procName,
+                input,
+                validatedInput,
+                output,
+                validatedOutput,
                 request: req,
                 response: res,
                 next,
-            };
-            function toResError(error) {
-                if (error instanceof RpcError)
-                    return { rpcError: true, error: error.toJSON() };
-                else
-                    return { rpcError: false };
-            }
-            try {
-                output = await procedure.handler({ input: validatedInput, ctx, error: errorHandler });
-            }
-            catch (error) {
-                seamSpace.emit("apiError", error, {
-                    routerPath: path,
-                    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, {
-                    routerPath: path,
-                    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, {
-                    routerPath: path,
-                    procedureName: req.params.procName,
-                    input,
-                    validatedInput,
-                    output,
-                    validatedOutput,
-                    request: req,
-                    response: res,
-                    next,
-                });
-                res.sendStatus(500);
+            });
+            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 });
+        }
+        catch (error) {
+            seamSpace.emit("apiError", error, {
+                routerPath: path,
+                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, {
+                routerPath: path,
+                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 = 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, {
+                routerPath: path,
+                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;
             }
-            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, {
-                    routerPath: path,
-                    procedureName: req.params.procName,
-                    input,
-                    validatedInput,
-                    output,
-                    validatedOutput,
-                    request: req,
-                    response: res,
-                    next: next,
+            // 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.sendStatus(500); //.send({ error: String(error) });
             }
-        });
-        seamSpace.app.use(path, 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);
+            res.writeHead(200, form.getHeaders());
+            form.pipe(res);
         }
-        else {
-            throw new Error("Unsupported content type.");
+        catch (error) {
+            seamSpace.emit("internalError", error, {
+                routerPath: path,
+                procedureName: req.params.procName,
+                input,
+                validatedInput,
+                output,
+                validatedOutput,
+                request: req,
+                response: res,
+                next: next,
+            });
+            res.sendStatus(500);
         }
-        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));
+    });
+    seamSpace.app.use(`/${path}`, router);
+}
+async function runMiddleware(seamSpace, 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(seamSpace.jsonParser);
     }
-    validateOutput(output, procOutput) {
-        return this.validateData(output, procOutput);
+    else if (contentType.startsWith("multipart/form-data")) {
+        await runMiddleware(seamSpace.fileHandler);
     }
-    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);
+    else {
+        throw new Error("Unsupported content type.");
     }
-    addProcedures(procedures) {
-        for (const proc in procedures) {
-            this.procedures[proc] = procedures[proc]._def;
-        }
+    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;
+}
+function validateInput(input, inputSchema) {
+    return validateData(input, z.object(inputSchema));
+}
+function validateOutput(output, procOutput) {
+    return validateData(output, procOutput);
+}
+function 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);
 }
 export class SeamSpace extends EventEmitter {
     constructor(_app, _fileHandler) {
@@ -241,10 +224,9 @@ export class SeamSpace extends EventEmitter {
         this._fileHandler = _fileHandler;
         this._jsonParser = express.json();
     }
-    createRouter(path, procedures = {}) {
-        const router = new SeamRouter(this, path);
-        router.addProcedures(procedures);
-        return router;
+    addRouters(routers) {
+        Object.entries(routers).forEach(e => defineSeamRouter(this, e[0], e[1]));
+        return {};
     }
     get app() { return this._app; }
     get jsonParser() { return this._jsonParser; }

package/dist/router.d.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,197 @@
+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]);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seam-rpc/server",
-  "version": "4.3.21",
+  "version": "5.0.0",
   "main": "dist/index.js",
   "type": "module",
   "bin": {