@suitegeezus/suitecloud-stacker 25.2.127

package/commands/projectDeploy.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askForDryrun = exports.logErrors = exports.promptForDeployFile = exports.forceLog = exports.runTestBeforeDeploy = exports.compileBeforeDeploy = exports.forceValidate = exports.offerValidate = exports.doDryRunAsChild = void 0;
+const promptHelper = require("../lib/promptHelpers");
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const onErrorHelper = require("../lib/onErrorHelper");
+const spawnSuitecloud = require("../lib/spawnSuitecloudChild");
+const deployFileHelper = require("../lib/deployFileHelper");
+const tempFileHelper = require("../lib/tempFileHelper");
+const compileHelper = require("../lib/compileHelper");
+const logHelper = require("../lib/logHelper");
+const pathHelper = require("../lib/pathHelpers");
+// CONSTANTS.PROJECT_JSON_PATH
+const doDryRunAsChild = async (authid) => {
+    process.stdout.write(promptHelper.goColor('INFO', '\nPerforming dryrun'));
+    const errorCode = await spawnSuitecloud.createAsync({
+        command: 'project:deploy',
+        args: ['--dryrun', '--authid', authid || 'foo'],
+        interact: true,
+    });
+    if (errorCode)
+        throw new Error('Dry Run failed. Check log');
+    return errorCode;
+};
+exports.doDryRunAsChild = doDryRunAsChild;
+const offerValidate = () => {
+    return {
+        _origin: 'offerValidate',
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (options?.arguments?.runhooks === 'quiet')
+                return options;
+            const choices = { 'Y': 'Yes', 'N': 'No' };
+            let answer = await promptHelper.promptChoices({
+                choices,
+                displayChoices: choices,
+                default: choices['Y'],
+                question: `Validate Deployment?`
+            });
+            options.arguments.validate = (answer === choices['Y']);
+            return options;
+        },
+        onCompleted: async (options) => {
+            return options;
+        }
+    };
+};
+exports.offerValidate = offerValidate;
+const forceValidate = () => {
+    return {
+        _origin: 'forceValidate',
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            options.arguments.validate = true;
+            return options;
+        },
+        onCompleted: async (options) => {
+            return options;
+        }
+    };
+};
+exports.forceValidate = forceValidate;
+const compileBeforeDeploy = () => {
+    const origin = 'compileBeforeDeploy';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            try {
+                if (spawnSuitecloud.isChildProcess())
+                    return options;
+                if (options?.arguments?.runhooks === 'quiet')
+                    return options;
+                const hasTsc = await compileHelper.hasTsConfig();
+                if (!hasTsc)
+                    return options;
+                const contents = compileHelper.previewFile(hasTsc);
+                process.stdout.write(promptHelper.goColor('SUBTLE', '\ntsConfig', contents));
+                const choices = { 'Y': 'Yes', 'N': 'No' };
+                let answer = await promptHelper.promptChoices({
+                    choices,
+                    displayChoices: choices,
+                    default: choices['Y'],
+                    question: `Compile Typescript?`
+                });
+                if (answer === choices['N'])
+                    return options;
+                const errorCode = await compileHelper.compileTsConfig();
+                if (errorCode === 0)
+                    return options;
+                answer = await promptHelper.promptChoices({
+                    choices,
+                    displayChoices: choices,
+                    default: choices['Y'],
+                    question: `Continue with errors?`
+                });
+                if (answer === choices['Y'])
+                    return options;
+                throw new Error(origin + ':Errors compiling');
+            }
+            catch (e) {
+                throw new Error(origin + ':Unexpected Error');
+            }
+            return options;
+        },
+        onError: async (error) => onErrorHelper.detectOriginAndReturn(origin, error),
+    };
+};
+exports.compileBeforeDeploy = compileBeforeDeploy;
+/**
+ * @deprecated
+ */
+const runTestBeforeDeploy = () => {
+    const origin = 'runTestBeforeDeploy';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            // passthrough child processes
+            try {
+                if (spawnSuitecloud.isChildProcess())
+                    return options;
+                if (options?.arguments?.runhooks === 'quiet')
+                    return options;
+                const choices = { 'Y': 'Yes (not supported yet)', 'N': 'No' };
+                let answer = await promptHelper.promptChoices({
+                    choices,
+                    displayChoices: choices,
+                    default: choices['Y'],
+                    question: `Run tests on deploying JS files? \n(This will perform a dryrun to obtain which files need testing)`,
+                });
+                if (answer === choices['N'])
+                    return options;
+                // wait for a dryun run
+                throw onErrorHelper.makeError(origin, new Error('Not supported yet'));
+                // get the files from the dryrun file
+                const results = await tempFileHelper.consumeTempFile('dryrun.json');
+                // console.log({results}, 'dryrun results');
+                const data = JSON.parse(results)?._data;
+                const testFiles = await data.reduce(async (flatAcc, l) => {
+                    const acc = await flatAcc;
+                    if (l.startsWith('Upload file') && l.endsWith('.js')) {
+                        const realPath = await deployFileHelper.getRealPathofInnerXmlPath(l);
+                        acc.push(realPath);
+                    }
+                    return acc;
+                }, Promise.resolve([]));
+                const errorCode = await compileHelper.runJestTest(testFiles).catch((e) => {
+                    if (spawnSuitecloud.isChildProcess())
+                        throw e;
+                    return 1;
+                });
+                if (errorCode !== 0) {
+                    const choices = { 'Y': 'Yes', 'N': 'No' };
+                    let answer = await promptHelper.promptChoices({
+                        choices,
+                        displayChoices: choices,
+                        default: choices['Y'],
+                        question: `Tests failed. Would you like to deploy Anyway?`
+                    });
+                    if (answer === choices['Y'])
+                        return options;
+                    throw onErrorHelper.makeError(origin, new Error('Jest Tests failed'));
+                }
+                return options;
+            }
+            catch (e) {
+                throw onErrorHelper.makeError(origin, e);
+            }
+        },
+        onCompleted: async (options) => {
+            return options;
+        },
+        onError: async (error) => onErrorHelper.detectOriginAndReturn(origin, error)
+    };
+};
+exports.runTestBeforeDeploy = runTestBeforeDeploy;
+const forceLog = () => {
+    return {
+        _origin: 'forceLog',
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            const now = new Date().toISOString();
+            const { log } = {
+                log: (await logHelper.useSdfLog(options.command || 'unknown')),
+                ...options?.arguments
+            };
+            options.arguments.log = log;
+            // make log dir
+            await fs.access(path.join(process.cwd(), path.dirname(options.arguments.log)))
+                .catch(() => fs.mkdir(path.join(process.cwd(), path.dirname(options.arguments.log))));
+            return options;
+        },
+        onCompleted: async (options) => {
+            return options;
+        }
+    };
+};
+exports.forceLog = forceLog;
+/**
+ * @description - prompt deployXml choices and confirm
+ * @see {SdfCommand}
+ */
+const promptForDeployFile = () => {
+    const toReturn = {
+        _origin: 'promptForDeployFile',
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (options?.arguments?.runhooks === 'quiet')
+                return options;
+            try {
+                process.stdout.write(promptHelper.goColor('SUBTLE', '\npromptForDeployFile', options));
+                const { projectPath } = options;
+                // check if there is a current deploy file at the root
+                let deployFilePath = await deployFileHelper.hasDeployXml(projectPath);
+                const choices = { 'Y': 'Yes', 'N': 'No' };
+                let answer = choices['N'];
+                if (deployFilePath && !spawnSuitecloud.isChildProcess()) {
+                    const contentDeployXml = await deployFileHelper.previewFile(deployFilePath);
+                    // display the chosen contents and confirm
+                    answer = await promptHelper.promptChoices({
+                        choices,
+                        displayChoices: choices,
+                        default: choices['Y'],
+                        question: 'Use this file? (Y/N)',
+                        premessage: contentDeployXml
+                    });
+                    //
+                    if (answer === choices['N'])
+                        await deployFileHelper.removeFile(deployFilePath);
+                    if (answer === choices['Y'])
+                        return options;
+                }
+                if ((!deployFilePath || answer === choices['N']) && !spawnSuitecloud.isChildProcess()) {
+                    // look for deploy files that we can use below the current working directory
+                    const deployXmlList = await deployFileHelper.listDeployXmlFiles(projectPath);
+                    deployFilePath = await promptHelper.promptChoices({
+                        choices: deployXmlList,
+                        displayChoices: deployXmlList.map((l) => [l, promptHelper.goColor('SUBTLE', `${options.projectPath}/${l}`.replace(/^.*(\bSuiteScripts\b.*)$/, '($1)'))].join(' ')),
+                        default: deployXmlList[0],
+                        question: 'Use which deploy file?',
+                    });
+                }
+                const filesFromXml = await deployFileHelper.extractFilePathsFromDeployXmlFile(options.projectPath, deployFilePath, 'SuiteScripts');
+                const objectsFromXml = await deployFileHelper.extractFilePathsFromDeployXmlFile(options.projectPath, deployFilePath, 'Objects');
+                const filecabinetHolder = await pathHelper.getFolderHoldingFileCabinetPlus(options.projectPath);
+                const filteredFilesAgainstGlobs = await pathHelper.getAllFilesRecursively(
+                // need to examine ALL files in the project
+                [filecabinetHolder, 'FileCabinet', 'SuiteScripts'], 'SuiteScripts', 
+                //
+                filesFromXml.map((fx) => fx.replace(/^.*(.\bSuiteScripts\b.*)$/, '$1')));
+                const filteredObjectsAgainstGlobs = await pathHelper.getAllFilesRecursively(
+                // need to examine ALL files in the project
+                [filecabinetHolder, 'Objects'], 'Objects', 
+                //
+                objectsFromXml
+                    .map((ox) => ox.replace(/^.*(.\bObjects\b.*)$/, '$1'))
+                    .map((ox) => {
+                    const [typeOrPath, pathOrUndefined] = ox.split(':');
+                    return pathOrUndefined || typeOrPath;
+                }));
+                const filteredLegalFiles = pathHelper.removeIllegalFileCabinetFiles(filteredFilesAgainstGlobs);
+                const deployXmlContent = deployFileHelper.makeDeployXmlString(filteredLegalFiles, filteredObjectsAgainstGlobs);
+                // make the candidate deployXml file inthe projectPath
+                await deployFileHelper.createDeployXmlFile(deployXmlContent, [filecabinetHolder, 'deploy.xml']);
+                await promptHelper.promptUser({
+                    message: 'kill me now',
+                });
+                // loop only for re-prompting
+                if (!spawnSuitecloud.isChildProcess())
+                    return await toReturn.beforeExecuting(options);
+                //
+                return options;
+            }
+            catch (e) {
+                console.log({ e });
+                throw e;
+            }
+        },
+        onCompleted: async (options) => {
+            // remove the temporary deploy.xml file?
+            return options;
+        }
+    };
+    return toReturn;
+};
+exports.promptForDeployFile = promptForDeployFile;
+const logErrors = () => {
+    return {
+        _origin: 'logError',
+        isStackable: true,
+        onError: async (error) => onErrorHelper.detectOriginAndReturn('logError', error, (error) => {
+            return error;
+        })
+    };
+};
+exports.logErrors = logErrors;
+/**
+ * @description -
+ * @
+ */
+const askForDryrun = () => {
+    const origin = 'askForDryrun';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            process.stdout.write(promptHelper.goColor('SUBTLE', options));
+            if (options?.arguments?.runhooks === 'quiet')
+                return options;
+            try {
+                const choices = { 'Y': 'Yes', 'N': 'No' };
+                let answer = choices['N'];
+                let innerDryRunError = false;
+                if (!options.arguments.dryrun && !spawnSuitecloud.isChildProcess()) {
+                    answer = await promptHelper.promptChoices({
+                        choices,
+                        displayChoices: choices,
+                        default: choices['Y'],
+                        question: 'Would ou like to do a dryrun first?',
+                    });
+                    if (answer === choices['Y']) {
+                        // mini internal dryrun
+                        // spawn child
+                        const errorCode = await (0, exports.doDryRunAsChild)(options.authId).catch((e) => {
+                            throw new Error(origin + ':Dryrun failed');
+                        });
+                        if (errorCode)
+                            innerDryRunError = true;
+                    }
+                }
+                if (!options.arguments.dryrun && !spawnSuitecloud.isChildProcess()) {
+                    if (answer === choices['N']) {
+                        // ask if this should be a dryrun
+                        const answer = await promptHelper.promptChoices({
+                            choices,
+                            displayChoices: choices,
+                            default: choices['Y'],
+                            question: 'Would you like to make this run a dryrun?',
+                        });
+                        if (answer === choices['Y'])
+                            options.arguments.dryrun = true;
+                    }
+                }
+                // these are exclusive options to each other
+                if (options.arguments.dryrun)
+                    options.arguments.validate = false;
+                return options;
+            }
+            catch (e) {
+                throw new Error(origin + ':Unexpected Error');
+            }
+        },
+        onCompleted: async (options) => {
+            // store results
+            process.stdout.write(promptHelper.goColor('SUBTLE', options));
+            if (/preview process/.test(options._resultMessage)) {
+                await tempFileHelper.makeTempFile('dryrun.json', JSON.stringify(options, null, 2));
+            }
+            return options;
+        },
+        onError: async (error) => onErrorHelper.detectOriginAndReturn(origin, error, (error) => {
+            // check log
+            console.error(error);
+            return error;
+        }),
+    };
+};
+exports.askForDryrun = askForDryrun;
+//# sourceMappingURL=projectDeploy.js.map

