@zuplo/cli 1.88.0 → 1.90.0

package/README.md

@@ -33,6 +33,7 @@ Project commands
 
 Commands:
   zup project update  Updates your project structure to the latest conventions
+  zup project import-openapi  Import an OpenAPI file into your Zuplo project
 
 zup tunnel
 

package/dist/cmds/project/import-openapi.js

@@ -0,0 +1,41 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a7cdf682-723c-53b1-b20c-0a26e9a504db")}catch(e){}}();
+import { captureEvent } from "../../common/analytics/lib.js";
+import setBlocking from "../../common/output.js";
+import { ZuploProjectValidator } from "../../common/validators/file-system-validator.js";
+import { YargsChecker } from "../../common/validators/lib.js";
+import { importOpenApi, } from "../../project/import-openapi/handler.js";
+export default {
+    desc: "Import an OpenAPI file into your Zuplo project",
+    command: "import-openapi",
+    builder: (yargs) => {
+        return yargs
+            .option("dir", {
+            type: "string",
+            describe: "The directory containing your config/routes.json",
+            default: ".",
+            normalize: true,
+            hidden: true,
+        })
+            .option("prompt", {
+            type: "boolean",
+            describe: "Prompt for confirmation before importing",
+            default: true,
+        })
+            .option("source", {
+            type: "string",
+            describe: "The OpenAPI file to import",
+        })
+            .demandOption(["source"])
+            .middleware([setBlocking])
+            .check(async (argv) => {
+            return await new YargsChecker(new ZuploProjectValidator()).check(argv);
+        });
+    },
+    handler: async (argv) => {
+        await captureEvent({ argv, event: "zup project import-open-api" });
+        await importOpenApi(argv);
+    },
+};
+//# sourceMappingURL=import-openapi.js.map
+//# debugId=a7cdf682-723c-53b1-b20c-0a26e9a504db

package/dist/cmds/project/index.js

@@ -1,15 +1,16 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="f9aa83d0-91be-5c97-ac89-131d1bec0878")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e46201b0-8148-5c25-a7c1-7ae7cdc49cbb")}catch(e){}}();
 import { groupHandler } from "../../common/handler.js";
+import importOpenApi from "./import-openapi.js";
 import update from "./update.js";
 const commands = {
     describe: "Project commands",
     command: "project",
     builder: (yargs) => {
-        return yargs.command(update).help();
+        return yargs.command(update).command(importOpenApi).help();
     },
     handler: groupHandler,
 };
 export default commands;
 //# sourceMappingURL=index.js.map
-//# debugId=f9aa83d0-91be-5c97-ac89-131d1bec0878
+//# debugId=e46201b0-8148-5c25-a7c1-7ae7cdc49cbb

package/dist/common/validators/file-system-validator.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="648539ee-2075-5ac0-b268-fc5ae066e234")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="5d2da21c-788d-547b-b136-8738ace98ad7")}catch(e){}}();
 import fg from "fast-glob";
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
@@ -16,7 +16,7 @@ export class NotAGitRepoError extends Error {
 }
 export class NotAZuploProject extends Error {
     constructor() {
-        super("Invalid directory: The current directory is not a Zuplo project.");
+        super("Invalid directory: The current directory is not the root of a Zuplo project.");
         Object.setPrototypeOf(this, NotAZuploProject.prototype);
     }
 }
