@seam-rpc/server 4.1.0 → 4.2.0

package/README.md

@@ -1,285 +1 @@
-<img width="1940" height="829" alt="image" src="https://github.com/user-attachments/assets/8a4a8a8b-1b57-4c1e-b6bb-ebab81ba8a32" />
-
-# SeamRPC
-
-## About
-SeamRPC is a simple RPC library for client-server communication using TypeScript using Express for the server.
-
-Making requests to the server is as simple as calling a function and SeamRPC sends it to server for you under the hood.
-
-## Setup
-### Server
-Implement your API functions in a TypeScript file. It's recommended to split different routes into different files, all inside the same folder. You can also optionally include JSDoc comments for the functions. The returned value of an API function is sent from the server to the client. If an error is thrown in the API function in the server, the function throws an error in the client as well (Seam RPC internally responds with HTTP code 400 which the client interprets as an error).
-
-> **Note:** For consistency reasons between server and client API functions, Seam RPC requires all API functions to return a Promise.
-
-**Example:**
-```
-server-app
-  ├─ index.ts
-  └─ api
-     ├─ users.ts
-     └─ posts.ts
-```
-
-`api/users.ts`
-```ts
-import { SeamFile } from "@seam-rpc/server";
-
-export interface User {
-    id: string;
-    name: string;
-}
-
-const users: User[] = [];
-
-/**
- * Creates a new user and returns its ID.
- * @param name The name of the user.
- * @returns ID of the newly created user.
- */
-export async function createUser(name: string): Promise<string> {
-    const user = {
-        id: Date.now().toString(),
-        name
-    };
-    users.push(user);
-    return user.id;
-}
-
-/**
- * Gets a user by ID.
- * @param id The ID of the user.
- * @returns The user object.
- */
-export async function getUser(id: string): Promise<User | undefined> {
-    const user = users.find(e => e.id == id);
-    if (user)
-        return user;
-    else
-        throw new Error("user not found");
-}
-```
-
-#### Create a Seam Space
-
-A Seam Space is linked to an Express app and is what you defined routers to. You define one Seam Space for your API, which can then be separated in to different routers. Each router can be any kind of structure with functions (e.g. an object or a module). This example uses files as modules.
-
-```ts
-import express from "express";
-import { createSeamSpace } from "@seam-rpc/server";
-
-// Import as modules
-import * as usersRouter from "./api/users.js";
-import * as postsRouter from "./api/posts.js";
-
-// Create express app
-const app = express();
-
-// Create Seam Space with express app
-const seamSpace = await createSeamSpace(app);
-
-// Create routers
-seamSpace.createRouter("/users", usersRouter);
-seamSpace.createRouter("/posts", postsRouter);
-
-// Start express server
-app.listen(3000, () => {
-    console.log("Listening on port 3000");
-});
-```
-
-### Client
-The client needs to have the same schema as your API so you can call the API functions and have autocomplete. Behind the scenes these functions will send an HTTP requests to the server. SeamRPC can automatically generate the client schema files. To do this, you can either run the command `seam-rpc gen-client <input-files> <output-folder>` or [define a config file](#config-file) and then run the command `seam-rpc gen-client`.
-
-- `input-files` - Specify what files to generate the client files from. You can use [glob pattern](https://en.wikipedia.org/wiki/Glob_(programming)) to specify the files.
-- `output-folder` - Specify the folder where to store the generated client api files.
-
-**Example:**
-`seam-rpc gen-client ./src/api/* ../server-app/src/api`
-
-```
-client-app
-  ├─ index.ts
-  └─ api
-     ├─ users.ts
-     └─ posts.ts
-```
-The api folder in the client contains the generated API client files, and should not be manually edited.
-
-The generated `api/users.ts` file:
-> Notice that the JSDoc comments are included in the client files.
-```ts
-import { callApi, SeamFile, ISeamFile } from "@seam-rpc/client";
-export interface User {
-    id: string;
-    name: string;
-}
-/**
- * Creates a new user and returns its ID.
- * @param name The name of the user.
- * @returns ID of the newly created user.
- */
-export function createUser(name: string): Promise<string> { return callApi("users", "createUser", [name]); }
-/**
- * Gets a user by ID.
- * @param id The ID of the user.
- * @returns The user object.
- */
-export function getUser(id: string): Promise<User | undefined> { return callApi("users", "getUser", [id]); }
-```
-
-#### Connect client to server
-To establish the connection from the client to the server, you need to specify which URL to call. This example is using a self-hosted server running on port 3000 so it uses `http://localhost:3000`. Just call `createClient` to create the client and specify the URL.
-
-```ts
-createClient("http://localhost:3000");
-```
-
-### Config file
-If you don't want to specify the input files and output folder every time you want to generate the client files, you can create a config file where you define these paths. You can create a `seam-rpc.config.json` file at the root of your project and use the following data:
-```json
-{
-    "inputFiles": "./src/api/*",
-    "outputFolder": "../client/src/api"
-}
-```
-or you can automatically generate a file using `seam-rpc gen-config [input-files] [output-folder]`. If you don't specify the input files and output folder, it will use the default paths (see JSON above).
-
-## Uploading and downloading files
-Both server and client can send files seamlessly. Just use the SeamFile class for this. You can have a parameter as a file or an array/object containing a file. You can have deeply nested files inside objects.
-
-A SeamFile has 3 properties:
-- `data` - binary data
-- `fileName` (optional) - name of the file
-- `mimeType` (optional) - The MIME type of the file ([Learn more](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/MIME_types))
-
-
-**Example:**
-```ts
-interface UserData {
-    id: string;
-    name: string;
-    avatar: SeamFile;
-}
-
-export async function updateUser(userId: string, userData: UserData): Promise<void> {
-    if (userData.avatar.mimeType != "image/png" && userData.avatar.mimeType != "image/jpeg")
-        throw new Error("Only PNGs and JPEGs allowed for avatar.");
-
-    users[userId].name = userData.name;
-    users[userId].avatar = userData.avatar.fileName;
-    writeFileSync(`../avatars/${userData.avatar.fileName}`, userData.avatar.data);
-}
-```
-
-## Important notices
-- 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`
-- `null`
-- `undefined`
-- arrays
-- objects
-
-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.
-
-## Context parameter
-
-### Server
-If you want, you can get access to the request, response and next function from Express. Just add a parameter of type SeamContext at the end of the API function. You can name the parameter whatever you like. This parameter is optional. This parameter is not included in the client generated files.
-
-Example:
-```ts
-export async function createUser(name: string, context: SeamContext): Promise<string> {
-    // Using the context to read the request path.
-    console.log("Request path:", context.request.originalUrl);
-
-    const user = {
-        id: Date.now().toString(),
-        name
-    };
-    users.push(user);
-    return user.id;
-}
-```
-
-### Client
-The client currently doesn't support access to the response object from the fetch.
-
-## Error handling
-
-### Server
-To catch errors across router functions in the server, you can use the `apiError` and `internalError` events.
-- `apiError` - Error ocurred when calling or during execution of your API function.
-- `internalError` - SeamRPC internal error. Please report if you find an error that seems like a bug or requires improvement.
-
-Example:
-```ts
-const seamSpace = await createSeamSpace(app);
-
-seamSpace.on("apiError", (error, context) => {
-    console.error(`API Error at ${context.functionName}!`, error);
-});
-
-seamSpace.on("internalError", (error, context) => {
-    console.error(`Internal Error at ${context.functionName}!`, error);
-});
-```
-
-> **Note:** The above example is to illustrate the use of error handlers and is not a complete example. Please consult the rest of the README or the examples in the examples directory.
-
-## Middleware
-
-### Client
-You can add middleware functions in the client. There's two types:
-- Pre-request - Before the request is sent. You might for example want to add some header to the request.
-- Post-request - After the request was sent. You might for example want to read some header from reponse.
-
-There's two ways to add middleware, either when creating the client:
-```ts
-createClient("http://localhost:3000", {
-    middleware: {
-        request: [
-            ctx => {
-                ctx.request.headers = {
-                    ...ctx.request.headers,
-                    "X-MyHeader": "Test"
-                };
-            },
-        ],
-        response: [
-            ctx => {
-                console.log(ctx.response.headers.get("X-SomeHeader"));
-            }
-        ]
-    }
-});
-```
-... or after creating the client:
-```ts
-const client = createClient("http://localhost:3000");
-
-client.preRequest(ctx => {
-    ctx.request.headers = {
-        ...ctx.request.headers,
-        "X-MyHeader": "Test"
-    };
-});
-
-client.postRequest(ctx => {
-    console.log(ctx.response.headers.get("X-SomeHeader"));
-});
-```
-
-> You can add as many middleware functions as you like.
+[Documentation](https://github.com/DanielC49/seam-rpc/blob/main/README.md)

package/dist/bin/generate.js

@@ -26,7 +26,7 @@ export async function generateClient() {
         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);
+        console.error("❌ Failed to generate client file:", err.message + "\n\n", err.stack);
         process.exit(1);
     }
 }
@@ -96,7 +96,7 @@ export async function generateClientFile({ tsPath, jsPath, outputPath, }) {
  * +===================================+
  */
 
-import { callApi } from "@seam-rpc/client";
+import { callApi, Result, RpcError } from "@seam-rpc/client";
 
 `;
     const functions = [];
@@ -116,14 +116,17 @@ import { callApi } from "@seam-rpc/client";
                 hasInput = true;
             }
         }
