@seam-rpc/server 1.1.1 → 2.0.0

package/README.md

@@ -142,3 +142,19 @@ export async function updateUser(userId: string, userData: UserData): Promise<vo
 - The generated client files contain all imports from the api implementation file in the backend that import from the current relative folder (`./`). This is the simplest way I have to include imports (at least for now). It may import functions and unused symbols but that shouldn't be too worrying.
 - Don't include backend/server functions inside the server api files.
 - Only exported functions will be included in the client generated files.
+
+## Supported types
+SeamRPC supports the following types (at least for now):
+- string
+- number
+- boolean
+- array
+- object
+- null
+- undefined
+
+Classes are technically supported, in that the data is serialized to JSON.
+
+Other JavaScript types are not supported, although SeamRPC doesn't prevent you from using them, in which case they might lead to unexpected beahviour or even errors.
+
+The Date object type is not supported (at least for now). However, you can use `number` and pass `Date.now()` or `string` and pass `new Date().toString()`. This is not different than a normal HTTP request using JSON. SeamRPC also uses JSON behind the scenes, that's why there's these limitations, which could be overcome but I've decided not to because it would probably add more overhead to the logic.

package/dist/bin/gen-client.js

@@ -0,0 +1,101 @@
+import fs from "fs";
+import ts from "typescript";
+import path from "path";
+import fg from "fast-glob";
+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 outputPath = path.resolve(config.outputFolder);
+    const rootPath = path.resolve(".");
+    try {
+        const outputFiles = [];
+        for (const inputFile of inputFiles) {
+            const outputFile = generateClientFile(inputFile, outputPath);
+            outputFiles.push(removeRootPath(outputFile, rootPath));
+        }
+        console.log("\x1b[32m%s\x1b[0m\n\x1b[36m%s\x1b[0m", `✅ Successfully generated client files at ${removeRootPath(outputPath, rootPath)}`, `${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());
+        }
+        else if (ts.isFunctionDeclaration(node) && hasExportModifier(node)) {
+            if (!node.name) {
+                console.error("Missing function name.");
+                process.exit(1);
+            }
+            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);
+        }
+    });
+    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;
+}
+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);
+    }
+    return false;
+}

package/dist/bin/gen-config.js

@@ -0,0 +1,44 @@
+import fs from "fs";
+import readline from "readline";
+export async function genConfig() {
+    const args = process.argv;
+    let inputFiles = "./src/api/*";
+    let outputFolder = "../client/src/api";
+    if (args.length == 5) {
+        inputFiles = args[3];
+        outputFolder = args[4];
+    }
+    else if (args.length > 3) {
+        return console.error("Usage: seam-rpc gen-config [input-files] [output-folder]");
+    }
+    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();
+            generateConfig();
+        });
+    }
+    else {
+        generateConfig();
+    }
+    function generateConfig() {
+        const config = {
+            inputFiles,
+            outputFolder
+        };
+        try {
+            fs.writeFileSync("./seam-rpc.config.json", JSON.stringify(config, null, 4), "utf-8");
+        }
+        catch (e) {
+            console.log("\x1b[31mFailed to generate config file ./seam-rpc.config.json\x1b[0m\n" + e);
+        }
+        console.log(`\x1b[32mSuccessfully generated config file ./seam-rpc.config.json\x1b[0m`);
+    }
+}

package/dist/bin/index.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { genClient } from "./gen-client.js";
+import { genConfig } from "./gen-config.js";
+main();
+function main() {
+    const args = process.argv;
+    switch (args[2]) {
+        case "gen-client":
+            genClient();
+            break;
+        case "gen-config":
+            genConfig();
+            break;
+        default:
+            console.log("Commands:\n- seam-rpc gen-client <input-files> <output-folder>\n- seam-rpc gen-config [input-files] [output-folder]");
+    }
+}

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { SeamFile, ISeamFile } from "@seam-rpc/core";
-import { Express, RequestHandler } from "express";
+import { Express, NextFunction, Request, RequestHandler, Response } from "express";
 export { SeamFile, ISeamFile };
 export interface RouterDefinition {
     [funcName: string]: (...args: any[]) => Promise<any>;
 }
-export declare function createSeamSpace(app: Express, fileHandler?: RequestHandler): SeamSpace;
+export declare function createSeamSpace(app: Express, fileHandler?: RequestHandler): Promise<SeamSpace>;
 export declare class SeamSpace {
     private app;
     private fileHandler;
@@ -12,3 +12,8 @@ export declare class SeamSpace {
     constructor(app: Express, fileHandler: RequestHandler);
     createRouter(path: string, routerDefinition: RouterDefinition): void;
 }
+export interface SeamContext {
+    request: Request;
+    response: Response;
+    next: NextFunction;
+}

package/dist/index.js

@@ -0,0 +1,95 @@
+import { SeamFile, extractFiles, injectFiles } from "@seam-rpc/core";
+import express, { Router } from "express";
+import FormData from "form-data";
+export { SeamFile };
+;
+export async function createSeamSpace(app, fileHandler) {
+    if (!fileHandler) {
+        let multer;
+        try {
+            multer = (await import("multer")).default;
+        }
+        catch {
+            throw new Error("Multer is required as default file handler. Install it or provide a custom fileHandler.");
+        }
+        const upload = multer();
+        fileHandler = upload.any();
+    }
+    return new SeamSpace(app, fileHandler);
+}
+export class SeamSpace {
+    constructor(app, fileHandler) {
+        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))
+                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;
+            }
+            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);
+            }
+            let result;
+            try {
+                const ctx = {
+                    request: req,
+                    response: res,
+                    next
+                };
+                result = await routerDefinition[req.params.funcName](...args, ctx);
+            }
+            catch (error) {
+                console.error(`Error at API function at router "${path}". Sent error to client.`, error);
+                res.status(400).send({ error: String(error) });
+                return;
+            }
+            try {
+                const { json, files, paths } = extractFiles({ result });
+                if (files.length === 0) {
+                    res.json(json);
+                    return;
+                }
+                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",
+                    });
+                });
+                res.writeHead(200, form.getHeaders());
+                form.pipe(res);
+            }
+            catch (error) {
+                console.error(`Internal error at API function at router "${path}". Returned 500 Internal Server Error to client.`, error);
+                res.status(500).send({ error: String(error) });
+            }
+        });
+        this.app.use(path, router);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seam-rpc/server",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -28,6 +28,7 @@
   },
   "devDependencies": {
     "@types/express": "^5.0.3",
+    "@types/multer": "^2.0.0",
     "@types/node": "^24.3.1",
     "express": "^5.1.0",
     "multer": "^2.0.2"