@expressots/cli 1.6.0 → 1.7.1

package/bin/generate/utils/command-utils.d.ts

@@ -0,0 +1,123 @@
+import { ExpressoConfig } from "../../types";
+export declare const enum PathStyle {
+    None = "none",
+    Single = "single",
+    Nested = "nested",
+    Sugar = "sugar"
+}
+/**
+ * File preparation
+ * @param schematic
+ * @param target
+ * @param method
+ * @param opinionated
+ * @param sourceRoot
+ * @returns the file output
+ */
+export type FilePreparation = {
+    schematic: string;
+    target: string;
+    method: string;
+    expressoConfig: ExpressoConfig;
+};
+/**
+ * File output
+ * @param path
+ * @param file
+ * @param className
+ * @param moduleName
+ * @param modulePath
+ * @param outputPath
+ * @param folderToScaffold
+ */
+export type FileOutput = {
+    path: string;
+    file: string;
+    className: string;
+    moduleName: string;
+    modulePath: string;
+    outputPath: string;
+    folderToScaffold: string;
+    fileName: string;
+    schematic: string;
+};
+/**
+ * Create a template based on the schematic
+ * @param fp
+ * @returns the file created
+ */
+export declare function validateAndPrepareFile(fp: FilePreparation): Promise<{
+    path: string;
+    file: string;
+    className: string;
+    moduleName: string;
+    modulePath: string;
+    outputPath: string;
+    folderToScaffold: string;
+    fileName: string;
+    schematic: string;
+}>;
+/**
+ * Get the file name without the extension
+ * @param filePath
+ * @returns the file name
+ */
+export declare function getFileNameWithoutExtension(filePath: string): string;
+/**
+ * Split the target into path, file, class name, module name and module path
+ * @param target
+ * @param schematic
+ * @returns the split target
+ */
+export declare const splitTarget: ({ target, schematic, }: {
+    target: string;
+    schematic: string;
+}) => Promise<{
+    path: string;
+    file: string;
+    className: string;
+    moduleName: string;
+    modulePath: string;
+}>;
+/**
+ * Write the template based on the http method
+ * @param method - the http method
+ * @returns decorator - the decorator to be used
+ */
+export declare const getHttpMethod: (method: string) => string;
+/**
+ * Write the template based on the schematics
+ * @param outputPath - the output path
+ * @param template - the template to be used
+ * @returns void
+ */
+export declare const writeTemplate: ({ outputPath, template: { path, data }, }: {
+    outputPath: string;
+    template: {
+        path: string;
+        data: Record<string, string>;
+    };
+}) => void;
+/**
+ * Returns the folder where the schematic should be placed
+ * @param schematic
+ */
+export declare const schematicFolder: (schematic: string) => string | undefined;
+/**
+ * Get the name with the scaffold pattern
+ * @param name
+ * @returns the name in the scaffold pattern
+ */
+export declare const getNameWithScaffoldPattern: (name: string) => Promise<string>;
+/**
+ * Extract the first word from a file and convert it to the scaffold pattern
+ * @param file
+ * @returns the first word in the scaffold pattern
+ */
+export declare function extractFirstWord(file: string): Promise<string>;
+/**
+ * Check if the path is a nested path, a single path or a sugar path
+ * @param path
+ * @returns the path style
+ */
+export declare const checkPathStyle: (path: string) => PathStyle;

package/bin/generate/utils/command-utils.js

