@prismatic-io/prism 4.1.1 → 4.2.2

package/lib/generate/action.js

@@ -44,45 +44,19 @@ const getPerformFunctionWSDL = (projectTemplatePath, action) => {
     })
         .join(",")});`;
 };
-const getPerformFunctionOpenApi = ({ actionObject, service, methodSignature, }) => {
-    const properties = actionObject.inputs.flatMap(({ properties }) => properties.map(({ propertyName }) => propertyName)) || [];
-    const propertiesText = properties.join(",");
-    return `const result = await ${service}.${methodSignature.getName()}(${propertiesText});`;
-};
-const instantiatePerformFunction = (action, project, includeClient, addRetry) => {
-    const { projectTemplatePath, projectType } = project;
-    const clientCallParams = (0, util_1.appendRequiredFields)({
-        inputFields: ["connection"],
-        addRetry,
-        includeClient,
-    });
-    const clientCall = `initializeClient({ ${clientCallParams.join(", ")} });`;
-    let performFunction;
-    if (projectType === "wsdl") {
-        performFunction = getPerformFunctionWSDL(projectTemplatePath, action);
-    }
-    else {
-        performFunction = getPerformFunctionOpenApi(action);
-    }
+const instantiatePerformFunction = (action, project) => {
+    const { projectTemplatePath } = project;
+    const performFunction = getPerformFunctionWSDL(projectTemplatePath, action);
     const performParams = action.actionObject.inputs
         .filter(({ shouldImport }) => shouldImport)
         .map(({ properties, shouldImport }) => {
         const name = properties.map(({ propertyName }) => propertyName).join(",");
         return shouldImport ? name : "";
     });
-    const updatedPerformParams = (0, util_1.appendRequiredFields)({
-        inputFields: includeClient
-            ? ["connection", ...performParams]
-            : projectType === "wsdl"
-                ? [...performParams, "headers"]
-                : performParams,
-        addRetry,
-        includeClient,
-    });
+    const updatedPerformParams = [...performParams, "headers"];
     return `async ({logger}, ${updatedPerformParams.length > 0
         ? `{ ${updatedPerformParams.join(", ")} }: Record<string,any>`
         : ""}) => {
-    ${projectType === "openApi" && includeClient ? clientCall : ""}
     ${performFunction}
     return {data: result};
       }`;
@@ -128,7 +102,7 @@ const compileAction = (actionService, actionMethod, project) => {
         actionObject: generateActionObject(actionMethod, project),
     });
 };
-const writeAction = async (action, project, includeClient, addRetry) => {
+const writeAction = async (action, project) => {
     const { actionFile } = project;
     // Apparently you can't generate an Object without adding it to the file
     // so this is our place holder to use as a template
@@ -147,16 +121,6 @@ const writeAction = async (action, project, includeClient, addRetry) => {
         }
         return shouldImport ? [name] : [];
     });
-    const updatedInputFields = (0, util_1.appendRequiredFields)({
-        inputFields: includeClient
-            ? [
-                `connection: { type: "connection", label: "connection", required: true }`,
-                ...inputFields,
-            ]
-            : inputFields,
-        includeClient,
-        addRetry,
-    });
     object.addPropertyAssignments([
         {
             name: "display",
@@ -167,21 +131,19 @@ const writeAction = async (action, project, includeClient, addRetry) => {
         },
         {
             name: "perform",
-            initializer: instantiatePerformFunction(action, project, includeClient, project.projectType === "openApi" && addRetry),
+            initializer: instantiatePerformFunction(action, project),
         },
         {
             name: "inputs",
-            initializer: `{${project.projectType === "wsdl"
-                ? [
-                    ...updatedInputFields,
-                    `headers: {
+            initializer: `{${[
+                ...inputFields,
+                `headers: {
             label: "Headers",
             type: "code",
             comments: "Provide headers to the SOAP client",
             default: '{}'
           }`,
-                ]
-                : [...updatedInputFields].join(", ")}}`,
+            ]}}`,
         },
     ]);
     //Add the action payload to the action
@@ -211,16 +173,8 @@ const writeInputsImport = async (inputNames, { actionFile }) => {
         namedImports: inputNames,
     });
 };
