@prismatic-io/prism 3.3.0 → 4.2.0

package/lib/generate/action.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -14,19 +18,10 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -49,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 = 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 = 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};
       }`;
@@ -100,8 +69,8 @@ const generateActionObject = (methodSignature, project) => {
         .map((parameter) => {
         const input = {
             name: parameter.getName(),
-            properties: input_1.getActionMethodInputProperties(parameter, parse_1.getParamTypeDefinition(project, parameter)),
-            paramTypeDefinition: parse_1.getParamTypeDefinition(project, parameter),
+            properties: (0, input_1.getActionMethodInputProperties)(parameter, (0, parse_1.getParamTypeDefinition)(project, parameter)),
+            paramTypeDefinition: (0, parse_1.getParamTypeDefinition)(project, parameter),
         };
         input.shouldImport =
             (input.properties.length > 0 &&
@@ -120,9 +89,9 @@ const compileAction = (actionService, actionMethod, project) => {
     var _a;
     return ({
         service: actionService,
-        key: camelcase_1.default(actionMethod.getName()),
+        key: (0, camelcase_1.default)(actionMethod.getName()),
         display: {
-            label: camelcase_1.default(actionMethod.getName(), { pascalCase: true })
+            label: (0, camelcase_1.default)(actionMethod.getName(), { pascalCase: true })
                 .split(/(?=[A-Z])/)
                 .join(" "),
             description: ((_a = actionMethod.getJsDocs()) === null || _a === void 0 ? void 0 : _a.length) > 0
@@ -133,7 +102,7 @@ const compileAction = (actionService, actionMethod, project) => {
         actionObject: generateActionObject(actionMethod, project),
     });
 };
-const writeAction = (action, project, includeClient, addRetry) => __awaiter(void 0, void 0, void 0, function* () {
+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
@@ -152,41 +121,29 @@ const writeAction = (action, project, includeClient, addRetry) => __awaiter(void
         }
         return shouldImport ? [name] : [];
     });
-    const updatedInputFields = util_1.appendRequiredFields({
-        inputFields: includeClient
-            ? [
-                `connection: { type: "connection", label: "connection", required: true }`,
-                ...inputFields,
-            ]
-            : inputFields,
-        includeClient,
-        addRetry,
-    });
     object.addPropertyAssignments([
         {
             name: "display",
             initializer: `{
       label: "${action.display.label}",
-      description: \`${util_1.createDescription(action.display.description)}\`
+      description: \`${(0, util_1.createDescription)(action.display.description)}\`
       }`,
         },
         {
             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
@@ -203,63 +160,49 @@ const writeAction = (action, project, includeClient, addRetry) => __awaiter(void
     // Remove the temporary action object now that we've placed our payload
     // into the action
     placeholder.remove();
-});
-const writeServicesImport = (services, { actionFile, definitionDirectory }) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const writeServicesImport = async (services, { actionFile, definitionDirectory }) => {
     actionFile.addImportDeclaration({
         moduleSpecifier: `../${definitionDirectory}/index`,
         namedImports: services,
     });
-});
-const writeInputsImport = (inputNames, { actionFile }) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const writeInputsImport = async (inputNames, { actionFile }) => {
     actionFile.addImportDeclaration({
         moduleSpecifier: "./inputs",
         namedImports: inputNames,
     });
-});
-exports.generateActions = (project, includeClient, addRetry) => __awaiter(void 0, void 0, void 0, function* () {
-    const { projectType, actionFile, inputsFile } = project;
-    if (projectType === "openApi" && includeClient) {
-        actionFile.addImportDeclarations([
-            {
-                moduleSpecifier: `./client`,
-                namedImports: ["initializeClient"],
-            },
-        ]);
-    }
-    const methods = parse_1.getActionMethods(project);
-    const actions = lodash_1.sortBy(Object.entries(methods).flatMap(([service, actionMethods]) => {
-        const dedupedActions = lodash_1.uniqBy(actionMethods, (a) => a.getName());
+};
+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());
         return dedupedActions.map((action) => compileAction(service, action, project));
     }), ({ key }) => key);
     const inputs = actions
         .flatMap(({ actionObject }) => actionObject.inputs)
         .filter(({ shouldImport }) => shouldImport)
         .flatMap(({ properties }) => properties);
-    const dedupedInputs = lodash_1.sortBy(lodash_1.uniqBy(inputs, (i) => i.propertyName.toLowerCase()), (i) => i.propertyName);
-    yield input_1.writeInputs(project, dedupedInputs);
+    const dedupedInputs = (0, lodash_1.sortBy)((0, lodash_1.uniqBy)(inputs, (i) => i.propertyName.toLowerCase()), (i) => i.propertyName);
+    await (0, input_1.writeInputs)(project, dedupedInputs);
     inputsFile.organizeImports();
     inputsFile.formatText();
