@seam-rpc/server 3.0.2 → 4.1.0

package/dist/bin/gen-client.d.ts

@@ -1 +1,8 @@
 export declare function genClient(): Promise<void>;
+interface GenerateOptions {
+    tsPath: string;
+    jsPath: string;
+    outputPath: string;
+}
+export declare function generateClientFile({ tsPath, jsPath, outputPath, }: GenerateOptions): Promise<string>;
+export {};

package/dist/bin/gen-client.js

@@ -1,101 +1,154 @@
 import fs from "fs";
-import ts from "typescript";
 import path from "path";
 import fg from "fast-glob";
+import ts from "typescript";
+import { zodToTs, createAuxiliaryTypeStore, printNode } from "zod-to-ts";
+import { existsSync, writeFileSync } from "fs";
 export async function genClient() {
     const args = process.argv;
-    let config;
-    if (args.length == 3) {
-        if (!fs.existsSync("./seam-rpc.config.json"))
-            return console.error("\x1b[31mCommand arguments omitted and no config file found.\x1b[0m\n"
-                + "Either define a config file with \x1b[36mseam-rpc gen-config\x1b[0m or generate the client files using \x1b[36mseam-rpc gen-client <input-files> <output-folder> [global-types-file]\x1b[0m.");
-        config = JSON.parse(fs.readFileSync("./seam-rpc.config.json", "utf-8"));
-    }
-    else if (args.length == 5 || args.length == 6) {
-        config = {
-            inputFiles: args[3],
-            outputFolder: args[4]
-        };
-    }
-    else {
-        return console.error("Usage: seam-rpc gen-client <input-files> <output-folder>");
-    }
-    const inputFiles = await fg(config.inputFiles);
+    const config = loadConfig(args);
+    if (!config)
+        return;
+    const sourceFiles = await fg(config.source);
+    const compiledFolder = path.resolve(config.compiledFolder);
     const outputPath = path.resolve(config.outputFolder);
     const rootPath = path.resolve(".");
+    function removeRootPath(path) {
+        return "." + path.slice(rootPath.length);
+    }
     try {
         const outputFiles = [];
-        for (const inputFile of inputFiles) {
-            const outputFile = generateClientFile(inputFile, outputPath);
-            outputFiles.push(removeRootPath(outputFile, rootPath));
+        for (let i = 0; i < sourceFiles.length; i++) {
+            const sourceFile = sourceFiles[i];
+            const path = await generateClientFile({ tsPath: sourceFile, jsPath: compiledFolder, outputPath });
+            const symb = i < sourceFiles.length - 1 ? " ├╴" : " └╴";
+            outputFiles.push(symb + removeRootPath(path));
         }
-        console.log("\x1b[32m%s\x1b[0m\n\x1b[36m%s\x1b[0m", `✅ Successfully generated client files at ${removeRootPath(outputPath, rootPath)}`, `${outputFiles.join("\n")}`);
+        console.log("\x1b[32m\x1b[1m%s\x1b[0m\n\x1b[94m%s\x1b[0m", `✅ Successfully generated client files at ${config.outputFolder}`, `${outputFiles.join("\n")}`);
     }
     catch (err) {
         console.error("❌ Failed to generate client file:", err.message);
         process.exit(1);
     }
 }
-function removeRootPath(path, rootPath) {
-    return "." + path.slice(rootPath.length);
-}
-function generateClientFile(inputFile, outputPath) {
-    const file = path.resolve(process.cwd(), inputFile);
-    if (!fs.existsSync(file)) {
-        console.error(`File ${file} not found`);
-        process.exit(1);
-    }
-    const imports = ["import { callApi, SeamFile, ISeamFile } from \"@seam-rpc/client\";"];
-    const apiDef = [];
-    const typeDefs = [];
-    const routerName = path.basename(file, path.extname(file));
-    const fileContent = fs.readFileSync(file, "utf-8");
-    const sourceFile = ts.createSourceFile(file, fileContent, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    ts.forEachChild(sourceFile, (node) => {
-        if (ts.isImportDeclaration(node)) {
-            const moduleSpecifier = node.moduleSpecifier.getText().replace(/['"]/g, "");
-            if (moduleSpecifier.startsWith("./"))
-                imports.push(node.getText());
+function loadConfig(args) {
+    if (args.length == 3) {
+        // Use config
+        // Check if config exists
+        if (!fs.existsSync("./seam-rpc.config.json")) {
+            console.error("\x1b[31mCommand arguments omitted and no config file found.\x1b[0m\n"
+                + "Either define a config file with \x1b[36mseam-rpc gen-config\x1b[0m or generate the client files using \x1b[36mseam-rpc gen-client <input-files> <output-folder> [global-types-file]\x1b[0m.");
+            return null;
         }
-        else if (ts.isFunctionDeclaration(node) && hasExportModifier(node)) {
-            if (!node.name) {
-                console.error("Missing function name.");
-                process.exit(1);
+        // Load config from config file
+        return JSON.parse(fs.readFileSync("./seam-rpc.config.json", "utf-8"));
+    }
+    else if (args.length == 5 || args.length == 6) {
+        // Use command args
+        // Load config from command args
+        return {
+            source: args[3],
+            compiledFolder: args[4],
+            outputFolder: args[5]
+        };
+    }
+    else {
+        // Invalid command usage
+        console.error("Usage: seam-rpc gen-client <input-files> <output-folder>");
+        return null;
+    }
+}
+// Extracts comments from TS file.
+function getProcedureComments(filePath) {
+    const sourceText = fs.readFileSync(filePath, "utf8");
+    const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true);
+    const comments = {};
+    function visit(node) {
+        if (ts.isVariableStatement(node)) {
+            const comment = getFullComment(node, sourceText);
+            for (const decl of node.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name))
+                    comments[decl.name.text] = comment;
             }
-            const funcName = node.name.getText();
-            const jsDoc = ts.getJSDocCommentsAndTags(node).map(e => e.getFullText()).filter(Boolean).join("\n");
-            let signature = `${jsDoc}\nexport function ${funcName}(`;
-            const params = node.parameters.filter(p => !(p.type && p.type.getText() === "SeamContext"));
-            const paramsText = params
-                .map((p) => {
-                const paramName = p.name.getText();
-                const optional = p.questionToken ? "?" : "";
-                const type = p.type ? p.type.getText() : "any";
-                return `${paramName}${optional}: ${type}`;
-            })
-                .join(", ");
-            const returnTypeText = node.type?.getText() ?? "any";
-            signature += `${paramsText}): ${returnTypeText} { return callApi("${routerName}", "${funcName}", [${params.map(e => e.name.getText()).join(", ")}]); }`;
-            apiDef.push(signature);
         }
-        else if ((ts.isInterfaceDeclaration(node) ||
-            ts.isTypeAliasDeclaration(node) ||
-            ts.isEnumDeclaration(node))
-            && hasExportModifier(node)) {
-            const text = node.getFullText(sourceFile).trim();
-            typeDefs.push(text);
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return comments;
+}
+function getFullComment(node, sourceText) {
+    const ranges = ts.getLeadingCommentRanges(sourceText, node.pos);
+    if (!ranges)
+        return "";
+    for (const range of ranges) {
+        const comment = sourceText.slice(range.pos, range.end);
+        // Only keep JSDoc-style comments
+        if (comment.startsWith("/**")) {
+            return comment;
         }
-    });
-    const content = [imports.join("\n"), typeDefs.join("\n"), apiDef.join("\n")].join("\n");
-    fs.writeFileSync(path.resolve(outputPath, path.basename(file)), content, "utf-8");
-    return file;
+    }
+    return "";
 }
-function hasExportModifier(node) {
-    if (ts.isVariableStatement(node) ||
-        ts.isFunctionDeclaration(node) ||
-        ts.isClassDeclaration(node) ||
-        ts.isInterfaceDeclaration(node)) {
-        return !!node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+function convert(schema) {
+    const store = createAuxiliaryTypeStore();
+    const { node } = zodToTs(schema, { auxiliaryTypeStore: store });
+    return printNode(node);
+}
+export async function generateClientFile({ tsPath, jsPath, outputPath, }) {
+    const tsFile = path.resolve(process.cwd(), tsPath);
+    const tsFileName = path.basename(tsFile).slice(0, -path.extname(tsFile).length);
+    const jsFile = path.resolve(process.cwd(), path.join(jsPath, tsFileName + ".js"));
+    if (!existsSync(tsFile)) {
+        throw new Error(`TS file not found: ${tsFile}`);
+    }
+    if (!existsSync(jsFile)) {
+        throw new Error(`JS file not found: ${jsFile}`);
+    }
+    const mod = await import("file://" + jsFile);
+    const procedures = mod.default;
+    const routerName = path.basename(jsFile, path.extname(jsFile));
+    const comments = getProcedureComments(tsFile);
+    let output = `/**
+ * +===================================+
+ * |  File auto-generated by SeamRPC.  |
+ * |        --- DO NOT EDIT ---        |
+ * +===================================+
+ */
+
+import { callApi } from "@seam-rpc/client";
+
+`;
+    const functions = [];
+    for (const [name, proc] of Object.entries(procedures)) {
+        // Input
+        let inputType = "void";
+        let hasInput = false;
+        if (proc._def.input) {
+            const fields = [];
+            for (const [key, schema] of Object.entries(proc._def.input)) {
+                const isOptional = schema.isOptional?.() ?? false;
+                const tsType = convert(schema);
+                fields.push(`${key}${isOptional ? "?" : ""}: ${tsType}`);
+            }
+            if (fields.length > 0) {
+                inputType = `{ ${fields.join("; ")} }`;
+                hasInput = true;
+            }
+        }
+        const returnType = proc._def.output ? convert(proc._def.output) : "void";
+        const params = hasInput ? `input: ${inputType}` : "";
+        const args = [`"${routerName}"`, `"${name}"`];
+        if (hasInput)
+            args.push("input");
+        const call = `callApi(${args.join(", ")})`;
+        const comment = comments[name] ? comments[name] + "\n" : "";
+        const func = `${comment}export function ${name}(${params}): Promise<${returnType}> {
+    return ${call};
+}`;
+        functions.push(func);
     }
-    return false;
+    output += functions.join("\n\n");
+    const outFile = path.join(outputPath, `${routerName}.ts`);
+    writeFileSync(outFile, output, "utf-8");
+    return outFile;
 }

package/dist/bin/gen-config.js

@@ -2,10 +2,11 @@ import fs from "fs";
 import readline from "readline";
 export async function genConfig() {
     const args = process.argv;
-    let inputFiles = "./src/api/*";
+    let source = "./src/api/*";
+    let compiledFolder = "./dist/api";
     let outputFolder = "../client/src/api";
     if (args.length == 5) {
-        inputFiles = args[3];
+        source = args[3];
         outputFolder = args[4];
     }
     else if (args.length > 3) {
@@ -30,7 +31,8 @@ export async function genConfig() {
     }
     function generateConfig() {
         const config = {
-            inputFiles,
+            source,
+            compiledFolder,
             outputFolder
         };
         try {

package/dist/bin/generate.d.ts

@@ -0,0 +1,8 @@
+export declare function generateClient(): Promise<void>;
+interface GenerateOptions {
+    tsPath: string;
+    jsPath: string;
+    outputPath: string;
+}
+export declare function generateClientFile({ tsPath, jsPath, outputPath, }: GenerateOptions): Promise<string>;
+export {};

package/dist/bin/generate.js

@@ -0,0 +1,135 @@
+import fs from "fs";
+import path from "path";
+import fg from "fast-glob";
+import ts from "typescript";
+import { zodToTs, createAuxiliaryTypeStore, printNode } from "zod-to-ts";
+import { existsSync, writeFileSync } from "fs";
+export async function generateClient() {
+    const config = loadConfig();
+    if (!config)
+        return;
+    const sourceFiles = await fg(config.source);
+    const compiledFolder = path.resolve(config.compiledFolder);
+    const outputPath = path.resolve(config.outputFolder);
+    const rootPath = path.resolve(".");
+    function removeRootPath(path) {
+        return "." + path.slice(rootPath.length);
+    }
+    try {
+        const outputFiles = [];
+        for (let i = 0; i < sourceFiles.length; i++) {
+            const sourceFile = sourceFiles[i];
+            const path = await generateClientFile({ tsPath: sourceFile, jsPath: compiledFolder, outputPath });
+            const symb = i < sourceFiles.length - 1 ? " ├╴" : " └╴";
+            outputFiles.push(symb + removeRootPath(path));
+        }
+        console.log("\x1b[32m\x1b[1m%s\x1b[0m\n\x1b[94m%s\x1b[0m", `✅ Successfully generated client files at ${config.outputFolder}`, `${outputFiles.join("\n")}`);
+    }
+    catch (err) {
+        console.error("❌ Failed to generate client file:", err.message);
+        process.exit(1);
+    }
+}
+function loadConfig() {
+    // Check if config exists
+    if (!fs.existsSync("./seam-rpc.config.json")) {
+        console.error("\x1b[31mNo config file found.\x1b[0m\n Create a config file with \x1b[36msrpc init\x1b[0m.");
+        return null;
+    }
+    // Load config from config file
+    return JSON.parse(fs.readFileSync("./seam-rpc.config.json", "utf-8"));
+}
+// Extracts comments from TS file.
+function getProcedureComments(filePath) {
+    const sourceText = fs.readFileSync(filePath, "utf8");
+    const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true);
+    const comments = {};
+    function visit(node) {
+        if (ts.isVariableStatement(node)) {
+            const comment = getFullComment(node, sourceText);
+            for (const decl of node.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name))
+                    comments[decl.name.text] = comment;
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return comments;
+}
+function getFullComment(node, sourceText) {
+    const ranges = ts.getLeadingCommentRanges(sourceText, node.pos);
+    if (!ranges)
+        return "";
+    for (const range of ranges) {
+        const comment = sourceText.slice(range.pos, range.end);
+        // Only keep JSDoc-style comments
+        if (comment.startsWith("/**")) {
+            return comment;
+        }
+    }
+    return "";
+}
+function convert(schema) {
+    const store = createAuxiliaryTypeStore();
+    const { node } = zodToTs(schema, { auxiliaryTypeStore: store });
+    return printNode(node);
+}
+export async function generateClientFile({ tsPath, jsPath, outputPath, }) {
+    const tsFile = path.resolve(process.cwd(), tsPath);
+    const tsFileName = path.basename(tsFile).slice(0, -path.extname(tsFile).length);
+    const jsFile = path.resolve(process.cwd(), path.join(jsPath, tsFileName + ".js"));
+    if (!existsSync(tsFile)) {
+        throw new Error(`TS file not found: ${tsFile}`);
+    }
+    if (!existsSync(jsFile)) {
+        throw new Error(`JS file not found: ${jsFile}`);
+    }
+    const mod = await import("file://" + jsFile);
+    const procedures = mod.default;
+    const routerName = path.basename(jsFile, path.extname(jsFile));
+    const comments = getProcedureComments(tsFile);
+    let output = `/**
+ * +===================================+
+ * |  File auto-generated by SeamRPC.  |
+ * |        --- DO NOT EDIT ---        |
+ * +===================================+
+ */
+
+import { callApi } from "@seam-rpc/client";
+
+`;
+    const functions = [];
+    for (const [name, proc] of Object.entries(procedures)) {
+        // Input
+        let inputType = "void";
+        let hasInput = false;
+        if (proc._def.input) {
+            const fields = [];
+            for (const [key, schema] of Object.entries(proc._def.input)) {
+                const isOptional = schema.isOptional?.() ?? false;
+                const tsType = convert(schema);
+                fields.push(`${key}${isOptional ? "?" : ""}: ${tsType}`);
+            }
+            if (fields.length > 0) {
+                inputType = `{ ${fields.join("; ")} }`;
+                hasInput = true;
+            }
+        }
+        const returnType = proc._def.output ? convert(proc._def.output) : "void";
+        const params = hasInput ? `input: ${inputType}` : "";
+        const args = [`"${routerName}"`, `"${name}"`];
+        if (hasInput)
+            args.push("input");
+        const call = `callApi(${args.join(", ")})`;
+        const comment = comments[name] ? comments[name] + "\n" : "";
+        const func = `${comment}export function ${name}(${params}): Promise<${returnType}> {
+    return ${call};
+}`;
+        functions.push(func);
+    }
+    output += functions.join("\n\n");
+    const outFile = path.join(outputPath, `${routerName}.ts`);
+    writeFileSync(outFile, output, "utf-8");
+    return outFile;
+}

package/dist/bin/index.d.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 export interface SeamConfig {
-    inputFiles: string;
+    source: string;
+    compiledFolder: string;
     outputFolder: string;
 }

package/dist/bin/index.js

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
-import { genClient } from "./gen-client.js";
-import { genConfig } from "./gen-config.js";
+import { generateClient } from "./generate.js";
+import { initConfig } from "./init.js";
 main();
 function main() {
     const args = process.argv;
     switch (args[2]) {
-        case "gen-client":
-            genClient();
+        case "generate":
+            generateClient();
             break;
-        case "gen-config":
-            genConfig();
+        case "init":
+            initConfig();
             break;
         default:
-            console.log("Commands:\n- seam-rpc gen-client <input-files> <output-folder>\n- seam-rpc gen-config [input-files] [output-folder]");
+            console.log("Commands:\n- \x1b[36msrpc generate\x1b[0m - Generate client files as defined in the config.\n- \x1b[36msrpc init\x1b[0m - Create config file.");
     }
 }

package/dist/bin/init.d.ts

@@ -0,0 +1 @@
+export declare function initConfig(): Promise<void>;

package/dist/bin/init.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import readline from "readline";
+export async function initConfig() {
+    let source = "./src/api/*";
+    let compiledFolder = "./dist/api";
+    let outputFolder = "../client/src/api";
+    if (fs.existsSync("./seam-rpc.config.json")) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question("Config file already exists. Do you want to overwrite it? [Y/n] ", answer => {
+            if (answer && answer.toLowerCase() != "y" && answer.toLowerCase() != "yes") {
+                console.log("Operation canceled.");
+                process.exit(0);
+            }
+            rl.close();
+            createConfig();
+        });
+    }
+    else {
+        createConfig();
+    }
+    function createConfig() {
+        const config = { source, compiledFolder, outputFolder };
+        try {
+            fs.writeFileSync("./seam-rpc.config.json", JSON.stringify(config, null, 4), "utf-8");
+        }
+        catch (e) {
+            console.log("\x1b[31mFailed to create config file ./seam-rpc.config.json\x1b[0m\n" + e);
+        }
+        console.log(`\x1b[32mSuccessfully created config file ./seam-rpc.config.json\x1b[0m`);
+    }
+}

package/dist/index.d.ts

@@ -1,31 +1,77 @@
-import { SeamFile, ISeamFile } from "@seam-rpc/core";
 import EventEmitter from "events";
-import { Express, NextFunction, Request, RequestHandler, Response } from "express";
-export { SeamFile, ISeamFile };
+import express, { Express, NextFunction, Request, RequestHandler, Response } from "express";
+import * as z from "zod";
 export interface RouterDefinition {
-    [funcName: string]: (...args: any[]) => Promise<any>;
+    [procName: string]: (...args: any[]) => Promise<any>;
+}
+export interface SeamContext {
+    request: Request;
+    response: Response;
+    next: NextFunction;
 }
-export declare function createSeamSpace(app: Express, fileHandler?: RequestHandler): Promise<SeamSpace>;
 export interface SeamErrorContext {
     routerPath: string;
-    functionName: string;
+    procedureName: string;
+    input?: Record<string, unknown> | null;
+    validatedInput?: Record<string, unknown> | null;
+    output?: unknown;
+    validatedOutput?: unknown;
     request: Request;
     response: Response;
     next: NextFunction;
 }
-export interface SeamSpaceEvents {
+export interface SeamEvents {
     apiError: [error: unknown, context: SeamErrorContext];
     internalError: [error: unknown, context: SeamErrorContext];
+    inputValidationError: [error: unknown, context: SeamErrorContext];
+    outputValidationError: [error: unknown, context: SeamErrorContext];
 }
-export declare class SeamSpace extends EventEmitter<SeamSpaceEvents> {
-    private app;
-    private fileHandler;
-    private jsonParser;
-    constructor(app: Express, fileHandler: RequestHandler);
-    createRouter(path: string, routerDefinition: RouterDefinition): void;
+type ProcedureHandler<Input extends ProcedureInput, Output extends z.ZodType> = (options: ProcedureOptions<Input>) => z.infer<Output> | Promise<z.infer<Output>>;
+type ProcedureInput = Record<string, z.ZodType>;
+type ProcedureOutput = z.ZodType;
+type ProcedureInputData<T extends ProcedureInput> = {
+    [K in keyof T]: z.infer<T[K]>;
+};
+interface ProcedureOptions<T extends ProcedureInput> {
+    input: Simplify<ProcedureInputData<T>>;
+    ctx: SeamContext;
 }
-export interface SeamContext {
-    request: Request;
-    response: Response;
-    next: NextFunction;
+type Simplify<T> = T extends File ? File : T extends object ? {
+    [K in keyof T]: Simplify<T[K]>;
+} : T;
+interface SeamProcedure<Input extends ProcedureInput, Output extends ProcedureOutput> {
+    input?: Input;
+    output?: Output;
+    handler?: ProcedureHandler<Input, Output>;
+}
+export type ProcedureBuilder<Input extends ProcedureInput, Output extends ProcedureOutput> = {
+    _def: SeamProcedure<Input, Output>;
+    input: <T extends ProcedureInput>(schema: T) => ProcedureBuilder<T, Output>;
+    output: <T extends ProcedureOutput>(schema: T) => ProcedureBuilder<Input, T>;
+    handler: (handler: ProcedureHandler<Input, Output>) => ProcedureBuilder<Input, Output>;
+};
+export declare function createSeamSpace(app: Express, fileHandler?: RequestHandler): Promise<SeamSpace>;
+export declare function seamProcedure(): ProcedureBuilder<ProcedureInput, ProcedureOutput>;
+export declare class SeamRouter {
+    private seamSpace;
+    private path;
+    private router;
+    private procedures;
+    constructor(seamSpace: SeamSpace, path: string);
+    private runMiddleware;
+    private validateInput;
+    private validateOutput;
+    private validateData;
+    addProcedures(procedures: Record<string, ProcedureBuilder<any, any>>): void;
+}
+export declare class SeamSpace extends EventEmitter<SeamEvents> {
+    private _app;
+    private _fileHandler;
+    private _jsonParser;
+    constructor(_app: Express, _fileHandler: RequestHandler);
+    createRouter(path: string): SeamRouter;
+    get app(): express.Express;
+    get jsonParser(): import("connect").NextHandleFunction;
+    get fileHandler(): express.RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
 }
+export {};

package/dist/index.js

@@ -1,8 +1,9 @@
-import { SeamFile, extractFiles, injectFiles } from "@seam-rpc/core";
+import { extractFiles, injectFiles } from "@seam-rpc/core";
 import EventEmitter from "events";
 import express, { Router } from "express";
 import FormData from "form-data";
-export { SeamFile };
+import * as z from "zod";
+;
 ;
 export async function createSeamSpace(app, fileHandler) {
     if (!fileHandler) {
@@ -18,93 +19,212 @@ export async function createSeamSpace(app, fileHandler) {
     }
     return new SeamSpace(app, fileHandler);
 }
-;
-export class SeamSpace extends EventEmitter {
-    constructor(app, fileHandler) {
-        super();
-        this.app = app;
-        this.fileHandler = fileHandler;
-        this.jsonParser = express.json();
-    }
-    createRouter(path, routerDefinition) {
-        const router = Router();
-        router.post("/:funcName", async (req, res, next) => {
-            if (!(req.params.funcName in routerDefinition))
+export function seamProcedure() {
+    return createProcedureBuilder();
+}
+function createProcedureBuilder(definition = {}) {
+    return {
+        _def: definition,
+        input: schema => createProcedureBuilder({
+            ...definition,
+            input: schema,
+        }),
+        output: schema => createProcedureBuilder({
+            ...definition,
+            output: schema,
+        }),
+        handler: handler => createProcedureBuilder({
+            ...definition,
+            handler
+        }),
+    };
+}
+export class SeamRouter {
+    constructor(seamSpace, path) {
+        this.seamSpace = seamSpace;
+        this.path = path;
+        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);
-            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.jsonParser);
-            }
-            else if (contentType.startsWith("multipart/form-data")) {
-                await runMiddleware(this.fileHandler);
-            }
-            else {
-                return res.status(415).send("Unsupported content type");
-            }
-            let args;
-            if (contentType.startsWith("application/json")) {
-                args = req.body;
+            let input;
+            let validatedInput = undefined;
+            let output;
+            let validatedOutput;
+            // Middleware
+            try {
+                input = await this.runMiddleware(req, res);
             }
-            else {
-                // multipart/form-data
-                args = JSON.parse(req.body.json);
-                const paths = JSON.parse(req.body.paths);
-                const files = (req.files ?? []).map((file, index) => ({
-                    path: paths[index],
-                    file: new SeamFile(file.buffer, file.originalname, file.mimetype),
-                }));
-                injectFiles(args, files);
+            catch (err) {
+                return res.status(415).send(String(err));
             }
-            let result;
+            // Validate input
             try {
-                const ctx = {
+                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
-                };
-                result = await routerDefinition[req.params.funcName](...args, ctx);
+                    next,
+                });
+                res.sendStatus(400);
+                return;
+            }
+            // Call procedure
+            const ctx = {
+                request: req,
+                response: res,
+                next
+            };
+            try {
+                output = await procedure.handler({ input: validatedInput, ctx });
             }
             catch (error) {
-                this.emit("apiError", error, {
+                seamSpace.emit("apiError", error, {
                     routerPath: path,
-                    functionName: req.params.funcName,
+                    procedureName: req.params.procName,
+                    input,
+                    validatedInput,
+                    output,
+                    validatedOutput,
                     request: req,
                     response: res,
-                    next: next,
+                    next,
                 });
                 res.status(400).send({ error: String(error) });
                 return;
             }
+            // Validate output
+            try {
+                validatedOutput = this.validateOutput(output, procedure.output);
+            }
+            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 });
+                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));
-                files.forEach((file, index) => {
-                    form.append(`file-${index}`, Buffer.from(file.data), {
-                        filename: file.fileName || `file-${index}`,
-                        contentType: file.mimeType || "application/octet-stream",
+                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) {
-                this.emit("internalError", error, {
+                seamSpace.emit("internalError", error, {
                     routerPath: path,
-                    functionName: req.params.funcName,
+                    procedureName: req.params.procName,
+                    input,
+                    validatedInput,
+                    output,
+                    validatedOutput,
                     request: req,
                     response: res,
                     next: next,
                 });
-                res.status(500).send({ error: String(error) });
+                console.log("INTERNAL ERROR", error);
+                res.sendStatus(500); //.send({ error: String(error) });
             }
         });
-        this.app.use(path, router);
+        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);
+        }
+        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;
+        }
+    }
+}
+export class SeamSpace extends EventEmitter {
+    constructor(_app, _fileHandler) {
+        super();
+        this._app = _app;
+        this._fileHandler = _fileHandler;
+        this._jsonParser = express.json();
+    }
+    createRouter(path) {
+        return new SeamRouter(this, path);
+    }
+    get app() {
+        return this._app;
+    }
+    get jsonParser() {
+        return this._jsonParser;
+    }
+    get fileHandler() {
+        return this._fileHandler;
     }
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@seam-rpc/server",
-  "version": "3.0.2",
+  "version": "4.1.0",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
-    "seam-rpc": "dist/bin/index.js"
+    "srpc": "dist/bin/index.js"
   },
   "types": "dist/index.d.ts",
   "files": [
@@ -34,9 +34,11 @@
     "multer": "^2.0.2"
   },
   "dependencies": {
-    "@seam-rpc/core": "^1.0.0",
+    "@seam-rpc/core": "*",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.5",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "zod": "^4.3.6",
+    "zod-to-ts": "^2.0.0"
   }
 }