autoforce 0.1.1

package/lib/helpers/github-graphql.js

@@ -0,0 +1,363 @@
+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 { graphql } from "@octokit/graphql";
+export class GitHubApi {
+    constructor(token, owner, repo, projectNumber) {
+        this.repoVar = { owner, repo };
+        this.projectNumber = projectNumber;
+        this.graphqlAuth = graphql.defaults({
+            headers: {
+                authorization: `Bearer ${token}`,
+                "X-Github-Next-Global-ID": 1
+            },
+        });
+    }
+    getUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `{
+      viewer {
+        login
+        id
+      }
+    }`;
+            const { viewer } = yield this.graphqlAuth(query);
+            return viewer;
+        });
+    }
+    getRepository(label) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `
+        query getRepo($owner:String!, $repo: String!, $projectNumber: Int!, ${label ? '$label: String!' : ''} ) {
+          repository(owner: $owner, name: $repo) {
+            id
+            ${label ?
+                `label(name: $label) {
+                id
+              }` : ''}
+            projectV2( number: $projectNumber ) {
+              id
+              field(name: "Status") {
+                ... on ProjectV2SingleSelectField {
+                  id
+                  name
+                  options {
+                    name
+                    id
+                  }
+                }                
+              }
+            }
+          }
+        }
+    `;
+            const { repository } = yield this.graphqlAuth(query, Object.assign({ label, projectNumber: this.projectNumber }, this.repoVar));
+            return repository;
+        });
+    }
+    createPullRequest(branchName, title, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const repository = yield this.getRepository();
+            const repositoryId = repository.id;
+            const headRefName = 'main';
+            const baseRefName = branchName;
+            const mutationPullRequest = `
+      mutation createPullRequest( $baseRefName: String!, $headRefName: String!, $headRepositoryId: ID, $repositoryId: ID!, $title: String!, $body: String ) {
+        createPullRequest(
+            input: {
+              repositoryId: $repositoryId,
+              headRefName: $headRefName,
+              headRepositoryId: $headRepositoryId,
+              baseRefName: $baseRefName,
+              title: $title,
+              body: $body
+            }
+        ) {
+          pullRequest {
+            id
+          }
+        }
+      }`;
+            try {
+                const { createPullRequest } = yield this.graphqlAuth(mutationPullRequest, { baseRefName, headRefName, headRepositoryId: repositoryId, repositoryId, title, body });
+                return createPullRequest.pullRequest ? true : false;
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return false;
+        });
+    }
+    getColumnValueMap() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `
+        query getFieldOptions($owner:String!, $repo: String!, $projectNumber: Int!) {
+          repository(owner: $owner, name: $repo) {
+            projectV2(number: $projectNumber) {
+              field(name: "Status") {
+                ... on ProjectV2SingleSelectField {
+                  id
+                  name
+                  options {
+                    name
+                    id
+                  }
+                }                
+              }
+            }
+          }
+        }
+    `;
+            const { repository } = yield this.graphqlAuth(query, Object.assign({ projectNumber: this.projectNumber }, this.repoVar));
+            const mapValues = {};
+            for (const option of repository.projectV2.field.options) {
+                mapValues[option.name] = option.id;
+            }
+            return mapValues;
+        });
+    }
+    createIssue(title, state, label, milestone, body) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.getUser();
+            const repository = yield this.getRepository(label);
+            const repositoryId = repository.id;
+            const labelId = (_a = repository.label) === null || _a === void 0 ? void 0 : _a.id;
+            const projectId = repository.projectV2.id;
+            const mutationIssue = `
+      mutation createIssue($repositoryId: ID!, $assignId: ID!, $title: String!, $body: String, ${labelId ? '$labelId: ID!' : ''} , $milestoneId: ID ) {
+        createIssue(
+            input: {
+              repositoryId: $repositoryId,
+              assigneeIds: [$assignId],
+              ${labelId ? 'labelIds: [$labelId],' : ''}
+              title: $title,
+              milestoneId: $milestoneId,
+              body: $body
+            }
+        ) {
+          issue {
+            id
+            number
+          }
+        }
+      }`;
+            const { createIssue } = yield this.graphqlAuth(mutationIssue, { labelId, body, assignId: user.id, projectId, repositoryId, title, label: label ? [label] : null });
+            const issue = createIssue.issue;
+            if (!state || !issue.number) {
+                return issue.number;
+            }
+            const mutationItem = `
+      mutation addProjectV2ItemById($projectId: ID!, $contentId: ID! ) {
+        addProjectV2ItemById(
+            input: {
+              projectId: $projectId
+              contentId: $contentId
+            }
+        ) {
+          clientMutationId,
+          item {
+            id
+          }
+        }
+      }`;
+            const { addProjectV2ItemById } = yield this.graphqlAuth(mutationItem, { projectId, contentId: issue.id });
+            const itemId = addProjectV2ItemById.item.id;
+            const fieldId = repository.projectV2.field.id;
+            const mapValues = yield this.getColumnValueMap();
+            const columnValue = mapValues[state];
+            const mutationColumn = `
+    mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $columnValue: String!) {
+      updateProjectV2ItemFieldValue(
+        input: {
+          projectId: $projectId,
+          itemId: $itemId,
+          fieldId: $fieldId,
+          value: {singleSelectOptionId: $columnValue}
+        }
+      ) {
+        clientMutationId
+      }
+    }`;
+            const { updateProjectV2ItemFieldValue } = yield this.graphqlAuth(mutationColumn, { projectId, itemId, fieldId, columnValue });
+            if (!updateProjectV2ItemFieldValue.clientMutationId) {
+                return 0;
+            }
+            return issue.number;
+        });
+    }
+    moveIssue(issueNumber, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const issue = yield this.getIssue(issueNumber);
+            const itemId = issue.projectItems.nodes[0].id;
+            const projectId = issue.projectItems.nodes[0].project.id;
+            const fieldId = issue.projectItems.nodes[0].fieldValueByName.field.id;
+            const mapValues = yield this.getColumnValueMap();
+            const columnValue = mapValues[state];
+            const mutation = `
+    mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $columnValue: String!) {
+      updateProjectV2ItemFieldValue(
+        input: {
+          projectId: $projectId,
+          itemId: $itemId,
+          fieldId: $fieldId,
+          value: {singleSelectOptionId: $columnValue}
+        }
+      ) {
+        projectV2Item {
+          id
+        }
+      }
+    }`;
+            const { updateProjectV2ItemFieldValue } = yield this.graphqlAuth(mutation, { projectId, itemId, fieldId, columnValue });
+            return (updateProjectV2ItemFieldValue === null || updateProjectV2ItemFieldValue === void 0 ? void 0 : updateProjectV2ItemFieldValue.projectV2Item) ? true : false;
+        });
+    }
+    assignIssueToMe(issueNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.getUser();
+            const issue = yield this.getIssue(issueNumber);
+            const mutation = `
+      mutation assignUser( $issueId: ID!, $userId: ID!) { 
+        addAssigneesToAssignable(input: {
+          assignableId: $issueId
+          assigneeIds: [ $userId ]
+        }) {
+          assignable {
+            assignees {
+              totalCount
+            }
+          }
+        } 
+      }    
+    `;
+            const { addAssigneesToAssignable } = yield this.graphqlAuth(mutation, { issueId: issue.id, userId: user.id });
+            return addAssigneesToAssignable.assignable.assignees.totalCount > 0;
+        });
+    }
+    getCommit(commitSha) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `
+      query getCommit($owner:String!, $repo: String!, $commitSha: String!) {
+        repository(owner: $owner, name: $repo) {
+          object(expression: $commitSha) {
+                ... on Commit {
+                  id
+                  oid
+                }
+              }
+        }
+      } `;
+            const { repository } = yield this.graphqlAuth(query, Object.assign({ commitSha }, this.repoVar));
+            return repository.object;
+        });
+    }
+    assignBranchToIssue(issueNumber, branchName, commitSha) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const issue = yield this.getIssue(issueNumber);
+            const commit = yield this.getCommit(commitSha);
+            const mutation = `
+      mutation createLinkedBranch( $issueId: ID!, $oid: GitObjectID!, $branchName: String!) { 
+        createLinkedBranch(input: {
+          issueId: $issueId
+          oid: $oid
+          name: $branchName
+        })
+        {
+          issue {
+            id
+          }
+        }
+      }`;
+            const { createLinkedBranch } = yield this.graphqlAuth(mutation, { issueId: issue.id, oid: commit.oid, branchName });
+            console.log(createLinkedBranch);
+            return ((_a = createLinkedBranch === null || createLinkedBranch === void 0 ? void 0 : createLinkedBranch.issue) === null || _a === void 0 ? void 0 : _a.id) ? true : false;
+        });
+    }
+    getIssueState(issueNumber) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const issue = yield this.getIssue(issueNumber);
+            return (_c = (_b = (_a = issue.projectItems) === null || _a === void 0 ? void 0 : _a.nodes[0]) === null || _b === void 0 ? void 0 : _b.fieldValueByName) === null || _c === void 0 ? void 0 : _c.name;
+        });
+    }
+    getIssueName(title) {
+        return title.toLowerCase().replaceAll(' ', '-');
+    }
+    getIssueObject(issueNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const issue = yield this.getIssue(issueNumber);
+            const issueObject = { title: issue.title };
+            issueObject.name = this.getIssueName(issue.title);
+            if (issue.linkedBranches.nodes.length > 0) {
+                issueObject.branch = issue.linkedBranches.nodes[0].ref.name;
+            }
+            if (issue.projectItems.nodes.length > 0) {
+                issueObject.state = issue.projectItems.nodes[0].fieldValueByName.name;
+            }
+            if (issue.labels.nodes.length > 0) {
+                issueObject.labels = [];
+                for (const node of issue.labels.nodes) {
+                    issueObject.labels.push(node.name);
+                }
+            }
+            return issueObject;
+        });
+    }
+    getIssue(issueNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `
+      query getIssue($owner:String!, $repo: String!, $issueNumber: Int!) {
+        repository(owner: $owner, name: $repo) {
+          issue(number: $issueNumber) {
+            title
+            id
+            labels(first:3, orderBy:  { field: CREATED_AT, direction: DESC}) {
+              nodes {
+                color
+                name
+              }
+            }
+            projectItems(last: 1) {
+              nodes{
+                id, 
+                project {
+                  id
+                }
+                fieldValueByName(name: "Status"){
+      						... on ProjectV2ItemFieldSingleSelectValue {
+                    name
+                    id
+                    field {
+                      ... on ProjectV2SingleSelectField {
+                        id
+                      }
+                    }
+                  }
+                }
+              }
+            }             
+            linkedBranches(last:1){
+                nodes {
+                    ref {
+                      id
+                      name
+                    }
+                }
+            }
+          }
+        }
+      }
+  `;
+            const { repository } = yield this.graphqlAuth(query, Object.assign({ issueNumber }, this.repoVar));
+            return repository.issue;
+        });
+    }
+}