-    yield inputsFile.save();
+    await inputsFile.save();
     const services = actions.map(({ service }) => service);
-    const dedupedServices = lodash_1.sortBy(lodash_1.uniq(services));
-    yield writeServicesImport(dedupedServices, project);
+    const dedupedServices = (0, lodash_1.sortBy)((0, lodash_1.uniq)(services));
+    await writeServicesImport(dedupedServices, project);
     const inputNames = dedupedInputs.map(({ propertyName }) => propertyName);
-    yield writeInputsImport(projectType === "openApi"
-        ? (yield util_1.appendRequiredFields({
-            inputFields: inputNames,
-            includeClient,
-            addRetry,
-        })) || []
-        : inputNames, project);
-    const actionPromises = actions.map((action) => writeAction(action, project, includeClient, projectType === "openApi" && addRetry));
-    yield Promise.all(actionPromises);
-    const actionExports = lodash_1.sortBy(actions.map(({ key }) => key));
+    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({
         isExportEquals: false,
         expression: `{${actionExports.join(",\n")}}`,
     });
     actionFile.organizeImports();
     actionFile.formatText();
-    yield actionFile.save();
-});
-//# sourceMappingURL=action.js.map
+    await actionFile.save();
+};
+exports.generateActions = generateActions;

package/lib/generate/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -14,37 +18,37 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generate = void 0;
+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");
-exports.generate = ({ projectRoot, projectTemplateName, projectTemplatePath, projectType, includeClient, addRetry, }) => __awaiter(void 0, void 0, void 0, function* () {
+const prettier_1 = __importDefault(require("prettier"));
+const fs_extra_1 = require("fs-extra");
+const generate = async ({ projectRoot, projectTemplateName, projectTemplatePath, }) => {
     var _a;
-    const project = 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) {
-        yield client_1.generateClient(project);
-        yield connection_1.generateConnections(project);
-    }
-    yield 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();
-    yield componentProject.save();
-});
-//# sourceMappingURL=index.js.map
+    await componentProject.save();
+};
+exports.generate = generate;
+const updatePackageJson = async ({ path, dependencies = {}, devDependencies = {}, }) => {
+    const contents = await (0, fs_extra_1.readJson)(path, { encoding: "utf-8" });
+    Object.assign(contents.dependencies, dependencies);
+    Object.assign(contents.devDependencies, devDependencies);
+    const formatted = prettier_1.default.format(JSON.stringify(contents, null, 2), {
+        parser: "json",
+    });
+    await (0, fs_extra_1.writeFile)(path, formatted);
+};
+exports.updatePackageJson = updatePackageJson;

package/lib/generate/input.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -15,39 +6,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeInputs = exports.getActionMethodInputProperties = void 0;
 const ts_morph_1 = require("ts-morph");
 const camelcase_1 = __importDefault(require("camelcase"));
-exports.getActionMethodInputProperties = (parameter, parameterTypeDefinition) => {
+const getActionMethodInputProperties = (parameter, parameterTypeDefinition) => {
     const paramName = parameter.getName();
     const propertyStructures = [];
     if (parameterTypeDefinition) {
-        try {
-            const paramDefinition = parameterTypeDefinition.getInterfaceOrThrow(camelcase_1.default(!paramName.includes("Param")
-                ? paramName
-                : paramName.split("Param")[0], { pascalCase: true }));
-            const paramProperties = paramDefinition.getProperties();
-            paramProperties.forEach((property) => {
-                // If its a single numeric the import of the input field will fail
-                // Assume single character inputs just suck
-                // and set it as a modified field
-                const [propertyName, modified] = property.getName().length !== 1
-                    ? [property.getName(), false]
-                    : [`param${property.getName()}`, true];
-                const propertyType = property.getType().getText(property);
-                const propertyStructure = {
-                    propertyName,
-                    modified,
-                    originalName: property.getName(),
-                    type: ["string", "boolean"].includes(propertyType)
-                        ? propertyType
-                        : "data",
-                    required: property.getType().isNullable(),
-                    inputFieldName: propertyName,
-                };
-                propertyStructures.push(propertyStructure);
-            });
-        }
-        catch (error) {
-            throw new Error(error);
-        }
+        const paramDefinition = parameterTypeDefinition.getInterfaceOrThrow((0, camelcase_1.default)(!paramName.includes("Param") ? paramName : paramName.split("Param")[0], { pascalCase: true }));
+        const paramProperties = paramDefinition.getProperties();
+        paramProperties.forEach((property) => {
+            // If its a single numeric the import of the input field will fail
+            // Assume single character inputs just suck
+            // and set it as a modified field
+            const [propertyName, modified] = property.getName().length !== 1
+                ? [property.getName(), false]
+                : [`param${property.getName()}`, true];
+            const propertyType = property.getType().getText(property);
+            const propertyStructure = {
+                propertyName,
+                modified,
+                originalName: property.getName(),
+                type: ["string", "boolean"].includes(propertyType)
+                    ? propertyType
+                    : "data",
+                required: property.getType().isNullable(),
+                inputFieldName: propertyName,
+            };
+            propertyStructures.push(propertyStructure);
+        });
     }
     else {
         const propertyType = parameter.getType().getText(parameter);
@@ -65,7 +49,8 @@ exports.getActionMethodInputProperties = (parameter, parameterTypeDefinition) =>
     }
     return propertyStructures;
 };
-exports.writeInputs = ({ inputsFile }, inputs) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getActionMethodInputProperties = getActionMethodInputProperties;
+const writeInputs = async ({ inputsFile }, inputs) => {
     inputs.forEach((propertyStructure) => {
         const placeholder = inputsFile.addVariableStatement({
             declarationKind: ts_morph_1.VariableDeclarationKind.Const,
@@ -79,7 +64,7 @@ exports.writeInputs = ({ inputsFile }, inputs) => __awaiter(void 0, void 0, void
         object.addPropertyAssignments([
             {
                 name: "label",
-                initializer: `"${camelcase_1.default(propertyStructure.propertyName, {
+                initializer: `"${(0, camelcase_1.default)(propertyStructure.propertyName, {
                     pascalCase: true,
                 })}"`,
             },
@@ -104,5 +89,5 @@ exports.writeInputs = ({ inputsFile }, inputs) => __awaiter(void 0, void 0, void
         });
         placeholder.remove();
     });
-});
-//# sourceMappingURL=input.js.map
+};
+exports.writeInputs = writeInputs;

