@seam-rpc/server 4.2.0 → 4.3.0

package/dist/bin/gen-client.js

@@ -0,0 +1,193 @@
+import fs from "fs";
+import path from "path";
+import fg from "fast-glob";
+import ts from "typescript";
+import * as z from "zod";
+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) {
+        // Use config
+        // Check if config exists
+        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.");
+        // Load config from config file
+        config = 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
+        config = {
+            inputFiles: args[3],
+            outputFolder: args[4]
+        };
+    }
+    else {
+        // Invalid command usage
+        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) {
+            // console.log(getProcedureInfo(inputFile));
+            const outputFile = await 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);
+    }
+}
+// interface ProcedureInfo {
+//     name: string;
+//     inputType: string;
+//     outputType: string;
+//     comments: string;
+// }
+// export function getProcedureInfo(filePath: string): ProcedureInfo[] {
+//     const fullPath = path.resolve(filePath);
+//     const sourceText = fs.readFileSync(fullPath, "utf8");
+//     const sourceFile = ts.createSourceFile(
+//         fullPath,
+//         sourceText,
+//         ts.ScriptTarget.Latest,
+//         true,
+//         ts.ScriptKind.TS
+//     );
+//     const procedures: ProcedureInfo[] = [];
+//     function visit(node: ts.Node) {
+//         // Look for const assignments
+//         if (ts.isVariableStatement(node)) {
+//             node.declarationList.declarations.forEach((decl) => {
+//                 if (ts.isIdentifier(decl.name) && decl.initializer) {
+//                     let varName = decl.name.text;
+//                     let inputType = "";
+//                     let outputType = "";
+//                     let comments = "";
+//                     const jsDocs = ts.getJSDocCommentsAndTags(node); // node = VariableStatement
+//                     // Get JSDoc comments
+//                     if (jsDocs.length > 0) {
+//                         comments = jsDocs.map(doc => doc.getText()).join("\n");
+//                     }
+//                     // Check for chain calls: .input(...).output(...)
+//                     if (ts.isCallExpression(decl.initializer) || ts.isPropertyAccessExpression(decl.initializer)) {
+//                         function extractChain(expr: ts.Expression) {
+//                             if (ts.isCallExpression(expr)) {
+//                                 if (ts.isPropertyAccessExpression(expr.expression)) {
+//                                     const propName = expr.expression.name.text;
+//                                     if (propName === "input" && expr.arguments.length > 0) {
+//                                         inputType = expr.arguments[0].getText();
+//                                     } else if (propName === "output" && expr.arguments.length > 0) {
+//                                         outputType = expr.arguments[0].getText();
+//                                     }
+//                                     extractChain(expr.expression.expression);
+//                                 }
+//                             } else if (ts.isPropertyAccessExpression(expr)) {
+//                                 extractChain(expr.expression);
+//                             }
+//                         }
+//                         extractChain(decl.initializer);
+//                     }
+//                     if (inputType || outputType || comments) {
+//                         procedures.push({ name: varName, inputType, outputType, comments });
+//                     }
+//                 }
+//             });
+//         }
+//         ts.forEachChild(node, visit);
+//     }
+//     visit(sourceFile);
+//     return procedures;
+// }
+function removeRootPath(path, rootPath) {
+    return "." + path.slice(rootPath.length);
+}
+async function generateClientFile(sourcePath, outputPath) {
+    const sourceFile = path.resolve(process.cwd(), sourcePath);
+    if (!existsSync(sourceFile)) {
+        console.error(`File ${sourceFile} not found`);
+        process.exit(1);
+    }
+    const module = await import("file://" + sourceFile);
+    const procedures = module.default;
+    const routerName = path.basename(sourceFile, path.extname(sourceFile));
+    let fileContent = `/* Auto-generated by SeamRPC - DO NOT EDIT */
+
+import { callApi } from \"@seam-rpc/client\";
+
+`;
+    // Parse the source file using TypeScript API
+    const program = ts.createProgram([sourceFile], {});
+    const tsFile = program.getSourceFile(sourceFile);
+    // Helper to get JSDoc comment for a variable
+    function getJsDocComment(node) {
+        const jsDocs = node.jsDoc;
+        if (!jsDocs || jsDocs.length === 0)
+            return "";
+        return jsDocs.map(doc => doc.comment).filter(Boolean).join("\n");
+    }
+    const functions = [];
+    for (const [procName, proc] of Object.entries(procedures)) {
+        // Input
+        const input = [];
+        if (proc._def.input) {
+            for (const [paramName, param] of Object.entries(proc._def.input)) {
+                input.push(`${paramName}${param instanceof z.ZodOptional ? "?" : ""}: ${convert(param)}`);
+            }
+        }
+        // Output
+        const returnType = proc._def.output ? convert(proc._def.output) : "void";
+        // Input
+        const hasInput = input.length != 0;
+        const params = hasInput ? `input: { ${input.join(", ")} }` : "";
+        // Function body
+        const body = `return callApi("${routerName}", "${procName}"${hasInput ? ", input" : ""});`;
+        // Comments
+        let comments = "";
+        ts.forEachChild(tsFile, node => {
+            if (ts.isVariableStatement(node)) {
+                node.declarationList.declarations.forEach(decl => {
+                    console.log(decl.name.getText(), procName);
+                    if (decl.name.getText() === procName) {
+                        const doc = getJsDocComment(decl);
+                        if (doc)
+                            comments = `/** ${doc} */\n`;
+                    }
+                });
+            }
+        });
+        const func = `${comments}export function ${procName}(${params}): Promise<${returnType}> { ${body} }`;
+        functions.push(func);
+    }
+    fileContent += functions.join("\n\n");
+    writeFileSync(`${outputPath}/${routerName}.ts`, fileContent, "utf-8");
+    return sourceFile;
+}
+function convert(schema) {
+    const auxiliaryTypeStore = createAuxiliaryTypeStore();
+    const { node } = zodToTs(schema, { auxiliaryTypeStore });
+    return printNode(node);
+}
+// function zodToTs(schema: z.ZodType): { value: string, definition?: string } {
+//     if (schema instanceof z.ZodString) {
+//         return { value: "string" };
+//     }
+//     if (schema instanceof z.ZodNumber) {
+//         return { value: "number" };
+//     }
+//     if (schema instanceof z.ZodArray) {
+//         return { value: zodToTs(schema.def.type) + "[]" };
+//     }
+//     if (schema instanceof z.ZodOptional) {
+//         return {value: };
+//     }
+//     return { value: "any" };
+// }

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/generate.d.ts

