autoforce 0.1.17 → 0.1.19

package/.autoforce.json

@@ -1,11 +1,15 @@
 {
-  "version": "0.1.17",
+  "version": "0.1.19",
   "backlogColumn": "Todo",
-  "model": "modelC",
-  "modelTemplates": "modelB",
   "gitServices": "github",
+  "gitModel": "githubflow",
+  "projectModel": "github-releases",
   "projectServices": "github",
   "projectId": "4",
   "listFilter": "mios",
-  "listTemplate": "openIssues"
+  "listTemplate": "openIssues",
+  "devModel": "npm",
+  "docModel": "processes",
+  "filter": "{states: OPEN}",
+  "template": "openIssues"
 }

package/CHANGELOG.md

@@ -1,7 +1,26 @@
 # Versiones
 
-## Version 0.1.16
+## Version 0.1.18
 - Fecha: 
+- Paquete: [Descargar](https://www.npmjs.com/package/autoforce/v/0.1.18ra la placa 
+
+TIPO CASO: Tarea Programada SF Deploy 254 Core & Industry 4 h)
+- Cambios:
+    * Reorganizar los modelos para que sea mas por la configuracion misma
+        - https://github.com/sebastianclaros/autoforce/issues/46
+
+
+## Version 0.1.17
+- Fecha: 13 Dic 2024
+- Paquete: [Descargar](https://www.npmjs.com/package/autoforce/v/0.1.17)
+- Cambios:
+    * [new] cuando se quiere crear un issue y se le manda  --milestone=v0.1.17 manda el title y no el id
+        - https://github.com/sebastianclaros/autoforce/issues/44
+    * Poder ejecutar autoforce en un subdirectorio, hoy tira un config como que no encuentra el autoforce.json
+        - https://github.com/sebastianclaros/autoforce/issues/45
+
+## Version 0.1.16
+- Fecha: 12 Dic 2024
 - Paquete: [Descargar](https://www.npmjs.com/package/autoforce/v/0.1.16)
 - Cambios:
     * [new] new milestone 

package/lib/auto.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());
-    });
-};
 // Comandos validos
-import { createObject, validateTask, getTasks, helpTask, runTask, getTaskFolder } from "./helpers/tasks.js";
+import { createObject, validateTask, getTasks, previewTask, helpTask, runTask } from "./helpers/tasks.js";
 import { logError } from "./helpers/color.js";
 import prompts from "prompts";
 import { createConfigurationFile, getConfigFile } from "./helpers/util.js";
@@ -21,51 +12,48 @@ const proxyCommand = {
 };
 const taskCommand = {
     'help': helpTask,
+    'preview': previewTask,
     'task': runTask,
     'new': runTask,
     'subtask': runTask
 };
-function showVersion() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const __dirname = dirname(fileURLToPath(import.meta.url));
-        const version = getConfigFile(__dirname + '/../.autoforce.json', 'version', '0.1.14');
-        console.log('AutoForce v' + version);
-        return true;
-    });
+async function showVersion() {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const version = getConfigFile(__dirname + '/../.autoforce.json', 'version', '0.1.14');
+    console.log('AutoForce v' + version);
+    return true;
 }
-export default function main() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const config = getConfigFromArgs(process.argv.slice(2));
-            const taskCommandKeys = Object.keys(taskCommand);
-            if (taskCommandKeys.includes(config.command)) {
-                const tasks = getTasks(config.taskFolder);
-                const taskName = yield askForTaskName(config.taskName, tasks);
-                if (taskName) {
-                    const task = tasks[taskName];
-                    context.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 taskCommand[config.command](task, context.options);
-                    }
-                    else {
-                        logError('Verifique que los json de task y subtask esten validos');
-                    }
+export default async function main() {
+    try {
+        const config = getConfigFromArgs(process.argv.slice(2));
+        const taskCommandKeys = Object.keys(taskCommand);
+        if (taskCommandKeys.includes(config.command)) {
+            const tasks = getTasks(config.subfolder);
+            const taskName = await askForTaskName(config.taskName, tasks);
+            if (taskName) {
+                const task = tasks[taskName];
+                context.options = config.arguments && task.arguments ? { ...config.options, ...createObject(task.arguments, config.arguments) } : config.options;
+                // Valida los json de task y subtask
+                if (validateTask(task)) {
+                    await taskCommand[config.command](task, context.options);
+                }
+                else {
+                    logError('Verifique que los json de task y subtask esten validos');
                 }
-            }
-            else {
-                yield proxyCommand[config.command](config.taskName, config.options);
             }
         }
-        catch (error) {
-            if (error instanceof Error) {
-                console.error(error.message);
-            }
+        else {
+            await proxyCommand[config.command](config.taskName, config.options);
         }
-    });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(error.message);
+        }
+    }
 }
 export function getConfigFromArgs(processArgs) {
-    const config = { options: {}, taskName: '', command: '', taskFolder: '' };
+    const config = { options: {}, taskName: '', command: '', subfolder: '', arguments: [] };
     const args = [];
     // Divide --xxx como options el resto como args
     for (const argName of processArgs) {
@@ -89,11 +77,11 @@ export function getConfigFromArgs(processArgs) {
     }
     // 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);
+        config.subfolder = currentArgument;
         currentArgument = args.shift();
     }
     else {
-        config.taskFolder = getTaskFolder(config.command);
+        config.subfolder = config.command;
     }
     if (typeof currentArgument == 'string') {
         config.taskName = currentArgument;
@@ -101,23 +89,21 @@ export function getConfigFromArgs(processArgs) {
     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;
+async function askForTaskName(taskName, tasks) {
+    // Si exite lo devuelve
+    if (tasks[taskName]) {
+        return taskName;
+    }
+    // Sino pregunta
+    const response = await 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

@@ -1,5 +1,6 @@
 import { DocumentationModule } from "../types/auto.js";
 export declare function getClasses(files: string[]): string[];
+export declare function executeClasses(items: string[], filename: string, folder: string): Promise<void>;
 declare const classModule: DocumentationModule;
 export default classModule;
 /**

package/lib/helpers/class.js

@@ -1,29 +1,24 @@
-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";
-import { DICTIONARY_FOLDER, TEMPLATE_MODEL_FOLDER } from "./util.js";
-const templateEngine = templateGenerator(`${TEMPLATE_MODEL_FOLDER}/dictionary`, "md");
+import { default as templateGenerator } from "./template.js";
+import { DICTIONARY_FOLDER, getModelFolders } from "./util.js";
+let _templateEngine;
+function getTemplateEngine() {
+    if (!_templateEngine) {
+        _templateEngine = templateGenerator(getModelFolders('dictionary'), "md");
+    }
+    return _templateEngine;
+}
 import { sortByName, getNamesByExtension, verFecha, splitFilename } 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 [];
-    });
+async function getMetadata(clases) {
+    try {
+        await sf.connect();
+        const classRecords = await sf.getClasses(clases);
+        return Array.isArray(classRecords) ? classRecords : [classRecords];
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return [];
 }
 export function getClasses(files) {
     const items = new Set();
@@ -128,70 +123,69 @@ function getInnerClasses(classes) {
     }
     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, {
+export async function executeClasses(items, filename, folder) {
+    const templateEngine = getTemplateEngine();
+    if (items.length === 0) {
+        return;
+    }
+    // Busca la metadata
+    let contexts = await 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,
-                filterByPublic,
                 classLinkGraph,
-                classLink
+                filterByPublic,
+                classAttributes,
+                scopeModifiers
             }
         });
-        templateEngine.save(filename, +"/" + folder);
+        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, +"/" + folder);
 }
 const classModule = {
     getItems: getClasses,