autoforce 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sebastian Claros
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# Autoforce
+
+## Objetivo
+
+La idea de la herramienta era facilitar y automatizar las tareas comunes que realizamos los desarrolladores. A medida que pasa el tiempo tenemos cada vez mas herramientas diarias y especificas, pero las tareas en si son las misma, queremos arrancar a desarrollar algo nuevo (start), terminar el desarrollo(finish), dejarlo a un costado (stop), o bien cancelarlo (cancel).
+
+En este repo las tareas buscan automatizar o integrar el siguiente tipo gestiones:
+
+- Branching Strategy en Git (Github o Gitlab)
+- Armado de ambiente de desarrollo (Salesforce)
+- Gestion de proyecto (Github projects, Gitlab projects o Jira).
+- Documentacion (Github pages o GitLab pages. Version mejorada con docusaurus)
+- Calidad de codigo (PMD)
+- Uso de IA ( OpenAI, )
+
+## Instalación
+
+```
+yarn add -D
+```
+
+## Usos
+
+
+```
+    "@docusaurus/core": "^3.0.1",
+    "@docusaurus/preset-classic": "^3.0.1",
+    "@docusaurus/theme-mermaid": "^3.0.1",
+    "docusaurus-plugin-drawio": "^0.4.0",
+```

package/lib/auto.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigArguments } from "./types/auto.js";
+export default function main(): Promise<void>;
+export declare function getConfigFromArgs(processArgs: string[]): ConfigArguments;

package/lib/auto.js

@@ -0,0 +1,103 @@
+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());
+    });
+};
+// Comandos validos
+import { createObject, validateTask, getTasks, helpTask, runTask, getTaskFolder } from "./helpers/tasks.js";
+import { logError } from "./helpers/color.js";
+import { createConfigurationFile } from "./helpers/context.js";
+import prompts from "prompts";
+const proxyCommnad = {
+    'help': helpTask,
+    'task': runTask,
+    'new': runTask,
+    'config': createConfigurationFile,
+    'subtask': runTask
+};
+export default function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const config = getConfigFromArgs(process.argv.slice(2));
+            const tasks = getTasks(config.taskFolder);
+            const taskName = yield askForTaskName(config.taskName, tasks);
+            if (taskName) {
+                const task = tasks[taskName];
+                const options = config.arguments && task.arguments ? Object.assign(Object.assign({}, config.options), createObject(task.arguments, config.arguments)) : config.options;
+                // Valida los json de task y subtask
+                if (validateTask(task)) {
+                    yield proxyCommnad[config.command](task, options);
+                }
+                else {
+                    logError('Verifique que los json de task y subtask esten validos');
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(error.message);
+            }
+        }
+    });
+}
+export function getConfigFromArgs(processArgs) {
+    const config = { options: {}, taskName: '', command: '', taskFolder: '' };
+    const args = [];
+    // Divide --xxx como options el resto como args
+    for (const argName of processArgs) {
+        if (argName.startsWith('--')) {
+            const [optionName, optionValue] = argName.substring(2).split('=');
+            config.options[optionName] = optionValue || true;
+        }
+        else {
+            args.push(argName);
+        }
+    }
+    // De acuerdo a args separa comando[help, preview, task o subtask]  de taskName 
+    let currentArgument = args.shift();
+    const comandosValidos = Object.keys(proxyCommnad);
+    if (currentArgument && comandosValidos.includes(currentArgument)) {
+        config.command = currentArgument;
+        currentArgument = args.shift();
+    }
+    else {
+        config.command = 'task';
+    }
+    // Setea el taskFolder segun si es un task o subtask
+    if ((config.command == 'help' || config.command == 'preview') && (currentArgument == 'subtask' || currentArgument == 'task')) {
+        config.taskFolder = getTaskFolder(currentArgument);
+        currentArgument = args.shift();
+    }
+    else {
+        config.taskFolder = getTaskFolder(config.command);
+    }
+    if (typeof currentArgument == 'string') {
+        config.taskName = currentArgument;
+    }
+    config.arguments = args;
+    return config;
+}
+function askForTaskName(taskName, tasks) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Si exite lo devuelve
+        if (tasks[taskName]) {
+            return taskName;
+        }
+        // Sino pregunta
+        const response = yield prompts({
+            type: "select",
+            name: "taskName",
+            message: taskName
+                ? `${taskName} no es un comando valido`
+                : "Seleccione un comando",
+            choices: Object.values(tasks).map((task) => {
+                return { title: task.name, value: task.name, description: task.description };
+            })
+        });
+        return response.taskName;
+    });
+}

package/lib/helpers/class.d.ts

@@ -0,0 +1,12 @@
+import { DocumentationModule } from "../types/auto.js";
+export declare function getClasses(files: string[]): string[];
+declare const classModule: DocumentationModule;
+export default classModule;
+/**
+ * TODO
+ * innerClass
+ * annotations
+ * locations links
+ * complex types Map<Class, Class>
+ * relaciones composicion, etc
+ */

package/lib/helpers/class.js