@@ -4,5 +4,9 @@ interface GenerateOptions {
     jsPath: string;
     outputPath: string;
 }
+export declare function getProcedureMetadata(filePath: string): Record<string, {
+    comment: string;
+    returnType?: string;
+}>;
 export declare function generateClientFile({ tsPath, jsPath, outputPath, }: GenerateOptions): Promise<string>;
 export {};

package/dist/bin/generate.js

@@ -15,20 +15,19 @@ export async function generateClient() {
     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 + "\n\n", err.stack);
-        process.exit(1);
+    // 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: any) {
+    //     console.error("❌ Failed to generate client file:", err.message + "\n\n", err.stack);
+    //     process.exit(1);
+    // }
 }
 function loadConfig() {
     // Check if config exists
@@ -40,22 +39,64 @@ function loadConfig() {
     return JSON.parse(fs.readFileSync("./seam-rpc.config.json", "utf-8"));
 }
 // Extracts comments from TS file.
-function getProcedureComments(filePath) {
+export function getProcedureMetadata(filePath) {
     const sourceText = fs.readFileSync(filePath, "utf8");
-    const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true);
-    const comments = {};
+    const program = ts.createProgram([filePath], {
+        target: ts.ScriptTarget.Latest,
+        module: ts.ModuleKind.CommonJS,
+        strict: true,
+    });
+    const checker = program.getTypeChecker();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile)
+        return {};
+    const metadata = {};
+    function getHandlerReturnType(node) {
+        let current = node;
+        while (current) {
+            if (ts.isCallExpression(current) &&
+                ts.isPropertyAccessExpression(current.expression)) {
+                const prop = current.expression;
+                if (prop.name.text === "handler") {
+                    const handlerFn = current.arguments[0];
+                    if (handlerFn &&
+                        (ts.isArrowFunction(handlerFn) ||
+                            ts.isFunctionExpression(handlerFn))) {
+                        const signature = checker.getSignatureFromDeclaration(handlerFn);
+                        if (!signature)
+                            return;
+                        const returnType = checker.getReturnTypeOfSignature(signature);
+                        return checker.typeToString(returnType);
+                    }
+                }
+                current = prop.expression;
+                continue;
+            }
+            break;
+        }
+        return;
+    }
     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;
+                if (!ts.isIdentifier(decl.name))
+                    continue;
+                const name = decl.name.text;
+                let returnType;
+                if (decl.initializer) {
+                    returnType = getHandlerReturnType(decl.initializer);
+                }
+                metadata[name] = {
+                    comment,
+                    returnType,
+                };
             }
         }
         ts.forEachChild(node, visit);
     }
     visit(sourceFile);
