@suitegeezus/suitecloud-stacker 25.2.127

package/commands/projectCreate.js

@@ -0,0 +1,506 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootProjectChoices = exports.newAccount = exports.projectJsonPromptAndEscape = void 0;
+const onErrorHelper = require("../lib/onErrorHelper");
+const pathHelper = require("../lib/pathHelpers");
+const safeCommands_1 = require("../safeCommands");
+const validators_1 = require("../lib/validators");
+const pathHelpers_1 = require("../lib/pathHelpers");
+const path = require('node:path');
+const fs = require('node:fs/promises');
+const cp = require('node:child_process');
+const addGitKeep = require('../lib/addGitKeep');
+const addSdfObjectDirs = require('../lib/addSdfObjectDirs');
+const makeModuleTypeDef = require('../templates/makeModuleTypeDef');
+const { promptUser, goColor, promptChoices } = require('../lib/promptHelpers');
+const messagesThatAreNotErrors = {
+    CREATE_PROJECT_JSON: 'Created project.json. Now exiting project:create',
+};
+const makeDefaultCallbacks = () => ({
+    _origin: 'makeDefaultCallbacks',
+    beforeExecuting: async (options) => {
+        return options;
+    },
+    onCompleted: async (options) => {
+        return options;
+    },
+    onError: async (error) => onErrorHelper.detectOriginAndReturn('makeDefaultCallback', error),
+    isStackable: true,
+});
+async function moveContentsUp(dir) {
+    try {
+        // Get all entries (files and folders) in the directory.
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        // Determine the parent directory.
+        const parentDir = path.dirname(dir);
+        for (const entry of entries) {
+            const oldPath = path.join(dir, entry.name);
+            const newPath = path.join(parentDir, entry.name);
+            // Move the entry using fs.rename.
+            await fs.rename(oldPath, newPath);
+            console.log(goColor('INFO', `Moved: `), goColor('SUBTLE', `${oldPath} -> ${newPath}`));
+        }
+        console.log(goColor('GOOD', 'All entries have been moved up one level.'));
+    }
+    catch (error) {
+        console.error(goColor('BAD', 'Error moving contents:'), error);
+    }
+}
+/**
+ * @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]
+ */
+const projectJsonPromptAndEscape = (opts) => {
+    return {
+        _origin: 'projectJsonPromptAndEscape',
+        beforeExecuting: async ( /* options */) => {
+            let message = '';
+            try {
+                // TODO should be a combo of options.projectPath and project.json
+                const { root: projectFolder } = { root: path.join(process.cwd(), 'project.json'), ...opts };
+                // enforce having a deploy directory with project.*.json files
+                const projectJsonList = await fs.readdir(path.join(projectFolder, 'deploy'))
+                    .then((files) => files.filter((pJson) => /^project(\.\w+)?\.json$/.test(pJson)))
+                    // failover to empty list
+                    .catch(() => {
+                    console.error(goColor('WARN', `${path.join(projectFolder, 'deploy')} does not exist! Suggest to create one manually.`));
+                    return [];
+                });
+                if (!projectJsonList || projectJsonList?.length === 0)
+                    throw new Error('projectJsonPromptAndEscape:NO deploy/project.*.json files found');
+                // cycle through project.json files
+                // ask user to confirm to use this one
+                const projectJsonToUse = await projectJsonList
+                    .reduce(async (acc, pJson) => {
+                    const answer = await acc;
+                    const candidatePath = path.join(projectFolder, 'deploy', pJson);
+                    console.log(answer);
+                    if (typeof answer === 'string' && /^Y(es|eah|up)?$/i.test(answer))
+                        return acc;
+                    const contents = await fs.readFile(candidatePath, 'utf8');
+                    // make sure it serializes
+                    JSON.stringify(JSON.parse(contents));
+                    return promptUser({
+                        message: [
+                            `Would you like to use ${pJson} with content:`,
+                            contents,
+                        ].join('\n'),
+                        timeout: 10000,
+                    }).then(() => candidatePath);
+                }, Promise.resolve(''));
+                // make chosen project.json the active one
+                if (projectJsonToUse) {
+                    console.log({ projectJsonToUse });
+                    await fs.cp(projectJsonToUse, path.join(projectFolder, 'project.json'));
+                    message = messagesThatAreNotErrors.CREATE_PROJECT_JSON;
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            if (message)
+                throw new Error(message);
+            throw new Error('projectJsonPromptAndEscape:Exiting Project JSON choice');
+        },
+        onError: async (error) => {
+            return onErrorHelper.detectOriginAndReturn('projectJsonPromptAndEscape', error, (error) => {
+                // console.error('options', options, typeof options, options.split(/\s/));
+                const goodMessage = Object.values(messagesThatAreNotErrors).find((msg) => error.endsWith(msg));
+                // console.log(goodMessage);
+                if (typeof goodMessage === 'string') {
+                    console.log(goColor('GOOD', 'Everything is fine. That error is a necessary evil', false));
+                    process.exit(0);
+                }
+                else {
+                    process.exit(1);
+                }
+            });
+        },
+        onCompleted: async (e) => {
+            console.log('project complete');
+        },
+        isStackable: true,
+    };
+};
+exports.projectJsonPromptAndEscape = projectJsonPromptAndEscape;
+/**
+ * @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}
+ */
+const newAccount = (opts) => {
+    const shared = { foo: () => console.log('not updated') };
+    return {
+        _origin: 'newAccount',
+        /**
+         * @description - asdf
+         * @param {BeforeExecutingOptions} options
+         */
+        beforeExecuting: async (options) => {
+            console.log(goColor('SUBTLE', { options }));
+            shared.foo = () => console.log(goColor('GOOD', 'updated!*****************************'));
+            return options;
+        },
+        /**
+         *
+         * @param {any} options
+         */
+        onCompleted: async (options) => {
+            console.log(goColor('INFO', 'onCompleted'), goColor('SUBTLE', options));
+            shared.foo();
+            if (options?._status === 'SUCCESS') {
+                let rootOrSrc = '';
+                const nag = async () => {
+                    rootOrSrc = await safeCommands_1.promptHelpers.promptUser({
+                        message: 'What root would you like? e.g. `src`'
+                    });
+                };
+                while (!/^\w{3,}$/.test(rootOrSrc)) {
+                    await nag();
+                }
+                const fileCabRoot = path.join(options._projectDirectory, rootOrSrc);
+                //(async ()=> {
+                //    await moveContentsUp(path.join(options._projectDirectory, 'src'));
+                //    // remove the empty src dir
+                //    await fs.rmdir(
+                //        path.join(options._projectDirectory, 'src'),
+                //        {force: true}
+                //    );
+                //})
+                // object subsfolders
+                await addSdfObjectDirs.add(path.join(fileCabRoot, 'Objects'));
+                // move the structure up one
+                // add gitKeep
+                await addGitKeep.add(fileCabRoot);
+                // backup deploy as it changes a lot
+                await fs.rename(path.join(fileCabRoot, 'deploy.xml'), path.join(fileCabRoot, 'deploy.generic.xml'));
+                // custom gitignore default
+                process.stdout.write('\n' + goColor('SUBTLE', path.join(__dirname, '../templates/sdfGitIgnore.txt', ' --> .gitignore')));
+                await fs.cp(path.join(__dirname, '../templates/sdfGitIgnore.txt'), path.join(pathHelper.getRootOfAccount(fileCabRoot), '.gitignore'))
+                    .then(() => process.stdout.write('✅'))
+                    .catch(() => process.stdout.write('❌'));
+                // default tsconfig
+                process.stdout.write('\n' + goColor('INFO', 'create tsconfig for ss2.1 '));
+                await fs.cp(path.join(__dirname, '../templates/tsconfig.ss21.projectroot.json'), path.join(pathHelper.getRootOfAccount(fileCabRoot), 'tsconfig.ss21.json'))
+                    .then(() => process.stdout.write('✅'))
+                    .catch(() => process.stdout.write('❌'));
+                // suitecloud config
+                process.stdout.write('\n' + goColor('INFO', 'create suitecloud.config.js for ss2.1 '));
+                await fs.cp(path.join(__dirname, '../templates/suitecloud.config.js'), path.join(options._projectDirectory, 'suitecloud.config.js'))
+                    .then(() => process.stdout.write('✅'))
+                    .catch(() => process.stdout.write('❌'));
+                // make types dir  (such as customizations.d.ts)
+                process.stdout.write('\n' + goColor('INFO', 'create customizations.d.ts for Type resolution'));
+                await Promise.allSettled([
+                    await fs.mkdir(path.join(options._projectDirectory, 'types')),
+                    await fs.cp(path.join(__dirname, '../templates/customizations.projectroot.d.ts'), path.join(pathHelper.getRootOfAccount(fileCabRoot), 'types', 'customizations.d.ts'))
+                ])
+                    .then(() => process.stdout.write('✅'))
+                    .catch(() => process.stdout.write('❌'));
+                // create account-specific N
+                // copy mocks
+                // run git init
+                process.stdout.write('\n' + goColor('INFO', 'git commands:'));
+                await [
+                    ['git', 'init'],
+                    ['git', 'add', '-A'],
+                    ['git', 'commit', '-m', 'firstcommit'],
+                ].reduce(async (promiseChain, command) => {
+                    await promiseChain;
+                    return new Promise((ok, no) => {
+                        const [first, second, ...args] = command;
+                        process.stdout.write(goColor('HIGHLIGHT', `\n    ${second} `));
+                        const initGit = cp.spawn(first, [second, ...args], { cwd: options._projectDirectory });
+                        initGit.on('close', (code) => {
+                            if (code)
+                                no(code);
+                            ok(true);
+                            process.stdout.write(`✅`);
+                        });
+                    });
+                }, Promise.resolve(true)).catch(() => process.stdout.write('❌'));
+            }
+        },
+        isStackable: true,
+        defaultProjectFolder: opts.root,
+    };
+};
+exports.newAccount = newAccount;
+/**
+ * @description
+ * - to be called from a beforeExecuting callback of 'project:create' in order to help create a ts project
+ * - the project name becomes the root folder so it is not an argument of this function
+ * - creates all the folders needed e.g. deploy, docs, entry
+ * - create a jest config for the project
+ * - creates a suitecloud.config file for the project
+ *
+ * @example
+ * ```bash
+ * suitecloud project:create --type ACCOUNTCUSTOMIZATION --projectname doesStuff
+ * ```
+ * @param {BeforeExecutingOptions} options
+ * @param {{authid: string; acctid: string}} extras
+ */
+const makeTsProject = (options, extras) => {
+    const Shared = {
+        casenumber: '',
+        casepath: '',
+        authid: extras.authid
+    };
+    return {
+        _origin: 'makeTsProject',
+        onError: async (error) => {
+            return onErrorHelper.detectOriginAndReturn('makeTsProject', error);
+        },
+        /**
+         * @description - for this function the project path given must be
+         * @param options
+         */
+        beforeExecuting: async (options) => {
+            try {
+                // check to make sure we are not going to overwrite anything
+                // TODO
+                // prompt for a caseNumber;
+                options.arguments.overwrite = false;
+                options.arguments.type = 'ACCOUNTCUSTOMIZATION';
+                /**
+                 * @description - recursive function until OP gets it correct
+                 * @param message
+                 */
+                const getCaseNumberCorrect = async (message) => {
+                    // list first level contents of SuiteScripts
+                    const ssFolders = await fs.readdir(path.join(process.cwd(), extras.folder, 'SuiteScripts', 'Apps'), { withFileTypes: true })
+                        .then((folders) => folders.filter((f) => f.isDirectory()))
+                        .catch(() => []);
+                    process.stdout.write(goColor('INFO', '\nExisting Folders: ', ssFolders.map(({ name }) => goColor('WARN', '\n    /SuiteScripts/Apps/', name)).join('\n')));
+                    // console.log({options, extras})
+                    Shared.casepath = await promptUser({
+                        message: `${message || ''}\nWhat is the new folder name? (e.g. Apps/glplugins)`,
+                        timeout: null
+                    });
+                    if (Shared?.casepath?.length === 0)
+                        return getCaseNumberCorrect('You must provide a folder');
+                    if (/^!(\w[\\\w]*\w|\w+)$/.test(Shared.casepath))
+                        return getCaseNumberCorrect('Bad folder name');
+                    Shared.casepath = Shared.casepath.replace(/.*\bSuiteScripts\b\/?/, '');
+                    return;
+                };
+                // trigger
+                await getCaseNumberCorrect();
+                Shared.casenumber = path.basename(Shared.casepath);
+                // this property gets used by SDF to create the folder and it will respect the slashes
+                options.arguments.projectname = path.join(extras.folder, 'SuiteScripts', Shared.casepath);
+                const newOptions = {
+                    ...options,
+                    projectPath: path.join(options.projectPath, 
+                    // os-agnostic safe
+                    extras.folder, 'SuiteScripts', Shared.casepath),
+                    overwrite: false,
+                };
+                // console.log({newOptions}, extras);
+                // check path and create pre-folder if needed so that SDF can create the last folder
+                await fs.mkdir(path.dirname(newOptions.projectPath), { recursive: true }).catch((error) => {
+                    console.error(error);
+                });
+                return newOptions;
+            }
+            catch (err) {
+                console.error(err);
+                throw err;
+            }
+        },
+        onCompleted: async (options) => {
+            // destroy all the stuff that SDF created in the folder that we don't want
+            // TODO
+            // this will be something like /Users/geraldgillespie/code/nsaccounts/65432/src/FileCabinet/SuiteScripts/Apps/foo
+            const folderToUse = options._projectDirectory; // path.join(await pathHelper.getFolderHoldingFileCabinetPlus(options._projectDirectory), 'FileCabinet');
+            {
+                // copy some demo templates
+                // console.log(path.join(process.cwd(), 'demo', 'FileCabinet', 'SuiteScripts', 'Apps', 'case123'));
+                const casePath = path.join(process.cwd(), 'demo', 'FileCabinet', 'SuiteScripts', 'Apps', 'case123');
+                await fs.access(casePath)
+                    .catch((e) => fs.mkdir(casePath, { recursive: true }))
+                    .then(() => fs.cp(casePath, folderToUse, { recursive: true }));
+                // neuter a file that can trip you up - note: it is gitignore but
+                await fs.writeFile(path.join(folderToUse, 'project.json'), JSON.stringify({
+                    defaultAuthId: null,
+                    caseNumber: Shared.casenumber,
+                    deployXml: null
+                }, null, 2), { encoding: 'utf-8' }).catch(console.error);
+            }
+            const fileCabinetPath = folderToUse.replace(/^.*(\bFileCabinet.*)$/, '$1');
+            // do not need this anymore?
+            {
+                // modify TS extends path
+                const currentTsJSon = await fs.readFile(path.join(folderToUse, 'tsconfig.json'), { encoding: 'utf8' });
+                const parsedTsConfig = JSON.parse(currentTsJSon);
+                {
+                    // e.g. "extends": ["../../../../tsconfig.ss21.json"],
+                    console.log(goColor('SUBTLE', { folderToUse, fileCabinetPath }));
+                    // console.log(goColor('HIGHLIGHT', 'this one?'), goColor('SUBTLE', path.relative(folderToUse, fileCabinetPath)));
+                    // console.log(goColor('HIGHLIGHT', 'or this one?'), goColor('SUBTLE', path.relative(fileCabinetPath, folderToUse)));
+                    parsedTsConfig.extends = [
+                        path.join(path.relative(folderToUse, pathHelper.getRootOfAccount(folderToUse)), 'tsconfig.ss21.json')
+                    ];
+                    // TODO: includes this?  "../../../../../types/*.d.ts",
+                    // map the relative path to the project's root types
+                    await fs.writeFile(path.join(folderToUse, 'tsconfig.json'), JSON.stringify(parsedTsConfig, null, 2), { encoding: 'utf8' });
+                }
+            }
+            // create some templates;
+            // create folder specific things;
+            // create module.d.ts that is specific;
+            const moduleContent = makeModuleTypeDef.fromRoot(folderToUse);
+            await fs.writeFile(path.join(folderToUse, 'module.d.ts'), moduleContent, { encoding: 'utf8' });
+            const deployXmlContent = `
+ <!-- for case number ${Shared.casenumber} for client ${Shared.authid} -->
+<deploy>
+    <files>
+        <path>~/${fileCabinetPath}/utils/utils.js</path>
+        <!--<path>~/${fileCabinetPath}/entry/example.js</path> -->       
+        <path>~/${fileCabinetPath}/docs/*</path>       
+    </files>
+    <!--
+    <objects>
+        <path>~/Objects/</path>
+    </objects>
+    -->
+</deploy>    
+`;
+            // write the xml
+            await fs.writeFile(path.join(folderToUse, 'deploy', `deploy.${path.basename(Shared.casenumber)}.xml`), deployXmlContent, { encoding: 'utf8' });
+            const projectJsonContent = JSON.stringify({
+                defaultAuthId: Shared.authid,
+                caseNumber: Shared.casenumber,
+                deployXml: `deploy.${Shared.casenumber}.xml`
+            }, null, 2);
+            await fs.writeFile(path.join(folderToUse, 'deploy', `project.${Shared.casenumber}.${Shared.authid}.json`), projectJsonContent, { encoding: 'utf8' });
+            // remove what SDF created by default
+            await fs.rm(path.join(folderToUse, pathHelpers_1.CONSTANTS.SDF_DEFAULT_ROOT), { recursive: true, force: true });
+            const created = await fs.readdir(folderToUse, { recursive: true });
+            console.log({ created });
+            try {
+                await [
+                    ['git', 'add', '-A'],
+                    ['git', 'commit', '-m', 'created project ' + options._projectName],
+                ].reduce(async (promiseChain, command) => {
+                    await promiseChain;
+                    return new Promise((ok, no) => {
+                        const [first, ...args] = command;
+                        const initGit = cp.spawn(first, args, { cwd: options._projectDirectory });
+                        initGit.on('close', (code) => {
+                            if (code)
+                                no(code);
+                            ok(true);
+                        });
+                    });
+                }, Promise.resolve(true));
+                process.stdout.write(goColor('SUCCESS', '\nGit initalized in ', options._projectDirectory));
+            }
+            catch (err) {
+                console.error('Git Commands failed', err);
+            }
+            process.stdout.write(goColor('SUCCESS', '\nNavigate to \n', goColor('HIGHLIGHT', options._projectDirectory), goColor('GOOD', '\n to continue')));
+        },
+        isStackable: true,
+    };
+};
+/**
+ * @description - hi
+ *
+ */
+const rootProjectChoices = () => {
+    const sdfCommand = makeDefaultCallbacks();
+    const origin = 'rootProjectChoices';
+    return {
+        _origin: origin,
+        beforeExecuting: async (options) => {
+            // force ACCOUNTCUSTOMIZATION
+            options.arguments.type = 'ACCOUNTCUSTOMIZATION';
+            options.arguments.overwrite = false;
+            // prompt for acct
+            const potentials = await pathHelper.findMatchingDirectories(process.cwd(), 
+            // length/depth of 3. first test must be to match account number (folder)
+            [/^(td)?\d+/, /^\w+$/, /^\w+$/, /^\w+$/]);
+            const filtered = potentials.filter((p) => /\bFileCabinet$/.test(p));
+            const choices = filtered.map((f) => f.replace(/^.*nsaccounts\b.((td)?\d+.*)$/, '$1'));
+            let folderChoice = await promptChoices({
+                choices: [...choices, 'NEW'],
+                displayChoices: [...choices, 'NEW'],
+                question: 'Which account? (or NEW?)',
+                default: 'NEW'
+            });
+            if (folderChoice === 'NEW') {
+                const nag = async () => {
+                    folderChoice = await promptUser({
+                        message: 'Type in the account id (e.g. 654321)'
+                    });
+                };
+                while (!filtered.includes(folderChoice) && !(0, validators_1.isValidAccountFolderName)(folderChoice)) {
+                    await nag();
+                }
+            }
+            // it will either be an existing choice OR a choice is a brand new value
+            const requestedAccount = folderChoice.replace(/^((td)?\d+).*$/, '$1');
+            // validate account
+            if (!/^(td)?\d+/.test(requestedAccount))
+                throw onErrorHelper.makeError(origin, new Error('Malformed account number ' + requestedAccount));
+            options.arguments.projectname = requestedAccount;
+            // check if it already exists
+            const matchedAccount = await fs.readdir(process.cwd(), { encoding: 'utf8' })
+                .then((candidates) => candidates.find(candidate => candidate === requestedAccount));
+            // give choices related to existing account
+            if (matchedAccount) {
+                const choices = ['Create TS Project for a case'];
+                const choiceMap = {
+                    [choices[0]]: () => makeTsProject(options, {
+                        /** @todo lookup the authid in the existing account project.json */
+                        authid: requestedAccount || 'TBD',
+                        acctid: matchedAccount,
+                        folder: folderChoice
+                    })
+                };
+                // list first level contents of SuiteScripts
+                const ssFolders = await fs.readdir(path.join(process.cwd(), folderChoice, 'SuiteScripts', 'Apps'), { withFileTypes: true })
+                    .then((folders) => folders.filter((f) => f.isDirectory()))
+                    .catch(() => []);
+                process.stdout.write(goColor('INFO', '\nExisting Folders: ', ssFolders.map(({ name }) => goColor('WARN', '\n    /SuiteScripts/Apps/', name)).join('\n')));
+                const answer = await safeCommands_1.promptHelpers.promptChoices({
+                    choices: Object.keys(choiceMap),
+                    displayChoices: Object.keys(choiceMap),
+                    question: 'Which type?',
+                    default: choices[0],
+                });
+                const choiceFunction = Reflect.get(choiceMap, answer);
+                if (typeof choiceFunction === 'function') {
+                    Object.assign(sdfCommand, choiceFunction());
+                }
+            }
+            else {
+                Object.assign(sdfCommand, (0, exports.newAccount)({ root: '.' }));
+            }
+            /*const confirm = await promptUser({
+                message: ['Proceed with these options?', JSON.stringify(options, null, 2),].join('\n'),
+                timeout: null
+            });
+            if (!/^y(es|up|eah)?$/i.test(confirm)) throw new Error("rootProjectChoices:Cancelled");*/
+            return sdfCommand.beforeExecuting(options);
+        },
+        onCompleted: async (options) => {
+            await sdfCommand.onCompleted(options);
+            return options;
+        },
+        onError: async (error) => {
+            return onErrorHelper.detectOriginAndReturn('rootProjectChoices', error);
+        },
+        isStackable: true,
+    };
+};
+exports.rootProjectChoices = rootProjectChoices;
+//# sourceMappingURL=projectCreate.js.map

package/commands/projectDeploy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file sdf/commands/projectDeploy.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "index";
+export declare const doDryRunAsChild: (authid: string | undefined) => Promise<number>;
+export declare const offerValidate: () => SdfCommand;
+export declare const forceValidate: () => SdfCommand;
+export declare const compileBeforeDeploy: () => SdfCommand;
+/**
+ * @deprecated
+ */
+export declare const runTestBeforeDeploy: () => SdfCommand;
+export declare const forceLog: () => SdfCommand;
+/**
+ * @description - prompt deployXml choices and confirm
+ * @see {SdfCommand}
+ */
+export declare const promptForDeployFile: () => SdfCommand;
+export declare const logErrors: () => SdfCommand;
+/**
+ * @description -
+ * @
+ */
+export declare const askForDryrun: () => SdfCommand;