@seam-rpc/server 4.3.22 → 5.0.0

package/dist/bin/generate.js

@@ -18,10 +18,11 @@ export async function generateClient() {
     // 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));
+        gen(sourceFiles[i], outputPath);
+        // 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) {
@@ -116,6 +117,26 @@ function convert(schema) {
     const { node } = zodToTs(schema, { auxiliaryTypeStore: store });
     return printNode(node);
 }
+function gen(src, outputPath) {
+    const options = {
+        declaration: true,
+        emitDeclarationOnly: true,
+        outDir: outputPath,
+        target: ts.ScriptTarget.ES2020,
+        module: ts.ModuleKind.NodeNext,
+        strict: true,
+    };
+    const host = ts.createCompilerHost(options);
+    const file = path.resolve(process.cwd(), src);
+    const program = ts.createProgram([file], options, host);
+    console.log(file, outputPath);
+    const emitResult = program.emit();
+    const diagnostics = ts.getPreEmitDiagnostics(program)
+        .concat(emitResult.diagnostics);
+    for (const d of diagnostics) {
+        console.log(ts.flattenDiagnosticMessageText(d.messageText, "\n"));
+    }
+}
 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);

package/dist/index copy.d.ts

@@ -0,0 +1,84 @@
+import { Result, ApiError } from "@seam-rpc/core";
+import EventEmitter from "events";
+import express, { Express, NextFunction, Request, RequestHandler, Response } from "express";
+import * as z from "zod";
+export { ApiError as RpcError };
+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;
+export interface SeamContext {
+    request: Request;
+    response: Response;
+    next: NextFunction;
+}
+export interface SeamErrorContext {
+    routerPath: string;
+    procedureName: string;
+    input?: Record<string, unknown> | null;
+    validatedInput?: Record<string, unknown> | null;
+    output?: unknown;
+    validatedOutput?: unknown;
+    request: Request;
+    response: Response;
+    next: NextFunction;
+}
+export interface SeamEvents {
+    apiError: [error: unknown, context: SeamErrorContext];
+    internalError: [error: unknown, context: SeamErrorContext];
+    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>, ApiError> | Promise<Result<z.infer<Output>, ApiError>>;
+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 SeamProcedure<Input extends ProcedureInput, Output extends ProcedureOutput, Errors extends ProcedureErrors> {
+    input?: Input;
+    output?: Output;
+    errors?: Errors;
+    handler?: ProcedureHandler<Input, Output, Errors>;
+}
+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 seamRouter(path: string, procedures: ProcedureBuilderList): SeamRouter;
+export declare function seamProcedure(): ProcedureBuilder<ProcedureInput, ProcedureOutput, ProcedureErrors>;
+export declare class SeamRouter extends EventEmitter<SeamEvents> {
+    private _procedures;
+    private _router;
+    constructor(path: string, procedures: ProcedureBuilderList);
+    get router(): express.Router;
+    private runMiddleware;
+    private validateInput;
+    private validateOutput;
+    private validateData;
+}
+export declare class SeamSpace extends EventEmitter<SeamEvents> {
+    private _app;
+    private _fileHandler;
+    private _jsonParser;
+    constructor(_app: Express, _fileHandler: RequestHandler);
+    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 copy.js

@@ -0,0 +1,254 @@
+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 { ApiError as RpcError };
+;
+;
+const errorHandler = (code, ...args) => {
+    return new ApiError(code, args[0]);
+};
+export async function createSeamSpace(app, fileHandler) {
+    if (!fileHandler) {
+        let multer;
+        try {
+            multer = (await import("multer")).default;
+        }
+        catch {
+            throw new Error("Multer is required as default file handler. Install it or provide a custom fileHandler.");
+        }
+        const upload = multer();
+        fileHandler = upload.any();
+    }
+    return new SeamSpace(app, fileHandler);
+}
+export function seamRouter(path, procedures) {
+    return new SeamRouter(path, procedures);
+}
+export function seamProcedure() {
+    return createProcedureBuilder();
+}
+function createProcedureBuilder(definition = {}) {
+    return {
+        _def: definition,
+        input: schema => createProcedureBuilder({
+            ...definition,
+            input: schema,
+        }),
+        output: schema => createProcedureBuilder({
+            ...definition,
+            output: schema,
+        }),
+        errors: errors => createProcedureBuilder({
+            ...definition,
+            errors
+        }),
+        handler: handler => createProcedureBuilder({
+            ...definition,
+            handler
+        }),
+    };
+}
+export class SeamRouter extends EventEmitter {
+    constructor(path, procedures) {
+        super();
+        this._procedures = {};
+        this._router = Router();
+        for (const proc in procedures) {
+            this._procedures[proc] = procedures[proc]._def;
+        }
+        // seamSpace.app.use(path, this._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) {
+                this.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 = {
+                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, error: errorHandler });
+            }
+            catch (error) {
+                this.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) {
+                this.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) {
+                this.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;
+                }
+                // 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) {
+                this.emit("internalError", error, {
+                    routerPath: path,
+                    procedureName: req.params.procName,
+                    input,
+                    validatedInput,
+                    output,
+                    validatedOutput,
+                    request: req,
+                    response: res,
+                    next: next,
+                });
+                res.sendStatus(500); //.send({ error: String(error) });
+            }
+        });
+    }
+    get router() {
+        return 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);
+        // } else {
+        //     throw new Error("Unsupported content type.");
+        // }
+        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));
+    }
+    validateOutput(output, procOutput) {
+        return this.validateData(output, procOutput);
+    }
+    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) {
+        super();
+        this._app = _app;
+        this._fileHandler = _fileHandler;
+        this._jsonParser = express.json();
+    }
+    createRouter(path, procedures = {}) {
+        const router = new SeamRouter(path, procedures);
+        // router.addProcedures(procedures);
+        return router;
+    }
+    get app() { return this._app; }
+    get jsonParser() { return this._jsonParser; }
+    get fileHandler() { return this._fileHandler; }
+}

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 as RpcError };
 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]>;
+};