package/commands/projectPackage.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/projectPackage
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "#root/index";
+/**
+ * @description - watches for a non-standard argument
+ * - meant for you to use nodemon to keep it runninga
+ */
+export declare const watchAndCompile: () => SdfCommand;

package/commands/projectPackage.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/projectPackage
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchAndCompile = void 0;
+const safeCommands = require("../safeCommands");
+/**
+ * @description - watches for a non-standard argument
+ * - meant for you to use nodemon to keep it runninga
+ */
+const watchAndCompile = () => {
+    const origin = 'watchAndCompile';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (process.argv.includes('watch')) {
+                // compile tsc
+                //TODO
+                // update module.d.ts
+                // exit cleanly  and pre-maturely on purpose
+                process.stdout.write(safeCommands.promptHelpers.goColor('SUBTLE', '\nWatch does nothing yet✅'));
+                process.exit(0);
+            }
+            return options;
+        }
+    };
+};
+exports.watchAndCompile = watchAndCompile;
+//# sourceMappingURL=projectPackage.js.map

package/commands/projectValidate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/projectValidate
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "#root/index";
+export declare const validateJest: () => SdfCommand;
+export declare const forceLog: () => SdfCommand;
+/**
+ * @description -
+ * @todo - make it a prompt?
+ */
+export declare const promptServer: () => SdfCommand;
+/**
+ * @description - runs all tests. Creates the jest config if needed
+ */
+export declare const runTests: () => {
+    _origin: string;
+    isStackable: boolean;
+    beforeExecuting: (options: any) => Promise<any>;
+    onError: (error: string) => Promise<string>;
+};

