autoforce 0.1.17 → 0.1.19

package/lib/helpers/context.js

@@ -1,14 +1,5 @@
-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 { executeShell, getOrganizationObject, getCurrentOrganization, getBranchName, getTargetOrg } from "./taskFunctions.js";
-import { convertNameToKey, convertKeyToName, getFiles, filterDirectory, addNewItems, CONFIG_FILE, createConfigurationFile, getDataFromPackage } from "./util.js";
+import { convertNameToKey, convertKeyToName, getFiles, filterDirectory, addNewItems, CONFIG_FILE, createConfigurationFile } from "./util.js";
 import { GitHubApi } from "./github-graphql.js";
 import { GitHubProjectApi } from "./github-project-graphql.js";
 import { GitLabApi } from "./gitlab-graphql.js";
@@ -37,65 +28,141 @@ export var ProjectServices;
 })(ProjectServices || (ProjectServices = {}));
 const filterProcesses = (fullPath) => fullPath.endsWith(".md"); // && !fullPath.endsWith("intro.md") 
 const ISSUES_TYPES = [{ value: 'feature', title: 'feature' }, { value: 'bug', title: 'bug' }, { value: 'documentation', title: 'documentation' }, { value: 'automation', title: 'automation' }];
+function searchInFolderHierarchy(element, parentFolder) {
+    if (fs.existsSync(`${parentFolder}/${element}`)) {
+        return `${parentFolder}/${element}`;
+    }
+    else {
+        const lastIndex = parentFolder.lastIndexOf('/');
+        if (lastIndex !== -1) {
+            const newParentFolder = parentFolder.substring(0, lastIndex);
+            if (newParentFolder !== '') {
+                return searchInFolderHierarchy(element, newParentFolder);
+            }
+        }
+    }
+    return '';
+}
+function getDataFromPackage() {
+    const data = {};
+    try {
+        const filename = searchInFolderHierarchy("package.json", process.cwd());
+        if (!filename) {
+            throw new Error("No se encontro el package.json en " + process.cwd());
+        }
+        const content = fs.readFileSync(filename, "utf8");
+        const packageJson = JSON.parse(content);
+        if (packageJson.repository) {
+            if (packageJson.repository.url) {
+                data.repositoryUrl = packageJson.repository.url;
+                data.repositoryType = packageJson.repository.type;
+                // Ver de sacar repo y owner
+                if (data.repositoryUrl) {
+                    if (data.repositoryUrl.includes("github.com")) {
+                        const repositoryArray = data.repositoryUrl.split('github.com/');
+                        [data.repositoryOwner, data.repositoryRepo] = repositoryArray[1].split('/');
+                    }
+                    if (data.repositoryUrl.includes("gitlab.com")) {
+                        const repositoryArray = data.repositoryUrl.split('gitlab.com/');
+                        [data.repositoryOwner, data.repositoryRepo] = repositoryArray[1].split('/');
+                    }
+                }
+            }
+            else if (typeof packageJson.repository === 'string') {
+                data.repositoryUrl = packageJson.repository;
+                const repositoryArray = data.repositoryUrl.split(':');
+                data.repositoryType = repositoryArray[0];
+                [data.repositoryOwner, data.repositoryRepo] = repositoryArray[1].split('/');
+            }
+            if (data.repositoryRepo && data.repositoryRepo.endsWith('.git')) {
+                data.repositoryRepo = data.repositoryRepo.replace('.git', '');
+            }
+        }
+    }
+    catch (error) {
+        console.log(error);
+        throw new Error(`Verifique que exista y sea valido el package.json`);
+    }
+    return data;
+}
 class Context {
+    devModel; // Default Model de commands
+    gitModel;
+    docModel;
+    projectModel;
+    gitServices = GitServices.None;
+    isGitApi = false;
+    gitApi;
+    version;
+    dictionaryFolder = process.cwd() + "/docs";
+    options = {};
+    projectServices = ProjectServices.None;
+    isProjectApi = false;
+    projectApi;
+    sfInstalled = true;
+    sfToken = true;
+    branchName;
+    issueNumber;
+    issueType;
+    _process;
+    _processesHeader;
+    _newIssueNumber;
+    _newIssueType;
+    newBranchName;
+    defaultDias = 7;
+    permissionSet;
+    issueTitle;
+    isVerbose = false;
+    _scratch;
+    _branchScratch;
+    existNewBranch = false;
+    _targetOrg;
+    // Documentacion
+    processes;
+    // Ultima salida del shell
+    salida = '';
+    // Git Repository
+    repositoryUrl;
+    repositoryType;
+    repositoryOwner;
+    repositoryRepo;
+    // Project Reference    
+    projectId;
+    backlogColumn = 'Todo';
+    //Templates especiales
+    listFilter = ListFilters.Mios;
+    listTemplate = 'openIssues';
     constructor() {
-        this.model = 'modelA'; // Default Model de commands
-        this.modelTemplates = 'modelA'; // Default Model de templates
-        this.gitServices = GitServices.None;
-        this.isGitApi = false;
-        this.options = {};
-        this.projectServices = ProjectServices.None;
-        this.isProjectApi = false;
-        this.sfInstalled = true;
-        this.sfToken = true;
-        this.defaultDias = 7;
-        this.isVerbose = false;
-        this.existNewBranch = false;
-        // Ultima salida del shell
-        this.salida = '';
-        this.backlogColumn = 'Todo';
-        //Templates especiales
-        this.listFilter = ListFilters.Mios;
-        this.listTemplate = 'openIssues';
         this.loadConfig();
         this.loadPackage();
     }
-    labels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const choices = [{ value: '', title: 'Ninguno' }, { value: 'new', title: 'Nuevo' }];
-            const labels = yield ((_a = this.gitApi) === null || _a === void 0 ? void 0 : _a.getLabels());
-            if (labels) {
-                labels.forEach(label => choices.push({ value: label.name, title: label.name }));
-            }
-            return choices;
-        });
+    async labels() {
+        const choices = [{ value: '', title: 'Ninguno' }, { value: 'new', title: 'Nuevo' }];
+        const labels = await this.gitApi?.getLabels();
+        if (labels) {
+            labels.forEach(label => choices.push({ value: label.name, title: label.name }));
+        }
+        return choices;
     }
     listFilters() {
         const filters = [{ title: 'Solo mios abiertos', value: ListFilters.Mios, description: 'Busca los issues donde este asignado y esten en state Open' }, { title: 'Por Milestone', value: ListFilters.PorMilestone, description: 'Busca los issues de un deterinado milestone' }, { title: 'Por Label', value: ListFilters.PorLabel, description: 'Busca los issues de un deterinado label' }];
         return filters;
     }
