@suitegeezus/suitecloud-stacker 25.2.127

package/commands/objectImport.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/objectImport
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createObjectsDir = exports.importGlobOrXml = exports.fixObjectImportPaths = exports.forceTypeAll = exports.forceDestination = void 0;
+const fs = require("node:fs/promises");
+const nodePath = require("node:path");
+const promptHelpers_1 = require("../lib/promptHelpers");
+const onErrorHelper = require("../lib/onErrorHelper");
+const spawnSuitecloud = require("../lib/spawnSuitecloudChild");
+const tempFileHelper = require("../lib/tempFileHelper");
+const minimatch_1 = require("minimatch");
+/**
+ * @description - the createObjectsDir job can organize them automatically and compliments this well
+ * @requires createObjectsDir
+ */
+const forceDestination = () => {
+    const origin = 'forceDestination';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            options.arguments.destinationfolder = '/Objects';
+            return options;
+        }
+    };
+};
+exports.forceDestination = forceDestination;
+/**
+ * @description -
+ */
+const forceTypeAll = () => {
+    const origin = 'forceTypeAll';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            options.arguments.type = options.arguments?.type || 'ALL';
+            // change this to a wildcard
+            if (typeof options.arguments.scriptid === 'undefined')
+                options.arguments.scriptid = [];
+            if (options.arguments.scriptid.includes('ALL'))
+                options.arguments.scriptid = ['*'];
+            return options;
+        }
+    };
+};
+exports.forceTypeAll = forceTypeAll;
+/**
+ * @description - similar tothe fixFileUploadPaths.  we need to compare against netsuite
+ * Also we don't filter out any files
+ */
+const fixObjectImportPaths = () => {
+    const origin = 'fileObjectImportPaths';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (!Array.isArray(options?.arguments?.scriptid))
+                options.arguments.scriptid = [];
+            // it is expected that parents will fix any paths before calling
+            if (spawnSuitecloud.isChildProcess())
+                return options;
+            const { projectPath } = options;
+            // deal with relative paths, etc 1️⃣
+            const objectsAsGlobs = options.arguments.scriptid.map((combo) => {
+                const [type, scriptid] = /:/.test(combo)
+                    ? combo.split(':')
+                    : [
+                        (options.arguments.type === 'ALL' ? '*' : options.arguments.type),
+                        combo
+                    ];
+                if (typeof scriptid !== 'string')
+                    throw onErrorHelper.makeError(origin, new Error('You need to specify a type'));
+                return [
+                    type,
+                    // e.g. ~/Objects/customrecord/custrecord_gg.xml
+                    scriptid.replace(/^.*?([\*\w]+)(\.xml)?$/, '$1')
+                ].join('/');
+                // TODO: any other patterns?
+            }).filter(Boolean);
+            // globbing has to be done here before we clean 2️⃣
+            const exitCode = await spawnSuitecloud.createAsync({
+                command: 'object:list',
+                args: [
+                    // '--scriptid' // no scriptid = all scriptid
+                    // '--type' // no type = all type
+                    '--authid', options.arguments.authid
+                ],
+                interact: false,
+            });
+            if (exitCode !== 0)
+                throw onErrorHelper.makeError(origin, new Error('List failed to generate'));
+            const jsonList = await tempFileHelper.consumeTempFile(tempFileHelper.FileNames.objectList);
+            const { _data: listOfObjects } = JSON.parse(jsonList);
+            const tests = objectsAsGlobs.map((glob) => (entry) => {
+                // console.log({ entry, glob});
+                return (0, minimatch_1.minimatch)(entry, glob);
+            });
+            const filteredList = new Set();
+            await Promise.allSettled(listOfObjects.map(({ type, scriptId }) => {
+                const globbed = [type, scriptId].join('/');
+                const pass = tests.reduce((answer, test) => (answer || test(globbed)), false);
+                if (pass)
+                    filteredList.add(scriptId);
+            }));
+            options.arguments.scriptid = [...filteredList];
+            // 3️⃣ -- no filtering out here
+            return options;
+        },
+        onError: async (error) => onErrorHelper.detectOriginAndReturn(origin, error, (e) => {
+            return e;
+        }),
+    };
+};
+exports.fixObjectImportPaths = fixObjectImportPaths;
+/**
+ * @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
+ *
+ */
+const importGlobOrXml = () => {
+    const origin = 'importGlobOrXml';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (options?.arguments?.runhooks === 'quiet')
+                return options;
+            if (!Array.isArray(options?.arguments?.scriptid))
+                options.arguments.scriptid = [];
+            const hasRequirements = ['type', 'scriptid', 'destinationfolder'].every((minimum) => {
+                return Object.keys(options.arguments).includes(minimum) && !/\*/.test(minimum);
+            });
+            if (spawnSuitecloud.isChildProcess() || hasRequirements)
+                return options;
+            const choices = [
+                'scriptid / partial scriptid', // deprecated
+                'glob of scriptids',
+                'a deploy.xml file'
+            ];
+            const nature = /\.xml$/.test(options.arguments.scriptid)
+                ? choices[2]
+                : choices[1];
+            if (nature === choices[2]) {
+                // prompt for a deploy.xml file choice
+                // TODO get this from somewehre else
+                // parse the objects out of the xml file
+                const filteredObjectsFromXml = [];
+                options.arguments.scriptid.push(filteredObjectsFromXml);
+                options.arguments.type = 'ALL';
+                return options;
+            }
+            if (nature === choices[0]) {
+                let specificId;
+                // prompt for clarification
+                const nag = async () => {
+                    specificId = await (0, promptHelpers_1.promptUser)({
+                        message: 'What Scriptid?'
+                    });
+                };
+                while (!specificId || !/^\w+$/.test(specificId)) {
+                    await nag();
+                }
+                options.arguments.scriptid.push(specificId);
+                options.arguments.type = 'All';
+                return options;
+            }
+            if (nature === choices[1]) {
+                const listObjectsAsync = spawnSuitecloud.createAsync({
+                    command: 'object:list',
+                    args: [
+                        /* empty for all */
+                        '--authid', options.arguments.authid
+                    ],
+                    interact: false,
+                    ultraQuiet: true,
+                });
+                const runGlobJob = async () => {
+                    let glob;
+                    glob = [
+                        (options.arguments.type === 'ALL' ? '*' : options.arguments.type),
+                        options.arguments.scriptid
+                    ].join('/');
+                    // wait for it here
+                    const listJob = await listObjectsAsync;
+                    // require the temp file
+                    if (listJob !== 0)
+                        throw onErrorHelper.makeError(origin, new Error('list failed to run'));
+                    // pick up the temp file
+                    const listJson = await tempFileHelper.consumeTempFile(tempFileHelper.FileNames.objectList);
+                    const { _data: unfilteredList } = JSON.parse(listJson);
+                    // console.log({listJson, unfilteredList});
+                    const toDisplay = [];
+                    unfilteredList.forEach((entry) => {
+                        if ((0, minimatch_1.minimatch)(entry.scriptId, glob)) {
+                            options.arguments.type = 'ALL';
+                            options.arguments.scriptid.push(entry.scriptId);
+                            toDisplay.push(`${entry.type}:${entry.scriptId}`);
+                        }
+                    });
+                    process.stdout.write((0, promptHelpers_1.goColor)('INFO', '\n', toDisplay.join('\n')));
+                    const choices = { 'Y': 'Yes', 'N': 'No' };
+                    let confirm = await (0, promptHelpers_1.promptChoices)({
+                        choices,
+                        displayChoices: choices,
+                        question: 'Are you good with this list?',
+                        default: 'Y'
+                    });
+                    if (confirm === choices['N'])
+                        options.arguments.scriptid = [];
+                    // anything other than 'Y' will mean quit
+                    return options;
+                };
+                return runGlobJob();
+            }
+            return options;
+        },
+        onCompleted: async (options) => {
+            console.log({ options });
+            return options;
+        }
+    };
+};
+exports.importGlobOrXml = importGlobOrXml;
+/**
+ * @description - Creates an Objects dir. e.g.
+ * - check the arguments to import
+ * @param {ObjectImportOptions} options
+ */
+const createObjectsDir = () => {
+    const origin = 'createObjectsDir';
+    return {
+        _origin: origin,
+        /**
+         * @description - creates an objects dir in order to organize the result
+         * @param {ObjectImportOptions} options
+         * @returns {Promise<ObjectImportOptions>}
+         */
+        beforeExecuting: async (options) => {
+            if (process.argv.includes('-i'))
+                return options;
+            if (!Array.isArray(options.arguments.scriptid) && !Array.isArray(options.arguments.type))
+                // return immediately which will be an error
+                return options;
+            console.log((0, promptHelpers_1.goColor)('SUBTLE', { options }, process.argv));
+            // a child process will create the dirs
+            //    const listJob = await spawnSuitecloud.createAsync({
+            //        command: 'object:list',
+            //        args:  [/* empty for all */],
+            //        interact: false,
+            //    })
+            //    // if success
+            //    if( listJob !== 0 ) throw onErrorHelper.makeError(origin,new Error('Could not create object folders'));
+            return options;
+        },
+        /**
+         * @description -
+         * @param options
+         */
+        onCompleted: async (options) => {
+            console.log({ options });
+            const root = JSON.parse(options._commandParameters.project).replace(/^(.*).\bFileCabinet\b.*$/, '$1');
+            // now move each
+            await Promise.all(options._data.successfulImports.map(async ({ customObject }, i) => {
+                const newPaths = ['Objects', customObject.type, `${customObject.id}.xml`];
+                if (i === 0)
+                    process.stdout.write('\nMoving to');
+                process.stdout.write((0, promptHelpers_1.goColor)('HIGHLIGHT', `\n~/${newPaths.join('/')}`, false));
+                await fs.rename(nodePath.join(root, 'Objects', `${customObject.id}.xml`), nodePath.join(root, ...newPaths)).then(() => console.log('✅'));
+            }));
+            return options;
+        },
+        onError: async (error) => {
+            return onErrorHelper.detectOriginAndReturn('createObjectDir', error, async (error) => {
+                process.stdout.write((0, promptHelpers_1.goColor)('ERROR', '\n', error));
+                return error;
+            });
+        },
+        isStackable: true,
+    };
+};
+exports.createObjectsDir = createObjectsDir;
+//# sourceMappingURL=objectImport.js.map

