@suitegeezus/suitecloud-stacker 25.2.127

package/lib/tempFileHelper.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/tempFileHelper
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeTempFiles = exports.consumeTempFile = exports.makeTempFile = exports.FileNames = void 0;
+const fs = require("node:fs/promises");
+const nodePath = require("node:path");
+const spawnSuitecloud = require("./spawnSuitecloudChild");
+const promptHelpers = require("./promptHelpers");
+exports.FileNames = {
+    accountManagementList: 'accountlist.json',
+    objectList: 'objectlist.json',
+    fileList: 'filelist.json'
+};
+const getPrefix = () => {
+    process.stdout.write(promptHelpers.goColor('SUBTLE', '\npids:', [process.env[spawnSuitecloud.getChildEnv()], process.pid].join(':')));
+    return ['sdftemp', String(process.env[spawnSuitecloud.getChildEnv()] || process.pid)].join('.');
+};
+/**
+ * @description - usually a temp file is:
+ * - created by an 'onCompleted' handler on a child process
+ * - consumed by a 'beforeExecuting' handler of a parent process
+ * - therefore watch out for file cleanup activities
+ * @param {string} fileName
+ * @param {string} data - serialized data
+ * @returns {Promise<string>} - the new file and path
+ */
+const makeTempFile = async (fileName, data) => {
+    const prefix = getPrefix();
+    const path = nodePath.join(process.cwd(), [prefix, fileName].join('_'));
+    await fs.writeFile(path, data, { encoding: 'utf-8' });
+    process.stdout.write(promptHelpers.goColor('SUBTLE', '\nTemp file created', path));
+    return path;
+};
+exports.makeTempFile = makeTempFile;
+/**
+ * @description - read and delete the temp file
+ * @param {string} fileName
+ * @returns {Promise<string>}
+ */
+const consumeTempFile = async (fileName) => {
+    const prefix = getPrefix();
+    const path = nodePath.join(process.cwd(), [prefix, fileName].join('_'));
+    const contents = await fs.readFile(path, { encoding: 'utf-8' });
+    // await fs.rm(path).catch(e => console.error(e));
+    process.stdout.write(promptHelpers.goColor('SUBTLE', '\nTemp file consumed (DISBALED)', path));
+    return contents;
+};
+exports.consumeTempFile = consumeTempFile;
+/**
+ * @description - removes temp files
+ */
+const removeTempFiles = async (prefix) => {
+    const files = await fs.readdir(process.cwd());
+    const toClean = files.filter((f) => f.startsWith(prefix || getPrefix()));
+    if (files.length > 0) {
+        process.stdout.write(promptHelpers.goColor('INFO', `\nCleaning ${toClean.length} temp files `));
+        await Promise.allSettled(toClean.map(async (file) => {
+            if (file.startsWith(prefix || getPrefix()))
+                await fs.rm(file).catch((e) => console.error(e));
+        })).catch(() => {
+            process.stdout.write('❌\n');
+        });
+        process.stdout.write('✅\n');
+    }
+};
+exports.removeTempFiles = removeTempFiles;
+//# sourceMappingURL=tempFileHelper.js.map

package/lib/updateModule.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/bin/updateModule
+ * - keeps module up to date with what is in the current directory
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description - Keep the module.d.ts file up to date with all relevant scripts that are in the current directory tree
+ * Filters out test files
+ */
+export declare const updateModuleTypeDef: () => Promise<void>;

