@prismatic-io/prism 4.1.1 → 4.2.0

package/lib/commands/components/dev/run.js

@@ -15,7 +15,7 @@ const spawnProcess = ([command, ...args], env) => {
 };
 class RunCommand extends core_1.Command {
     async run() {
-        const { argv, flags: { integrationId, configVarKey }, } = await this.parse(RunCommand);
+        const { argv, flags: { integrationId, connectionKey }, } = await this.parse(RunCommand);
         const result = await (0, graphql_1.gqlRequest)({
             document: (0, graphql_1.gql) `
         query integration($id: ID!) {
@@ -42,7 +42,7 @@ class RunCommand extends core_1.Command {
             },
         });
         const nodes = result.integration.testConfigVariables.nodes;
-        const [connection] = nodes.filter(({ requiredConfigVariable: { key } }) => key === configVarKey);
+        const [connection] = nodes.filter(({ requiredConfigVariable: { key } }) => key === connectionKey);
         if (!connection) {
             core_1.CliUx.ux.error("Failed to find active connection.", { exit: 1 });
         }
@@ -56,7 +56,21 @@ class RunCommand extends core_1.Command {
     }
 }
 exports.default = RunCommand;
-RunCommand.description = "Run an arbitrary command within a Prismatic context";
+RunCommand.description = `Fetch an integration's active connection and execute a CLI command with that connection's fields as an environment variable.`;
+RunCommand.usage = "prism components:dev:run -i <value> -c <value> -- /command/to/run";
+RunCommand.examples = [
+    {
+        description: `To simply print an integration's basic auth config variable named "My Credentials" and pipe the resulting JSON to jq, run:`,
+        command: `$ prism components:dev:run
+    --integrationId SW50ZWdyYXRpb246Y2YyMjJlMWUtMzJiYy00NTNhLWIzOWQtYTliNzUwMDAyNjBk
+    --connectionKey "My Credentials" --
+    printenv \${PRISMATIC_CONNECTION_VALUE} | jq`,
+    },
+    {
+        description: `If one of your integrations has an authenticated OAuth 2.0 config variable "Slack Connection", you could run your component's unit tests with that environment variable:`,
+        command: `$ prism components:dev:run -i SW50ZWexample -c "Slack Connection" -- yarn run test`,
+    },
+];
 // Allow us to manually capture argv so we can isolate the wrapped command.
 RunCommand.strict = false;
 // TODO: Make this derive from the component manifest using the same
@@ -67,9 +81,9 @@ RunCommand.flags = {
         char: "i",
         description: "Integration ID",
     }),
-    configVarKey: core_1.Flags.string({
+    connectionKey: core_1.Flags.string({
         required: true,
         char: "c",
-        description: "Key of the Connection Config Var to fetch meta/state for",
+        description: "Key of the connection config variable to fetch meta/state for",
     }),
 };

package/lib/commands/components/dev/test.js

@@ -179,7 +179,7 @@ class TestCommand extends core_1.Command {
             integrationInfo: {
                 name: (0, definition_1.componentTestIntegrationName)(componentKey, name),
             },
-            componentInfo: { key: componentKey, isPublic: isPublic !== null && isPublic !== void 0 ? isPublic : false },
+            componentInfo: { key: definition.key, isPublic: isPublic !== null && isPublic !== void 0 ? isPublic : false },
             actionInfo,
             connectionInfo,
         });

package/lib/commands/components/init/index.js

@@ -32,31 +32,10 @@ const path = __importStar(require("path"));
 const wsdl_tsclient_1 = require("wsdl-tsclient");
 const logger_1 = require("wsdl-tsclient/dist/src/utils/logger");
 const index_1 = require("../../../generate/index");
-const openapi_typescript_codegen_1 = require("openapi-typescript-codegen");
 const prettier_1 = __importDefault(require("prettier"));
 const glob_promise_1 = __importDefault(require("glob-promise"));
 const yeoman_1 = require("../../../yeoman");
 const componentNameRegex = /^[a-zA-Z0-9][a-zA-Z0-9-_]*[a-zA-Z0-9]$/;
-const insertText = /* javascript */ `
-interface EnhancedConfig extends Config {
-  timeout?: number;
-  CLIENT?: AxiosInstance;
-}
-export const EnhancedOpenAPI: EnhancedConfig = OpenAPI;`;
-const injectAxiosToOpenAPI = async (basePath) => {
-    const fileLocation = path.resolve(basePath, "core", "request.ts");
-    const replaceLocation = path.join(__dirname, "..", "..", "..", "..", "templates", "component", "openapi", "request.ts");
-    await fs_1.promises.copyFile(replaceLocation, fileLocation);
-    const file = path.resolve(basePath, "core", "OpenAPI.ts");
-    const contents = await fs_1.promises.readFile(file);
-    const parts = [contents, insertText].join("\n\n").split("\n");
-    const additions = [
-        ...parts.slice(0, 3),
-        /* javascript */ `import { AxiosInstance } from "axios";`,
-        ...parts.slice(3),
-    ].join("\n");
-    await fs_1.promises.writeFile(file, additions);
-};
 const getFilesToFormat = async (basename) => {
     return await (0, glob_promise_1.default)("**/*.ts", {
         ignore: ["**/node_modules/**"],
@@ -73,7 +52,7 @@ const formatSourceFiles = async (basePath, files) => {
 };
 class InitializeComponent extends core_1.Command {
     async run() {
-        const { args: { name }, flags: { verbose, "wsdl-path": wsdlPath, "open-api-path": openApiPath, "skip-auth": skipAuth, "add-retry": addRetry, }, } = await this.parse(InitializeComponent);
+        const { args: { name }, flags: { verbose, "wsdl-path": wsdlPath, "open-api-path": openApiPath }, } = await this.parse(InitializeComponent);
         if (!componentNameRegex.test(name)) {
             this.error(`'${name}' contains invalid characters. Please select a component name that starts and ends with alphanumeric characters, and contains only alphanumeric characters, hyphens, and underscores. See https://regex101.com/?regex=${encodeURIComponent(componentNameRegex.source)}`, { exit: 1 });
         }
@@ -82,81 +61,50 @@ class InitializeComponent extends core_1.Command {
                 exit: 1,
             });
         }
-        if (skipAuth && !openApiPath) {
-            this.error("Auth templating is only supported when generating components from Open API specifications", {
-                exit: 1,
-            });
-        }
-        if (addRetry && !openApiPath) {
-            this.error("HTTP retry logic is only supported when generating components from OpenAPI specifications", {
-                exit: 1,
-            });
-        }
         this.log(`Creating component directory for "${name}"...`);
         await fs_1.promises.mkdir(name);
         const cwd = process.cwd();
         process.chdir(name);
-        await (0, yeoman_1.runGenerator)("component", process.env.NODE_ENV === "test"
-            ? {
+        if (openApiPath) {
+            await (0, yeoman_1.runGenerator)("formats", {
                 name,
-                description: "Prism-generated Component",
-                connectionType: "basic",
-                skipInstall: true,
-            }
-            : { name, skipInstall: Boolean(wsdlPath) || Boolean(openApiPath) });
-        process.chdir(cwd);
-        if (wsdlPath) {
-            if (!verbose) {
-                // wsdl-tsclient emits pretty noisy logs that aren't particularly useful
-                logger_1.Logger.disabled();
-            }
-            const wsdlName = path.basename(wsdlPath).split(".wsdl")[0];
-            await (0, wsdl_tsclient_1.parseAndGenerate)(wsdlPath, path.join(name), {
-                caseInsensitiveNames: true,
-            });
-            await (0, index_1.generate)({
-                projectRoot: name,
-                projectTemplateName: wsdlName,
-                projectTemplatePath: wsdlPath,
-                projectType: "wsdl",
-                includeClient: false,
-                addRetry: false,
-            });
-            await (0, index_1.updatePackageJson)({
-                path: path.resolve(name, "package.json"),
-                dependencies: { soap: "0.40.0" },
+                openapi: openApiPath,
             });
         }
-        else if (openApiPath) {
-            const openApiName = path.basename(openApiPath).split(".")[0];
-            const basePath = path.resolve(name, openApiName);
-            await (0, openapi_typescript_codegen_1.generate)({
-                input: openApiPath,
-                output: path.join(name, openApiName),
-                httpClient: openapi_typescript_codegen_1.HttpClient.NODE,
-                useUnionTypes: true, // handles the case of enums using reserved keywords
-            });
-            await (0, index_1.generate)({
-                projectRoot: name,
-                projectTemplateName: openApiName,
-                projectTemplatePath: openApiPath,
-                projectType: "openApi",
-                includeClient: !skipAuth,
-                addRetry,
-            });
-            await (0, index_1.updatePackageJson)({
-                path: path.resolve(name, "package.json"),
-                dependencies: {
-                    axios: "0.21.4",
-                    "axios-retry": "3.1.9",
-                    "form-data": "4.0.0",
-                },
-            });
-            await injectAxiosToOpenAPI(basePath);
-            const filesToFormat = await getFilesToFormat(basePath);
-            await formatSourceFiles(basePath, filesToFormat);
-        }
-        this.log(`
+        else {
+            // Legacy code paths (mostly; keep the component generator call)
+            await (0, yeoman_1.runGenerator)("component", process.env.NODE_ENV === "test"
+                ? {
+                    name,
+                    description: "Prism-generated Component",
+                    connectionType: "basic",
+                    skipInstall: true,
+                }
+                : { name, skipInstall: Boolean(wsdlPath) });
+            // Need to pop back as the WSDL generator assumes it's a directory up
+            process.chdir(cwd);
+            if (wsdlPath) {
+                if (!verbose) {
+                    // wsdl-tsclient emits pretty noisy logs that aren't particularly useful
+                    logger_1.Logger.disabled();
+                }
+                const wsdlName = path.basename(wsdlPath).split(".wsdl")[0];
+                await (0, wsdl_tsclient_1.parseAndGenerate)(wsdlPath, name, {
+                    caseInsensitiveNames: true,
+                });
+                await (0, index_1.generate)({
+                    projectRoot: name,
+                    projectTemplateName: wsdlName,
+                    projectTemplatePath: wsdlPath,
+                });
+                await (0, index_1.updatePackageJson)({
+                    path: path.resolve(name, "package.json"),
+                    dependencies: { soap: "0.40.0" },
+                });
+                const filesToFormat = await getFilesToFormat(name);
+                await formatSourceFiles(name, filesToFormat);
+            }
+            this.log(`
 "${name}" is ready for development.
 To install dependencies, run either "npm install" or "yarn install"
 To test the component, run "npm run test" or "yarn test"
@@ -165,6 +113,7 @@ To publish the component, run "prism components:publish"
 
 For documentation on writing custom components, visit https://prismatic.io/docs/custom-components/writing-custom-components/
     `);
+        }
     }
 }
 exports.default = InitializeComponent;
@@ -178,21 +127,11 @@ InitializeComponent.flags = {
         required: false,
         description: "The path to an OpenAPI Specification file (JSON or YAML) used to generate a Component",
     }),
-    "skip-auth": core_1.Flags.boolean({
-        required: false,
-        default: false,
-        description: "Skip templating authentication for an OpenAPI-based component. Use this option for OpenAPI specs that do not require authentication.",
-    }),
     verbose: core_1.Flags.boolean({
         required: false,
         default: false,
         description: "Output more verbose logging from Component generation",
     }),
-    "add-retry": core_1.Flags.boolean({
-        required: false,
-        default: false,
-        description: "Add inputs to each action to utilize Axios retry logic",
-    }),
 };
 InitializeComponent.args = [
     {

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;