autoforce 0.1.1

package/lib/helpers/metadata.js

@@ -0,0 +1,119 @@
+import objectHelper from "./object.js";
+import classHelper from "./class.js";
+import lwcHelper from "./lwc.js";
+// Logica especificas de cada componente
+const helpers = {
+    objects: objectHelper,
+    classes: classHelper,
+    lwc: lwcHelper
+};
+export default helpers;
+/*
+import context from "./context.js";
+import { DOCS_FOLDER } from "./util.js";
+import type { DocumentationModule, IProcessInfo, IMetadataNode, IMetadataComponentNode } from "../types/auto.js";
+function getMetadataFromContext(components: string[]) {
+    return getMetadataArray(context.getProcessMetadata(), components);
+}
+
+function mergeArray(baseArray: string[], newArray: string[]) {
+    if (!Array.isArray(newArray) && !Array.isArray(baseArray)) {
+      return [];
+    }
+    // Si el new esta vacio
+    if (!Array.isArray(newArray) || newArray.length == 0) {
+      return baseArray;
+    }
+    // Si el base esta vacio
+    if (!Array.isArray(baseArray) || baseArray.length == 0) {
+      return newArray;
+    }
+    // Sino filtra y concatena
+    const notIncludeInBaseArray = (a:string) => baseArray.indexOf(a) === -1;
+    return baseArray.concat(newArray.filter(notIncludeInBaseArray));
+}
+  
+  
+function getMetadataArray(metadata: IProcessInfo[], props: string[]) {
+    const mergeObject = (root: IMetadataNode, childs: IMetadataNode[]) => {
+      for (const item of childs) {
+        for (const key of props as (keyof IMetadataComponentNode)[]) {
+          root[key] = mergeArray(root[key], item[key]);
+        }
+      }
+      return root;
+    };
+    const getItemsFromTree = (node: IMetadataNode, parentPath = '') => {
+      const items: IMetadataNode[] = [];
+      if (Array.isArray(node)) {
+        for (const item of node) {
+          items.push(...getItemsFromTree(item, parentPath));
+        }
+      } else {
+        const folder = node.hasChilds ? node.folder : node.name;
+        node.path = parentPath ? `${parentPath}/${folder}` : folder;
+        if (node.hasChilds) {
+          // Borra el childs, pero le deja hasChilds en true para saber si es una hoja del arbol
+          const { childs, ...itemToAdd } = node;
+          itemToAdd.hasChilds = true;
+          const childItems = getItemsFromTree(childs, node.path);
+          items.push(mergeObject(itemToAdd, childItems));
+          items.push(...childItems);
+        } else {
+          items.push(node);
+        }
+      }
+      return items;
+    };
+  
+    return getItemsFromTree({ folder: DOCS_FOLDER, childs: metadata });
+  }
+  
+export async function execute() {
+  const components = Object.keys(helpers);
+  const nodes = getMetadataFromContext(components);
+
+  for (const node of nodes) {
+    for (const component of components) {
+        const filename = node.hasChilds
+        ? `${node.path}/intro.md`
+        : `${node.path}/${node.name}.md`;
+        const items = node[component];
+        if (items?.length > 0) {
+            const helper = helpers[component];
+            await helper.execute(items, filename, node.path);
+        }
+    }
+  }
+}
+
+
+
+*/
+/**
+ * example json
+ *
+    "process-name": {
+      "classes": string:[],
+      "objects": string:[]
+    },
+
+
+
+[
+    {
+        "name": "modulo",
+        "description": "descripcion del modulo",
+        "components": [
+            {
+                "name": "",
+                "description": "descripcion del item",
+                "path": "folder-name-only",
+                "objects": [ "", ""],
+                "classes": [ "", ""],
+                "lwc": [ "", ""]
+            }
+        ]
+    }
+]
+ */ 

package/lib/helpers/object.d.ts

@@ -0,0 +1,3 @@
+import { DocumentationModule } from "../types/auto.js";
+declare const objectModule: DocumentationModule;
+export default objectModule;

package/lib/helpers/object.js