@@ -0,0 +1,310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPathStyle = exports.extractFirstWord = exports.getNameWithScaffoldPattern = exports.schematicFolder = exports.writeTemplate = exports.getHttpMethod = exports.splitTarget = exports.getFileNameWithoutExtension = exports.validateAndPrepareFile = void 0;
+const node_fs_1 = require("node:fs");
+const nodePath = __importStar(require("node:path"));
+const mustache_1 = require("mustache");
+const boost_ts_1 = require("@expressots/boost-ts");
+const cli_ui_1 = require("../../utils/cli-ui");
+const verify_file_exists_1 = require("../../utils/verify-file-exists");
+const compiler_1 = __importDefault(require("../../utils/compiler"));
+/**
+ * Create a template based on the schematic
+ * @param fp
+ * @returns the file created
+ */
+async function validateAndPrepareFile(fp) {
+    const { sourceRoot, scaffoldSchematics, opinionated } = fp.expressoConfig;
+    if (sourceRoot === "") {
+        (0, cli_ui_1.printError)("You must specify a source root in your expressots.config.ts", "sourceRoot");
+        process.exit(1);
+    }
+    if (opinionated) {
+        const folderSchematic = (0, exports.schematicFolder)(fp.schematic);
+        const folderToScaffold = `${sourceRoot}/${folderSchematic}`;
+        const { path, file, className, moduleName, modulePath } = await (0, exports.splitTarget)({
+            target: fp.target,
+            schematic: fp.schematic,
+        });
+        const outputPath = `${folderToScaffold}/${path}/${file}`;
+        await (0, verify_file_exists_1.verifyIfFileExists)(outputPath, fp.schematic);
+        (0, node_fs_1.mkdirSync)(`${folderToScaffold}/${path}`, { recursive: true });
+        return {
+            path,
+            file,
+            className,
+            moduleName,
+            modulePath,
+            outputPath,
+            folderToScaffold,
+            fileName: getFileNameWithoutExtension(file),
+            schematic: fp.schematic,
+        };
+    }
+    const folderSchematic = "";
+    const folderToScaffold = `${sourceRoot}/${folderSchematic}`;
+    const { path, file, className, moduleName, modulePath } = await (0, exports.splitTarget)({
+        target: fp.target,
+        schematic: fp.schematic,
+    });
+    const fileBaseSchema = scaffoldSchematics === null || scaffoldSchematics === void 0 ? void 0 : scaffoldSchematics[fp.schematic];
+    const validateFileSchema = fileBaseSchema !== undefined
+        ? file.replace(fp.schematic, fileBaseSchema)
+        : file;
+    const outputPath = `${folderToScaffold}/${path}/${validateFileSchema}`;
+    await (0, verify_file_exists_1.verifyIfFileExists)(outputPath, fp.schematic);
+    (0, node_fs_1.mkdirSync)(`${folderToScaffold}/${path}`, { recursive: true });
+    return {
+        path,
+        file,
+        className,
+        moduleName,
+        modulePath,
+        outputPath,
+        folderToScaffold,
+        fileName: getFileNameWithoutExtension(file),
+        schematic: fileBaseSchema !== undefined ? fileBaseSchema : fp.schematic,
+    };
+}
+exports.validateAndPrepareFile = validateAndPrepareFile;
+/**
+ * Get the file name without the extension
+ * @param filePath
+ * @returns the file name
+ */
+function getFileNameWithoutExtension(filePath) {
+    return filePath.split(".")[0];
+}
+exports.getFileNameWithoutExtension = getFileNameWithoutExtension;
+/**
+ * Split the target into path, file, class name, module name and module path
+ * @param target
+ * @param schematic
+ * @returns the split target
+ */
+const splitTarget = async ({ target, schematic, }) => {
+    const pathContent = target
+        .split("/")
+        .filter((item) => item !== "");
+    const endsWithSlash = target.endsWith("/");
+    let path = "";
+    let fileName = "";
+    let module = "";
+    let modulePath = "";
+    if (target.includes("/") ||
+        target.includes("\\") ||
+        target.includes("//")) {
+        if (schematic === "service")
+            schematic = "controller";
+        if (schematic === "service" ||
+            (schematic === "controller" && pathContent.length > 4)) {
+            (0, cli_ui_1.printError)("Max path depth is 4.", pathContent.join("/"));
+            process.exit(1);
+        }
+        if (endsWithSlash) {
+            fileName = pathContent[pathContent.length - 1];
+            path = pathContent.join("/");
+            module =
+                pathContent.length == 1
+                    ? pathContent[pathContent.length - 1]
+                    : pathContent[pathContent.length - 2];
+            modulePath = pathContent.slice(0, -1).join("/");
+        }
+        else {
+            fileName = pathContent[pathContent.length - 1];
+            path = pathContent.slice(0, -1).join("/");
+            module =
+                pathContent.length == 2
+                    ? pathContent[pathContent.length - 2]
+                    : pathContent[pathContent.length - 3];
+            modulePath = pathContent.slice(0, -2).join("/");
+        }
+        return {
+            path,
+            file: `${await (0, exports.getNameWithScaffoldPattern)(fileName)}.${schematic}.ts`,
+            className: (0, boost_ts_1.anyCaseToPascalCase)(fileName),
+            moduleName: module,
+            modulePath,
+        };
+    }
+    else {
+        if (schematic === "service")
+            schematic = "controller";
+        // 1. Extract the name (first part of the target)
+        const [name, ...remainingPath] = target.split("/");
+        // 2. Check if the name is camelCase or kebab-case
+        const camelCaseRegex = /[A-Z]/;
+        const kebabCaseRegex = /[_\-\s]+/;
+        const isCamelCase = camelCaseRegex.test(name);
+        const isKebabCase = kebabCaseRegex.test(name);
+        if (isCamelCase || isKebabCase) {
+            const [wordName, ...path] = name === null || name === void 0 ? void 0 : name.split(isCamelCase ? /(?=[A-Z])/ : kebabCaseRegex).map((word) => word.toLowerCase());
+            return {
+                path: `${wordName}/${pathEdgeCase(path)}${pathEdgeCase(remainingPath)}`,
+                file: `${await (0, exports.getNameWithScaffoldPattern)(name)}.${schematic}.ts`,
+                className: (0, boost_ts_1.anyCaseToPascalCase)(name),
+                moduleName: wordName,
+                modulePath: pathContent[0].split("-")[1],
+            };
+        }
+        // 3. Return the base case
+        return {
+            path: "",
+            file: `${await (0, exports.getNameWithScaffoldPattern)(name)}.${schematic}.ts`,
+            className: (0, boost_ts_1.anyCaseToPascalCase)(name),
+            moduleName: name,
+            modulePath: "",
+        };
+    }
+};
+exports.splitTarget = splitTarget;
+/**
+ * Write the template based on the http method
+ * @param method - the http method
+ * @returns decorator - the decorator to be used
+ */
+const getHttpMethod = (method) => {
+    switch (method) {
+        case "put":
+            return "Put";
+        case "post":
+            return "Post";
+        case "patch":
+            return "Patch";
+        case "delete":
+            return "Delete";
+        default:
+            return "Get";
+    }
+};
+exports.getHttpMethod = getHttpMethod;
+/**
+ * Write the template based on the schematics
+ * @param outputPath - the output path
+ * @param template - the template to be used
+ * @returns void
+ */
+const writeTemplate = ({ outputPath, template: { path, data }, }) => {
+    (0, node_fs_1.writeFileSync)(outputPath, (0, mustache_1.render)((0, node_fs_1.readFileSync)(nodePath.join(__dirname, path), "utf8"), data));
+};
+exports.writeTemplate = writeTemplate;
+/**
+ * Returns the folder where the schematic should be placed
+ * @param schematic
+ */
+const schematicFolder = (schematic) => {
+    switch (schematic) {
+        case "usecase":
+            return "useCases";
+        case "controller":
+            return "useCases";
+        case "dto":
+            return "useCases";
+        case "service":
+            return "useCases";
+        case "provider":
+            return "providers";
+        case "entity":
+            return "entities";
+        case "middleware":
+            return "providers/middlewares";
+        case "module":
+            return "useCases";
+    }
+    return undefined;
+};
+exports.schematicFolder = schematicFolder;
+/**
+ * Get the name with the scaffold pattern
+ * @param name
+ * @returns the name in the scaffold pattern
+ */
+const getNameWithScaffoldPattern = async (name) => {
+    const configObject = await compiler_1.default.loadConfig();
+    switch (configObject.scaffoldPattern) {
+        case "lowercase" /* Pattern.LOWER_CASE */:
+            return (0, boost_ts_1.anyCaseToLowerCase)(name);
+        case "kebab-case" /* Pattern.KEBAB_CASE */:
+            return (0, boost_ts_1.anyCaseToKebabCase)(name);
+        case "PascalCase" /* Pattern.PASCAL_CASE */:
+            return (0, boost_ts_1.anyCaseToPascalCase)(name);
+        case "camelCase" /* Pattern.CAMEL_CASE */:
+            return (0, boost_ts_1.anyCaseToCamelCase)(name);
+    }
+};
+exports.getNameWithScaffoldPattern = getNameWithScaffoldPattern;
+/**
+ * Get the path edge case
+ * @param path
+ * @returns the path edge case from the last element of the path
+ */
+const pathEdgeCase = (path) => {
+    return `${path.join("/")}${path.length > 0 ? "/" : ""}`;
+};
+/**
+ * Extract the first word from a file and convert it to the scaffold pattern
+ * @param file
+ * @returns the first word in the scaffold pattern
+ */
+async function extractFirstWord(file) {
+    const f = file.split(".")[0];
+    const regex = /(?:-|(?<=[a-z])(?=[A-Z]))/;
+    const firstWord = f.split(regex)[0];
+    const config = await compiler_1.default.loadConfig();
+    switch (config.scaffoldPattern) {
+        case "lowercase" /* Pattern.LOWER_CASE */:
+            return (0, boost_ts_1.anyCaseToLowerCase)(firstWord);
+        case "kebab-case" /* Pattern.KEBAB_CASE */:
+            return (0, boost_ts_1.anyCaseToKebabCase)(firstWord);
+        case "PascalCase" /* Pattern.PASCAL_CASE */:
+            return (0, boost_ts_1.anyCaseToPascalCase)(firstWord);
+        case "camelCase" /* Pattern.CAMEL_CASE */:
+            return (0, boost_ts_1.anyCaseToCamelCase)(firstWord);
+    }
+}
+exports.extractFirstWord = extractFirstWord;
+/**
+ * Check if the path is a nested path, a single path or a sugar path
+ * @param path
+ * @returns the path style
+ */
+const checkPathStyle = (path) => {
+    const singleOrNestedPathRegex = /\/|\\/;
+    const sugarPathRegex = /^\w+-\w+$/;
+    if (singleOrNestedPathRegex.test(path)) {
+        return "nested" /* PathStyle.Nested */;
+    }
+    else if (sugarPathRegex.test(path)) {
+        return "sugar" /* PathStyle.Sugar */;
+    }
+    else {
+        return "single" /* PathStyle.Single */;
+    }
+};
+exports.checkPathStyle = checkPathStyle;