package/commands/projectValidate.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/projectValidate
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTests = exports.promptServer = exports.forceLog = exports.validateJest = void 0;
+const fs = require("node:fs/promises");
+const onErrorHelper = require("../lib/onErrorHelper");
+const promptHelper = require("../lib/promptHelpers");
+const compileHelper = require("../lib/compileHelper");
+const logHelper = require("../lib/logHelper");
+const validateJest = () => {
+    const origin = 'validateJest';
+    const badTestFiles = [];
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            // make sure that all test files are in the right place
+            const invalidTestFiles = await fs.readdir(process.cwd(), { recursive: true }).then((list) => {
+                return Promise.all(list.map(async (f) => {
+                    // test if it is a dir
+                    const stats = await fs.stat(f);
+                    if (stats.isDirectory()) {
+                        if (!f.includes('test'))
+                            return;
+                        // tests directories need to have a certain name
+                        if (!/\W__tests__\W?$/.test(f))
+                            return f;
+                    }
+                    else if (stats.isFile()) {
+                        if (!f.endsWith('.js'))
+                            return;
+                        if (!f.includes('test'))
+                            return;
+                        if (f.endsWith('.test.js') && !f.includes('__tests'))
+                            return f;
+                        if (!f.endsWith('.test.js'))
+                            return f;
+                    }
+                    return;
+                })).then((l) => l.filter(Boolean));
+            }).catch(() => []);
+            if (invalidTestFiles.length > 0) {
+                badTestFiles.push(...invalidTestFiles);
+                throw onErrorHelper.makeError(origin, new Error('Tests are not organized properly'));
+            }
+            else {
+                process.stdout.write(promptHelper.goColor('INFO', '\nNo test file problems detected'));
+            }
+            return options;
+        },
+        onError: async (error) => onErrorHelper.detectOriginAndReturn(origin, error, (error) => {
+            if (badTestFiles.length > 0) {
+                process.stdout.write(promptHelper.goColor('BAD', '\nThese files are not organized correctly', badTestFiles));
+            }
+            return error;
+        }),
+    };
+};
+exports.validateJest = validateJest;
+const forceLog = () => {
+    const origin = 'forceLog';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            options.arguments.log = await logHelper.useSdfLog(options.command || 'unknown');
+            return options;
+        },
+    };
+};
+exports.forceLog = forceLog;
+/**
+ * @description -
+ * @todo - make it a prompt?
+ */
+const promptServer = () => {
+    const origin = 'promptServer';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            options.arguments.server = true;
+            return options;
+        }
+    };
+};
+exports.promptServer = promptServer;
+/**
+ * @description - runs all tests. Creates the jest config if needed
+ */
+const runTests = () => {
+    const origin = 'runTests';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            // make sure there is a jest.config file
+            await compileHelper.makeJestConfig();
+            // run tests
+            await compileHelper.runJestTest(['ALL'], false);
+            return options;
+        },
+        onError: async (error) => onErrorHelper.detectOriginAndReturn(origin, error, (error) => {
+            return error;
+        })
+    };
+};
+exports.runTests = runTests;
+//# sourceMappingURL=projectValidate.js.map

