autoforce 0.1.1

package/lib/helpers/connect.js

@@ -0,0 +1,261 @@
+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 jsforce from "jsforce";
+const DEBUG = process.env.DEBUG || false;
+const API_VERSION = "60.0";
+let conn;
+function connect() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const orgObject = context.scratch;
+        const accessToken = orgObject.accessToken;
+        const instanceUrl = orgObject.instanceUrl;
+        if (!(accessToken && instanceUrl)) {
+            console.error("Para bajar la metadata la herramienta se loguea a Salesforce con la default org. Verifique sf config get target-org");
+            throw new Error("Falta configurar ejecute: yarn auto config");
+        }
+        if (accessToken && instanceUrl) {
+            try {
+                conn = new jsforce.Connection({
+                    instanceUrl,
+                    accessToken,
+                    version: API_VERSION
+                });
+                //      const identity = await conn.identity();
+                //    console.log(identity);
+                if (DEBUG) {
+                    console.log(conn);
+                }
+            }
+            catch (e) {
+                if (DEBUG) {
+                    console.log(e);
+                }
+                throw `Por favor verifique accessToken y instanceUrl ${accessToken} ${instanceUrl}`;
+            }
+        }
+        //  if (username && password) {
+        //    try {
+        //      conn = new jsforce.Connection({
+        //        loginUrl: process.env.SF_LOGINURL || "https://test.salesforce.com",
+        //        version: API_VERSION
+        //      });
+        //      const userInfo = await conn.login(username, password);
+        //
+        //      if (DEBUG) {
+        //        console.log("accessToken", conn.accessToken);
+        //      }
+        //    } catch (e) {
+        //      if (DEBUG) {
+        //        console.log(e);
+        //      }
+        //      throw `Por favor verifique usuario y password ${username} ${password}`;
+        //    }
+        //  }
+    });
+}
+function check() {
+    return conn.accessToken ? true : false;
+}
+// async function getOmni(fullNames: string[]) {}
+// 
+// async function getIP(fullNames: string[]) {}
+function getDependencies(listOfIds) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const up = yield conn.tooling
+            .sobject("MetadataComponentDependency")
+            .find({ RefMetadataComponentId: listOfIds }, [
+            "RefMetadataComponentId",
+            "MetadataComponentId",
+            "MetadataComponentName",
+            "MetadataComponentType"
+        ]);
+        const down = yield conn.tooling
+            .sobject("MetadataComponentDependency")
+            .find({ MetadataComponentId: listOfIds }, [
+            "MetadataComponentId",
+            "RefMetadataComponentId",
+            "RefMetadataComponentName",
+            "RefMetadataComponentType"
+        ]);
+        const dependencies = {};
+        for (const record of up) {
+            const entry = {
+                Id: record.MetadataComponentId,
+                name: record.MetadataComponentName,
+                type: record.MetadataComponentType
+            };
+            let item = dependencies[record.RefMetadataComponentId];
+            if (!item) {
+                item = { parents: [], childs: [] };
+            }
+            item.childs.push(entry);
+        }
+        for (const record of down) {
+            const entry = {
+                Id: record.RefMetadataComponentId,
+                name: record.RefMetadataComponentName,
+                type: record.RefMetadataComponentType
+            };
+            let item = dependencies[record.MetadataComponentId];
+            if (!item) {
+                item = { parents: [], childs: [] };
+            }
+            item.parents.push(entry);
+        }
+        //   console.log(up, down, dependencies);
+        return dependencies;
+    });
+}
+function expiredSession() {
+    console.error("El token de la sesion expiro, puede actualizarlo manualmente corriendo sf org display y copiar el Access Token en el .env ");
+    process.exit(-1);
+}
+function getLwc(fullNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        /**
+      Archivos, JS => JSDoc
+      */
+        //console.log( JSON.stringify(conn.version) );
+        try {
+            const bundle = yield conn.tooling
+                .sobject("LightningComponentBundle")
+                .find({ MasterLabel: fullNames }, [
+                "MasterLabel",
+                "Language",
+                "Metadata",
+                "NamespacePrefix",
+                "Id"
+            ]);
+            const listOfIds = bundle.map((item) => item.Id);
+            if (listOfIds.length > 0) {
+                const listOfResources = yield conn.tooling
+                    .sobject("LightningComponentResource")
+                    .find({ LightningComponentBundleId: listOfIds }, [
+                    "LightningComponentBundleId",
+                    "Format",
+                    "FilePath",
+                    "Source"
+                ]);
+                // Convierte los resources en un mapa con clave el Id y como valor la lista de sus resources
+                const resources = {};
+                for (const resource of listOfResources) {
+                    const lwcId = resource.LightningComponentBundleId;
+                    if (!resources[lwcId]) {
+                        resources[lwcId] = [resource];
+                    }
+                    else {
+                        resources[lwcId].push(resource);
+                    }
+                }
+                // Saca las dependencias
+                const dependencies = yield getDependencies(listOfIds);
+                const metadata = bundle.map((item) => {
+                    return Object.assign({ Name: item.MasterLabel, resources: resources[item.Id], dependencies: dependencies[item.Id] }, item.Metadata);
+                });
+                return metadata;
+            }
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                if (e.name == "INVALID_SESSION_ID" || e.name == "sf:INVALID_SESSION_ID") {
+                    expiredSession();
+                }
+                if (DEBUG) {
+                    console.log(e);
+                }
+                const msg = (e.name == 'ERROR_HTTP_420') ? 'El accesstoken y el instance url en el .env parece que no coinciden, verifique con sf org display' : `Error buscando metadata de los lwc ${fullNames}. ERR-NAME: ${e.name}`;
+                throw msg;
+            }
+        }
+        return [];
+    });
+}
+function getClasses(fullNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // > tooling.sobject('ApexClass').find({ Name: "AsistenciasController" })
+            const classNames = fullNames.map((clase) => clase.replace(".cls", ""));
+            const metadata = yield conn.tooling
+                .sobject("ApexClass")
+                .find({ Name: classNames }, [
+                "Name",
+                "Status",
+                "IsValid",
+                "ApiVersion",
+                "CreatedDate",
+                "LastModifiedDate",
+                "SymbolTable"
+            ]);
+            if (DEBUG) {
+                console.log(JSON.stringify(metadata));
+            }
+            return metadata;
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                if (e.name == "INVALID_SESSION_ID" || e.name == "sf:INVALID_SESSION_ID") {
+                    expiredSession();
+                }
+                if (DEBUG) {
+                    console.log(e);
+                }
+                const msg = (e.name == 'ERROR_HTTP_420') ? 'El accesstoken y el instance url en el .env parece que no coinciden, verifique con sf org display' : `Error buscando metadata de las clases ${fullNames}. ERR-NAME: ${e.name}`;
+                throw msg;
+            }
+        }
+        return [];
+    });
+}
+function customObjects(fullNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let metadata;
+            if (fullNames.length <= 10) {
+                metadata = (yield conn.metadata.read("CustomObject", fullNames));
+            }
+            else {
+                metadata = [];
+                do {
+                    const items = fullNames.splice(0, 10);
+                    const result = yield conn.metadata.read("CustomObject", items);
+                    metadata = metadata.concat(result);
+                } while (fullNames.length > 0);
+            }
+            if (DEBUG) {
+                console.log(JSON.stringify(metadata));
+            }
+            return metadata;
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                if (e.name == "INVALID_SESSION_ID" || e.name == "sf:INVALID_SESSION_ID") {
+                    expiredSession();
+                }
+                if (DEBUG) {
+                    console.log(e);
+                }
+                const msg = (e.name == 'ERROR_HTTP_420') ? 'El accesstoken y el instance url en el .env parece que no coinciden, verifique con sf org display' : `Error buscando metadata de los objetos ${fullNames}. ERR-NAME: ${e.name}`;
+                throw msg;
+            }
+        }
+        return [];
+    });
+}
+export default {
+    connect,
+    check,
+    customObjects,
+    getDependencies,
+    getClasses,
+    getLwc
+};
+// getIP
+// getOmni

