autoforce 0.1.1

package/lib/helpers/tasks.js

@@ -0,0 +1,241 @@
+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 from "./context.js";
+import { logError, logStep } from "./color.js";
+import fs from "fs";
+import { getFiles, filterJson } from "./util.js";
+import { validateCommand, validateFunction, executeFunction, executeCommand, taskFunctions } from "./taskFunctions.js";
+import prompts from "prompts";
+export const TASKS_FOLDER = process.cwd() + "/commands/tasks";
+export const SUBTASKS_FOLDER = process.cwd() + "/commands/subtasks";
+export const NEW_FOLDER = process.cwd() + "/commands/new";
+export function getTaskFolder(command) {
+    const folders = {
+        'task': TASKS_FOLDER,
+        'subtask': SUBTASKS_FOLDER,
+        'tasks': TASKS_FOLDER,
+        'subtasks': SUBTASKS_FOLDER,
+        'new': NEW_FOLDER
+    };
+    return folders[command.toLowerCase()] || folders.tasks;
+}
+function getTaskLists(folder) {
+    const files = getFiles(folder, filterJson);
+    return files.map(filename => filename.split(".")[0]);
+}
+export function getTasks(folder = TASKS_FOLDER) {
+    const tasks = {};
+    for (const taskName of getTaskLists(folder)) {
+        tasks[taskName] = getTask(taskName, folder);
+    }
+    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 isCriteriaMet(criteria) {
+    if (!criteria) {
+        return true;
+    }
+    const { field, value } = criteria;
+    // si no viene valor solo verifica que tenga no este vacio
+    if (typeof value == 'undefined') {
+        return context.get(field);
+        ;
+    }
+    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 function validateTask(task) {
+    if (task.guards) {
+        // Valida que sea 
+    }
+    // Pide datos de entrada y los deja en context
+    if (task.arguments) {
+        // Valida que sea 
+    }
+    for (const step of task.steps) {
+        if (step.criteria) {
+            // Valida que sea
+        }
+        let validateStep = false;
+        if (typeof step.command === 'string') {
+            validateStep = validateCommand(step);
+        }
+        else if (typeof step.function === 'string') {
+            validateStep = validateFunction(step);
+        }
+        else if (typeof step.subtask === 'string') {
+            const subtask = getTask(step.subtask, SUBTASKS_FOLDER);
+            validateStep = validateTask(subtask);
+        }
+        else {
+            console.log('Step no tiene command ni function ni subtask');
+        }
+        if (!validateStep) {
+            return false;
+        }
+    }
+    return true;
+}
+export function runTask(task, taskContext, tabs = '') {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 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);
+        }
+        logStep(`[INICIO] ${task.name}`, tabs);
+        for (const step of task.steps) {
+            if (isCriteriaMet(step.criteria)) {
+                if (!(yield executeStep(step, tabs + '\t'))) {
+                    return false;
+                }
+            }
+        }
+        logStep(`[FIN] ${task.name}`, tabs);
+        return true;
+    });
+}
+export function previewTask(task, tabs = '') {
+    return __awaiter(this, void 0, void 0, function* () {
+        logStep(`${task.name}: ${task.description}`, tabs);
+        for (const step of task.steps) {
+            previewStep(step, tabs);
+        }
+    });
+}
+function previewStep(step, 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);
+    }
+    else {
+        logStep(`${step.name}`, tabs);
+    }
+}
+export function createObject(fields, values) {
+    const fieldArray = Array.isArray(fields) ? fields : Object.keys(fields);
+    const argsObject = {};
+    for (const value of values) {
+        const field = fieldArray.shift();
+        if (field) {
+            argsObject[field] = value;
+        }
+    }
+    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);
+        }
+        else if (typeof step.subtask === 'string') {
+            const subtask = getTask(step.subtask, SUBTASKS_FOLDER);
+            let stepContext = 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;
+    });
+}
+function getStepError(step, stepName) {
+    return step.errorMessage ? context.merge(step.errorMessage) : stepName ? `Fallo el step ${stepName}` : '';
+}
+function executeStep(step, tabs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stepName = step.name ? context.merge(step.name) : undefined;
+        if (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();
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    logError(error.message, tabs);
+                }
+            }
+            if (!success) {
+                const result = yield askForContinueOrRetry();
+                retry = result == 'retry';
+                success = result == 'continue';
+            }
+        } while (!success && retry);
+        if (stepName) {
+            logStep(`[FIN] ${stepName}`, tabs);
+        }
+        if (!success) {
+            process.exit(!context.isVerbose ? -1 : 0);
+        }
+        return success;
+    });
+}

package/lib/helpers/template.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="handlebars" />
+declare class TemplateEngine<T> {
+    _template: HandlebarsTemplateDelegate | undefined;
+    _rendered: string | undefined;
+    _extension: string;
+    _sourceFolder: string;
+    constructor(source: string, extension: string);
+    getTemplates(): string[];
+    read(templateName: string): void;
+    render(context: object, options?: RuntimeOptions): void;
+    save(filename: string, folder: string, options?: SaveTemplateOptions): void;
+}
+declare const _default: (source: string, extension: string) => TemplateEngine<unknown>;
+export default _default;

