autoforce 0.1.17 → 0.1.19

package/lib/helpers/tasks.d.ts

@@ -1,12 +1,9 @@
 import { ITask } from "../types/helpers/tasks.js";
 import { AnyValue, CommandOptions, ObjectRecord } from "../types/auto.js";
-export declare const TASKS_FOLDER: string;
-export declare const SUBTASKS_FOLDER: string;
-export declare const NEW_FOLDER: string;
-export declare function getTaskFolder(command: string): string;
-export declare function getTasks(folder?: string): Record<string, ITask>;
+export declare function getTaskFolders(command?: string): string[];
+export declare function getTasks(command?: string): Record<string, ITask>;
 export declare function helpTask(task: ITask): Promise<boolean>;
 export declare function validateTask(task: ITask): boolean;
 export declare function runTask(task: ITask, taskContext: CommandOptions, tabs?: string): Promise<boolean>;
-export declare function previewTask(task: ITask, tabs?: string): Promise<void>;
+export declare function previewTask(task: ITask, taskContext: CommandOptions, tabs?: string): Promise<boolean>;
 export declare function createObject(fields: ObjectRecord, values: AnyValue[]): ObjectRecord;

package/lib/helpers/tasks.js

@@ -1,30 +1,15 @@
-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());
-    });
-};
 import context, { initializeContext } from "./context.js";
 import { logError, logStep } from "./color.js";
-import fs from "fs";
-import { getFiles, filterJson, searchInFolderHierarchy } from "./util.js";
+import { getModelFolders, getFiles, filterJson, readJsonSync } from "./util.js";
 import { validateCommand, validateFunction, executeFunction, executeCommand, taskFunctions } from "./taskFunctions.js";
 import prompts from "prompts";