-        const returnType = proc._def.output ? convert(proc._def.output) : "void";
+        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 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}> {
+        const func = `${comment}export function ${name}(${params}): Promise<${fullReturnType}> {
     return ${call};
 }`;
         functions.push(func);

package/dist/index.d.ts

@@ -4,6 +4,9 @@ import * as z from "zod";
 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;
 export interface SeamContext {
     request: Request;
     response: Response;
@@ -26,50 +29,52 @@ export interface SeamEvents {
     inputValidationError: [error: unknown, context: SeamErrorContext];
     outputValidationError: [error: unknown, context: SeamErrorContext];
 }
-type ProcedureHandler<Input extends ProcedureInput, Output extends z.ZodType> = (options: ProcedureOptions<Input>) => z.infer<Output> | Promise<z.infer<Output>>;
+type ProcedureHandler<Input extends ProcedureInput, Output extends ProcedureOutput, Errors extends ProcedureErrors> = (options: ProcedureOptions<Input, Errors>) => z.infer<Output> | Promise<z.infer<Output>>;
+interface ProcedureOptions<Input extends ProcedureInput, Errors extends ProcedureErrors> {
+    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 ProcedureInputData<T extends ProcedureInput> = {
     [K in keyof T]: z.infer<T[K]>;
 };
-interface ProcedureOptions<T extends ProcedureInput> {
-    input: Simplify<ProcedureInputData<T>>;
-    ctx: SeamContext;
-}
-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> {
+interface SeamProcedure<Input extends ProcedureInput, Output extends ProcedureOutput, Errors extends ProcedureErrors> {
     input?: Input;
     output?: Output;
-    handler?: ProcedureHandler<Input, Output>;
+    errors?: Errors;
+    handler?: ProcedureHandler<Input, Output, Errors>;
 }
-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 type ProcedureBuilder<Input extends ProcedureInput, Output extends ProcedureOutput, 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>;
 };
 export declare function createSeamSpace(app: Express, fileHandler?: RequestHandler): Promise<SeamSpace>;
-export declare function seamProcedure(): ProcedureBuilder<ProcedureInput, ProcedureOutput>;
+export declare function seamProcedure(): ProcedureBuilder<ProcedureInput, ProcedureOutput, ProcedureErrors>;
 export declare class SeamRouter {
     private seamSpace;
-    private path;
-    private router;
     private procedures;
+    private router;
     constructor(seamSpace: SeamSpace, path: string);
     private runMiddleware;
     private validateInput;
     private validateOutput;
     private validateData;
-    addProcedures(procedures: Record<string, ProcedureBuilder<any, any>>): void;
+    addProcedures(procedures: ProcedureBuilderList): void;
 }
 export declare class SeamSpace extends EventEmitter<SeamEvents> {
     private _app;
     private _fileHandler;
     private _jsonParser;
     constructor(_app: Express, _fileHandler: RequestHandler);
-    createRouter(path: string): SeamRouter;
+    createRouter(path: string, procedures?: ProcedureBuilderList): 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>>;

package/dist/index.js

@@ -1,10 +1,13 @@
-import { extractFiles, injectFiles } from "@seam-rpc/core";
+import { extractFiles, injectFiles, RpcError } from "@seam-rpc/core";
 import EventEmitter from "events";
 import express, { Router } from "express";
 import FormData from "form-data";
 import * as z from "zod";
 ;
 ;
+const errorHandler = (code, ...args) => {
+    return new RpcError(code, args[0]);
+};
 export async function createSeamSpace(app, fileHandler) {
     if (!fileHandler) {
         let multer;
@@ -33,6 +36,10 @@ function createProcedureBuilder(definition = {}) {
             ...definition,
             output: schema,
         }),
+        errors: errors => createProcedureBuilder({
+            ...definition,
+            errors
+        }),
         handler: handler => createProcedureBuilder({
             ...definition,
             handler
@@ -42,7 +49,6 @@ function createProcedureBuilder(definition = {}) {
 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) => {
@@ -86,9 +92,19 @@ export class SeamRouter {
                 next
             };
             try {
-                output = await procedure.handler({ input: validatedInput, ctx });
+                output = await procedure.handler({ input: validatedInput, ctx, error: errorHandler });
             }
             catch (error) {
+                let errorResult = { rpcError: false };
+                if (error instanceof RpcError) {
+                    errorResult = {
+                        rpcError: true,
+                        error: {
+                            code: error.code,
+                            data: error.data,
+                        }
+                    };
+                }
                 seamSpace.emit("apiError", error, {
                     routerPath: path,
                     procedureName: req.params.procName,
@@ -100,7 +116,7 @@ export class SeamRouter {
                     response: res,
                     next,
                 });
-                res.status(400).send({ error: String(error) });
+                res.status(400).json(errorResult);
                 return;
             }
             // Validate output
@@ -215,16 +231,12 @@ export class SeamSpace extends EventEmitter {
         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;
+    createRouter(path, procedures = {}) {
+        const router = new SeamRouter(this, path);
+        router.addProcedures(procedures);
+        return router;
     }
+    get app() { return this._app; }
+    get jsonParser() { return this._jsonParser; }
+    get fileHandler() { return this._fileHandler; }
 }

package/package.json

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

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

@@ -1,8 +0,0 @@
-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,154 +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 genClient() {
-    const args = process.argv;
-    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 (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(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;
-        }
-        // 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;
-            }
-        }
-        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/gen-config.d.ts

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

package/dist/bin/gen-config.js

@@ -1,46 +0,0 @@
-import fs from "fs";
-import readline from "readline";
-export async function genConfig() {
-    const args = process.argv;
-    let source = "./src/api/*";
-    let compiledFolder = "./dist/api";
-    let outputFolder = "../client/src/api";
-    if (args.length == 5) {
-        source = 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 = {
-            source,
-            compiledFolder,
-            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`);
-    }
-}