package/lib/generate/parse.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -14,7 +18,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
 };
@@ -37,81 +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);
-    }
-};
-exports.getParamTypeDefinition = (project, parameter) => {
-    const { componentProject, projectType, projectRoot, definitionDirectory, } = project;
-    try {
-        if (projectType === "wsdl") {
-            const paramName = parameter.getName();
-            return componentProject.getSourceFileOrThrow(path.join(projectRoot, definitionDirectory, "definitions", `${camelcase_1.default(!paramName.includes("Param")
-                ? paramName
-                : paramName.split("Param")[0], {
-                pascalCase: true,
-            })}.ts`));
-        }
-        else if (projectType === "openApi") {
-            //Base types and literal unions don't have definition files
-            parameter
-                .getType()
-                .getUnionTypes()
-                .every((type) => {
-                return (["string", "boolean", "number", "any"].includes(type.getText()) ||
-                    type.isObject() ||
-                    type.isLiteral());
-            });
-            if (["string", "boolean", "number"].includes(parameter.getType().getText(parameter)) ||
-                parameter
-                    .getType()
-                    .getUnionTypes()
-                    .every((type) => ["string", "boolean", "number", "any"].includes(type.getText()) ||
-                    type.isObject() ||
-                    type.isLiteral())) {
-                return undefined;
-            }
-            return componentProject.getSourceFileOrThrow(path.join(projectRoot, definitionDirectory, "models", `${camelcase_1.default(parameter.getName(), {
-                pascalCase: true,
-            })}.ts`));
-        }
-        else {
-            console.error("Not implemented");
-            process.exit(1);
-        }
-    }
-    catch (error) {
-        console.error("Unable to find parameter definition file" + error);
-        process.exit(1);
-    }
+const getParamTypeDefinition = (project, parameter) => {
+    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
-exports.getActionMethods = (projectStructure) => {
+const getActionMethods = (projectStructure) => {
     const { projectRoot, componentProject, projectTemplateName, definitionDirectory, } = projectStructure;
-    let serviceMethods = {};
-    if (projectStructure.projectType === "wsdl") {
-        const methods = getWSDLClientMethods(path.join(projectRoot, definitionDirectory, "client.ts"), `${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),
+    };
 };
-//# sourceMappingURL=parse.js.map
+exports.getActionMethods = getActionMethods;

package/lib/generate/sourceFile.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -14,7 +18,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
 };
@@ -26,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({
@@ -35,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({
@@ -56,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
@@ -73,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;
 };
-exports.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) {
-        util_1.addRequiredInputs(projectType, inputsFile, addRetry);
-    }
     const project = {
         projectRoot,
-        projectTemplateName: camelcase_1.default(projectTemplateName),
-        definitionDirectory: projectType === "wsdl"
-            ? camelcase_1.default(projectTemplateName).toLowerCase()
-            : projectTemplateName,
+        projectTemplateName: (0, camelcase_1.default)(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;
 };
-//# sourceMappingURL=sourceFile.js.map
+exports.initializeProject = initializeProject;