package/lib/updateModule.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/bin/updateModule
+ * - keeps module up to date with what is in the current directory
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateModuleTypeDef = void 0;
+const fs = require("node:fs/promises");
+const nodePath = require("node:path");
+/** @internal
+ * @see makeModuleTypeDef
+ * */
+const makeModuleContent = (list, GoRoot) => {
+    // remove their extensions and make them unique
+    const unique = new Set(list.map((x) => x.replace(/(\.d)?\.[jt]s$/, '')));
+    const rootFromSS = GoRoot ? GoRoot.replace(/^.*(\bSuiteScripts\b.*)$/, '/$1') : '';
+    const toReturn = `/**
+ * This a map of modules used by Go. And provides resolution and typing of those paths.
+ * N/* modules are implicit and do not need to be listed here
+ * @example 
+ * const myUtilityLib = Go['/SuiteScripts/Apps/MyApp/utils/myUtility'];
+ * const Nrecord = Go['N/record'];
+ * const asyncNrecord = await Go.promise['N/record'];
+ * \`\`\`
+ */ 
+
+export type ModuleMap = {
+    //'/SuiteScripts/Apps/MyApp/utils/myUtility': typeof import('/SuiteScripts/Apps/MyApp/utils/myUtility');
+${[...unique]
+        .map((l) => l.replace(/^.*(\bSuiteScripts\b.*)$/, '/$1'))
+        .flatMap((m) => {
+        const tuple = [];
+        tuple.push(`    '${m}': typeof import('${m}');`);
+        if (rootFromSS) {
+            const relative = nodePath.relative(rootFromSS, m);
+            if (/\//.test(relative))
+                tuple.push(`    '${relative}': typeof import('${m}');`);
+            else
+                tuple.push(`    './${relative}': typeof import('${m}');`);
+        }
+        return tuple;
+    })
+        .sort()
+        .join('\n')}
+} // do not add N here. add that in the local index Module Map
+`;
+    return toReturn;
+};
+/**
+ * @description - Keep the module.d.ts file up to date with all relevant scripts that are in the current directory tree
+ * Filters out test files
+ */
+const updateModuleTypeDef = async () => {
+    const cwd = process.cwd();
+    if (!/\bFileCabinet\b.\bSuiteScripts\b/.test(cwd))
+        throw new Error('must provide a path that contains SuiteScripts');
+    const list = await fs.readdir(process.cwd(), { recursive: true });
+    //
+    const moduleFilesToUpdate = [];
+    const toList = list.flatMap((l) => {
+        if (/module.d.ts/.test(l)) {
+            moduleFilesToUpdate.push(nodePath.join(process.cwd(), l));
+            return [];
+        }
+        if (!/\.ts$/.test(l))
+            return [];
+        // no tests
+        if (/__tests__/.test(l))
+            return [];
+        return [nodePath.join(process.cwd(), l)];
+    });
+    const [utilsFile] = toList.filter((m) => /\butils\/utils\b/.test(m));
+    await Promise.allSettled(moduleFilesToUpdate.map(async (modFile) => {
+        await fs.writeFile(modFile, makeModuleContent(toList, nodePath.dirname(utilsFile)), { encoding: 'utf-8' });
+    }));
+};
+exports.updateModuleTypeDef = updateModuleTypeDef;
+//# sourceMappingURL=updateModule.js.map

package/lib/validators.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file sdf/lib/formatRules.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description
+ * @param name
+ * @returns {boolean}
+ */
+export declare const isValidAccountName: (name: string) => boolean;
+export declare const isValidAccountFolderName: (name: string) => boolean;
+export declare const isValidAuthId: (name: string) => boolean;

package/lib/validators.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @file sdf/lib/formatRules.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidAuthId = exports.isValidAccountFolderName = exports.isValidAccountName = void 0;
+/**
+ * @description
+ * @param name
+ * @returns {boolean}
+ */
+const isValidAccountName = (name) => {
+    return /^(TD)?\d+(_(SB)[1-9]\d*|RP)?$/.test(name);
+};
+exports.isValidAccountName = isValidAccountName;
+const isValidAccountFolderName = (name) => {
+    return /^(td)?\d+(_(SB)[1-9]\d*|RP|CUS\d?\d?)?$/.test(name);
+};
+exports.isValidAccountFolderName = isValidAccountFolderName;
+const isValidAuthId = (name) => {
+    return /[A-Z0-9_-]+$/.test(name);
+};
+exports.isValidAuthId = isValidAuthId;
+//# sourceMappingURL=validators.js.map

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@suitegeezus/suitecloud-stacker",
+  "version": "25.2.127",
+  "description": "SuiteCloud Stacker",
+  "main": "safeCommands.js",
+  "scripts": {
+    "test": "test",
+    "build:sdf": "tsc -p ./tsconfig.json",
+    "update:module": "node ./bin/updateModule.js"
+  },
+  "type": "commonjs",
+  "imports": {
+    "#root/*": "./*",
+    "#sdf/*": "./*"
+  },
+  "publishConfig":{
+    "access": "public"
+  },
+  "keywords": [
+    "sdf",
+    "netsuite",
+    "suitescript"
+  ],
+  "author": "Gerald Gillespie <gerald.gillespie@fullscript.com>",
+  "license": "ISC",
+  "peerDependencies": {
+    "@suitegeezus/suitecloud-cli": "^3.1.6-5"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.9.0",
+    "jest": "^29.7.0",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "minimatch": "^10.0.1"
+  }
+}

