@seam-rpc/server 1.1.1 → 1.1.2

package/dist/bin/gen-client.js

@@ -0,0 +1,103 @@
+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 paramsText = node.parameters
+                .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";
+            const finalReturnType = returnTypeText.startsWith("Promise<")
+                ? returnTypeText
+                : `Promise<${returnTypeText}>`;
+            signature += `${paramsText}): ${finalReturnType} { return callApi("${routerName}", "${funcName}", [${node.parameters.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.js

@@ -0,0 +1,90 @@
+import { SeamFile, extractFiles, injectFiles } from "@seam-rpc/core";
+import express, { Router } from "express";
+import FormData from "form-data";
+export { SeamFile };
+;
+export function createSeamSpace(app, fileHandler) {
+    if (!fileHandler) {
+        let multer;
+        try {
+            multer = require("multer");
+        }
+        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 {
+                result = await routerDefinition[req.params.funcName](...args);
+            }
+            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": "1.1.2",
   "main": "dist/index.js",
   "type": "module",
   "bin": {