package/commands/sdfAcs_authmap.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file sdf/commands/sdfAcs_authmap.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description - Display the authid map for the provided authid / folder combo.
+ * - if no combo is given then display the entire map
+ * - the process of doing the import is asynchronous but this should be the final operation.
+ * @returns {boolean}
+ */
+declare const checkAuthMap: (options: {
+    authid?: string;
+    folder?: string;
+}) => Promise<string | boolean>;
+export = checkAuthMap;

package/commands/sdfAcs_authmap.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @file sdf/commands/sdfAcs_authmap.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const nodePath = require("node:path");
+/**
+ * @description - Display the authid map for the provided authid / folder combo.
+ * - if no combo is given then display the entire map
+ * - the process of doing the import is asynchronous but this should be the final operation.
+ * @returns {boolean}
+ */
+const checkAuthMap = async (options) => {
+    const { authid, folder } = options;
+    return Promise.resolve(`${nodePath.join(process.cwd(), 'suitecloud.config.js')}`).then(s => require(s)).then((x) => {
+        const stringifiedMap = JSON.stringify(x.default.authFolderMap, null, 2);
+        // yconsole.log(`${
+        if (!authid)
+            return stringifiedMap;
+        // boolean on whether the folder relationship with the authid exists
+        const folders = x?.default?.authFolderMap?.[authid];
+        return Array.isArray(folders) && folders.includes(folder);
+    });
+};
+module.exports = checkAuthMap;
+//# sourceMappingURL=sdfAcs_authmap.js.map