@@ -0,0 +1,133 @@
+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 { sortByLabel, DICTIONARY_FOLDER, DOCS_FOLDER, } from "./util.js";
+function getMetadata(objetos) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield sf.connect();
+            const objects = yield sf.customObjects(objetos);
+            return Array.isArray(objects) ? objects : [objects];
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return [];
+    });
+}
+function descriptionFormula() {
+    var _a;
+    return (_a = this.description) === null || _a === void 0 ? void 0 : _a.replaceAll(/[\n\r]/g, "<br/>");
+}
+function isManaged() {
+    return this.fullName.split("__").length == 3;
+}
+function isMetadataFormula() {
+    var _a;
+    return ((_a = this.fullName) === null || _a === void 0 ? void 0 : _a.endsWith("__mdt")) || this.customSettingsType;
+}
+function attributesFormula() {
+    const attributes = [];
+    // Object Attributes
+    if (this.enableHistory === "true") {
+        attributes.push(`![Track History](/img/tracker_60.png)`);
+    }
+    // "enableActivities": "true",
+    // "enableBulkApi": "true",
+    // "enableChangeDataCapture": "false",
+    // "enableFeeds": "false",
+    // "enableHistory": "true",
+    // "enableReports": "true",
+    // "enableSearch": "false",
+    // "enableSharing": "true",
+    // "enableStreamingApi": "true",
+    // "externalSharingModel": "Private",
+    // Field Attributes
+    if (this.required === "true") {
+        attributes.push(`![Required](/img/lock_60.png)`);
+    }
+    if (this.trackHistory === "true") {
+        attributes.push(`![Track History](/img/tracker_60.png)`);
+    }
+    // if ( this.inlineHelpText ) {
+    //     attributes.push( `![${this.inlineHelpText}](/img/help_60.png)` );
+    // }
+    if (this.externalId === "true") {
+        attributes.push(`![External Id](/img/database_60.png)`);
+    }
+    if (this.encrypted === "true") {
+        attributes.push(`![Encripted](/img/password_60.png)`);
+    }
+    return attributes.join(" ");
+}
+function typeFormula() {
+    if (this.formula) {
+        return `Formula(${this.type})`;
+    }
+    if (this.type === "Lookup" || this.type === "MasterDetail") {
+        return `[Lookup a ${this.referenceTo}](/diccionarios/objects/${this.referenceTo})`;
+    }
+    if (this.length || this.precision) {
+        const longitud = (this.length || this.precision) +
+            (this.scale && this.scale > 0 ? "." + this.scale : "");
+        return `${this.type}(${longitud})`;
+    }
+    return this.type;
+}
+function getObjects(files) {
+    const items = new Set();
+    for (const file of files) {
+        let desde = file.indexOf("/objects/");
+        if (desde !== -1) {
+            desde += 9; // se desplaza hasta el proximo slash
+            const hasta = file.indexOf("/", desde + 1);
+            const objectName = file.substring(desde, hasta);
+            items.add(objectName);
+        }
+    }
+    return [...items.values()];
+}
+function executeObjects(items, filename, folder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (items.length === 0) {
+            return;
+        }
+        // Busca la metadata
+        const contexts = yield getMetadata(items);
+        if (!contexts || contexts.length === 0) {
+            return;
+        }
+        // Arma el diccionario de cada Objeto
+        templateEngine.read("object");
+        for (const context of contexts) {
+            if (context.fullName) {
+                templateEngine.render(context, {
+                    helpers: { isManaged, descriptionFormula, typeFormula, attributesFormula }
+                });
+                templateEngine.save(context.fullName, DICTIONARY_FOLDER + "/objects");
+            }
+        }
+        // Arma el documento indice del grupo de objetos
+        contexts.sort(sortByLabel);
+        templateEngine.read("objects");
+        const objectContext = { objects: contexts };
+        templateEngine.render(objectContext, {
+            helpers: { isManaged, isMetadataFormula, attributesFormula }
+        });
+        templateEngine.save(filename, DOCS_FOLDER + "/" + folder);
+    });
+}
+const objectModule = {
+    getItems: getObjects,
+    execute: executeObjects
+};
+export default objectModule;

package/lib/helpers/openai.d.ts

@@ -0,0 +1 @@
+export declare function getCommitMessage(): Promise<string | null>;

package/lib/helpers/openai.js

@@ -0,0 +1,53 @@
+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 OpenAI from 'openai';
+const client = new OpenAI({
+    apiKey: process.env['OPENAI_API_KEY'], // This is the default and can be omitted
+});
+export function getCommitMessage() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (process.env['OPENAI_API_KEY']) {
+            const params = {
+                messages: [{ role: 'user', content: 'Say this is a test' }],
+                model: 'gpt-3.5-turbo',
+            };
+            const chatCompletion = yield client.chat.completions.create(params);
+            return (_a = chatCompletion.choices[0].message) === null || _a === void 0 ? void 0 : _a.content;
+        }
+        return null;
+    });
+}
+/*
+// getCommitMessage();
+{
+                model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: generatePrompt(locale, maxLength, type),
+                    },
+                    {
+                        role: 'user',
+                        content: diff,
+                    },
+                ],
+                temperature: 0.7,
+                top_p: 1,
+                frequency_penalty: 0,
+                presence_penalty: 0,
+                max_tokens: 200,
+                stream: false,
+                n: completions,
+            },
+            timeout,
+            proxy
+        );
+*/ 

package/lib/helpers/taskFunctions.d.ts

@@ -0,0 +1,14 @@
+import type { IStepCommand, IStepFunction } from "../types/helpers/tasks.js";
+import { AnyValue } from "../types/auto.js";
+export declare function executeCommand(step: IStepCommand): Promise<boolean>;
+export declare function validateCommand(step: IStepCommand): boolean;
+export declare function validateFunction(step: IStepFunction): boolean;
+export declare function getCurrentOrganization(): OrganizationInfo;
+export declare function getOrganizationObject(alias: string, type?: string): OrganizationInfo;
+export declare function getTargetOrg(): string;
+export declare function getBranchName(): string;
+export declare function executeFunction(step: IStepFunction): Promise<boolean>;
+export declare function executeShell(command: string): string;
+export declare const taskFunctions: {
+    [s: string]: AnyValue;
+};