@suitegeezus/suitecloud-stacker 25.2.127

package/commands/fileUpload.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testFilesPrompt = exports.compileFilesPrompt = exports.fixFileUploadPaths = exports.confirmFileList = exports.getFilesFromDeployXml = exports.promptForPath = void 0;
+const nodePath = require("node:path");
+const errorHelper = require("../lib/onErrorHelper");
+const compileHelper = require("../lib/compileHelper");
+const promptHelpers = require("../lib/promptHelpers");
+const pathHelpers = require("../lib/pathHelpers");
+const deployFileHelper_1 = require("../lib/deployFileHelper");
+const onErrorHelper_1 = require("../lib/onErrorHelper");
+const spawnSuitecloud = require("../lib/spawnSuitecloudChild");
+const promptHelpers_1 = require("../lib/promptHelpers");
+/**
+ * @description - only prompt if not paths given
+ * @param {string} opts.message
+ */
+const promptForPath = (opts) => {
+    const origin = 'promptForPath';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (spawnSuitecloud.isChildProcess())
+                return options;
+            if (options.arguments.interactive)
+                return options;
+            if (options.arguments.runhooks == 'quiet')
+                return options;
+            let arrayKey = options.command === 'object:import' ? 'scriptid' : 'paths';
+            // only prompt if currently empty
+            if (Array.isArray(Reflect.get(options.arguments, arrayKey)) &&
+                Reflect.get(options.arguments, arrayKey)?.length !== 0)
+                return options;
+            // init
+            Reflect.set(options.arguments, arrayKey, []);
+            const choices = { 'Y': 'Yes', 'N': 'No' };
+            let answer = choices['Y'];
+            const whatToDo = async () => {
+                let more = await promptHelpers.promptUser({
+                    message: opts?.message || 'Missing Message',
+                });
+                more = more.trim().toLowerCase();
+                // very basic validation here...
+                if (options.command === 'object:import') {
+                    // note: they can enter a deploy file from the command line
+                    if (!/^[a-z\*][\w_\*]*:[a-z\*][\w_\*]*$/.test(more)) {
+                        process.stdout.write((0, promptHelpers_1.goColor)('BAD', '\nBad input...missing wildcards?.  input removed: ', more));
+                        return;
+                    }
+                }
+                // add
+                Reflect.get(options.arguments, arrayKey).push(more);
+            };
+            while (answer !== choices['N']) {
+                await whatToDo();
+                answer = await promptHelpers.promptChoices({
+                    choices: choices,
+                    displayChoices: choices,
+                    question: `Do you want to add more to this list ?`,
+                    premessage: Reflect.get(options.arguments, arrayKey)
+                        .map((p) => promptHelpers.goColor('HIGHLIGHT', '   ', p)).join('\n'),
+                    default: null
+                });
+            }
+            return options;
+        },
+        onError: async (error) => (0, onErrorHelper_1.detectOriginAndReturn)(origin, error, (error) => {
+            return error;
+        })
+    };
+};
+exports.promptForPath = promptForPath;
+/**
+ * @description - deploy.xml files are filtered out of an upload allowed in the upload, buuut...
+ * - If you provide one as the only file to upload then it will load the files listed in it
+ *
+ * - they are allowed in an import BUT that is rare so if an import see this path then it will not import
+ * it but treat it like an import instructions
+ *
+ */
+const getFilesFromDeployXml = () => {
+    const origin = 'getFilesFromDeployXml';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (spawnSuitecloud.isChildProcess())
+                return options;
+            // ignore this combo
+            if (options.command === 'file:import' &&
+                // @ts-expect-error it is in file:import
+                options.arguments?.calledfromcomparefiles)
+                return options;
+            const arrayKey = options.command === 'object:import' ? 'scriptid' : 'paths';
+            if (!Array.isArray(Reflect.get(options.arguments, arrayKey)))
+                return options;
+            const [first] = Reflect.get(options.arguments, arrayKey);
+            if (!/\bdeploy\b.*\bxml\b$/.test(first))
+                return options;
+            //zero-out the array
+            Reflect.set(options.arguments, arrayKey, []);
+            // open the file and get all the paths from it
+            // relies upon the xml being in a good structure
+            try {
+                const fromXml = await (0, deployFileHelper_1.extractFilePathsFromDeployXmlFile)(options.projectPath, first, options.command === 'object:import' ? 'Objects' : 'SuiteScripts');
+                if (options.command === 'object:import') {
+                    Reflect.set(options.arguments, arrayKey, 
+                    // add the type prefix that doesn't exist in the deploy file
+                    // TODO: guessing the prefix from the record folder
+                    fromXml.map((x) => [
+                        '*',
+                        // e.g. ~/Objects/customrecord/customrecord__gg_allfieldtypes
+                        x
+                    ].join(':')));
+                }
+                else {
+                    Reflect.set(options.arguments, arrayKey, 
+                    // add the type prefix
+                    fromXml);
+                }
+                return options;
+            }
+            catch (e) {
+                throw (0, onErrorHelper_1.makeError)(origin, new Error('DeployXml Could not be found'));
+            }
+        },
+        onError: async (error) => (0, onErrorHelper_1.detectOriginAndReturn)(origin, error, (error) => {
+            return error;
+        })
+    };
+};
+exports.getFilesFromDeployXml = getFilesFromDeployXml;
+/**
+ * @description -
+ */
+const confirmFileList = () => {
+    const origin = 'confirmFileList';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (spawnSuitecloud.isChildProcess())
+                return options;
+            const isQuiet = options.arguments.runhooks === 'quiet';
+            const arrayKey = options.command === 'object:import' ? 'scriptid' : 'paths';
+            const noFiles = Reflect.get(options.arguments, arrayKey)?.length === 0;
+            if (noFiles && !isQuiet) {
+                let answer = await promptHelpers.promptChoices({
+                    choices: [],
+                    displayChoices: [],
+                    question: `Nothing to do?`,
+                    default: null
+                });
+                return options;
+            }
+            if (noFiles && isQuiet) {
+                process.stdout.write(promptHelpers.goColor('INFO', 'Nothing to do'));
+                return options;
+            }
+            const premessage = Reflect.get(options.arguments, arrayKey)
+                .map((p) => promptHelpers.goColor('HIGHLIGHT', '   ', p)).join('\n');
+            if (isQuiet) {
+                process.stdout.write((0, promptHelpers_1.goColor)('SUBTLE', '\n', premessage));
+            }
+            else {
+                const choices = { 'Y': 'Yes', 'N': 'No' };
+                let answer = await promptHelpers.promptChoices({
+                    choices: choices,
+                    displayChoices: choices,
+                    question: `Are you good with this list?`,
+                    premessage,
+                    default: null
+                });
+                // force it empty which will quit
+                if (answer === choices['N'])
+                    Reflect.set(options.arguments, arrayKey, []);
+            }
+            return options;
+        }
+    };
+};
+exports.confirmFileList = confirmFileList;
+/**
+ * @description - fix paths in a way that file:upload needs them fixed.
+ * - 0️⃣ paths that begin with SuiteScripts or SuiteBundles or SuiteApps are left as-is.
+ * - 1️⃣ relative paths -- these SHOULD begin with `.` or `..` or they will be treated as relative to cwd.
+ * - 2️⃣ globbing -- all paths are essentially viewed as a glob. globs that are
+ * - 3️⃣ clean and prevent bad files. e.g. typescript should be swapped for js (This should occur AFTER resolving any globs).
+ * - 4️⃣ check if the file exists and remove it
+ * - 5️⃣ finally trim to valid SDK path such as /SuiteScripts
+ *
+ * #Globbing:
+ * - every path here is SuiteScripts so ...
+ *
+ * - ignore certain files
+ */
+const fixFileUploadPaths = () => {
+    const origin = 'fixFileUploadPaths';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (!Array.isArray(options?.arguments?.paths))
+                options.arguments.paths = [];
+            // it is expected that paths should be fixed by parent processes that are calling
+            // TODO: is spawnSuitecloud.isChildProcess()  relevant ever here and what to do
+            console.log(origin, { options });
+            console.log(options.arguments.paths);
+            const { projectPath } = options;
+            // deal with relative paths, etc 1️⃣
+            const shortenedPathOrGlobs = options.arguments.paths.map((path) => {
+                // go to the project root and get ALL the files in it
+                // relative paths that do not have SuiteScripts
+                if (/^\.+[\\\/]/.test(path) && !/\bSuiteScripts\b/.test(path))
+                    return nodePath.join(process.cwd(), 
+                    // could be . or a ..
+                    ...path.split(/[\\\/]/))
+                        .replace(/^.*(\bSuiteScripts\b.*)/, '/$1');
+                // anything longer that might be relative but has SuiteScripts in path
+                const fixed = [/^.*(\bSuiteScripts\b.*)$/].reduce((p, rgx) => {
+                    if (p)
+                        return p;
+                    if (!rgx.test(path))
+                        return p;
+                    // already good
+                    return path.replace(rgx, '/$1');
+                }, '');
+                if (fixed)
+                    return fixed;
+                // TODO: any other patterns?
+            }).filter(Boolean);
+            // globbing has to be done here before we clean 2️⃣
+            const filteredAgainstGlobs = await pathHelpers.getAllFilesRecursively(
+            // only care about the SuiteScripts as trunk of the tree
+            [projectPath], 'SuiteScripts', shortenedPathOrGlobs
+            //
+            );
+            process.stdout.write(promptHelpers.goColor('SUBTLE', '\npaths:', shortenedPathOrGlobs));
+            // 3️⃣
+            options.arguments.paths = pathHelpers.removeIllegalFileCabinetFiles(filteredAgainstGlobs);
+            return options;
+        },
+    };
+};
+exports.fixFileUploadPaths = fixFileUploadPaths;
+/**
+ * @description - Guesses at what files might be TS and then generates
+ * @deprecated - not sure the benefit of this is worth the trouble
+ * @todo -
+ * @returns {SdfCommand}
+ */
+const compileFilesPrompt = () => {
+    return {
+        _origin: "compileFilesPrompt",
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            const isQuiet = options.arguments.runhooks === 'quiet';
+            let { files } = await compileHelper.generateTsConfigFromList(options.arguments.paths, false) || { files: [] };
+            if (files.length === 0)
+                return options;
+            const choices = { 'Y': 'Yes', 'N': 'No' };
+            let answer = isQuiet
+                ? choices['Y']
+                : await promptHelpers.promptChoices({
+                    choices: choices,
+                    displayChoices: choices,
+                    question: `Would you like to compile typescript?`,
+                    premessage: JSON.stringify(files, null, 2),
+                    default: choices['Y']
+                });
+            if (answer === choices['N']) {
+                promptHelpers.goColor('INFO', '\nNo Files to compile');
+                return options;
+            }
+            process.stdout.write((0, promptHelpers_1.goColor)('INFO', '\ncompiling'));
+            // ({files} = await compileHelper.generateTsConfigFromList(options.arguments.paths, true) || {files: []});
+            // compile it
+            await compileHelper.compileTsConfig();
+            return options;
+        }
+    };
+};
+exports.compileFilesPrompt = compileFilesPrompt;
+/**
+ * @description - calls jest for the files involved
+ * ⚠️ - make sure paths are fixed first
+ */
+const testFilesPrompt = () => {
+    const origin = 'testFilesPrompt';
+    let command;
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            command = options.command || 'unknown';
+            const choices = { 'Y': 'Yes', 'N': 'No' };
+            // remove the "N" choice for prod
+            if (options._isProd)
+                delete choices['N'];
+            let answer;
+            if (spawnSuitecloud.isChildProcess() || options.arguments.runhooks === 'quiet') {
+                answer = choices['Y'];
+            }
+            else {
+                answer = await promptHelpers.promptChoices({
+                    choices: choices,
+                    displayChoices: choices,
+                    premessage: options._isProd ? 'This is PROD' : '',
+                    question: `Would you like to run relatedTests?`,
+                    default: choices['Y']
+                });
+            }
+            if (answer === choices['N'])
+                return options;
+            // make sure paths are correct for jest
+            const didTheyPass = await compileHelper.runJestTest(options.arguments.paths.map((p) => {
+                return nodePath.join(options.projectPath.replace(/^(.*)(.\bFileCabinet\b.\bSuiteScripts\b.*)?$/, '$1/FileCabinet'), p.replace(/^.*FileCabinet/, ''));
+            }), Boolean(!options._isProd))
+                .then(() => true)
+                .catch((e) => {
+                // TODO turn this on
+                // if (options._isProd) throw errorHelper.makeError(origin,new Error('Tests must exist AND pass for PROD ' + options.command));
+                return false;
+            });
+            if (didTheyPass)
+                return options;
+            if (!spawnSuitecloud.isChildProcess() && options.arguments.runhooks !== 'quiet') {
+                // remove the "N" choice for prod
+                const choices2 = { 'Y': 'Yes' };
+                const answer2 = await promptHelpers.promptChoices({
+                    choices: { ...choices2, 'N': 'No' },
+                    displayChoices: choices2,
+                    premessage: options._isProd ? 'This is PROD' : '',
+                    question: `Tests failed. Would you like to upload anyway?`,
+                    default: null,
+                });
+                if (answer2 === 'Yes')
+                    return options;
+                throw errorHelper.makeError(origin, new Error('User Chose to Quit'));
+            }
+            // if( !didTheyPass)
+            throw errorHelper.makeError(origin, new Error('Tests failed in child process'));
+        },
+        onError: async (error) => {
+            return errorHelper.detectOriginAndReturn(origin, error, (error) => {
+                if (/PROD/m.test(error)) {
+                    process.stdout.write(promptHelpers.goColor('BAD', '\n ❌ ', error.replace(/.*\bDetails:\n?/, '')));
+                }
+                return error;
+            });
+        },
+    };
+};
+exports.testFilesPrompt = testFilesPrompt;
+//# sourceMappingURL=fileUpload.js.map