package/commands/sdfAcs_clean.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file sdf/commands/sdfAcs_clean.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description - Can be used to wip a directory or setup a new project
+ * - the root directory needs to exist first
+ * - because you have everything under source control you do not need to worry
+ * - you should do the auth setup at the same time
+ * @example
+ * ```ts
+ * sdfAcs:clean --authid 3905005_bl
+ * ```
+ * @param {string} options.authid
+ * @returns {boolean}
+ */
+declare const cleanProject: (options: {
+    authid: string;
+}) => boolean;
+export = cleanProject;

package/commands/sdfAcs_clean.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @file sdf/commands/sdfAcs_clean.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description - Can be used to wip a directory or setup a new project
+ * - the root directory needs to exist first
+ * - because you have everything under source control you do not need to worry
+ * - you should do the auth setup at the same time
+ * @example
+ * ```ts
+ * sdfAcs:clean --authid 3905005_bl
+ * ```
+ * @param {string} options.authid
+ * @returns {boolean}
+ */
+const cleanProject = (options) => {
+    return true;
+};
+module.exports = cleanProject;
+//# sourceMappingURL=sdfAcs_clean.js.map

package/deleteManifest.cjs

@@ -0,0 +1,11 @@
+/**
+ * @file deleteManifest.cjs
+ * - delete the manifest.xml file in the suitecloud working directory
+ */
+
+const fs = require('node:fs');
+const nodePath = require('node:path');
+const pathOfRoot = nodePath.basename(require.resolve('#root'));
+
+// delete the current manifest.xml
+fs.rmSync(nodePath.join(pathOfRoot, 'manifest.xml'));

package/demo.md

@@ -0,0 +1,26 @@
+# Overview / Features
+
+* build a UserEvent that will help with adhoc debugging
+* 3 different UEs
+  * separation of beforeLoad, beforeSubmit, afterSubmit
+  * deployable to any record
+  * easier ordering of rank
+  * each can launch other UEs
+
+# Requirements
+
+
+# Objects & Scripts
+
+## Objects 
+1. UserEvent record for each entry point method
+   2. script parameter that will accept a scriptid / filepath (string) 
+
+## Scripts 
+1. Script for beforeLoad
+2. Script for beforeSubmit
+3. Script for afterSubmit
+4. A generic function to proxy an unknown script
+
+
+