-import { fileURLToPath } from 'url';
-const COMMAND_FOLDER = searchInFolderHierarchy('commands', fileURLToPath(import.meta.url));
-export const TASKS_FOLDER = `${COMMAND_FOLDER}/${context.model}/tasks`;
-export const SUBTASKS_FOLDER = `${COMMAND_FOLDER}/${context.model}/subtasks`;
-export const NEW_FOLDER = `${COMMAND_FOLDER}/${context.model}/new`;
-export function getTaskFolder(command) {
+export function getTaskFolders(command = 'task') {
     const folders = {
-        'task': TASKS_FOLDER,
-        'subtask': SUBTASKS_FOLDER,
-        'tasks': TASKS_FOLDER,
-        'subtasks': SUBTASKS_FOLDER,
-        'new': NEW_FOLDER
+        'task': getModelFolders('tasks'),
+        'subtask': getModelFolders('subtasks'),
+        'tasks': getModelFolders('tasks'),
+        'subtasks': getModelFolders('subtasks'),
+        'new': getModelFolders('new')
     };
     return folders[command.toLowerCase()] || folders.tasks;
 }
@@ -32,22 +17,33 @@ function getTaskLists(folder) {
     const files = getFiles(folder, filterJson);
     return files.map(filename => filename.split(".")[0]);
 }
-export function getTasks(folder = TASKS_FOLDER) {
+export function getTasks(command = 'tasks') {
+    const folders = getTaskFolders(command);
     const tasks = {};
-    for (const taskName of getTaskLists(folder)) {
-        tasks[taskName] = getTask(taskName, folder);
+    for (const folder of folders) {
+        for (const taskName of getTaskLists(folder)) {
+            const filename = folder + "/" + taskName + ".json";
+            const task = readJsonSync(filename);
+            tasks[taskName] = tasks[taskName] ? mergeTask(tasks[taskName], task) : task;
+        }
     }
     return tasks;
 }
-function getTask(taskName, folder) {
-    const filename = folder + "/" + taskName + ".json";
-    const content = fs.readFileSync(filename, "utf8");
-    try {
-        return JSON.parse(content);
-    }
-    catch (_a) {
-        throw new Error(`Verifique que el ${filename} sea json valido`);
+function mergeTask(newTask, oldTask) {
+    const newSteps = newTask.steps ? [...newTask.steps, ...oldTask.steps] : oldTask.steps;
+    const newArguments = newTask.arguments ? { ...newTask.arguments, ...oldTask.arguments } : oldTask.arguments;
+    const newGuards = newTask.guards ? [...newTask.guards, ...oldTask.guards] : oldTask.guards;
+    const newVerbose = newTask.verbose || oldTask.verbose;
+    const newDescription = newTask.description ? newTask.description + ' ' + oldTask.description : oldTask.description;
+    const mergedTask = { name: newTask.name, verbose: newVerbose, description: newDescription, arguments: newArguments, guards: newGuards, steps: newSteps };
+    return mergedTask;
+}
+function getTask(taskName, subfolder) {
+    const tasks = getTasks(subfolder);
+    if (!tasks[taskName]) {
+        throw new Error(`Verifique que el ${taskName} exista en alguno las subcarpetas de ${subfolder}`);
     }
+    return tasks[taskName];
 }
 function isCriteriaMet(criteria) {
     if (!criteria) {
@@ -62,14 +58,12 @@ function isCriteriaMet(criteria) {
     const result = context[field] == value;
     return result;
 }
-export function helpTask(task) {
-    return __awaiter(this, void 0, void 0, function* () {
-        console.log('Nombre:', task.name);
-        console.log('Descripcion:', task.description);
-        console.log('Guards:', task.guards);
-        console.log('Argumentos:', task.arguments);
-        return true;
-    });
+export async function helpTask(task) {
+    console.log('Nombre:', task.name);
+    console.log('Descripcion:', task.description);
+    console.log('Guards:', task.guards);
+    console.log('Argumentos:', task.arguments);
+    return true;
 }
 export function validateTask(task) {
     initializeContext();
@@ -92,11 +86,11 @@ export function validateTask(task) {
             validateStep = validateFunction(step);
         }
         else if (typeof step.subtask === 'string') {
-            const subtask = getTask(step.subtask, SUBTASKS_FOLDER);
+            const subtask = getTask(step.subtask, 'subtasks');
             validateStep = validateTask(subtask);
         }
         else if (typeof step.task === 'string') {
-            const subtask = getTask(step.task, TASKS_FOLDER);
+            const subtask = getTask(step.task, 'tasks');
             validateStep = validateTask(subtask);
         }
         else {
@@ -108,54 +102,51 @@ export function validateTask(task) {
     }
     return true;
 }
-export function runTask(task_1, taskContext_1) {
-    return __awaiter(this, arguments, void 0, function* (task, taskContext, tabs = '') {
-        initializeContext();
-        // Valida que este ya esten las variables de enotorno y  configuracion
-        if (task.guards) {
-            yield context.validate(task.guards);
-        }
-        // Pide datos de entrada y los deja en context
-        if (task.arguments) {
-            if (taskContext) {
-                context.setObject(taskContext);
-            }
-            yield context.askForArguments(task.arguments);
-        }
-        if (task.verbose) {
-            logStep(`[INICIO] ${task.name}`, tabs);
+export async function runTask(task, taskContext, tabs = '') {
+    initializeContext();
+    // Valida que este ya esten las variables de enotorno y  configuracion
+    if (task.guards) {
+        await context.validate(task.guards);
+    }
+    // Pide datos de entrada y los deja en context
+    if (task.arguments) {
+        if (taskContext) {
+            context.setObject(taskContext);
         }
-        for (const step of task.steps) {
-            if (isCriteriaMet(step.criteria)) {
-                if (!(yield executeStep(step, tabs + '\t', task.verbose))) {
-                    return false;
-                }
+        await context.askForArguments(task.arguments);
+    }
+    if (task.verbose) {
+        logStep(`[INICIO] ${task.name}`, tabs);
+    }
+    for (const step of task.steps) {
+        if (isCriteriaMet(step.criteria)) {
+            if (!await executeStep(step, tabs + '\t', task.verbose)) {
+                return false;
             }
         }
-        if (task.verbose) {
-            logStep(`[FIN] ${task.name}`, tabs);
-        }
-        return true;
-    });
+    }
+    if (task.verbose) {
+        logStep(`[FIN] ${task.name}`, tabs);
+    }
+    return true;
 }
-export function previewTask(task_1) {
-    return __awaiter(this, arguments, void 0, function* (task, tabs = '') {
-        initializeContext();
-        logStep(`${task.name}: ${task.description}`, tabs);
-        for (const step of task.steps) {
-            previewStep(step, tabs);
-        }
-    });
+export async function previewTask(task, taskContext, tabs = '') {
+    initializeContext();
+    logStep(`${task.name}: ${task.description}`, tabs);
+    for (const step of task.steps) {
+        previewStep(step, taskContext, tabs);
+    }
+    return true;
 }
-function previewStep(step, tabs = '') {
+function previewStep(step, taskContext, tabs = '') {
     if (step.criteria) {
         logStep(`Si ${step.criteria.field} ${step.criteria.operator || '=='} ${step.criteria.value}`, tabs);
         tabs += '\t';
     }
     if (step.subtask) {
         tabs += '\t';
-        const subtask = getTask(step.subtask, SUBTASKS_FOLDER);
-        previewTask(subtask, tabs);
+        const subtask = getTask(step.subtask, 'subtasks');
+        previewTask(subtask, taskContext, tabs);
     }
     else {
         logStep(`${step.name}`, tabs);
@@ -172,83 +163,77 @@ export function createObject(fields, values) {
     }
     return argsObject;
 }
-function runStep(step, tabs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof step.command === 'string') {
-            return executeCommand(step);
-        }
-        else if (typeof step.function === 'string') {
-            return yield executeFunction(step);
+async function runStep(step, tabs) {
+    if (typeof step.command === 'string') {
+        return executeCommand(step);
+    }
+    else if (typeof step.function === 'string') {
+        return await executeFunction(step);
+    }
+    else if (typeof step.subtask === 'string' || typeof step.task === 'string') {
+        const subtask = typeof step.subtask === 'string' ? getTask(step.subtask, 'subtask') : getTask(step.task, 'tasks');
+        let stepContext = step.arguments ? context.mergeArgs(step.arguments) : {};
+        if (Array.isArray(stepContext)) {
+            stepContext = createObject(subtask.arguments, stepContext);
         }
-        else if (typeof step.subtask === 'string' || typeof step.task === 'string') {
-            const subtask = typeof step.subtask === 'string' ? getTask(step.subtask, SUBTASKS_FOLDER) : getTask(step.task, TASKS_FOLDER);
-            let stepContext = step.arguments ? context.mergeArgs(step.arguments) : {};
-            if (Array.isArray(stepContext)) {
-                stepContext = createObject(subtask.arguments, stepContext);
-            }
-            return yield runTask(subtask, stepContext, tabs);
-        }
-        throw new Error(`No se pudo ejecutar el step ${step.name} porque no tiene command, function o subtasks`);
-    });
-}
-function askForContinueOrRetry() {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!context.isVerbose) {
-            return 'quit';
-        }
-        const answer = yield prompts([
-            {
-                type: "select",
-                name: "continue",
-                message: "No se pudo ejecutar el step, ¿que quiere hacer? ",
-                choices: [{ title: 'Salir', value: 'quit' }, { title: 'Continuar', value: 'continue' }, { title: 'Reintentar', value: 'retry' }],
-            }
-        ]);
-        return answer.continue;
-    });
+        return await runTask(subtask, stepContext, tabs);
+    }
+    throw new Error(`No se pudo ejecutar el step ${step.name} porque no tiene command, function o subtasks`);
+}
+async function askForContinueOrRetry() {
+    if (!context.isVerbose) {
+        return 'quit';
+    }
+    const answer = await prompts([
+        {
+            type: "select",
+            name: "continue",
+            message: "No se pudo ejecutar el step, ¿que quiere hacer? ",
+            choices: [{ title: 'Salir', value: 'quit' }, { title: 'Continuar', value: 'continue' }, { title: 'Reintentar', value: 'retry' }],
+        }
+    ]);
+    return answer.continue;
 }
 function getStepError(step, stepName) {
     return step.errorMessage ? context.merge(step.errorMessage) : stepName ? `Fallo el step ${stepName}` : '';
 }
-function executeStep(step_1, tabs_1) {
-    return __awaiter(this, arguments, void 0, function* (step, tabs, verbose = false) {
-        const stepName = step.name ? context.merge(step.name) : undefined;
-        if (verbose && stepName) {
-            logStep(`[INICIO] ${stepName}`, tabs);
-        }
-        let retry = false;
-        let success = false;
-        do {
-            try {
-                success = yield runStep(step, tabs);
-                if (!success) {
-                    logError(getStepError(step, stepName), tabs);
-                    // Si tiene un custom handler cuando hay un error
-                    if (step.onError) {
-                        const errorHandler = taskFunctions[step.onError];
-                        if (typeof errorHandler === 'function') {
-                            success = yield errorHandler();
-                        }
+async function executeStep(step, tabs, verbose = false) {
+    const stepName = step.name ? context.merge(step.name) : undefined;
+    if (verbose && stepName) {
+        logStep(`[INICIO] ${stepName}`, tabs);
+    }
+    let retry = false;
+    let success = false;
+    do {
+        try {
+            success = await runStep(step, tabs);
+            if (!success) {
+                logError(getStepError(step, stepName), tabs);
+                // Si tiene un custom handler cuando hay un error
+                if (step.onError) {
+                    const errorHandler = taskFunctions[step.onError];
+                    if (typeof errorHandler === 'function') {
+                        success = await errorHandler();
                     }
                 }
             }
-            catch (error) {
-                if (error instanceof Error) {
-                    logError(error.message, tabs);
-                }
-            }
-            if (!success) {
-                const result = yield askForContinueOrRetry();
-                retry = result == 'retry';
-                success = result == 'continue';
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logError(error.message, tabs);
             }
-        } while (!success && retry);
-        if (verbose && stepName) {
-            logStep(`[FIN] ${stepName}`, tabs);
         }
         if (!success) {
-            process.exit(!context.isVerbose ? -1 : 0);
+            const result = await askForContinueOrRetry();
+            retry = result == 'retry';
+            success = result == 'continue';
         }
-        return success;
-    });
+    } while (!success && retry);
+    if (verbose && stepName) {
+        logStep(`[FIN] ${stepName}`, tabs);
+    }
+    if (!success) {
+        process.exit(!context.isVerbose ? -1 : 0);
+    }
+    return success;
 }

package/lib/helpers/template.d.ts

@@ -1,15 +1,19 @@
-declare class TemplateEngine {
+export declare class TemplateEngine {
     _template: HandlebarsTemplateDelegate | undefined;
     _rendered: string | undefined;
     _extension: string;
-    _sourceFolder: string;
-    constructor(source: string, extension?: string);
+    _sourceFolders: string[];
+    constructor(sources: string[], extension?: string);
     getTemplates(): string[];
-    getNameAndExtension(templateName: string): string[];
+    findTemplateByName(templateName: string): {
+        folder: string;
+        name: string;
+        extension: string;
+    };
     read(templateName: string): void;
     render(context: object, options?: RuntimeOptions): void;
     get rendered(): string | undefined;
     save(filename: string, folder: string, options?: SaveTemplateOptions): void;
 }
-declare const _default: (source: string, extension: string) => TemplateEngine;
+declare const _default: (source: string[], extension: string) => TemplateEngine;
 export default _default;

package/lib/helpers/template.js

@@ -1,7 +1,7 @@
 import fs from "fs";
 import Handlebars from "handlebars";
 import { merge } from "./merge.js";
-import { getFiles } from "./util.js";
+import { getFiles, getFilesInFolders } from "./util.js";
 function isObjectEmpty(objectName) {
     return (objectName &&
         Object.keys(objectName).length === 0 &&
@@ -22,44 +22,57 @@ function openTemplate(sourceFolder, templateName, extension) {
     }
     return content;
 }
-class TemplateEngine {
-    constructor(source, extension = '*') {
-        this._sourceFolder = source;
-        if (!fs.existsSync(this._sourceFolder)) {
-            throw new Error(`La carpeta source ${this._sourceFolder} no existe!`);
-        }
+export class TemplateEngine {
+    _template;
+    _rendered;
+    _extension;
+    _sourceFolders;
+    constructor(sources, extension = '*') {
+        this._sourceFolders = sources;
         this._extension = extension;
+        for (const sourceFolder of this._sourceFolders) {
+            if (!fs.existsSync(sourceFolder)) {
+                throw new Error(`La carpeta source ${sourceFolder} no existe!`);
+            }
+        }
     }
     ;
     getTemplates() {
         const filterThisExtension = (file) => file.endsWith(`.${this._extension}`) || this._extension === '*';
         const templates = [];
-        const files = getFiles(this._sourceFolder, filterThisExtension, true, ['dictionary']);
+        const files = getFilesInFolders(this._sourceFolders, filterThisExtension, true, ['dictionary']);
         for (const filename of files) {
             const [name] = filename.split(".");
             templates.push(name);
         }
         return templates;
     }
-    getNameAndExtension(templateName) {
+    findTemplateByName(templateName) {
+        let folder;
+        let name = templateName;
+        let extension = this._extension;
         // Si viene la extension en el nombre la extrae
         if (templateName.split(".").length > 1) {
-            return templateName.split(".");
+            [name, extension] = templateName.split(".");
         }
-        // Si viene la extension * busca cual puede ser en el directorio
-        if (this._extension === '*' || this._extension === '') {
-            const fileNames = getFiles(this._sourceFolder, fileName => fileName.split(".")[0].endsWith(templateName));
+        // Busca en las carpetas el archivo
+        for (const currentFolder of this._sourceFolders) {
+            folder = currentFolder;
+            const filterWithExtension = (fileName) => fileName === `${name}.${extension}`;
+            const filterWithoutExtension = (fileName) => fileName.split(".")[0].endsWith(name);
+            const filter = (extension === '*' || extension === '') ? filterWithoutExtension : filterWithExtension;
+            const fileNames = getFiles(folder, filter);
             if (fileNames.length > 0) {
-                return fileNames[0].split(".");
+                [name, extension] = fileNames[0].split(".");
+                return { folder, name, extension };
             }
         }
-        // Por defecto usa el templateName como nombre y la extension
-        return [templateName, this._extension];
+        throw new Error(`No se encontro el template ${templateName} en ninguna de las carpetas ${this._sourceFolders}`);
     }
     read(templateName) {
         // Por defecto usa el templateName como nombre y la extension
-        const [name, extension] = this.getNameAndExtension(templateName);
-        const rawTemplate = openTemplate(this._sourceFolder, name, extension);
+        const { folder, name, extension } = this.findTemplateByName(templateName);
+        const rawTemplate = openTemplate(folder, name, extension);
         this._template = Handlebars.compile(rawTemplate);
     }
     render(context, options = {}) {

package/lib/helpers/util.d.ts

@@ -1,10 +1,8 @@
-import prompts, { Choice } from "prompts";
+import { Choice } from "prompts";
 import { AnyValue } from "../types/auto.js";
+export declare const WORKING_FOLDER: string;
 export declare const CONFIG_FILE: string;
-export declare const TEMPLATES_FOLDER: string;
-export declare const TEMPLATE_MODEL_FOLDER: string;
 export declare const DICTIONARY_FOLDER: string;
-export declare const WORKING_FOLDER: string;
 export declare const filterJson: (fullPath: string) => boolean;
 export declare const filterDirectory: (fullPath: string) => boolean;
 export declare const filterFiles: (fullPath: string) => boolean;
@@ -20,8 +18,9 @@ export declare function titlesToChoices(list: string[], titleToValue?: (title: s
     title: string;
     value: string;
 }[];
-export declare function getDataFromPackage(): Record<string, string>;
 export declare function findChoicesPosition(choices: Choice[], value: string): number;
+export declare function getFilesInFolders(folders: string[], filter: (fullPath: string) => boolean, recursive?: boolean, ignoreList?: string[]): string[];
+export declare function getModelFolders(subfolder: string): string[];
 export declare function createConfigurationFile(taskName?: string): Promise<boolean>;
 export declare function getConfigFile(file: string, variable: string, defaultValue: AnyValue): any;
 export declare function getConfig(variable: string, defaultValue: AnyValue): any;
@@ -52,4 +51,4 @@ export declare function searchInFolderHierarchy(element: string, parentFolder: s
 export declare function getFiles(source: string, filter?: (file: string) => boolean, recursive?: boolean, ignoreList?: string[]): string[];
 export declare function convertNameToKey(name: string): string;
 export declare function convertKeyToName(key: string): string;
-export declare function readJsonSync(filename: string): prompts.Choice[];
+export declare function readJsonSync<T>(filename: string): T;