-    return comments;
+    return metadata;
 }
 function getFullComment(node, sourceText) {
     const ranges = ts.getLeadingCommentRanges(sourceText, node.pos);
@@ -88,7 +129,7 @@ export async function generateClientFile({ tsPath, jsPath, outputPath, }) {
     const mod = await import("file://" + jsFile);
     const procedures = mod.default;
     const routerName = path.basename(jsFile, path.extname(jsFile));
-    const comments = getProcedureComments(tsFile);
+    const procMetadata = getProcedureMetadata(tsFile);
     let output = `/**
  * +===================================+
  * |  File auto-generated by SeamRPC.  |
@@ -116,17 +157,18 @@ import { callApi, Result, RpcError } from "@seam-rpc/client";
                 hasInput = true;
             }
         }
-        const dataType = proc._def.output ? convert(proc._def.output) : "void";
-        const errors = Object.entries(proc._def.errors ?? {});
-        const errorType = errors.map(e => `RpcError<"${e[0]}", ${convert(e[1])}>`).join(" | ");
-        const fullReturnType = `Result<${dataType}${errors.length > 0 ? `, ${errorType}` : ""}>`;
+        // const dataType = proc._def.output ? convert(proc._def.output) : "void";
+        // const errors = Object.entries(proc._def.errors ?? {});
+        // const errorType = errors.map(e => `RpcError<"${e[0]}", ${convert(e[1] as any)}>`).join(" | ");
+        // const fullReturnType = `Promise<Result<${dataType}${errors.length > 0 ? `, ${errorType}` : ""}>>`;
+        const fullReturnType = procMetadata[name].returnType;
         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<${fullReturnType}> {
+        const comment = procMetadata[name].comment ? procMetadata[name].comment + "\n" : "";
+        const func = `${comment}export function ${name}(${params}): ${fullReturnType} {
     return ${call};
 }`;
         functions.push(func);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { Result } from "@seam-rpc/core";
 import EventEmitter from "events";
 import express, { Express, NextFunction, Request, RequestHandler, Response } from "express";
 import * as z from "zod";
@@ -29,7 +30,7 @@ export interface SeamEvents {
     inputValidationError: [error: unknown, context: SeamErrorContext];
     outputValidationError: [error: unknown, context: SeamErrorContext];
 }
-type ProcedureHandler<Input extends ProcedureInput, Output extends ProcedureOutput, Errors extends ProcedureErrors> = (options: ProcedureOptions<Input, Errors>) => z.infer<Output> | Promise<z.infer<Output>>;
+type ProcedureHandler<Input extends ProcedureInput, Output extends ProcedureOutput, Errors extends ProcedureErrors> = (options: ProcedureOptions<Input, Errors>) => Result<z.infer<Output>, unknown> | Promise<Result<z.infer<Output>, unknown>>;
 interface ProcedureOptions<Input extends ProcedureInput, Errors extends ProcedureErrors> {
     input: Simplify<ProcedureInputData<Input>>;
     ctx: SeamContext;

package/dist/validation.js

@@ -0,0 +1,54 @@
+export class ValString {
+    constructor(value) {
+        this._isValid = true;
+        this._value = value;
+    }
+    get isValid() {
+        return this._isValid;
+    }
+    min(value) {
+        if (this._isValid)
+            this._isValid = this._value.length >= value;
+        return this;
+    }
+    max(value) {
+        if (this._isValid)
+            this._isValid = this._value.length <= value;
+        return this;
+    }
+    length(value) {
+        if (this._isValid)
+            this._isValid = this._value.length == value;
+        return this;
+    }
+    startsWith(value) {
+        if (this._isValid)
+            this._isValid = this._value.startsWith(value);
+        return this;
+    }
+    endsWith(value) {
+        if (this._isValid)
+            this._isValid = this._value.endsWith(value);
+        return this;
+    }
+    includes(value) {
+        if (this._isValid)
+            this._isValid = this._value.includes(value);
+        return this;
+    }
+    regex(regExpr) {
+        //  if (this._isValid)
+        //     this._isValid = this._value.startsWith(value);
+        return this;
+    }
+    email() {
+        return this;
+    }
+}
+function createUser(name, age, data) {
+    name.min(3).max(50);
+    age.gte(1).lt(150);
+    data.description?.max(250);
+}
+function validate(data) {
+}

package/package.json

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