-    milestoneNumbers() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const choices = [{ value: '', title: 'Ninguno' }];
-            const milestones = yield ((_a = this.gitApi) === null || _a === void 0 ? void 0 : _a.getMilestones());
-            if (milestones) {
-                milestones.forEach(milestone => choices.push({ value: milestone.number, title: milestone.title }));
-            }
-            return choices;
-        });
+    async milestoneNumbers() {
+        const choices = [{ value: '', title: 'Ninguno' }];
+        const milestones = await this.gitApi?.getMilestones();
+        if (milestones) {
+            milestones.forEach(milestone => choices.push({ value: milestone.number, title: milestone.title }));
+        }
+        return choices;
     }
-    milestones() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const choices = [{ value: '', title: 'Ninguno' }, { value: 'new', title: 'Nuevo' }];
-            const milestones = yield ((_a = this.gitApi) === null || _a === void 0 ? void 0 : _a.getMilestones());
-            if (milestones) {
-                milestones.forEach(milestone => choices.push({ value: milestone.id, title: milestone.title }));
-            }
-            return choices;
-        });
+    async milestones() {
+        const choices = [{ value: '', title: 'Ninguno' }, { value: 'new', title: 'Nuevo' }];
+        const milestones = await this.gitApi?.getMilestones();
+        if (milestones) {
+            milestones.forEach(milestone => choices.push({ value: milestone.id, title: milestone.title }));
+        }
+        return choices;
     }
     loadProjectApi() {
         if (!this.isProjectApi) {
@@ -167,37 +234,35 @@ class Context {
         this.repositoryOwner = data.repositoryOwner;
         this.repositoryRepo = data.repositoryRepo;
     }
-    loadConfig() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!fs.existsSync(CONFIG_FILE)) {
-                logWarning('Bienvenido! La herramienta Autoforce necesita un primer paso de configuracion antes de usarla.');
-                logWarning('- Podes usar el asistente ejecutando npx autoforce config');
-                logWarning('- Podes hacerlo manualmente leyendo la documentacion y creando .autoforce.json manualmente en el root del proyecto (https://sebastianclaros.github.io/autoforce/docs/configuracion)');
-                const answer = yield prompts([
-                    {
-                        type: "confirm",
-                        name: "asistente",
-                        message: "Queres ejecutar el asistente ahora?"
-                    }
-                ]);
-                if (answer.asistente) {
-                    yield createConfigurationFile();
-                    return true;
-                }
-                return false;
-            }
-            const content = fs.readFileSync(CONFIG_FILE, "utf8");
-            try {
-                const config = JSON.parse(content);
-                for (const key in config) {
-                    this.set(key, config[key]);
+    async loadConfig() {
+        if (!fs.existsSync(CONFIG_FILE)) {
+            logWarning('Bienvenido! La herramienta Autoforce necesita un primer paso de configuracion antes de usarla.');
+            logWarning('- Podes usar el asistente ejecutando npx autoforce config');
+            logWarning('- Podes hacerlo manualmente leyendo la documentacion y creando .autoforce.json manualmente en el root del proyecto (https://sebastianclaros.github.io/autoforce/docs/configuracion)');
+            const answer = await prompts([
+                {
+                    type: "confirm",
+                    name: "asistente",
+                    message: "Queres ejecutar el asistente ahora?"
                 }
+            ]);
+            if (answer.asistente) {
+                await createConfigurationFile();
+                return true;
             }
-            catch (_a) {
-                throw new Error(`Verifique que el ${CONFIG_FILE} sea json valido`);
+            return false;
+        }
+        const content = fs.readFileSync(CONFIG_FILE, "utf8");
+        try {
+            const config = JSON.parse(content);
+            for (const key in config) {
+                this.set(key, config[key]);
             }
-            return true;
-        });
+        }
+        catch {
+            throw new Error(`Verifique que el ${CONFIG_FILE} sea json valido`);
+        }
+        return true;
     }
     init() {
         this.loadProjectApi();
@@ -246,21 +311,21 @@ class Context {
             config.processes = processes;
             fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
         }
-        catch (_a) {
+        catch {
             throw new Error(`No se pudo guardar la metadata`);
         }
     }
     get processesHeader() {
         if (!this._processesHeader) {
             this._processesHeader = {};
-            const folders = getFiles(process.cwd() + "/docs", filterDirectory, true, ['diccionarios']);
+            const folders = getFiles(this.dictionaryFolder, filterDirectory, true, ['diccionarios']);
             for (const folder of folders) {
-                const fullpath = `${process.cwd()}/docs/${folder}`;
+                const fullpath = `${this.dictionaryFolder}/${folder}`;
                 const filenames = getFiles(fullpath, filterProcesses);
                 for (const filename of filenames) {
                     const header = this.getProcessHeader(fullpath + "/" + filename);
                     if (header.process) {
-                        this._processesHeader[header.process] = Object.assign(Object.assign({}, header), { folder: fullpath, filename });
+                        this._processesHeader[header.process] = { ...header, folder: fullpath, filename };
                     }
                 }
             }
@@ -269,7 +334,7 @@ class Context {
     }
     // TODO: merge con getProcessFromDocs
     getProcessMetadata() {
-        const folders = getFiles(process.cwd() + "/docs", filterDirectory, true, ['diccionarios']);
+        const folders = getFiles(this.dictionaryFolder, filterDirectory, true, ['diccionarios']);
         const retArray = [];
         for (const folder of folders) {
             const fullpath = `${process.cwd()}/docs/${folder}`;
@@ -278,14 +343,18 @@ class Context {
                 const header = this.getProcessHeader(fullpath + "/" + process);
                 const processKey = convertNameToKey(header.slug || header.title || process);
                 if (this.processes && this.processes[processKey]) {
-                    retArray.push(Object.assign({ folder, name: convertKeyToName(processKey) }, this.processes[processKey]));
+                    retArray.push({
+                        folder,
+                        name: convertKeyToName(processKey),
+                        ...this.processes[processKey]
+                    });
                 }
             }
         }
         return retArray;
     }
     getModules() {
-        return getFiles(process.cwd() + "/docs", filterDirectory, false, ['diccionarios']);
+        return getFiles(this.dictionaryFolder, filterDirectory, false, ['diccionarios']);
     }
     get modules() {
         return this.getModules().map(module => { return { value: module, title: module }; });
@@ -299,23 +368,21 @@ class Context {
         }
         return this._scratch;
     }
-    validate(guards) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const guard of guards) {
-                // Chequeo de variables de entorno
-                if (guard[0] === '$') {
-                    if (!process.env[guard.substring(1)]) {
-                        throw new Error(`La variable de entorno ${guard} no esta configurada.`);
-                    }
+    async validate(guards) {
+        for (const guard of guards) {
+            // Chequeo de variables de entorno
+            if (guard[0] === '$') {
+                if (!process.env[guard.substring(1)]) {
+                    throw new Error(`La variable de entorno ${guard} no esta configurada.`);
                 }
-                else {
-                    const value = yield this.get(guard);
-                    if (!value) {
-                        throw new Error(`No se encontro la variable ${guard} en el contexto. Ejecute yarn auto config o lea el index.md para mas informacion.`);
-                    }
+            }
+            else {
+                const value = await this.get(guard);
+                if (!value) {
+                    throw new Error(`No se encontro la variable ${guard} en el contexto. Ejecute yarn auto config o lea el index.md para mas informacion.`);
                 }
             }
-        });
+        }
     }
     issueFromBranch(branchName) {
         const branchSplit = branchName.split("/");
@@ -367,31 +434,27 @@ class Context {
             this.existNewBranch = typeof salida === 'string' && (salida.includes(this.newBranchName));
         }
     }
-    askFornewBranchName() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.newBranchName) {
-                if (!this.newIssueType) {
-                    this.newIssueType = yield this.askFornewIssueType();
-                }
-                if (!this.newIssueNumber) {
-                    this.newIssueNumber = yield this.askFornewIssueNumber();
-                }
-                this.setNewBranchName();
+    async askFornewBranchName() {
+        if (!this.newBranchName) {
+            if (!this.newIssueType) {
+                this.newIssueType = await this.askFornewIssueType();
             }
-            return this.newBranchName;
-        });
+            if (!this.newIssueNumber) {
+                this.newIssueNumber = await this.askFornewIssueNumber();
+            }
+            this.setNewBranchName();
+        }
+        return this.newBranchName;
     }
-    askFornewIssueNumber() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const answer = yield prompts([
-                {
-                    type: "text",
-                    name: "newIssueNumber",
-                    message: "Por favor ingrese el nuevo issueNumber?"
-                }
-            ]);
-            return answer.newIssueNumber;
-        });
+    async askFornewIssueNumber() {
+        const answer = await prompts([
+            {
+                type: "text",
+                name: "newIssueNumber",
+                message: "Por favor ingrese el nuevo issueNumber?"
+            }
+        ]);
+        return answer.newIssueNumber;
     }
     set process(value) {
         this._process = value;
@@ -413,83 +476,78 @@ class Context {
         }
         return this._process;
     }
-    askForprocess() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.projectApi && !this.issueTitle && this.issueNumber) {
-                const issue = yield this.projectApi.getIssue(this.issueNumber);
-                this.issueTitle = issue.title;
-            }
-            if (this.issueTitle) {
-                const process = this.getProcessFromTitle(this.issueTitle);
-                if (process && this.processesHeader[process]) {
-                    return process;
-                }
+    async askForprocess() {
+        if (this.projectApi && !this.issueTitle && this.issueNumber) {
+            const issue = await this.projectApi.getIssue(this.issueNumber);
+            this.issueTitle = issue.title;
+        }
+        if (this.issueTitle) {
+            const process = this.getProcessFromTitle(this.issueTitle);
+            if (process && this.processesHeader[process]) {
+                return process;
             }
-            const choices = Object.values(this.processesHeader).map(header => {
-                return { value: header.process, title: header.title };
-            });
-            const answer = yield prompts([{
-                    type: "select",
-                    name: "process",
-                    message: "Por favor seleccione el proceso",
-                    choices
-                }]);
-            return answer.process;
+        }
+        const choices = Object.values(this.processesHeader).map(header => {
+            return { value: header.process, title: header.title };
         });
-    }
-    askFornewIssueType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const answer = yield prompts([
-                {
-                    type: "list",
-                    name: "newIssueType",
-                    initial: "feature",
-                    message: "Por favor ingrese el type del issue?",
-                    choices: ISSUES_TYPES
+        const answer = await prompts([{
+                type: "select",
+                name: "process",
+                message: "Por favor seleccione el proceso",
+                choices
+            }]);
+        return answer.process;
+    }
+    async askFornewIssueType() {
+        const answer = await prompts([
+            {
+                type: "list",
+                name: "newIssueType",
+                initial: "feature",
+                message: "Por favor ingrese el type del issue?",
+                choices: ISSUES_TYPES
+            }
+        ]);
+        return answer.newIssueType;
+    }
+    async convertToArrayOfInputs(inputs) {
+        let inputsArray = [];
+        if (Array.isArray(inputs)) {
+            // Si viene los args como ['name1', 'names] lo convierte a [{name: 'name1'}, {name: 'name2'}]
+            inputsArray = inputs.map(input => { return { name: input, type: 'text', message: `Por favor ingrese ${input}?` }; });
+        }
+        else {
+            // Si viene args como objeto { name1: {...}, name2: {...}} lo convierte a [{name: name1...}, {name: name2...}]
+            for (const key in inputs) {
+                if (typeof inputs[key].default === 'string') {
+                    inputs[key].initial = this.merge(inputs[key].default);
                 }
-            ]);
-            return answer.newIssueType;
-        });
-    }
-    convertToArrayOfInputs(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let inputsArray = [];
-            if (Array.isArray(inputs)) {
-                // Si viene los args como ['name1', 'names] lo convierte a [{name: 'name1'}, {name: 'name2'}]
-                inputsArray = inputs.map(input => { return { name: input, type: 'text', message: `Por favor ingrese ${input}?` }; });
-            }
-            else {
-                // Si viene args como objeto { name1: {...}, name2: {...}} lo convierte a [{name: name1...}, {name: name2...}]
-                for (const key in inputs) {
-                    if (typeof inputs[key].default == 'string') {
-                        inputs[key].initial = this.merge(inputs[key].default);
-                    }
-                    if (typeof inputs[key].values == 'string' && typeof this[inputs[key].values] == 'function') {
-                        const choices = yield this[inputs[key].values]();
+                if (typeof inputs[key].values === 'string') {
+                    const methodName = inputs[key].values;
+                    if (typeof this[methodName] === 'function') {
+                        const choices = await this[methodName]();
                         if (Array.isArray(choices)) {
                             inputs[key].choices = choices;
                         }
                     }
-                    inputsArray.push(Object.assign({ name: key, type: 'text', message: `Por favor ingrese ${key}?` }, inputs[key]));
-                }
-            }
-            return inputsArray;
-        });
-    }
-    askForExit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const answer = yield prompts([
-                {
-                    type: "confirm",
-                    name: "exit",
-                    initial: true,
-                    message: "Desea salir?"
                 }
-            ]);
-            if (answer.exit) {
-                process.exit(-1);
+                inputsArray.push({ ...{ name: key, type: 'text', message: `Por favor ingrese ${key}?` }, ...inputs[key] });
             }
-        });
+        }
+        return inputsArray;
+    }
+    async askForExit() {
+        const answer = await prompts([
+            {
+                type: "confirm",
+                name: "exit",
+                initial: true,
+                message: "Desea salir?"
+            }
+        ]);
+        if (answer.exit) {
+            process.exit(-1);
+        }
     }
     mergeArgs(args) {
         if (Array.isArray(args)) {
@@ -510,18 +568,16 @@ class Context {
         }
         throw new Error(`Los argumentos ${args} son incompatibles para el merge`);
     }
-    askForArguments(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // unifica los dos tipos de inputs (array y objeto) en un array de inputs
-            const inputsArray = yield this.convertToArrayOfInputs(inputs);
-            for (const input of inputsArray) {
-                const hasValue = yield this.get(input.name);
-                if (!hasValue) {
-                    const answer = yield prompts([input], { onCancel: this.askForExit });
-                    this[input.name] = answer[input.name];
-                }
+    async askForArguments(inputs) {
+        // unifica los dos tipos de inputs (array y objeto) en un array de inputs
+        const inputsArray = await this.convertToArrayOfInputs(inputs);
+        for (const input of inputsArray) {
+            const hasValue = await this.get(input.name);
+            if (!hasValue) {
+                const answer = await prompts([input], { onCancel: this.askForExit });
+                this[input.name] = answer[input.name];
             }
-        });
+        }
     }
     setObject(obj) {
         for (const field in obj) {
@@ -532,31 +588,29 @@ class Context {
         try {
             this[key] = value;
         }
-        catch (_a) {
+        catch {
             throw new Error(`No se puede setear el ${key} con el valor ${value} en context`);
         }
     }
     // Devuelve el valor o hace un askFor si esta vacio
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const value = this[key];
-                if (!value) {
-                    const askForMethod = 'askFor' + key;
-                    if (this[askForMethod] && typeof this[askForMethod] == 'function') {
-                        this[key] = yield this[askForMethod]();
-                    }
+    async get(key) {
+        try {
+            const value = this[key];
+            if (!value) {
+                const askForMethod = 'askFor' + key;
+                if (this[askForMethod] && typeof this[askForMethod] == 'function') {
+                    this[key] = await this[askForMethod]();
                 }
-                return this[key];
             }
-            catch (_a) {
-                throw new Error(`No se puedo obtener la propiedad ${key} en context`);
-            }
-        });
+            return this[key];
+        }
+        catch {
+            throw new Error(`No se puedo obtener la propiedad ${key} en context`);
+        }
     }
     merge(text) {
         if (typeof text != 'string' || text.indexOf('${') === -1) {
-            return text;
+            return text || '';
         }
         const matches = text.matchAll(/\$\{([^}]+)}/g);
         // si no tiene para merge