package/lib/helpers/gitlab-graphql.d.ts

@@ -0,0 +1,19 @@
+import { GraphQLClient } from 'graphql-request';
+import { AnyValue } from '../types/auto.js';
+export declare class GitLabApi implements IGitApi {
+    repoVar: {
+        owner: string;
+        repo: string;
+    };
+    projectNumber: number | undefined;
+    graphqlAuth: GraphQLClient;
+    constructor(token: string, owner: string, repo: string, projectNumber?: number);
+    getUser(): Promise<{
+        login: string;
+        id: number;
+    }>;
+    graphqlQuery(query: string, vars: Record<string, AnyValue>): Promise<unknown>;
+    getRepository(): Promise<void>;
+    createPullRequest(branchName: string, title: string, body: string): Promise<boolean>;
+    assignBranchToIssue(issueNumber: number, branchName: string, commitSha: string): Promise<boolean>;
+}

package/lib/helpers/gitlab-graphql.js

@@ -0,0 +1,78 @@
+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 { GraphQLClient } from 'graphql-request';
+const GITLAB_API = 'https://gitlab.com/api/graphql?remove_deprecated=true';
+export class GitLabApi {
+    constructor(token, owner, repo, projectNumber) {
+        this.graphqlAuth = new GraphQLClient(GITLAB_API);
+        this.repoVar = { owner, repo };
+        this.projectNumber = projectNumber;
+        this.graphqlAuth.setHeaders({ authorization: `Bearer ${token}` });
+    }
+    getUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `{
+          viewer {
+            login
+            id
+          }
+        }`;
+            const { viewer } = yield this.graphqlAuth.request(query);
+            return viewer;
+        });
+    }
+    // async request ( document: string, variables: Record<string, AnyValue> ) {
+    //   return await request({
+    //     url: GITLAB_API,
+    //     document,
+    //     variables,
+    //     headers: this.headers
+    //   })
+    // }
+    graphqlQuery(query, vars) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.graphqlAuth.request(query, vars);
+            return result;
+            //   let toProcess = result[endpoint]
+            //   let returnVal = toProcess.nodes
+            //   let pageInfo = toProcess.pageInfo
+            //   let curPage = pageInfo.endCursor
+            //   if ( pageInfo.hasNextPage ) {
+            //      curPage = pageInfo.endCursor
+            //     result = await this.graphql.request(query, vars)
+            //     returnVal = returnVal.concat(result[endpoint].nodes)
+            //     pageInfo = result[endpoint].pageInfo
+            //   }    
+            //  return returnVal
+        });
+    }
+    getRepository() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    createPullRequest(branchName, title, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `mutation($branchName: ID!, $title: String!, $body: String!) {
+
+        }`;
+            yield this.graphqlQuery(query, { branchName, title, body });
+            return true;
+        });
+    }
+    assignBranchToIssue(issueNumber, branchName, commitSha) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `mutation($branchName: ID!, $issueNumber: Int!, $commitSha: String!) {
+        
+      }`;
+            yield this.graphqlQuery(query, { branchName, issueNumber, commitSha });
+            return true;
+        });
+    }
+}