-const generateActions = async (project, includeClient, addRetry) => {
-    const { projectType, actionFile, inputsFile } = project;
-    if (projectType === "openApi" && includeClient) {
-        actionFile.addImportDeclarations([
-            {
-                moduleSpecifier: `./client`,
-                namedImports: ["initializeClient"],
-            },
-        ]);
-    }
+const generateActions = async (project) => {
+    const { actionFile, inputsFile } = project;
     const methods = (0, parse_1.getActionMethods)(project);
     const actions = (0, lodash_1.sortBy)(Object.entries(methods).flatMap(([service, actionMethods]) => {
         const dedupedActions = (0, lodash_1.uniqBy)(actionMethods, (a) => a.getName());
@@ -239,14 +193,8 @@ const generateActions = async (project, includeClient, addRetry) => {
     const dedupedServices = (0, lodash_1.sortBy)((0, lodash_1.uniq)(services));
     await writeServicesImport(dedupedServices, project);
     const inputNames = dedupedInputs.map(({ propertyName }) => propertyName);
-    await writeInputsImport(projectType === "openApi"
-        ? (await (0, util_1.appendRequiredFields)({
-            inputFields: inputNames,
-            includeClient,
-            addRetry,
-        })) || []
-        : inputNames, project);
-    const actionPromises = actions.map((action) => writeAction(action, project, includeClient, projectType === "openApi" && addRetry));
+    await writeInputsImport(inputNames, project);
+    const actionPromises = actions.map((action) => writeAction(action, project));
     await Promise.all(actionPromises);
     const actionExports = (0, lodash_1.sortBy)(actions.map(({ key }) => key));
     actionFile.addExportAssignment({

package/lib/generate/index.js

@@ -30,19 +30,13 @@ exports.updatePackageJson = exports.generate = void 0;
 const path = __importStar(require("path"));
 const sourceFile_1 = require("./sourceFile");
 const action_1 = require("./action");
-const client_1 = require("./client");
-const connection_1 = require("./connection");
 const prettier_1 = __importDefault(require("prettier"));
 const fs_extra_1 = require("fs-extra");
-const generate = async ({ projectRoot, projectTemplateName, projectTemplatePath, projectType, includeClient, addRetry, }) => {
+const generate = async ({ projectRoot, projectTemplateName, projectTemplatePath, }) => {
     var _a;
-    const project = (0, sourceFile_1.initializeProject)(projectRoot, projectTemplateName, projectTemplatePath, projectType, includeClient, addRetry);
+    const project = (0, sourceFile_1.initializeProject)(projectRoot, projectTemplateName, projectTemplatePath);
     const { componentProject } = project;
-    if (projectType === "openApi" && includeClient) {
-        await (0, client_1.generateClient)(project);
-        await (0, connection_1.generateConnections)(project);
-    }
-    await (0, action_1.generateActions)(project, includeClient, projectType === "openApi" && addRetry);
+    await (0, action_1.generateActions)(project);
     (_a = componentProject
         .getSourceFile(path.join(projectRoot, "src", "index.test.ts"))) === null || _a === void 0 ? void 0 : _a.delete();
     await componentProject.save();

package/lib/generate/parse.js

@@ -41,71 +41,19 @@ const getWSDLClientMethods = (clientPath, clientInterface, componentProject) =>
         process.exit(1);
     }
 };
-const getOpenApiMethods = (servicesPath, componentProject) => {
-    try {
-        const servicesFiles = componentProject
-            .getDirectoryOrThrow(servicesPath)
-            .getSourceFiles();
-        const serviceToMethodsMapping = Object.fromEntries(servicesFiles.map((serviceFile) => {
-            let methods = [];
-            const serviceClass = serviceFile.getClassOrThrow(serviceFile.getBaseName().split(".ts")[0]);
-            methods = serviceClass
-                .getMethods()
-                .map((method) => method.getSignature().getDeclaration());
-            return [serviceClass.getNameOrThrow(), methods];
-        }));
-        return serviceToMethodsMapping;
-    }
-    catch (error) {
-        console.error("Unable to find services directory." + error);
-        process.exit(1);
-    }
-};
-const isPrimitiveType = (type) => type.isObject() ||
-    type.isLiteral() ||
-    type.isString() ||
-    type.isBoolean() ||
-    type.isNumber() ||
-    type.isAny() ||
-    type.isUndefined();
 const getParamTypeDefinition = (project, parameter) => {
-    const { componentProject, projectType, projectRoot, definitionDirectory } = project;
-    if (projectType === "wsdl") {
-        const paramName = parameter.getName();
-        return componentProject.getSourceFile(path.join(projectRoot, definitionDirectory, "definitions", `${(0, camelcase_1.default)(!paramName.includes("Param")
-            ? paramName
-            : paramName.split("Param")[0], {
-            pascalCase: true,
-        })}.ts`));
-    }
-    else if (projectType === "openApi") {
-        // The OpenAPI generator skips certain types
-        const paramType = parameter.getType();
-        if (isPrimitiveType(paramType) ||
-            paramType.getUnionTypes().every(isPrimitiveType)) {
-            return undefined;
-        }
-        return componentProject.getSourceFile(path.join(projectRoot, definitionDirectory, "models", `${(0, camelcase_1.default)(parameter.getName(), {
-            pascalCase: true,
-        })}.ts`));
-    }
-    else {
-        console.error("Not implemented");
-        process.exit(1);
-    }
+    const { componentProject, projectRoot, definitionDirectory } = project;
+    const paramName = parameter.getName();
+    return componentProject.getSourceFile(path.join(projectRoot, definitionDirectory, "definitions", `${(0, camelcase_1.default)(!paramName.includes("Param") ? paramName : paramName.split("Param")[0], {
+        pascalCase: true,
+    })}.ts`));
 };
 exports.getParamTypeDefinition = getParamTypeDefinition;
 // Gather the methods that will be translated to actions
 const getActionMethods = (projectStructure) => {
     const { projectRoot, componentProject, projectTemplateName, definitionDirectory, } = projectStructure;
-    let serviceMethods = {};
-    if (projectStructure.projectType === "wsdl") {
-        const methods = getWSDLClientMethods(path.join(projectRoot, definitionDirectory, "client.ts"), `${(0, camelcase_1.default)(projectTemplateName, { pascalCase: true })}Client`, componentProject);
-        serviceMethods["createClientAsync"] = methods;
-    }
-    else if (projectStructure.projectType === "openApi") {
-        serviceMethods = getOpenApiMethods(path.join(projectRoot, definitionDirectory, "services"), componentProject);
-    }
-    return serviceMethods;
+    return {
+        createClientAsync: getWSDLClientMethods(path.join(projectRoot, definitionDirectory, "client.ts"), `${(0, camelcase_1.default)(projectTemplateName, { pascalCase: true })}Client`, componentProject),
+    };
 };
 exports.getActionMethods = getActionMethods;

package/lib/generate/sourceFile.js

@@ -30,7 +30,6 @@ exports.initializeProject = void 0;
 const camelcase_1 = __importDefault(require("camelcase"));
 const ts_morph_1 = require("ts-morph");
 const path = __importStar(require("path"));
-const util_1 = require("./util");
 const initializeActionFile = (componentProject, projectRoot) => {
     const actionFile = componentProject.createSourceFile(path.join(projectRoot, "src", "actions.ts"), undefined, { overwrite: true });
     actionFile.addImportDeclaration({
@@ -39,14 +38,6 @@ const initializeActionFile = (componentProject, projectRoot) => {
     });
     return actionFile;
 };
-const initializeClientFile = (componentProject, projectRoot) => {
-    const clientFile = componentProject.createSourceFile(path.join(projectRoot, "src", "client.ts"), undefined, { overwrite: true });
-    return clientFile;
-};
-const initializeConnectionsFile = (componentProject, projectRoot) => {
-    const connectionsFile = componentProject.createSourceFile(path.join(projectRoot, "src", "connections.ts"), undefined, { overwrite: true });
-    return connectionsFile;
-};
 const initializeInputsFile = (componentProject, projectRoot) => {
     const inputsFile = componentProject.createSourceFile(path.join(projectRoot, "src", "inputs.ts"), undefined, { overwrite: true });
     inputsFile.addImportDeclaration({
@@ -60,12 +51,6 @@ const copyTemplateFileToProject = (componentProject, projectRoot, projectTemplat
     const templateFile = componentProject.getSourceFileOrThrow(projectTemplatePath);
     templateFile.copy(path.join(process.cwd(), projectRoot, fileName));
 };
-const initializeOpenApi = ({ projectRoot, projectTemplatePath, componentProject, }) => {
-    // Copy our template file into the component project
-    copyTemplateFileToProject(componentProject, projectRoot, projectTemplatePath, path.basename(projectTemplatePath));
-    // Return the relative path of the OpenAPI spec
-    return path.relative(path.join(projectRoot, "src"), path.join(projectRoot, path.basename(projectTemplatePath)));
-};
 const initializeWSDL = ({ projectRoot, projectTemplateName, projectTemplatePath, componentProject, actionFile, }) => {
     const wsdlProjectLocation = path.join(projectRoot, `${projectTemplateName}.wsdl`);
     // Copy the wsdl used for generation to the project root
@@ -77,47 +62,29 @@ const initializeWSDL = ({ projectRoot, projectTemplateName, projectTemplatePath,
     // Return the relative path of the WSDL
     return path.relative(path.join(projectRoot, "src"), wsdlProjectLocation);
 };
-const projectTypeSetup = (project, projectType) => {
-    if (projectType === "wsdl") {
-        const wsdlPath = initializeWSDL(project);
-        // Update the WSDL Path to be in our component project
-        project.projectTemplatePath = wsdlPath;
-    }
-    else if (projectType === "openApi") {
-        const openApiPath = initializeOpenApi(project);
-        project.projectTemplatePath = openApiPath;
-    }
+const projectTypeSetup = (project) => {
+    const wsdlPath = initializeWSDL(project);
+    // Update the WSDL Path to be in our component project
+    project.projectTemplatePath = wsdlPath;
 };
-const initializeProject = (projectRoot, projectTemplateName, projectTemplatePath, projectType, includeClient, addRetry) => {
+const initializeProject = (projectRoot, projectTemplateName, projectTemplatePath) => {
     const componentProject = new ts_morph_1.Project({
         tsConfigFilePath: path.join(projectRoot, "tsconfig.json"),
     });
     componentProject.addSourceFilesAtPaths(path.join(projectRoot, "**/*"));
     const actionFile = initializeActionFile(componentProject, projectRoot);
     const inputsFile = initializeInputsFile(componentProject, projectRoot);
-    if (projectType === "openApi" && inputsFile) {
-        (0, util_1.addRequiredInputs)(projectType, inputsFile, addRetry);
-    }
     const project = {
         projectRoot,
         projectTemplateName: (0, camelcase_1.default)(projectTemplateName),
-        definitionDirectory: projectType === "wsdl"
-            ? (0, camelcase_1.default)(projectTemplateName).toLowerCase()
-            : projectTemplateName,
+        definitionDirectory: (0, camelcase_1.default)(projectTemplateName).toLowerCase(),
         projectTemplatePath,
-        projectType,
         componentProject,
         actionFile,
         inputsFile,
     };
-    if (projectType === "openApi" && includeClient) {
-        const clientFile = initializeClientFile(componentProject, projectRoot);
-        project.clientFile = clientFile;
-        const connectionsFile = initializeConnectionsFile(componentProject, projectRoot);
-        project.connectionsFile = connectionsFile;
-    }
     // Setup type specific project details
-    projectTypeSetup(project, projectType);
+    projectTypeSetup(project);
     return project;
 };
 exports.initializeProject = initializeProject;

package/lib/generate/util.js

@@ -3,9 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.appendRequiredFields = exports.addRequiredInputs = exports.createDescription = void 0;
+exports.createDescription = void 0;
 const striptags_1 = __importDefault(require("striptags"));
-const ts_morph_1 = require("ts-morph");
 const createDescription = (text) => {
     if (!text) {
         return "";
@@ -16,106 +15,3 @@ const createDescription = (text) => {
     return fragment.replace(/`/g, "'");
 };
 exports.createDescription = createDescription;
-const addProperty = (inputsFile, inputName, propertyList) => {
-    const placeholder = inputsFile.addVariableStatement({
-        declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-        declarations: [
-            { name: "genericActionInput", initializer: ts_morph_1.Writers.object({}) },
-        ],
-    });
-    const object = placeholder.getDeclarations()[0].getInitializer();
-    object.addPropertyAssignments(propertyList);
-    inputsFile.addVariableStatement({
-        declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-        isExported: true,
-        declarations: [
-            { name: inputName, initializer: `input(${object.print()})` },
-        ],
-    });
-    placeholder.remove();
-};
-const addRequiredInputs = (projectType, inputsFile, addRetry) => {
-    addProperty(inputsFile, "apiBaseUrl", [
-        { name: `"label"`, initializer: `"API Base URL"` },
-        { name: `"type"`, initializer: `"string"` },
-        { name: `"required"`, initializer: `false` },
-        {
-            name: `"comments"`,
-            initializer: `"An optional url you can specify to override the default provided by the OpenAPI spec."`,
-        },
-    ]);
-    addProperty(inputsFile, "debugRequest", [
-        { name: `"label"`, initializer: `"Debug Request"` },
-        { name: `"type"`, initializer: `"boolean"` },
-        { name: `"required"`, initializer: `false` },
-        {
-            name: `"comments"`,
-            initializer: `"An optional boolean you can toggle to log the contents of the HTTP request for each action."`,
-        },
-    ]);
-    addProperty(inputsFile, "timeout", [
-        { name: `"label"`, initializer: `"Timeout"` },
-        { name: `"type"`, initializer: `"string"` },
-        { name: `"required"`, initializer: `false` },
-        {
-            name: `"comments"`,
-            initializer: `"An optional input that indicates how long the client will await a response."`,
-        },
-    ]);
-    if (addRetry) {
-        addProperty(inputsFile, "maxRetries", [
-            { name: `"label"`, initializer: `"Max Retries"` },
-            { name: `"type"`, initializer: `"string"` },
-            { name: `"required"`, initializer: `false` },
-            {
-                name: `"comments"`,
-                initializer: `"An optional input that indicates how many times this client will retry the request."`,
-            },
-        ]);
-        addProperty(inputsFile, "retryDelayMS", [
-            { name: `"label"`, initializer: `"Retry Delay (MS)"` },
-            { name: `"type"`, initializer: `"string"` },
-            { name: `"required"`, initializer: `false` },
-            {
-                name: `"comments"`,
-                initializer: `"An optional input that indicates a delay between retries."`,
-            },
-        ]);
-        addProperty(inputsFile, "retryOnAllErrors", [
-            { name: `"label"`, initializer: `"Retry On All Errors"` },
-            { name: `"type"`, initializer: `"boolean"` },
-            { name: `"required"`, initializer: `false` },
-            {
-                name: `"comments"`,
-                initializer: `"An optional boolean that will have the client retry the request, regardless of what type of error is thrown."`,
-            },
-        ]);
-        addProperty(inputsFile, "useExponentialBackoff", [
-            { name: `"label"`, initializer: `"Use Exponential Backoff"` },
-            { name: `"type"`, initializer: `"boolean"` },
-            { name: `"required"`, initializer: `false` },
-            {
-                name: `"comments"`,
-                initializer: `"An optional boolean that will enable exponential backoff on retry."`,
-            },
-        ]);
-    }
-    return inputsFile;
-};
-exports.addRequiredInputs = addRequiredInputs;
-const appendRequiredFields = ({ inputFields, addRetry, includeClient, }) => {
-    if (!includeClient) {
-        return inputFields;
-    }
-    const base = [...inputFields, "apiBaseUrl", "debugRequest", "timeout"];
-    return addRetry
-        ? [
-            ...base,
-            "maxRetries",
-            "retryDelayMS",
-            "retryOnAllErrors",
-            "useExponentialBackoff",
-        ]
-        : base;
-};
-exports.appendRequiredFields = appendRequiredFields;

package/lib/yeoman.js

@@ -11,6 +11,7 @@ const generatorTypes = [
     "action",
     "trigger",
     "connection",
+    "formats",
 ];
 const runGenerator = async (generatorName, options) => {
     if (!generatorTypes.includes(generatorName)) {