package/safeCommands.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @file sdf/safeCommands.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import * as promptHelper from './lib/promptHelpers';
+import { ProjectJsonContents, SdfCommand } from './index';
+import * as accountManageAuth from './commands/accountManageauth';
+import * as accountSetup from './commands/accountSetup';
+import * as fileImports from './commands/fileImport';
+import * as projectCreates from './commands/projectCreate';
+import * as projectDeploys from './commands/projectDeploy';
+import * as fileUpload from "./commands/fileUpload";
+import * as projectValidates from './commands/projectValidate';
+import * as objectLists from './commands/objectList';
+import * as objectImports from './commands/objectImport';
+export declare const promptHelpers: typeof promptHelper;
+export declare const fileImportCommand: typeof fileImports;
+export declare const projectCreateCommand: typeof projectCreates;
+export declare const projectDeployCommand: typeof projectDeploys;
+export declare const projectValidateCommand: typeof projectValidates;
+export declare const objectListCommand: typeof objectLists;
+export declare const objectImportCommand: typeof objectImports;
+export declare const fileUploadCommand: typeof fileUpload;
+export declare const accountSetupCommand: typeof accountSetup;
+export declare const accountManageAuthCommand: typeof accountManageAuth;
+/**
+ * @description - if blocked then an error is thrown (useful for temporarily neutering a capability)
+ * - the original candidate can satisfy the handler then it will
+ * - otherwise the replacement will
+ * @param {function} candidate - the root object
+ * @param {boolean} doBlock - whether to block access to the true candidate or not -- useful in debugging
+ * @param {boolean} debug - Whether to print useful values such as the property, value, arguments
+ */
+export declare const makeFunctionProxy: <T>(candidate: T, doBlock: boolean | Array<string | symbol>, debug: boolean) => T;
+/**
+ * @description - converts an "existing" command object into a proxy for both the existing and missing pieces so you can track the inputs and outputs
+ * @param {object} existing
+ * @param {boolean} doBlock
+ * @param {boolean} debug
+ */
+export declare const genericCommandProxy: (existing: object | Function, doBlock: boolean, debug: boolean) => object | Function;
+/**
+ * @deprecated
+ * @description - Take commands and export safe commands.
+ * - Proxies the function of each command
+ * - Anytime the `authid` option is seen it will strip it out as this is coming from native.
+ * - Will replace the `authid` option with a value that is taken from a transient .project.json file. Note that the
+ * transient file will only exist if it was called properly.
+ * @param options
+ */
+export declare const makeSuiteCloudConfig: (options: {
+    commands: object;
+}, authFolderMap?: Record<string, string[]>, extras?: {
+    debug: boolean;
+}) => {
+    commands: object;
+};
+/**
+ * @description -
+ * - Be careful about what you return. Each function in the stack should return options BUT some of the properties in a function are effectively `readonly` --
+ * i.e. they are not frozen and do not behave readonly until the very last handler.
+ * e.g. if you modify the property `options.arguments.authid` in `beforeExecuting` then you will be able to
+ * but the final SDF internal handler will not read the updated value.
+ * - Further some functions do not need to export options, BUT this process will pass them on to the next.  This is an
+ * opportunity to modify those options, but it is a rare cases so be careful
+ * @param {string} command - e.g. 'file:import'
+ * @returns {Function}
+ */
+export declare const stack: Function;
+/**
+ * @description - getters so that stack is not invoked until called and they are readonly
+ */
+export declare const defaultCommands: Record<string, SdfCommand>;
+/**
+ * @description - getters
+ */
+export declare const caseCommands: Record<string, SdfCommand>;
+/**
+ * @description - THIS MUST BE SYNCHRONOUS - you will get errors if the account is not setup.
+ * The  way around that is to prompt the user and then they can try again
+ * @param options
+ * @param {object} extra
+ * @param {string[]} [extra.clean] - Files to remove after running. Default is `deploy.xml` and `.project.json`. `sdftemp.*` files are always removed
+ * @param {function} [extra.onExit] - callback that run on Exit of the process. Whatever string[] are returned will be printed as lines to the console
+ * @param {module} module
+ */
+export declare const makeSafeExports: <T extends ProjectJsonContents & {
+    commands: Record<string, SdfCommand>;
+}>(options: T, extra: {
+    debug?: boolean;
+    block?: boolean;
+    autoCreateProjectJson?: boolean;
+    clean?: string[];
+    onExit?: (...m: any[]) => any;
+}, module: any) => void;