package/lib/helpers/lwc.d.ts

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

package/lib/helpers/lwc.js

@@ -0,0 +1,69 @@
+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, splitFilename, DICTIONARY_FOLDER, DOCS_FOLDER } from "./util.js";
+function getMetadata(lwc) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield sf.connect();
+            const lwcRecords = yield sf.getLwc(lwc);
+            return Array.isArray(lwcRecords) ? lwcRecords : [lwcRecords];
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return [];
+    });
+}
+function getLwc(files) {
+    const items = new Set();
+    for (const file of files) {
+        if (file.indexOf("/lwc/") > 0) {
+            const { filename } = splitFilename(file);
+            items.add(filename.split(".")[0]);
+        }
+    }
+    return [...items.values()];
+}
+function executeLwc(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 LWC
+        templateEngine.read("lwc");
+        for (const context of contexts) {
+            templateEngine.render(context, {
+                helpers: {}
+            });
+            templateEngine.save(context.Name, DICTIONARY_FOLDER + "/lwc");
+        }
+        // Arma el documento indice del grupo de lwc
+        contexts.sort(sortByName);
+        templateEngine.read("lwcs");
+        const lwcContext = { lwc: contexts };
+        templateEngine.render(lwcContext, {
+            helpers: {}
+        });
+        templateEngine.save(filename, DOCS_FOLDER + "/" + folder);
+    });
+}
+const lwcModule = {
+    getItems: getLwc,
+    execute: executeLwc
+};
+export default lwcModule;