@@ -0,0 +1,233 @@
+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 sf from "./connect.js";
+import templateGenerator from "./template.js";
+const templateEngine = templateGenerator("dictionary", "md");
+import { sortByName, getNamesByExtension, verFecha, splitFilename, DICTIONARY_FOLDER, DOCS_FOLDER } from "./util.js";
+function getMetadata(clases) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield sf.connect();
+            const classRecords = yield sf.getClasses(clases);
+            return Array.isArray(classRecords) ? classRecords : [classRecords];
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return [];
+    });
+}
+export function getClasses(files) {
+    const items = new Set();
+    for (const file of files) {
+        if (file.indexOf("/classes/") > 0) {
+            const { filename } = splitFilename(file);
+            items.add(filename.split(".")[0]);
+        }
+    }
+    return [...items.values()];
+}
+function classLink() {
+    const name = this.Name;
+    return `./diccionarios/classes/${name}`;
+}
+function classLinkGraph() {
+    const name = this.Name;
+    return `./diccionarios/classes/${name}`;
+}
+function linkToType() {
+    const dictionaryClasses = getNamesByExtension(DICTIONARY_FOLDER + "/classes", "md");
+    const fullType = this.replace("<", "~").replace(">", "~");
+    const types = fullType.split("~");
+    for (const t in types) {
+        if (dictionaryClasses.includes(t)) {
+            fullType.replace(t, `[{t}](./diccionarios/classes/{t})`);
+        }
+    }
+    return fullType;
+}
+function filterByPublic() {
+    return this.modifiers.includes("public") || this.modifiers.includes("global");
+}
+function scopeModifiers() {
+    const modifiers = [];
+    if (this.modifiers.includes("public") || this.modifiers.includes("global")) {
+        modifiers.push(`+`);
+    }
+    if (this.modifiers.includes("private")) {
+        modifiers.push(`-`);
+    }
+    if (this.modifiers.includes("protected")) {
+        modifiers.push(`#`);
+    }
+    return modifiers.join(" ");
+}
+function modifiers() {
+    const modifiers = [];
+    if (this.modifiers.includes("abstract")) {
+        modifiers.push(`*`);
+    }
+    if (this.modifiers.includes("override")) {
+        modifiers.push(`o`);
+    }
+    if (this.modifiers.includes("static") || this.modifiers.includes("final")) {
+        modifiers.push(`$`);
+    }
+    return modifiers.join(" ");
+}
+function classAttributes() {
+    const attributes = [];
+    // if (this.isValid === "true") {
+    //   attributes.push(`![Encripted](/img/password_60.png)`);
+    // }
+    const systemTable = this.SymbolTable;
+    if (systemTable.tableDeclaration.modifiers.includes("static")) {
+        attributes.push(`$`);
+    }
+    if (systemTable.tableDeclaration.modifiers.includes("public") ||
+        systemTable.tableDeclaration.modifiers.includes("global")) {
+        attributes.push(`+`);
+    }
+    if (systemTable.tableDeclaration.modifiers.includes("private")) {
+        attributes.push(`-`);
+    }
+    if (systemTable.tableDeclaration.modifiers.includes("protected")) {
+        attributes.push(`#`);
+    }
+    if (systemTable.tableDeclaration.modifiers.includes("global")) {
+        attributes.push(`G`);
+    }
+    return attributes.join(" ");
+}
+function getInnerClasses(classes) {
+    let ret = [];
+    for (const clase of classes) {
+        if (clase.SymbolTable && clase.SymbolTable.innerClasses.length > 0) {
+            const innerClases = clase.SymbolTable.innerClasses.map((subclase) => {
+                subclase.namespace =
+                    (clase.namespace ? clase.namespace + "." : "") + clase.Name;
+                return {
+                    Name: subclase.Name,
+                    type: "inner",
+                    namespace: subclase.namespace,
+                    SymbolTable: [subclase]
+                };
+            });
+            ret = ret.concat(innerClases);
+            const subInner = getInnerClasses(clase.SymbolTable.innerClasses);
+            ret = ret.concat(subInner);
+        }
+    }
+    return ret;
+}
+function executeClasses(items, filename, folder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (items.length === 0) {
+            return;
+        }
+        // Busca la metadata
+        let contexts = yield getMetadata(items);
+        if (!contexts || contexts.length === 0) {
+            return;
+        }
+        // Arma el diccionario de cada Clase
+        templateEngine.read("class");
+        for (const context of contexts) {
+            templateEngine.render(context, {
+                helpers: {
+                    verFecha,
+                    modifiers,
+                    linkToType,
+                    classLinkGraph,
+                    filterByPublic,
+                    classAttributes,
+                    scopeModifiers
+                }
+            });
+            templateEngine.save(context.Name, DICTIONARY_FOLDER + "/classes");
+        }
+        // Saca las innerClass y las pone como clases con namespace
+        const innerClasses = getInnerClasses(contexts);
+        const namespaces = {};
+        if (innerClasses.length > 0) {
+            templateEngine.read("class-inner");
+            for (const context of innerClasses) {
+                templateEngine.render(context, {
+                    helpers: { verFecha, modifiers, linkToType }
+                });
+                templateEngine.save(context.Name, DICTIONARY_FOLDER + "/classes/" + context.namespace);
+                // arma un mapa de namespace con el array de sus innerclases
+                if (context.namespace) {
+                    if (namespaces[context.namespace] === undefined) {
+                        namespaces[context.namespace] = [context.Name];
+                    }
+                    else {
+                        namespaces[context.namespace].push(context.Name);
+                    }
+                }
+            }
+            contexts = contexts.concat(innerClasses);
+        }
+        // Arma el documento indice del grupo de clases
+        contexts.sort(sortByName);
+        templateEngine.read("classes");
+        const classContext = { classes: contexts, namespaces };
+        templateEngine.render(classContext, {
+            helpers: {
+                verFecha,
+                modifiers,
+                linkToType,
+                filterByPublic,
+                classLinkGraph,
+                classLink
+            }
+        });
+        templateEngine.save(filename, DOCS_FOLDER + "/" + folder);
+    });
+}
+const classModule = {
+    getItems: getClasses,
+    execute: executeClasses
+};
+export default classModule;
+/**
+ * TODO
+ * innerClass
+ * annotations
+ * locations links
+ * complex types Map<Class, Class>
+ * relaciones composicion, etc
+ */
+/* annotations
+@AuraEnabled
+@TestSetup
+@TestVisible
+@IsTest
+@Future
+
+@Deprecated
+@InvocableMethod
+@InvocableVariable
+@JsonAccess
+@NamespaceAccessible
+@ReadOnly
+@RemoteAction
+@SuppressWarnings
+
+@ReadOnly
+
+REST API
+@RestResource(urlMapping='/nombremiapi')
+@HttpDelete
+@HttpGet
+@HttpPatch
+@HttpPost
+@HttpPut
+*/

