@zuplo/cli 1.24.0 → 1.26.0

package/.mocharc.json

@@ -0,0 +1,6 @@
+{
+  "extension": ["js"],
+  "spec": "dist/**/*.spec.js",
+  "enable-source-maps": true,
+  "timeout": 5000
+}

package/README.md

@@ -4,10 +4,11 @@
 zup <command>
 
 Commands:
-  zup delete  Deletes the zup at the URL
-  zup deploy  Deploys current Git branch of the current directory.
-  zup list    Lists all deployed zups
-  zup test    Runs the tests under /tests against an endpoint
+  zup convert  Converts routes.json to routes.oas.json
+  zup delete   Deletes the zup at the URL
+  zup deploy   Deploys current Git branch of the current directory
+  zup list     Lists all deployed zups
+  zup test     Runs the tests under /tests against an endpoint
 
 Options:
   --version  Show version number                                       [boolean]

package/dist/cli.js

@@ -3,6 +3,7 @@ dotenv.config();
 import { gte } from "semver";
 import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
+import convert from "./cmds/convert.js";
 import deleteZup from "./cmds/delete.js";
 import deploy from "./cmds/deploy.js";
 import list from "./cmds/list.js";
@@ -12,6 +13,7 @@ const MIN_NODE_VERSION = "18.0.0";
 if (gte(process.versions.node, MIN_NODE_VERSION)) {
     void yargs(hideBin(process.argv))
         .env("ZUPLO")
+        .command(convert)
         .command(deleteZup)
         .command(deploy)
         .command(list)

package/dist/cmds/convert.js

@@ -0,0 +1,21 @@
+import setBlocking from "../common/output.js";
+import { convert } from "../convert/handler.js";
+export default {
+    desc: "Converts routes.json to routes.oas.json",
+    command: "convert",
+    builder: (yargs) => {
+        return yargs
+            .option("dir", {
+            type: "string",
+            describe: "The directory containing your config/routes.json",
+            default: ".",
+            normalize: true,
+            hidden: true,
+        })
+            .middleware([setBlocking]);
+    },
+    handler: async (argv) => {
+        await convert(argv);
+    },
+};
+//# sourceMappingURL=convert.js.map

package/dist/convert/__tests__/engine.spec.js

@@ -0,0 +1,303 @@
+import { expect } from "chai";
+import { convertRoutes } from "../engine.js";
+describe("Routes.json Conversion Engine", () => {
+    it("should handle simple route conversion (no version)", () => {
+        const routesConfig = {
+            versions: [
+                {
+                    name: "v1",
+                    pathPrefix: "/v1",
+                },
+                {
+                    name: "none",
+                    pathPrefix: "",
+                },
+            ],
+            routes: [
+                {
+                    methods: ["GET"],
+                    path: "/test",
+                    summary: "Test route",
+                    version: "none",
+                    corsPolicy: "anything-goes",
+                    description: "This is a test route",
+                    operationId: "random",
+                    handler: {
+                        export: "urlRewriteHandler",
+                        module: "$import(@zuplo/runtime)",
+                        options: {
+                            rewritePattern: "https://jsonplaceholder.typicode.com/todos",
+                            forwardSearch: true,
+                        },
+                    },
+                },
+            ],
+        };
+        const expected = {
+            openapi: "3.1.0",
+            info: {
+                title: "Converted from config/routes.json",
+                version: "1.0.0",
+            },
+            paths: {
+                "/test": {
+                    get: {
+                        summary: "Test route",
+                        description: "This is a test route",
+                        operationId: "random",
+                        "x-zuplo-route": {
+                            corsPolicy: "anything-goes",
+                            handler: {
+                                export: "urlRewriteHandler",
+                                module: "$import(@zuplo/runtime)",
+                                options: {
+                                    rewritePattern: "https://jsonplaceholder.typicode.com/todos",
+                                    forwardSearch: true,
+                                },
+                            },
+                            version: "none",
+                        },
+                    },
+                    "x-zuplo-path": {
+                        pathMode: "path-to-regexp",
+                    },
+                },
+            },
+        };
+        const actual = convertRoutes(routesConfig);
+        expect(actual).to.deep.equal(expected);
+    });
+    it("should handle simple route conversion (with version)", () => {
+        const routesConfig = {
+            versions: [
+                {
+                    name: "v1",
+                    pathPrefix: "/v1",
+                },
+                {
+                    name: "none",
+                    pathPrefix: "",
+                },
+            ],
+            routes: [
+                {
+                    methods: ["GET"],
+                    path: "/test",
+                    summary: "Test route",
+                    version: "v1",
+                    corsPolicy: "anything-goes",
+                    description: "This is a test route",
+                    operationId: "random",
+                    handler: {
+                        export: "urlRewriteHandler",
+                        module: "$import(@zuplo/runtime)",
+                        options: {
+                            rewritePattern: "https://jsonplaceholder.typicode.com/todos",
+                            forwardSearch: true,
+                        },
+                    },
+                },
+            ],
+        };
+        const expected = {
+            openapi: "3.1.0",
+            info: {
+                title: "Converted from config/routes.json",
+                version: "1.0.0",
+            },
+            paths: {
+                "/v1/test": {
+                    get: {
+                        summary: "Test route",
+                        description: "This is a test route",
+                        operationId: "random",
+                        "x-zuplo-route": {
+                            corsPolicy: "anything-goes",
+                            handler: {
+                                export: "urlRewriteHandler",
+                                module: "$import(@zuplo/runtime)",
+                                options: {
+                                    rewritePattern: "https://jsonplaceholder.typicode.com/todos",
+                                    forwardSearch: true,
+                                },
+                            },
+                            version: "none",
+                        },
+                    },
+                    "x-zuplo-path": {
+                        pathMode: "path-to-regexp",
+                    },
+                },
+            },
+        };
+        const actual = convertRoutes(routesConfig);
+        expect(actual).to.deep.equal(expected);
+    });
+    it("should handle single route with multiple methods", () => {
+        const routesConfig = {
+            versions: [
+                {
+                    name: "v1",
+                    pathPrefix: "/v1",
+                },
+                {
+                    name: "none",
+                    pathPrefix: "",
+                },
+            ],
+            routes: [
+                {
+                    methods: ["GET", "POST", "HEAD"],
+                    path: "/test",
+                    summary: "Test route",
+                    version: "v1",
+                    corsPolicy: "anything-goes",
+                    description: "This is a test route",
+                    operationId: "random",
+                    handler: {
+                        export: "urlRewriteHandler",
+                        module: "$import(@zuplo/runtime)",
+                        options: {
+                            rewritePattern: "https://jsonplaceholder.typicode.com/todos",
+                            forwardSearch: true,
+                        },
+                    },
+                },
+            ],
+        };
+        const expected = {
+            openapi: "3.1.0",
+            info: {
+                title: "Converted from config/routes.json",
+                version: "1.0.0",
+            },
+            paths: {
+                "/v1/test": {
+                    "get,post,head": {
+                        summary: "Test route",
+                        description: "This is a test route",
+                        operationId: "random",
+                        "x-zuplo-route": {
+                            corsPolicy: "anything-goes",
+                            handler: {
+                                export: "urlRewriteHandler",
+                                module: "$import(@zuplo/runtime)",
+                                options: {
+                                    rewritePattern: "https://jsonplaceholder.typicode.com/todos",
+                                    forwardSearch: true,
+                                },
+                            },
+                            version: "none",
+                        },
+                    },
+                    "x-zuplo-path": {
+                        pathMode: "path-to-regexp",
+                    },
+                },
+            },
+        };
+        const actual = convertRoutes(routesConfig);
+        expect(actual).to.deep.equal(expected);
+    });
+    it("should handle single route with different methods", () => {
+        const routesConfig = {
+            versions: [
+                {
+                    name: "v1",
+                    pathPrefix: "/v1",
+                },
+                {
+                    name: "none",
+                    pathPrefix: "",
+                },
+            ],
+            routes: [
+                {
+                    methods: ["GET"],
+                    path: "/test",
+                    summary: "Test route",
+                    description: "This is a test route",
+                    version: "v1",
+                    corsPolicy: "anything-goes",
+                    handler: {
+                        export: "urlRewriteHandler",
+                        module: "$import(@zuplo/runtime)",
+                        options: {
+                            rewritePattern: "https://welcome.zuplo.io/",
+                            forwardSearch: true,
+                        },
+                    },
+                    operationId: "random1",
+                },
+                {
+                    methods: ["POST"],
+                    path: "/test",
+                    summary: "Test route",
+                    description: "This is a test route",
+                    version: "v1",
+                    corsPolicy: "anything-goes",
+                    handler: {
+                        export: "urlRewriteHandler",
+                        module: "$import(@zuplo/runtime)",
+                        options: {
+                            rewritePattern: "https://welcome.zuplo.io/",
+                            forwardSearch: true,
+                        },
+                    },
+                    operationId: "random2",
+                },
+            ],
+        };
+        const expected = {
+            openapi: "3.1.0",
+            info: {
+                title: "Converted from config/routes.json",
+                version: "1.0.0",
+            },
+            paths: {
+                "/v1/test": {
+                    get: {
+                        summary: "Test route",
+                        description: "This is a test route",
+                        operationId: "random1",
+                        "x-zuplo-route": {
+                            corsPolicy: "anything-goes",
+                            handler: {
+                                export: "urlRewriteHandler",
+                                module: "$import(@zuplo/runtime)",
+                                options: {
+                                    rewritePattern: "https://welcome.zuplo.io/",
+                                    forwardSearch: true,
+                                },
+                            },
+                            version: "none",
+                        },
+                    },
+                    post: {
+                        summary: "Test route",
+                        description: "This is a test route",
+                        operationId: "random2",
+                        "x-zuplo-route": {
+                            corsPolicy: "anything-goes",
+                            handler: {
+                                export: "urlRewriteHandler",
+                                module: "$import(@zuplo/runtime)",
+                                options: {
+                                    rewritePattern: "https://welcome.zuplo.io/",
+                                    forwardSearch: true,
+                                },
+                            },
+                            version: "none",
+                        },
+                    },
+                    "x-zuplo-path": {
+                        pathMode: "path-to-regexp",
+                    },
+                },
+            },
+        };
+        const actual = convertRoutes(routesConfig);
+        expect(actual).to.deep.equal(expected);
+    });
+});
+//# sourceMappingURL=engine.spec.js.map

package/dist/convert/engine.js

@@ -0,0 +1,53 @@
+import { join } from "node:path";
+export function convertRoutes(routesConfig) {
+    const base = generateBaseOpenAPIConfig();
+    const paths = base.paths;
+    routesConfig.routes.forEach((route) => {
+        const pathObjectKey = fullPath(route, routesConfig);
+        let pathObject;
+        if (!paths[pathObjectKey]) {
+            pathObject = {};
+            pathObject["x-zuplo-path"] = {
+                pathMode: "path-to-regexp",
+            };
+            paths[pathObjectKey] = pathObject;
+        }
+        pathObject = paths[pathObjectKey];
+        const operationKey = route.methods.map((m) => m.toLowerCase()).join(",");
+        const operation = {};
+        operation["summary"] = route.summary;
+        operation["description"] = route.description;
+        operation["operationId"] = route.operationId;
+        const xZuploRoute = {};
+        xZuploRoute["version"] = "none";
+        if (route.corsPolicy)
+            xZuploRoute["corsPolicy"] = route.corsPolicy;
+        if (route.custom)
+            xZuploRoute["custom"] = route.custom;
+        if (route.policies)
+            xZuploRoute["policies"] = route.policies;
+        if (route.key)
+            xZuploRoute["key"] = route.key;
+        if (route.label)
+            xZuploRoute["label"] = route.label;
+        xZuploRoute["handler"] = route.handler;
+        operation["x-zuplo-route"] = xZuploRoute;
+        pathObject[operationKey] = operation;
+    });
+    return base;
+}
+function generateBaseOpenAPIConfig() {
+    return {
+        openapi: "3.1.0",
+        info: {
+            title: "Converted from config/routes.json",
+            version: "1.0.0",
+        },
+        paths: {},
+    };
+}
+function fullPath(path, context) {
+    const versionPrefix = context.versions.filter((v) => v.name === path.version)[0].pathPrefix;
+    return join(versionPrefix, path.path);
+}
+//# sourceMappingURL=engine.js.map

package/dist/convert/handler.js

@@ -0,0 +1,42 @@
+import { writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import prettier from "prettier";
+import { logger } from "../common/logger.js";
+import { printCriticalFailureToConsoleAndExit } from "../common/output.js";
+import { convertRoutes } from "./engine.js";
+export async function convert(argv) {
+    try {
+        const dir = argv.dir;
+        const normalizedDir = join(relative(process.cwd(), dir));
+        const rawRoutes = await readFile(join(normalizedDir, "config", "routes.json"));
+        const routes = JSON.parse(rawRoutes.toString());
+        const openApi = convertRoutes(routes);
+        const openAPIFilePath = join(normalizedDir, "config", "routes.oas.json");
+        const formattedOpenAPI = prettier.format(JSON.stringify(openApi), {
+            parser: "json-stringify",
+        });
+        writeFileSync(openAPIFilePath, formattedOpenAPI, {
+            flag: "w",
+        });
+        const policies = routes.policies;
+        const corsPolicies = routes.corsPolicies;
+        if (policies) {
+            const policiesFilePath = join(normalizedDir, "config", "policies.json");
+            const formattedPolicies = prettier.format(JSON.stringify({
+                policies: [...policies],
+                corsPolicies: corsPolicies ? [...corsPolicies] : [],
+            }, null, 2), {
+                parser: "json-stringify",
+            });
+            writeFileSync(policiesFilePath, formattedPolicies, {
+                flag: "w",
+            });
+        }
+    }
+    catch (err) {
+        logger.error(err);
+        printCriticalFailureToConsoleAndExit(err);
+    }
+}
+//# sourceMappingURL=handler.js.map

package/dist/convert/routes.generated.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=routes.generated.js.map

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@zuplo/cli",
-  "version": "1.24.0",
+  "version": "1.26.0",
   "type": "module",
   "repository": "https://github.com/zuplo/cli",
   "author": "Zuplo, Inc.",
   "license": "Copyright 2022",
   "scripts": {
-    "build": "tsc --build"
+    "build": "tsc --build",
+    "test": "mocha",
+    "test:debug": "mocha --timeout 0"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -23,7 +25,10 @@
     ]
   },
   "devDependencies": {
+    "@types/chai": "^4.3.4",
+    "@types/mocha": "^10.0.1",
     "@types/node": "^18.11.5",
+    "@types/prettier": "^2.7.2",
     "@types/rimraf": "^3.0.2",
     "@types/semver": "^7.3.13",
     "@types/tar": "^6.1.3",
@@ -31,6 +36,7 @@
     "@types/yargs": "^17.0.13",
     "@typescript-eslint/eslint-plugin": "^5.42.0",
     "@typescript-eslint/parser": "^5.42.0",
+    "chai": "^4.3.7",
     "eslint": "^8.26.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
@@ -38,7 +44,8 @@
     "eslint-plugin-unicorn": "^44.0.2",
     "husky": "^8.0.1",
     "lint-staged": "^13.0.3",
-    "prettier": "^2.7.1",
+    "mocha": "^10.2.0",
+    "prettier": "^2.8.4",
     "prettier-plugin-organize-imports": "^3.1.1",
     "typescript": "^4.8.4"
   },