package/lib/helpers/context.d.ts

@@ -0,0 +1,80 @@
+import type { PromptChoices } from "../types/helpers/context.js";
+import type { IProcessHeader, Processes, AnyValue, IProcessInfo, ObjectRecord, IObjectRecord } from "../types/auto.js";
+import type { TaskArguments, TaskArgument, StepArguments } from "../types/helpers/tasks.js";
+export declare function createConfigurationFile(): Promise<boolean>;
+declare class Context implements IObjectRecord {
+    [s: string]: AnyValue | undefined;
+    isGitApi: boolean;
+    gitApi: IGitApi | undefined;
+    projectApi: IProjectApi | undefined;
+    sfInstalled: boolean;
+    sfToken: boolean;
+    branchName: string | undefined;
+    issueNumber: number | undefined;
+    issueType: string | undefined;
+    _process: string | undefined;
+    _processesHeader: Record<string, IProcessHeader> | undefined;
+    _newIssueNumber: number | undefined;
+    _newIssueType: string | undefined;
+    newBranchName: string | undefined;
+    defaultDias: number;
+    permissionSet: string | undefined;
+    issueTitle: string | undefined;
+    isVerbose: boolean;
+    projectPath: string;
+    _scratch: OrganizationInfo | undefined;
+    _branchScratch: OrganizationInfo | undefined;
+    existNewBranch: boolean;
+    _targetOrg: string | undefined;
+    processes: Processes | undefined;
+    salida: string;
+    repositoryUrl: string | undefined;
+    repositoryType: string | undefined;
+    repositoryOwner: string | undefined;
+    repositoryRepo: string | undefined;
+    projectNumber: number | undefined;
+    loadGitApi(): void;
+    loadPackage(): void;
+    loadConfig(): void;
+    init(): void;
+    get targetOrg(): string;
+    get existBranchScratch(): boolean;
+    get branchScratch(): OrganizationInfo | undefined;
+    getProcessHeader(fullpath: string): {
+        [key: string]: any;
+    };
+    addProcessMetadata(component: string, items: string[]): void;
+    get processesHeader(): Record<string, IProcessHeader>;
+    getProcessMetadata(): IProcessInfo[];
+    getModules(): string[];
+    get modules(): PromptChoices;
+    get existScratch(): boolean;
+    get scratch(): OrganizationInfo;
+    validate(guards: string[]): Promise<void>;
+    issueFromBranch(branchName: string): void;
+    branchNameFromIssue(issueType: string, issueNumber: number, title?: string): string;
+    get isDevelopment(): boolean;
+    get isNewDevelopment(): boolean;
+    get newIssueNumber(): number | undefined;
+    set newIssueNumber(value: number | undefined);
+    get newIssueType(): string | undefined;
+    set newIssueType(value: string | undefined);
+    setNewBranchName(): void;
+    askFornewBranchName(): Promise<string | undefined>;
+    askFornewIssueNumber(): Promise<any>;
+    set process(value: string | undefined);
+    getProcessFromTitle(title: string): string | undefined;
+    get process(): string | undefined;
+    askForprocess(): Promise<any>;
+    askFornewIssueType(): Promise<any>;
+    convertToArrayOfInputs(inputs: TaskArguments): TaskArgument[];
+    askForExit(): Promise<void>;
+    mergeArgs(args: StepArguments): StepArguments;
+    askForArguments(inputs: TaskArguments): Promise<void>;
+    setObject(obj: ObjectRecord): void;
+    set(key: keyof IObjectRecord, value: AnyValue): void;
+    get(key: string): Promise<AnyValue>;
+    merge(text: string): string;
+}
+declare const context: Context;
+export default context;