package/lib/helpers/color.d.ts

@@ -0,0 +1,3 @@
+export declare function logError(message: string, tabs?: string): void;
+export declare function logStep(message: string, tabs?: string): void;
+export declare function getColored(text: string, colorName: string): string;

package/lib/helpers/color.js

@@ -0,0 +1,47 @@
+const Reset = "\x1b[0m";
+const FgBlack = "\x1b[30m";
+const FgRed = "\x1b[31m";
+const FgGreen = "\x1b[32m";
+const FgYellow = "\x1b[33m";
+const FgBlue = "\x1b[34m";
+const FgMagenta = "\x1b[35m";
+const FgCyan = "\x1b[36m";
+const FgWhite = "\x1b[37m";
+const FgGray = "\x1b[90m";
+// const Bright = "\x1b[1m"
+// const Dim = "\x1b[2m"
+// const Underscore = "\x1b[4m"
+// const Blink = "\x1b[5m"
+// const Reverse = "\x1b[7m"
+// const Hidden = "\x1b[8m"
+// const BgBlack = "\x1b[40m"
+// const BgRed = "\x1b[41m"
+// const BgGreen = "\x1b[42m"
+// const BgYellow = "\x1b[43m"
+// const BgBlue = "\x1b[44m"
+// const BgMagenta = "\x1b[45m"
+// const BgCyan = "\x1b[46m"
+// const BgWhite = "\x1b[47m"
+// const BgGray = "\x1b[100m"
+export function logError(message, tabs = '') {
+    console.error(getColored(`[ERROR] ${tabs}${message}`, "red"));
+}
+export function logStep(message, tabs = '') {
+    console.info(getColored(`${tabs}${message}`, "green"));
+}
+function getColorName(name) {
+    const colors = { "Black": FgBlack,
+        "red": FgRed,
+        "green": FgGreen,
+        "yellow": FgYellow,
+        "blue": FgBlue,
+        "magenta": FgMagenta,
+        "cyan": FgCyan,
+        "white": FgWhite,
+        "gray": FgGray };
+    return colors[name] ? colors[name] : FgBlack;
+}
+export function getColored(text, colorName) {
+    const color = getColorName(colorName.toLowerCase());
+    return `${color}${text}${Reset}`;
+}

package/lib/helpers/connect.d.ts

@@ -0,0 +1,16 @@
+import { CustomObject } from "jsforce/lib/api/metadata.js";
+declare function connect(): Promise<void>;
+declare function check(): boolean;
+declare function getDependencies(listOfIds: string[]): Promise<Dependencies>;
+declare function getLwc(fullNames: string[]): Promise<ILwc[]>;
+declare function getClasses(fullNames: string[]): Promise<IApexClass[]>;
+declare function customObjects(fullNames: string[]): Promise<CustomObject[]>;
+declare const _default: {
+    connect: typeof connect;
+    check: typeof check;
+    customObjects: typeof customObjects;
+    getDependencies: typeof getDependencies;
+    getClasses: typeof getClasses;
+    getLwc: typeof getLwc;
+};
+export default _default;