package/commands/generic.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @file sdf/commands/generic.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+export declare const proxiedBlocker: {};

package/commands/generic.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @file sdf/commands/generic.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxiedBlocker = void 0;
+exports.proxiedBlocker = new Proxy({}, {
+    get(target, property, receiver) {
+        throw new Error('nope');
+    }
+});
+//# sourceMappingURL=generic.js.map

package/commands/objectImport.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/objectImport
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "index";
+/**
+ * @description - the createObjectsDir job can organize them automatically and compliments this well
+ * @requires createObjectsDir
+ */
+export declare const forceDestination: () => SdfCommand;
+/**
+ * @description -
+ */
+export declare const forceTypeAll: () => SdfCommand;
+/**
+ * @description - similar tothe fixFileUploadPaths.  we need to compare against netsuite
+ * Also we don't filter out any files
+ */
+export declare const fixObjectImportPaths: () => SdfCommand;
+/**
+ * @description - if scriptid is a glob then we need a list so that we can filter it
+ * @deprecated - replaced by a better stack
+ * @requires saveObjectListToTemp - This requires the object:list task to run this handler
+ *
+ */
+export declare const importGlobOrXml: () => SdfCommand;
+/**
+ * @description - Creates an Objects dir. e.g.
+ * - check the arguments to import
+ * @param {ObjectImportOptions} options
+ */
+export declare const createObjectsDir: () => SdfCommand;