package/commands/objectList.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/objectList
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "#root/index";
+/**
+ * @description - create a temp json file with all the objects
+ */
+export declare const saveObjectListToTemp: () => SdfCommand;
+/**
+ * @description -
+*/
+export declare const createFoldersForAllTypes: () => SdfCommand;

package/commands/objectList.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFoldersForAllTypes = exports.saveObjectListToTemp = void 0;
+const promptHelpers = require("../lib/promptHelpers");
+const tempFileHelper = require("../lib/tempFileHelper");
+const fs = require("node:fs/promises");
+const pathHelper = require("../lib/pathHelpers");
+const spawnSuitecloud = require("../lib/spawnSuitecloudChild");
+/**
+ * @description - create a temp json file with all the objects
+ */
+const saveObjectListToTemp = () => {
+    const origin = 'saveObjectListToTemp';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            return options;
+        },
+        onCompleted: async (options) => {
+            // allow both child and parent processes to do this
+            process.stdout.write(promptHelpers.goColor('SUBTLE', '\n', origin, ': ', options));
+            await tempFileHelper.makeTempFile(tempFileHelper.FileNames.objectList, JSON.stringify(options, null, 2));
+            return options;
+        }
+    };
+};
+exports.saveObjectListToTemp = saveObjectListToTemp;
+/**
+ * @description -
+*/
+const createFoldersForAllTypes = () => {
+    const origin = 'createFoldersForAllTypes';
+    let isQuiet = false;
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            isQuiet = options?.arguments?.runhooks === 'quiet';
+            return options;
+        },
+        onCompleted: async (options) => {
+            // make the folders
+            if (Array.isArray(options._data)) {
+                let answer = 'Yes';
+                if (!spawnSuitecloud.isChildProcess() && !isQuiet) {
+                    const choices = { 'Y': 'Yes', 'N': 'No' };
+                    answer = await promptHelpers.promptChoices({
+                        choices,
+                        displayChoices: choices,
+                        default: answer,
+                        question: `Would you like to create all missing \`Objects\` folders?`
+                    });
+                }
+                console.log({ answer });
+                const uniqueTypes = new Set();
+                options._data.forEach(({ type }) => uniqueTypes.add(type));
+                if (answer === 'Yes')
+                    await Promise.allSettled([...uniqueTypes].map(async (type) => {
+                        const pathToCheck = await pathHelper.getAccountDir('Objects', [type]);
+                        const exists = await fs.access(pathToCheck)
+                            .then(() => true)
+                            .catch(() => false);
+                        if (!exists) {
+                            await fs.mkdir(pathToCheck, { recursive: true });
+                            // write empty file
+                            process.stdout.write(promptHelpers.goColor('INFO', '\nCreating ', pathToCheck.replace(/^.*(\bObjects.*)$/, '~/$1')));
+                            const writePath = await pathHelper.getAccountDir('Objects', [type, '.gitKeep']);
+                            await fs.writeFile(writePath, '');
+                        }
+                    }));
+            }
+            return options;
+        }
+    };
+};
+exports.createFoldersForAllTypes = createFoldersForAllTypes;
+//# sourceMappingURL=objectList.js.map

package/commands/projectCreate.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file
+ * @author
+ */
+import { SdfCommand } from "#root/index";
+/**
+ * @description - For an existing mini-project. Use the 'project:create' command as a way to switch accounts
+ * Assumes the following:
+ * - you have a subdirectory called "deploy"
+ * - uses local project.json permuations as a configuration file from that
+ * @param {root: string} [opts]
+ */
+export declare const projectJsonPromptAndEscape: (opts?: {
+    root?: string;
+}) => SdfCommand;
+/**
+ * @description - For setting up a new account on your machine
+ * # Restrictions
+ * - Account must have a name that matches a certain name format
+ *
+ * @param opts
+ * @returns {any}
+ */
+export declare const newAccount: (opts: {
+    root: string;
+}) => any;
+/**
+ * @description - hi
+ *
+ */
+export declare const rootProjectChoices: () => SdfCommand;