@seam-rpc/server 4.3.22 → 5.0.1

package/dist/index.d.ts

@@ -1,12 +1,9 @@
-import { Result, RpcError } from "@seam-rpc/core";
+import { Result, ApiError, ApiErrorInterface } from "@seam-rpc/core";
 import EventEmitter from "events";
 import express, { Express, NextFunction, Request, RequestHandler, Response } from "express";
 import * as z from "zod";
-export { RpcError };
+export { ApiError };
 export type { Result };
-export interface RouterDefinition {
-    [procName: string]: (...args: any[]) => Promise<any>;
-}
 type Simplify<T> = T extends File ? File : T extends object ? {
     [K in keyof T]: Simplify<T[K]>;
 } : T;
@@ -32,53 +29,64 @@ 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>) => Result<z.infer<Output>, RpcError> | Promise<Result<z.infer<Output>, RpcError>>;
-interface ProcedureOptions<Input extends ProcedureInput, Errors extends ProcedureErrors> {
+type ProcedureHandler<Input extends ProcedureInput, Output extends ProcedureOutput> = (options: ProcedureOptions<Input>) => Result<z.infer<Output>, ApiError> | Promise<Result<z.infer<Output>, ApiError>>;
+interface ProcedureOptions<Input extends ProcedureInput> {
     input: Simplify<ProcedureInputData<Input>>;
     ctx: SeamContext;
-    error: RpcErrorFactory<Errors>;
 }
-type RpcErrorFactory<Errors extends ProcedureErrors> = <Code extends keyof Errors>(code: Code, ...args: z.infer<Errors[Code]> extends undefined ? [] : [data: z.infer<Errors[Code]>]) => void;
 type ProcedureInput = Record<string, z.ZodType>;
 type ProcedureOutput = z.ZodType;
-type ProcedureErrors = Record<string, z.ZodType>;
-type ProcedureBuilderList = Record<string, ProcedureBuilder<any, any, any>>;
+type ProcedureErrors = Record<string, z.ZodType | undefined>;
 type ProcedureInputData<T extends ProcedureInput> = {
     [K in keyof T]: z.infer<T[K]>;
 };
-interface SeamProcedure<Input extends ProcedureInput, Output extends ProcedureOutput, Errors extends ProcedureErrors> {
+interface SeamProcedure<Input extends ProcedureInput = {}, Output extends ProcedureOutput = z.ZodUndefined, Errors extends ProcedureErrors = {}> {
     input?: Input;
     output?: Output;
     errors?: Errors;
-    handler?: ProcedureHandler<Input, Output, Errors>;
+    handler?: ProcedureHandler<Input, Output>;
 }
-export type ProcedureBuilder<Input extends ProcedureInput, Output extends ProcedureOutput, Errors extends ProcedureErrors> = {
+type ExtractResultError<T> = Awaited<T> extends Result<any, infer E> ? E : never;
+type ErrorUnionToMap<E> = {
+    [K in E extends ApiErrorInterface<any, infer Code> ? Code : never]: Extract<E, ApiErrorInterface<any, K>> extends ApiErrorInterface<infer Map, K> ? Map[K] : never;
+};
+export type ProcedureBuilder<Input extends ProcedureInput = {}, Output extends ProcedureOutput = z.ZodUndefined, Errors extends ProcedureErrors = {}> = {
     _def: SeamProcedure<Input, Output, Errors>;
     input: <T extends ProcedureInput>(schema: T) => ProcedureBuilder<T, Output, Errors>;
     output: <T extends ProcedureOutput>(schema: T) => ProcedureBuilder<Input, T, Errors>;
-    errors: <T extends ProcedureErrors>(errors: T) => ProcedureBuilder<Input, Output, T>;
-    handler: (handler: ProcedureHandler<Input, Output, Errors>) => ProcedureBuilder<Input, Output, Errors>;
+    handler: <H extends ProcedureHandler<Input, Output>>(handler: H) => ProcedureBuilder<Input, Output, ErrorUnionToMap<ExtractResultError<ReturnType<H>>>>;
 };
 export declare function createSeamSpace(app: Express, fileHandler?: RequestHandler): Promise<SeamSpace>;
-export declare function seamProcedure(): ProcedureBuilder<ProcedureInput, ProcedureOutput, ProcedureErrors>;
-export declare class SeamRouter {
-    private seamSpace;
-    private procedures;
-    private router;
-    constructor(seamSpace: SeamSpace, path: string);
-    private runMiddleware;
-    private validateInput;
-    private validateOutput;
-    private validateData;
-    addProcedures(procedures: ProcedureBuilderList): void;
-}
+export declare function seamProcedure(): ProcedureBuilder;
+export type SeamRouterBuilder = Record<string, ProcedureBuilder<any, any, any>>;
 export declare class SeamSpace extends EventEmitter<SeamEvents> {
     private _app;
     private _fileHandler;
     private _jsonParser;
     constructor(_app: Express, _fileHandler: RequestHandler);
-    createRouter(path: string, procedures?: ProcedureBuilderList): SeamRouter;
+    addRouters<T extends Record<string, SeamRouterBuilder>>(routers: T): RouterToClient<T>;
     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>>;
 }
+type ErrorMapToUnion<E extends Record<string, any>> = {
+    [K in keyof E]: ApiError<{
+        [P in K]: E[K];
+    }, K>;
+}[keyof E];
+type ResultFromErrors<Data, Errors extends Record<string, any>> = {
+    ok: true;
+    data: Data;
+} | (ErrorMapToUnion<Errors> extends infer E ? E extends ApiError<any, any> ? {
+    ok: false;
+    error: E;
+} : never : never);
+type InferInput<P> = P extends ProcedureBuilder<infer I, any, any> ? {
+    [K in keyof I]: I[K] extends z.ZodType ? z.infer<I[K]> : never;
+} : never;
+type InferOutput<P> = P extends ProcedureBuilder<any, infer O, any> ? O extends z.ZodType ? z.infer<O> : never : never;
+type InferErrors<P> = P extends ProcedureBuilder<any, any, infer E> ? E : never;
+type ProcedureToFn<P> = P extends ProcedureBuilder<any, any, any> ? (input: InferInput<P>) => Promise<ResultFromErrors<InferOutput<P>, InferErrors<P>>> : never;
+type RouterToClient<T> = {
+    [K in keyof T]: T[K] extends ProcedureBuilder<any, any, any> ? ProcedureToFn<T[K]> : RouterToClient<T[K]>;
+};

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 };
 ;
-;
-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/package.json

@@ -1,11 +1,8 @@
 {
   "name": "@seam-rpc/server",
-  "version": "4.3.22",
+  "version": "5.0.1",
   "main": "dist/index.js",
   "type": "module",
-  "bin": {
-    "srpc": "dist/bin/index.js"
-  },
   "types": "dist/index.d.ts",
   "files": [
     "dist"

package/dist/bin/gen-client.js

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

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

@@ -1,12 +0,0 @@
-export declare function generateClient(): Promise<void>;
-interface GenerateOptions {
-    tsPath: string;
-    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

@@ -1,187 +0,0 @@
-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: any) {
-    //     console.error("❌ Failed to generate client file:", err.message + "\n\n", err.stack);
-    //     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.
-export function getProcedureMetadata(filePath) {
-    const sourceText = fs.readFileSync(filePath, "utf8");
-    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, undefined, ts.TypeFormatFlags.NoTruncation);
-                    }
-                }
-                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))
-                    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 metadata;
-}
-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 routerName = tsFileName.slice(0, tsFileName.indexOf("."));
-    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 procMetadata = getProcedureMetadata(tsFile);
-    let output = `/**
- * +===================================+
- * |  File auto-generated by SeamRPC.  |
- * |        --- DO NOT EDIT ---        |
- * +===================================+
- */
-
-import { callApi, RpcError } 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) {
-            try {
-                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;
-                }
-            }
-            catch (e) {
-                console.error(`Failed to process input of procedure "${name}".`);
-                process.exit(1);
-            }
-        }
-        // 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 = procMetadata[name].comment ? procMetadata[name].comment + "\n" : "";
-        const func = `${comment}export function ${name}(${params}): ${fullReturnType} {
-    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,6 +0,0 @@
-#!/usr/bin/env node
-export interface SeamConfig {
-    source: string;
-    compiledFolder: string;
-    outputFolder: string;
-}

package/dist/bin/index.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-import { generateClient } from "./generate.js";
-import { initConfig } from "./init.js";
-main();
-function main() {
-    const args = process.argv;
-    switch (args[2]) {
-        case "generate":
-            generateClient();
-            break;
-        case "init":
-            initConfig();
-            break;
-        default:
-            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

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

package/dist/bin/init.js

@@ -1,34 +0,0 @@
-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/test.d.ts

@@ -1,2 +0,0 @@
-import * as z from "zod";
-export declare function convert(schema: z.ZodTypeAny): string;

package/dist/test.js

@@ -1,56 +0,0 @@
-import { zodToTs, createAuxiliaryTypeStore, printNode } from "zod-to-ts";
-import * as z from "zod";
-import ts from "typescript";
-export function convert(schema) {
-    const store = createAuxiliaryTypeStore();
-    const { node } = zodToTs(schema, {
-        auxiliaryTypeStore: store,
-    });
-    const typeAlias = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier("GeneratedType"), undefined, node);
-    const file = ts.createSourceFile("types.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const printer = ts.createPrinter({
-        newLine: ts.NewLineKind.LineFeed,
-        removeComments: false,
-    });
-    return printer.printNode(ts.EmitHint.Unspecified, typeAlias, file);
-}
-function convert2(schema) {
-    const store = createAuxiliaryTypeStore();
-    const { node } = zodToTs(schema, { auxiliaryTypeStore: store });
-    return printNode(node);
-}
-console.log(convert2(z.object({
-    user: z.object({
-        email: z.string(),
-        id: z.string(),
-        createdAt: z.date(),
-        firstName: z.string(),
-        lastName: z.string(),
-        trackingStartDate: z.string(),
-        trackingWorkItemId: z.string(),
-    }),
-    roles: z.object({
-        id: z.string(),
-        name: z.string(),
-        createdAt: z.date(),
-        permissions: z.number().array(),
-        projectId: z.string(),
-    }),
-    workItems: z.object({
-        id: z.string(),
-        createdAt: z.date(),
-        date: z.date(),
-        link: z.string(),
-        title: z.string(),
-        description: z.string(),
-        projectId: z.string(),
-        authorId: z.string(),
-        durationMethod: z.string(),
-        startTime: z.number(),
-        endTime: z.number(),
-        duration: z.number(),
-        labels: z.string(),
-        updatedAt: z.string(),
-        projectMemberId: z.string(),
-    })
-})));

package/dist/validation.js

@@ -1,54 +0,0 @@
-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) {
-}