@@ -163,4 +163,4 @@ export const validDeployDirectoryValidator = new CompositeValidator(new ZuploPro
 export const validTestDirectoryValidator = new CompositeValidator(new ZuploProjectValidator(), new ZuploProjectHasTestsValidator());
 export const validLinkDirectoryValidator = new CompositeValidator(new ZuploProjectValidator(), new UserIsLoggedInValidator());
 //# sourceMappingURL=file-system-validator.js.map
-//# debugId=648539ee-2075-5ac0-b268-fc5ae066e234
+//# debugId=5d2da21c-788d-547b-b136-8738ace98ad7

package/dist/project/import-openapi/handler.js

@@ -0,0 +1,86 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7a8f9c9d-06a4-50e2-963a-5a23166de5eb")}catch(e){}}();
+import { confirm } from "@inquirer/prompts";
+import { existsSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, extname, join, relative } from "node:path";
+import prettier from "prettier";
+import { printCriticalFailureToConsoleAndExit, printDiagnosticsToConsole, printResultToConsoleAndExitGracefully, } from "../../common/output.js";
+import { addOperationIdsAsNecessary, generateMergeChangeset, parseOpenApiFile, } from "./utils.js";
+const BASE_TEMPLATE = `
+{
+  "openapi": "3.1.0",
+  "info": {
+    "version": "1.0.0",
+    "title": "My Zuplo API"
+  },
+  "paths": {}
+}
+
+`;
+export async function importOpenApi(argv) {
+    const filePath = argv.source;
+    const normalizedFilePath = join(relative(process.cwd(), filePath));
+    if (!existsSync(normalizedFilePath)) {
+        printCriticalFailureToConsoleAndExit(`The file ${normalizedFilePath} to import does not exist.`);
+    }
+    const rawOpenApiSpec = await readFile(normalizedFilePath);
+    const extName = extname(normalizedFilePath);
+    const basePath = basename(normalizedFilePath, extName);
+    const fileContent = rawOpenApiSpec.toString();
+    const parsedOpenApiSpec = await parseOpenApiFile(extName, fileContent);
+    const destinationFilePath = join(process.cwd(), "config", `${basePath.replace("oas", "")}.oas.json`);
+    let originalDocument;
+    if (!existsSync(destinationFilePath)) {
+        originalDocument = (await parseOpenApiFile(".json", BASE_TEMPLATE));
+    }
+    else {
+        const existingOpenApiSpec = await readFile(destinationFilePath);
+        const existingFileContent = existingOpenApiSpec.toString();
+        originalDocument = (await parseOpenApiFile(extName, existingFileContent));
+    }
+    const { created, merged, retained } = generateMergeChangeset(originalDocument, parsedOpenApiSpec);
+    printDiagnosticsToConsole("This import will...");
+    printDiagnosticsToConsole("");
+    if (created.size > 0) {
+        printDiagnosticsToConsole(`Create ${created.size} new ${created.size > 1 ? "operations" : "operation"}`);
+        printDiagnosticsToConsole("");
+        created.forEach((operation) => {
+            printDiagnosticsToConsole(operation);
+        });
+        printDiagnosticsToConsole("");
+    }
+    if (merged.size > 0) {
+        printDiagnosticsToConsole(`Merge ${merged.size} new ${merged.size > 1 ? "operations" : "operation"}`);
+        printDiagnosticsToConsole("");
+        merged.forEach((operation) => {
+            printDiagnosticsToConsole(operation);
+        });
+        printDiagnosticsToConsole("");
+    }
+    if (retained.size > 0) {
+        printDiagnosticsToConsole(`Retain ${retained.size} new ${retained.size > 1 ? "operations" : "operation"}`);
+        printDiagnosticsToConsole("");
+        retained.forEach((operation) => {
+            printDiagnosticsToConsole(operation);
+        });
+        printDiagnosticsToConsole("");
+    }
+    if (argv.prompt) {
+        printDiagnosticsToConsole("");
+        const answer = await confirm({ message: "Proceed?", default: true });
+        if (!answer) {
+            printResultToConsoleAndExitGracefully("Import cancelled.");
+        }
+    }
+    addOperationIdsAsNecessary(parsedOpenApiSpec);
+    const formattedOpenApi = prettier.format(JSON.stringify(parsedOpenApiSpec), {
+        parser: "json-stringify",
+    });
+    writeFileSync(destinationFilePath, formattedOpenApi, {
+        flag: "w",
+    });
+    printResultToConsoleAndExitGracefully(`Import successful. File written to ${destinationFilePath}`);
+}
+//# sourceMappingURL=handler.js.map
+//# debugId=7a8f9c9d-06a4-50e2-963a-5a23166de5eb

package/dist/project/import-openapi/interfaces.js

@@ -0,0 +1,8 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b14028c7-4667-5a33-8f2d-e6c8216e26eb")}catch(e){}}();
+export const ZUPLO_OPEN_API_VENDOR_PREFIX = "x-zuplo";
+export const OPEN_API_INTERNAL_PROPERTY_VENDOR_TAG = "x-internal";
+export const ZUPLO_OPEN_API_PATH_KEY = `${ZUPLO_OPEN_API_VENDOR_PREFIX}-path`;
+export const ZUPLO_OPEN_API_ROUTE_KEY = `${ZUPLO_OPEN_API_VENDOR_PREFIX}-route`;
+//# sourceMappingURL=interfaces.js.map
+//# debugId=b14028c7-4667-5a33-8f2d-e6c8216e26eb

package/dist/project/import-openapi/utils.js

@@ -0,0 +1,223 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c089ea78-2efe-51c0-aa97-d386b8b87324")}catch(e){}}();
+import yaml from "js-yaml";
+import { v4 } from "uuid";
+import { ZUPLO_OPEN_API_PATH_KEY, ZUPLO_OPEN_API_ROUTE_KEY, } from "./interfaces.js";
+export const OPERATION_PATH_MERGE_DELIMITER = ">";
+export const OPEN_API_FILE_TYPES = [".json", ".yml", ".yaml"];
+export const parseOpenApiFile = async (extName, fileText) => {
+    if (!OPEN_API_FILE_TYPES.includes(extName)) {
+        throw new Error(`Invalid file type. Supported file types are: ${OPEN_API_FILE_TYPES.join(", ")}`);
+    }
+    if (extName.includes("json")) {
+        return JSON.parse(fileText);
+    }
+    return yaml.load(fileText);
+};
+export const addOperationIdsAsNecessary = (openApi) => {
+    const paths = openApi.paths;
+    if (!paths) {
+        return;
+    }
+    for (const path of Object.keys(paths)) {
+        const pathItem = paths[path];
+        if (!pathItem) {
+            continue;
+        }
+        const methods = [
+            "get",
+            "put",
+            "post",
+            "delete",
+            "options",
+            "head",
+            "patch",
+            "trace",
+        ];
+        for (const method of methods) {
+            const operation = pathItem[method];
+            if (operation && !operation.operationId) {
+                operation.operationId = v4();
+            }
+        }
+    }
+};
+export const mergeOpenApiDocuments = (originalDocument, newDocument) => {
+    return mergeOpenApiDocumentOnPathMethod(originalDocument, newDocument);
+};
+const mergeOpenApiDocumentOnPathMethod = (originalDocument, newDocument) => {
+    let paths = originalDocument.paths;
+    if (newDocument.paths) {
+        paths = Object.entries(newDocument.paths).reduce((mergedPaths, [path, pathObject]) => {
+            const existingEntry = mergedPaths[path];
+            if (!existingEntry) {
+                mergedPaths[path] = pathObject;
+            }
+            else {
+                mergedPaths[path] = mergePathItems(existingEntry, pathObject);
+            }
+            return mergedPaths;
+        }, originalDocument.paths ?? {});
+    }
+    return {
+        info: newDocument.info,
+        openapi: mergeOpenApiVersion(originalDocument.openapi, newDocument.openapi),
+        components: mergeComponents(originalDocument.components, newDocument.components),
+        jsonSchemaDialect: newDocument.jsonSchemaDialect ?? originalDocument.jsonSchemaDialect,
+        servers: newDocument.servers ?? originalDocument.servers,
+        security: newDocument.security ?? originalDocument.security,
+        tags: newDocument.tags ?? originalDocument.tags,
+        externalDocs: newDocument.externalDocs ?? originalDocument.externalDocs,
+        paths,
+    };
+};
+const mergeComponents = (originalComponents, newComponents) => {
+    if (!originalComponents) {
+        return newComponents;
+    }
+    if (!newComponents) {
+        return originalComponents;
+    }
+    const { schemas, responses, parameters, examples, requestBodies, headers, securitySchemes, links, callbacks, pathItems, } = originalComponents;
+    const { schemas: newSchemas, responses: newResponses, parameters: newParameters, examples: newExamples, requestBodies: newRequestBodies, headers: newHeaders, securitySchemes: newSecuritySchemes, links: newLinks, callbacks: newCallbacks, pathItems: newPathItems, } = newComponents;
+    return {
+        schemas: schemas ? { ...schemas, ...newSchemas } : newSchemas,
+        responses: responses ? { ...responses, ...newResponses } : newResponses,
+        parameters: parameters
+            ? { ...parameters, ...newParameters }
+            : newParameters,
+        examples: examples ? { ...examples, ...newExamples } : newExamples,
+        requestBodies: requestBodies
+            ? { ...requestBodies, ...newRequestBodies }
+            : newRequestBodies,
+        headers: headers ? { ...headers, ...newHeaders } : newHeaders,
+        securitySchemes: securitySchemes
+            ? { ...securitySchemes, ...newSecuritySchemes }
+            : newSecuritySchemes,
+        links: links ? { ...links, ...newLinks } : newLinks,
+        callbacks: callbacks ? { ...callbacks, ...newCallbacks } : newCallbacks,
+        pathItems: pathItems ? { ...pathItems, ...newPathItems } : newPathItems,
+    };
+};
+const mergeOpenApiVersion = (originalVersion, newDocumentVersion) => {
+    if (originalVersion === "3.1.0") {
+        return originalVersion;
+    }
+    if (newDocumentVersion === "3.1.0") {
+        return newDocumentVersion;
+    }
+    return originalVersion;
+};
+const mergePathItems = (originalPathItem, newPathItem) => {
+    const { summary, description, get, put, post, delete: deleteOperation, options, head, patch, trace, servers, parameters, } = originalPathItem;
+    const zuploPathProperties = originalPathItem[ZUPLO_OPEN_API_PATH_KEY];
+    const newZuploPathProperty = typeof newPathItem === "object" &&
+        newPathItem !== null &&
+        ZUPLO_OPEN_API_PATH_KEY in newPathItem
+        ? newPathItem[ZUPLO_OPEN_API_PATH_KEY]
+        : undefined;
+    const { summary: newSummary, description: newDescription, get: newGetOperation, put: newPutOperation, post: newPostOperation, delete: newDeleteOperation, options: newOptionsOperation, head: newHeadOperation, patch: newPatchOperation, trace: newTraceOperation, servers: newServers, parameters: newParameters, } = newPathItem;
+    return {
+        summary: newSummary ?? summary,
+        description: newDescription ?? description,
+        [ZUPLO_OPEN_API_PATH_KEY]: newZuploPathProperty ?? zuploPathProperties,
+        servers: newServers ?? servers,
+        parameters: newParameters ?? parameters,
+        get: mergeOperationObjects(get, newGetOperation),
+        put: mergeOperationObjects(put, newPutOperation),
+        post: mergeOperationObjects(post, newPostOperation),
+        delete: mergeOperationObjects(deleteOperation, newDeleteOperation),
+        options: mergeOperationObjects(options, newOptionsOperation),
+        head: mergeOperationObjects(head, newHeadOperation),
+        patch: mergeOperationObjects(patch, newPatchOperation),
+        trace: mergeOperationObjects(trace, newTraceOperation),
+    };
+};
+const mergeOperationObjects = (originalOperationObject, newOperationObject) => {
+    if (!newOperationObject) {
+        return originalOperationObject;
+    }
+    const originalZuploProperties = originalOperationObject?.[ZUPLO_OPEN_API_ROUTE_KEY];
+    return {
+        operationId: v4(),
+        [ZUPLO_OPEN_API_ROUTE_KEY]: originalZuploProperties,
+        ...newOperationObject,
+    };
+};
+export const generateMergeChangeset = (originalDocument, newDocument) => {
+    return generatePathMethodMergeChangeset(originalDocument, newDocument);
+};
+const generatePathMethodMergeChangeset = (originalDocument, newDocument) => {
+    let created = new Set();
+    const merged = new Set();
+    let retained = new Set();
+    const originalPaths = originalDocument.paths;
+    const newPaths = newDocument.paths;
+    if (!originalPaths && !newPaths) {
+        return { created, merged, retained };
+    }
+    if (!originalPaths && newPaths) {
+        created = new Set(getAllOperationKeys(newPaths));
+        return { created, merged, retained };
+    }
+    if (!newPaths && originalPaths) {
+        retained = new Set(getAllOperationKeys(originalPaths));
+        return { created, merged, retained };
+    }
+    if (newPaths && originalPaths) {
+        const oldOperationKeys = getAllOperationKeys(originalPaths);
+        const newOperationKeys = getAllOperationKeys(newPaths);
+        const oldOperationKeysSet = new Set(oldOperationKeys);
+        const newOperationKeysSet = new Set(newOperationKeys);
+        newOperationKeys.forEach((operationKey) => {
+            if (oldOperationKeysSet.has(operationKey)) {
+                merged.add(operationKey);
+            }
+            else {
+                created.add(operationKey);
+            }
+        });
+        oldOperationKeys.forEach((operationKey) => {
+            if (!newOperationKeysSet.has(operationKey)) {
+                retained.add(operationKey);
+            }
+        });
+    }
+    return { created, merged, retained };
+};
+const getAllOperationKeys = (pathsObject) => {
+    return Object.entries(pathsObject)
+        .map(([path, pathObject]) => {
+        const pathItemObject = pathObject;
+        const { get, put, post, delete: deleteOperation, options, head, patch, trace, } = pathItemObject;
+        const operations = [];
+        if (get) {
+            operations.push("get");
+        }
+        if (put) {
+            operations.push("put");
+        }
+        if (post) {
+            operations.push("post");
+        }
+        if (deleteOperation) {
+            operations.push("delete");
+        }
+        if (options) {
+            operations.push("options");
+        }
+        if (head) {
+            operations.push("head");
+        }
+        if (patch) {
+            operations.push("patch");
+        }
+        if (trace) {
+            operations.push("trace");
+        }
+        return operations.map((operation) => `${operation}${OPERATION_PATH_MERGE_DELIMITER}${path}`);
+    })
+        .flat();
+};
+//# sourceMappingURL=utils.js.map
+//# debugId=c089ea78-2efe-51c0-aa97-d386b8b87324

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuplo/cli",
-  "version": "1.88.0",
+  "version": "1.90.0",
   "type": "module",
   "repository": "https://github.com/zuplo/cli",
   "description": "The command-line interface for Zuplo",
@@ -30,6 +30,7 @@
   "devDependencies": {
     "@sentry/cli": "^2.20.7",
     "@types/chai": "^4.3.4",
+    "@types/js-yaml": "^4.0.8",
     "@types/mocha": "^10.0.1",
     "@types/node": "^18.15.11",
     "@types/prettier": "^2.7.2",
@@ -37,6 +38,7 @@
     "@types/semver": "^7.3.13",
     "@types/tar": "^6.1.4",
     "@types/temp": "^0.9.1",
+    "@types/uuid": "^9.0.6",
     "@types/yargs": "^17.0.24",
     "@typescript-eslint/eslint-plugin": "^5.57.1",
     "@typescript-eslint/parser": "^5.57.1",
@@ -49,6 +51,7 @@
     "husky": "^8.0.3",
     "lint-staged": "^13.2.0",
     "mocha": "^10.2.0",
+    "openapi-types": "^12.1.3",
     "prettier-plugin-organize-imports": "^3.2.2",
     "typescript": "^5.2.2"
   },
@@ -58,9 +61,9 @@
     "@inquirer/prompts": "^3.0.4",
     "@sentry/node": "7.69.0",
     "@swc/core": "1.3.78",
-    "@zuplo/core": "5.1401.0",
+    "@zuplo/core": "5.1450.0",
     "@zuplo/pino-pretty-configurations": "^1.5.0",
-    "@zuplo/runtime": "5.1401.0",
+    "@zuplo/runtime": "5.1450.0",
     "chalk": "^5.1.2",
     "chokidar": "^3.5.3",
     "deno-bin": "1.37.1",
@@ -73,6 +76,7 @@
     "fastify-sse-v2": "^3.1.2",
     "ignore": "^5.2.4",
     "jose": "^4.14.4",
+    "js-yaml": "^4.1.0",
     "jsonc-parser": "^3.2.0",
     "open": "^9.1.0",
     "pino": "^8.11.0",
@@ -85,6 +89,7 @@
     "simple-git": "^3.17.0",
     "tar": "^6.1.13",
     "temp": "^0.9.4",
+    "uuid": "^9.0.1",
     "yargs": "^17.7.1"
   }
 }