package/lib/helpers/merge.d.ts

@@ -0,0 +1 @@
+export declare function merge(newContent: string, existingContent: string, cleanNotExistingTags?: boolean): string;

package/lib/helpers/merge.js

@@ -0,0 +1,81 @@
+/*
+ * busca los tags que empiezan <!-- START UNIQUE_KEY --> <!-- END UNIQUE_KEY -->
+ * @return matchObject {} Mapa de String a  {start, end, text}. Donde la key es UNIQUE_KEY, start es donde empieza el primer <!-- y end donde termina el segundo -->
+ */
+function createMatchObject(matches) {
+    const matchObject = {}; // mapa de key => { start: indice donde empieza, end: indice donde termina, text: texto entre ambos indices }
+    const indices = [];
+    for (const match of matches) {
+        //const tag = match[0];
+        const key = match[2].trim();
+        const startOrEnd = match[1].toLowerCase().trim(); // guarda si el match es start o end
+        if (startOrEnd !== 'start' && startOrEnd !== 'end') {
+            throw new Error(`No se puede hacer un merge porque se esperea un 'start' or'end' en vez de ${startOrEnd} `);
+        }
+        if (matchObject[key] && matchObject[key][startOrEnd] !== undefined) {
+            throw new Error(`No se puede hacer un merge porque hay mas de un ${startOrEnd} de ${key}. Debe haber uno solo por archivo `);
+        }
+        if (matchObject[key] === undefined) {
+            matchObject[key] = {};
+        }
+        if (typeof match.index !== 'undefined') {
+            matchObject[key][startOrEnd] =
+                startOrEnd === 'start' ? match.index : match.index + match[0].length;
+        }
+        const startIndex = matchObject[key].start;
+        const endIndex = matchObject[key].end;
+        if (startIndex !== undefined && endIndex !== undefined) {
+            if (endIndex < startIndex) {
+                throw new Error(`No se puede hacer un merge porque el start de ${key} esta despues del end`);
+            }
+            if (typeof match.input !== 'undefined') {
+                indices[startIndex] = endIndex;
+                matchObject[key].text = match.input.substring(startIndex, endIndex);
+            }
+        }
+    }
+    // Valida entradas incompletas
+    for (const key of Object.keys(matchObject)) {
+        if (matchObject[key].start === undefined ||
+            matchObject[key].end === undefined) {
+            throw new Error(`No se puede hacer un merge porque ${key} no tiene una apertura y cierre`);
+        }
+    }
+    // Valida que no haya anidamientos
+    let lastEndIndex = 0;
+    for (const start of Object.keys(indices).sort((a, b) => parseInt(a) - parseInt(b))) {
+        const startAsNumber = parseInt(start);
+        if (startAsNumber < lastEndIndex) {
+            throw new Error(`No se puede hacer un merge porque estan anidados los start y end tags`);
+        }
+        lastEndIndex = indices[startAsNumber];
+    }
+    return matchObject;
+}
+export function merge(newContent, existingContent, cleanNotExistingTags = true) {
+    let mergeContent = existingContent;
+    const regexp = /<!--[ ]*(start|end)[ ]*([^>]*)-->/gi;
+    const newMatches = createMatchObject(newContent.matchAll(regexp));
+    const existingMatches = createMatchObject(existingContent.matchAll(regexp));
+    const newKeys = Object.keys(newMatches);
+    const existingKeys = Object.keys(existingMatches);
+    for (const key of newKeys) {
+        // Por cada coincidencia reemplaza el texto existente por el texto nuevo
+        if (existingKeys.includes(key)) {
+            mergeContent = mergeContent.replace(existingMatches[key].text, newMatches[key].text);
+        }
+        else {
+            // Si no esta lo appendea (ideal seria que quede en el lugar)
+            mergeContent += newMatches[key].text;
+        }
+    }
+    // Borra los viejos
+    if (cleanNotExistingTags) {
+        for (const key of existingKeys) {
+            if (!newKeys.includes(key)) {
+                mergeContent = mergeContent.replace(existingMatches[key].text, "");
+            }
+        }
+    }
+    return mergeContent;
+}

package/lib/helpers/metadata.d.ts

@@ -0,0 +1,30 @@
+import type { DocumentationModule } from "../types/auto.js";
+declare const helpers: Record<string, DocumentationModule>;
+export default helpers;
+/**
+ * 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": [ "", ""]
+            }
+        ]
+    }
+]
+ */