package/bin/generate/utils/nonopininated-cmd.d.ts

@@ -0,0 +1,9 @@
+import { ExpressoConfig } from "../../@types";
+/**
+ * Process the non-opinionated command
+ * @param schematic - The schematic
+ * @param target - The target
+ * @param method - The method
+ * @param expressoConfig - The expresso config
+ */
+export declare function nonOpinionatedProcess(schematic: string, target: string, method: string, expressoConfig: ExpressoConfig): Promise<string>;

package/bin/generate/utils/nonopininated-cmd.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonOpinionatedProcess = void 0;
+const boost_ts_1 = require("@expressots/boost-ts");
+const cli_ui_1 = require("../../utils/cli-ui");
+const command_utils_1 = require("./command-utils");
+/**
+ * Process the non-opinionated command
+ * @param schematic - The schematic
+ * @param target - The target
+ * @param method - The method
+ * @param expressoConfig - The expresso config
+ */
+async function nonOpinionatedProcess(schematic, target, method, expressoConfig) {
+    let f = await (0, command_utils_1.validateAndPrepareFile)({
+        schematic,
+        target,
+        method,
+        expressoConfig,
+    });
+    switch (schematic) {
+        case "service":
+            f = await (0, command_utils_1.validateAndPrepareFile)({
+                schematic: "controller",
+                target,
+                method,
+                expressoConfig,
+            });
+            await generateController(f.outputPath, f.className, f.path, method, f.file, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            f = await (0, command_utils_1.validateAndPrepareFile)({
+                schematic: "usecase",
+                target,
+                method,
+                expressoConfig,
+            });
+            await generateUseCase(f.outputPath, f.className, f.moduleName, f.path, f.fileName, f.schematic, "../templates/nonopinionated/usecase.tpl");
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            f = await (0, command_utils_1.validateAndPrepareFile)({
+                schematic: "dto",
+                target,
+                method,
+                expressoConfig,
+            });
+            await generateDTO(f.outputPath, f.className, f.moduleName, f.path, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            f = await (0, command_utils_1.validateAndPrepareFile)({
+                schematic: "module",
+                target,
+                method,
+                expressoConfig,
+            });
+            await generateModule(f.outputPath, f.className, f.moduleName, f.path, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            break;
+        case "usecase":
+            await generateUseCase(f.outputPath, f.className, f.moduleName, f.path, f.fileName, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            break;
+        case "controller":
+            await generateController(f.outputPath, f.className, f.path, method, f.file, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            break;
+        case "dto":
+            await generateDTO(f.outputPath, f.className, f.moduleName, f.path, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            break;
+        case "provider":
+            await generateProvider(f.outputPath, f.className, f.moduleName, f.path, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            break;
+        case "entity":
+            await generateEntity(f.outputPath, f.className, f.moduleName, f.path, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            break;
+        case "middleware":
+            await generateMiddleware(f.outputPath, f.className, f.moduleName, f.path, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            break;
+        case "module":
+            await generateModule(f.outputPath, f.className, f.moduleName, f.path, f.schematic);
+            await (0, cli_ui_1.printGenerateSuccess)(f.schematic, f.file);
+            break;
+    }
+    return f.file;
+}
+exports.nonOpinionatedProcess = nonOpinionatedProcess;
+/* Generate Resource */
+/**
+ * Generate a use case
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ * @param template - The template
+ */
+async function generateUseCase(outputPath, className, moduleName, path, fileName, schematic, template) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: template
+                ? template
+                : "../templates/nonopinionated/usecase.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+                fileName,
+                schematic: (0, boost_ts_1.anyCaseToPascalCase)(schematic),
+            },
+        },
+    });
+}
+/**
+ * Generate a controller
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param path - The path
+ * @param method - The method
+ * @param file - The file
+ */
+async function generateController(outputPath, className, path, method, file, schematic) {
+    const templateBasedMethod = "../templates/nonopinionated/controller.tpl";
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: templateBasedMethod,
+            data: {
+                className,
+                fileName: (0, command_utils_1.getFileNameWithoutExtension)(file),
+                useCase: (0, boost_ts_1.anyCaseToCamelCase)(className),
+                route: className
+                    ? className.toLowerCase()
+                    : path.replace(/\/$/, ""),
+                construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
+                method: (0, command_utils_1.getHttpMethod)(method),
+                schematic: (0, boost_ts_1.anyCaseToPascalCase)(schematic),
+            },
+        },
+    });
+}
+/**
+ * Generate a DTO
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateDTO(outputPath, className, moduleName, path, schematic) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/nonopinionated/dto.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+                schematic: (0, boost_ts_1.anyCaseToPascalCase)(schematic),
+            },
+        },
+    });
+}
+/**
+ * Generate a provider
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateProvider(outputPath, className, moduleName, path, schematic) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/nonopinionated/provider.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+                schematic: (0, boost_ts_1.anyCaseToPascalCase)(schematic),
+            },
+        },
+    });
+}
+/**
+ * Generate an entity
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateEntity(outputPath, className, moduleName, path, schematic) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/nonopinionated/entity.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+                schematic: (0, boost_ts_1.anyCaseToPascalCase)(schematic),
+            },
+        },
+    });
+}
+/**
+ * Generate a middleware
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateMiddleware(outputPath, className, moduleName, path, schematic) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/nonopinionated/middleware.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+                schematic: (0, boost_ts_1.anyCaseToPascalCase)(schematic),
+            },
+        },
+    });
+}
+/**
+ * Generate a module
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateModule(outputPath, className, moduleName, path, schematic) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/nonopinionated/module.tpl",
+            data: {
+                className,
+                moduleName: className
+                    ? (0, boost_ts_1.anyCaseToPascalCase)(className)
+                    : (0, boost_ts_1.anyCaseToPascalCase)(moduleName),
+                path,
+                schematic: (0, boost_ts_1.anyCaseToPascalCase)(schematic),
+            },
+        },
+    });
+}

package/bin/generate/utils/opinionated-cmd.d.ts

@@ -0,0 +1,11 @@
+import { ExpressoConfig } from "../../@types";
+/**
+ * Process commands for opinionated service scaffolding
+ * @param schematic - Resource to scaffold
+ * @param target - Target path
+ * @param method - HTTP method
+ * @param expressoConfig - Expresso configuration [expressots.config.ts]
+ * @param pathStyle - Path command style [sugar, nested, single]
+ * @returns
+ */
+export declare function opinionatedProcess(schematic: string, target: string, method: string, expressoConfig: ExpressoConfig, pathStyle: string): Promise<string>;