package/lib/helpers/template.js

@@ -0,0 +1,86 @@
+import fs from "fs";
+import Handlebars from "handlebars";
+import { merge } from "./merge.js";
+import { getFiles } from "./util.js";
+const TEMPLATE_ROOT_FOLDER = process.cwd() + "/templates";
+function isObjectEmpty(objectName) {
+    return (objectName &&
+        Object.keys(objectName).length === 0 &&
+        objectName.constructor === Object);
+}
+// Abre el archivo, y antes de devolver el contenido busca si tiene tags {{import subarchivos}} y los incorpora al mismo
+function openTemplate(sourceFolder, templateName, extension) {
+    const source = `${sourceFolder}/${templateName}.${extension}`;
+    let content = fs.readFileSync(source, "utf8");
+    const regexp = /{{[ ]*(import)[ ]*([^}]+)}}/gi;
+    const matches = content.matchAll(regexp);
+    if (matches !== null) {
+        for (const match of matches) {
+            const [subfile, subextension] = match[2].trim().split(".");
+            const subcontent = openTemplate(sourceFolder, subfile, subextension || extension);
+            content = content.replace(match[0], subcontent);
+        }
+    }
+    return content;
+}
+class TemplateEngine {
+    constructor(source, extension) {
+        this._sourceFolder = `${TEMPLATE_ROOT_FOLDER}/${source}`;
+        if (!fs.existsSync(this._sourceFolder)) {
+            throw new Error(`La carpeta source ${this._sourceFolder} no existe!`);
+        }
+        this._extension = extension;
+    }
+    ;
+    getTemplates() {
+        const filterThisExtension = (file) => file.endsWith(`.${this._extension}`);
+        const templates = [];
+        const files = getFiles(this._sourceFolder, filterThisExtension, true, ['dictionary']);
+        for (const filename of files) {
+            const [name] = filename.split(".");
+            templates.push(name);
+        }
+        return templates;
+    }
+    read(templateName) {
+        const rawTemplate = openTemplate(this._sourceFolder, templateName, this._extension);
+        this._template = Handlebars.compile(rawTemplate);
+    }
+    render(context, options = {}) {
+        if (isObjectEmpty(context) || this._template === undefined) {
+            return;
+        }
+        this._rendered = this._template(context, options);
+    }
+    save(filename, folder, options = { create: true, overwrite: true }) {
+        let accion = "creo";
+        if (folder && !fs.existsSync(folder)) {
+            if (options.create) {
+                fs.mkdirSync(folder);
+            }
+            else {
+                throw new Error(`La carpeta ${folder} no existe!`);
+            }
+        }
+        if (!filename.endsWith("." + this._extension)) {
+            filename += "." + this._extension;
+        }
+        const destination = folder ? `${folder}/${filename}` : `${filename}`;
+        let content = this._rendered;
+        if (content) {
+            if (fs.existsSync(destination)) {
+                if (!options.overwrite) {
+                    throw new Error(`El archivo ${folder} ya existe!`);
+                }
+                accion = "combino";
+                const existingContent = fs.readFileSync(destination, "utf8");
+                content = merge(content, existingContent, false);
+            }
+            fs.writeFileSync(destination, content);
+            console.log(`Se ${accion} el archivo ${filename} con exito!`);
+        }
+    }
+}
+export default (source, extension) => {
+    return new TemplateEngine(source, extension);
+};

package/lib/helpers/util.d.ts

@@ -0,0 +1,31 @@
+export declare const DOCS_FOLDER: string;
+export declare const DICTIONARY_FOLDER: string;
+export declare const WORKING_FOLDER: string;
+export declare function sortByName(objA: {
+    Name: string;
+}, objB: {
+    Name: string;
+}): 0 | 1 | -1;
+export declare function sortByLabel(objA: {
+    label?: string | null;
+}, objB: {
+    label?: string | null;
+}): 0 | 1 | -1;
+export declare function verFecha(this: Date): string | Date;
+export declare function getNamesByExtension(folder: string, extension: string): string[];
+export declare function splitFilename(fullname: string, defaultFolder?: string): {
+    filename: string;
+    folder: string;
+};
+export declare const filterJson: (fullPath: string) => boolean;
+export declare const filterDirectory: (fullPath: string) => boolean;
+export declare const filterFiles: (fullPath: string) => boolean;
+/**
+ * Agrega los elementos de newArray a baseArray, si no existen previamente en baseArray.
+ * @param {string[]} baseArray El array donde se agregan los elementos
+ * @param {string[]} newArray El array de elementos a agregar
+ */
+export declare function addNewItems(baseArray: string[], newArray: string[]): void;
+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;

package/lib/helpers/util.js

@@ -0,0 +1,85 @@
+import fs from "fs";
+export const DOCS_FOLDER = process.cwd() + "/docs";
+export const DICTIONARY_FOLDER = process.cwd() + "/docs/diccionarios";
+export const WORKING_FOLDER = process.env.INIT_CWD || ".";
+export function sortByName(objA, objB) {
+    return objA.Name > objB.Name ? 1 : objA.Name < objB.Name ? -1 : 0;
+}
+export function sortByLabel(objA, objB) {
+    return (objA.label && objB.label && objA.label > objB.label || !objB.label) ? 1 : (objA.label && objB.label && objA.label < objB.label || !objA.label) ? -1 : 0;
+}
+export function verFecha() {
+    try {
+        const fecha = new Date(this);
+        return fecha.toLocaleString("es", {
+            day: "numeric",
+            year: "2-digit",
+            month: "long"
+        });
+    }
+    catch (e) {
+        console.error(e);
+        return this;
+    }
+}
+// Devuelve la lista de nombres de archivos de una extension de una carpeta, sin la extension.
+export function getNamesByExtension(folder, extension) {
+    const allFiles = fs.readdirSync(folder);
+    const filterFiles = [];
+    for (const fullname in allFiles) {
+        if (fullname.endsWith(extension)) {
+            filterFiles.push(fullname.replace("." + extension, ""));
+        }
+    }
+    return filterFiles;
+}
+export function splitFilename(fullname, defaultFolder = '') {
+    let filename = fullname;
+    let folder = defaultFolder;
+    const separatorIndex = fullname.lastIndexOf("/");
+    if (separatorIndex !== -1) {
+        folder = fullname.substring(0, separatorIndex);
+        filename = fullname.substring(separatorIndex + 1);
+    }
+    return { filename, folder };
+}
+export const filterJson = (fullPath) => fullPath.endsWith(".json");
+export const filterDirectory = (fullPath) => fs.lstatSync(fullPath).isDirectory();
+export const filterFiles = (fullPath) => !fs.lstatSync(fullPath).isDirectory();
+/**
+ * Agrega los elementos de newArray a baseArray, si no existen previamente en baseArray.
+ * @param {string[]} baseArray El array donde se agregan los elementos
+ * @param {string[]} newArray El array de elementos a agregar
+ */
+export function addNewItems(baseArray, newArray) {
+    for (const item of newArray) {
+        if (!baseArray.includes(item)) {
+            baseArray.push(item);
+        }
+    }
+}
+export function getFiles(source, filter = (file) => file !== undefined, recursive = false, ignoreList = []) {
+    const files = [];
+    for (const file of fs.readdirSync(source)) {
+        const fullPath = source + "/" + file;
+        const filtered = filter(fullPath);
+        if (!ignoreList.includes(file)) {
+            if (filtered) {
+                files.push(file);
+            }
+            if (fs.lstatSync(fullPath).isDirectory() && recursive) {
+                getFiles(fullPath, filter, recursive, ignoreList).forEach((x) => files.push(file + "/" + x));
+            }
+        }
+    }
+    return files;
+}
+export function convertNameToKey(name) {
+    return name.toLowerCase().replaceAll(/[ /]/g, '-');
+}
+export function convertKeyToName(key) {
+    return key.replaceAll('-', ' ')
+        .split(' ')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -0,0 +1,2 @@
+import main from "./auto.js";
+main();

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "autoforce",
+  "homepage": "https://sebastianclaros.github.io/autoforce",
+  "private": false,
+  "version": "0.1.1",
+  "description": "Developer Automation tool for Github / Gitlab and Salesforce projects.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sebastianclaros/autoforce"
+  },
+  "main": "./lib/index.js",
+  "files": [
+    "lib/**/*"
+  ],
+  "type": "module",
+  "scripts": {
+    "prebuild": "rm -rf ./lib/",
+    "build": "tsc --project tsconfig.build.json",
+    "prettier": "prettier --write \"**/*.{css,html,js,json,ts,md,xml,yaml,yml}\"",
+    "test": "jest --config jest.config.js"
+  },
+  "dependencies": {
+    "@eslint/js": "^9.9.1",
+    "@types/jest": "29.4.0",
+    "@typescript-eslint/eslint-plugin": "5.54.0",
+    "@typescript-eslint/parser": "5.52.0",
+    "eslint": "^9.9.1",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-jest": "^26.1.2",
+    "husky": "^7.0.4",
+    "jest": "29.4.3",
+    "lint-staged": "^12.3.7",
+    "prettier": "^2.6.0",
+    "ts-jest": "29.0.5",
+    "ts-node": "^10.9.2",
+    "typescript": "4.9.5",
+    "typescript-eslint": "^8.3.0"
+  },
+  "devDependencies": {
+    "@octokit/graphql": "^8.1.1",
+    "@types/graphql": "^14.5.0",
+    "@types/jsforce": "^1.11.5",
+    "@types/prompts": "^2.4.9",
+    "graphql": "^16.9.0",
+    "graphql-request": "^7.1.0",
+    "gray-matter": "^4.0.3",
+    "handlebars": "^4.7.8",
+    "jsforce": "^3.4.1",
+    "octokit": "^4.0.2",
+    "openai": "^4.54.0",
+    "prompts": "^2.4.2"
+  },
+  "author": "Sebastian Claros <sclaros@gmail.com>",
+  "license": "MIT"
+}