@suitegeezus/suitecloud-stacker 25.2.127

package/lib/makeDeployXml.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @file sdf/lib/makeDeployXml.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const fs = require("node:fs");
+const generic = `<deploy>
+    <configuration>
+        <path>~/AccountConfiguration/*</path>
+    </configuration>
+    <files>
+        <path>~/FileCabinet/*</path>
+    </files>
+    <objects>
+        <path>~/Objects/*</path>
+    </objects>
+    <translationimports>
+        <path>~/Translations/*</path>
+    </translationimports>
+</deploy>`;
+const makeDeployXml = async (path) => {
+    try {
+        fs.writeFileSync(path, generic, 'utf8');
+    }
+    catch {
+        console.error('Error writing deploy ***************************', path);
+    }
+};
+module.exports = makeDeployXml;
+//# sourceMappingURL=makeDeployXml.js.map

package/lib/makeJest.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file sdf/lib/makeJest.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description - Makes the Jest export for your folder.
+ * It can figure out the rootDir based on the current-working-directory.
+ * @param [folder] - maybe the account . e.g. 135243 or ['26346363','src']. usually this can be calculated
+ * @param [jestRoot] - usually needed
+ * @returns {object} exports needed for your local jest config
+ */
+export declare const makeJest: (folder?: string, jestRoot?: string) => any;

package/lib/makeJest.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * @file sdf/lib/makeJest.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeJest = void 0;
+// @ts-expect-error it does not have a typedef yet
+const SuiteCloudJestConfiguration = require("@oracle/suitecloud-unit-testing/jest-configuration/SuiteCloudJestConfiguration");
+const nodePath = require("node:path");
+const pathHelpers = require("./pathHelpers");
+/**
+ * @description - Makes the Jest export for your folder.
+ * It can figure out the rootDir based on the current-working-directory.
+ * @param [folder] - maybe the account . e.g. 135243 or ['26346363','src']. usually this can be calculated
+ * @param [jestRoot] - usually needed
+ * @returns {object} exports needed for your local jest config
+ */
+const makeJest = (folder, jestRoot) => {
+    // this is the root of the project
+    const rootDir = jestRoot || pathHelpers.getRootOfProject();
+    const derivedFolder = pathHelpers.getDifferenceFromProjectRootToFileCabinet(process.cwd(), rootDir);
+    const effectiveFolder = folder || derivedFolder;
+    //   console.log({folder,rootDir,derivedFolder, effectiveFolder}, process.cwd());
+    const { moduleNameMapper, ...rest } = SuiteCloudJestConfiguration.build({
+        /** @description - typically this is src, but it is whatever is under FileCabinet and between the root
+         __dirname.replace(/^.*\/([^\/]+)\/FileCabinet\/SuiteScripts\/.*$/,'$1' ),
+         */
+        // symlink as a pre-test action or load this from a config
+        projectFolder: folder || derivedFolder,
+        projectType: SuiteCloudJestConfiguration.ProjectType.ACP,
+        restoreMocks: true
+    });
+    const bits = ['<rootDir>'];
+    if (effectiveFolder)
+        bits.push(effectiveFolder);
+    const mapped = nodePath.join(...bits.filter(Boolean), 'FileCabinet/SuiteScripts/$1.js');
+    //    console.log({mapped});
+    // add globals for Netsuite
+    Object.assign(globalThis, {
+        debug: (a, b) => undefined,
+        audit: (a, b) => undefined,
+        error: (a, b) => undefined,
+        emergency: (a, b) => undefined,
+    });
+    return {
+        rootDir,
+        testMatch: [`${folder || process.cwd()}/**/__tests__/**/*.[jt]s?(x)`, `${folder || process.cwd()}/**/?(*.)+(test).[jt]s?(x)`],
+        moduleNameMapper: {
+            // allow a leading slash or not
+            ['^/?\\bSuiteScripts\\b/(.*)(.js)?$']: mapped,
+            ...moduleNameMapper,
+        },
+        ...rest,
+    };
+};
+exports.makeJest = makeJest;
+//# sourceMappingURL=makeJest.js.map

package/lib/makeManifestXml.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file sdf/lib/makeManifestXml.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+declare const makeManifest: (path: string, folder: string, fileName?: string) => Promise<void>;
+export = makeManifest;

package/lib/makeManifestXml.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @file sdf/lib/makeManifestXml.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const fs = require("node:fs/promises");
+const nodePath = require("node:path");
+const makeManifest = async (path, folder, fileName = 'manifest.xml') => {
+    const generic = `<manifest projecttype="ACCOUNTCUSTOMIZATION">
+  <projectname>${folder}</projectname>
+  <frameworkversion>1.0</frameworkversion>
+</manifest>`;
+    try {
+        return fs.writeFile(nodePath.join(path, fileName), generic, { encoding: 'utf-8' });
+    }
+    catch {
+        console.error('Error writing manifest ***************************', folder);
+    }
+};
+module.exports = makeManifest;
+//# sourceMappingURL=makeManifestXml.js.map

package/lib/makeProjectJson.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file sdf/lib/makeProjectJson.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+declare const makeProjectJson: (path: string, authid: string, folder: string, debug: boolean) => void;
+export = makeProjectJson;

package/lib/makeProjectJson.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @file sdf/lib/makeProjectJson.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const fs = require("node:fs");
+const makeProjectJson = (path, authid, folder, debug) => {
+    const generic = JSON.stringify({
+        "defaultAuthId": authid,
+        "defaultProjectFolder": folder,
+        "debug": Boolean(debug)
+    }, null, 2);
+    return fs.writeFileSync(path, generic, { encoding: 'utf-8' });
+};
+module.exports = makeProjectJson;
+//# sourceMappingURL=makeProjectJson.js.map

package/lib/onErrorHelper.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/onErrorHelper
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description - make an error message
+ * - SDF does not like `Error` objects, but we want the stack info so we require one but then we serialize it to report it later
+ * - if it detects that the error is already of the same origin then it will return that same error instead of creating a new one
+
+ * @example When calling this directly you should use the form where like this:
+ * ```ts
+ * makeError('whateverOrigin', new Error('my custom message'));
+ * ```
+ * this will log the stack for you but also pass it correctly to `onError` which requires a string;
+ * @param {string} origin - becomes the name
+ * @param {Error} [error]
+ * @returns {string} - we have to return a string for SDF `onError`
+ */
+export declare const makeError: (origin: string, error?: string | Error | object | unknown) => string;
+/**
+ * @description - Will detect if the origin matches the handler.  call the handler when it does
+ *
+ * The handler is your
+ * @see {SdfCommand}
+ * @param {string} origin - the name of the handler
+ * @param {string} error - the native error
+ * @param {Function} [onMatch] - async friendly callback
+ */
+export declare const detectOriginAndReturn: <E extends string | {
+    _defaultMessage: string;
+}>(origin: string, error: E, onMatch?: (error: string) => Promise<E | string> | E | string) => Promise<string | E>;

package/lib/onErrorHelper.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/onErrorHelper
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOriginAndReturn = exports.makeError = void 0;
+const promptHelper = require("./promptHelpers");
+const printError = (error) => {
+};
+/**
+ * @description - make an error message
+ * - SDF does not like `Error` objects, but we want the stack info so we require one but then we serialize it to report it later
+ * - if it detects that the error is already of the same origin then it will return that same error instead of creating a new one
+
+ * @example When calling this directly you should use the form where like this:
+ * ```ts
+ * makeError('whateverOrigin', new Error('my custom message'));
+ * ```
+ * this will log the stack for you but also pass it correctly to `onError` which requires a string;
+ * @param {string} origin - becomes the name
+ * @param {Error} [error]
+ * @returns {string} - we have to return a string for SDF `onError`
+ */
+const makeError = (origin, error) => {
+    if (typeof error === 'string') {
+        // check if it was a rethrown custom error
+        try {
+            JSON.parse(error);
+            // if it's JSON then it's already good
+            return error;
+        }
+        catch (e) {
+            // otherwise make our own
+            const asError = new Error(error);
+            asError.name = origin.toUpperCase();
+            return (0, exports.makeError)(origin, asError);
+        }
+    }
+    if (error === null)
+        return (0, exports.makeError)(origin, new Error('Unknown'));
+    if (typeof error === 'object' && typeof Reflect.get(error, 'message') === 'string') {
+        // we need to print it and then serialize it and recurse
+        const uniqueName = new Set();
+        uniqueName.add(origin.toUpperCase());
+        if (!Reflect.has(error, 'name'))
+            throw new Error('make Error was not called correctly');
+        uniqueName.add(Reflect.get(error, 'name').toUpperCase());
+        const name = [...uniqueName].join(':');
+        // re-name this error object
+        const custom = JSON.stringify({
+            name,
+            message: Reflect.get(error, 'message')
+        } /* no formatting */);
+        // print it for forensics
+        process.stdout.write(promptHelper.goColor('SUBTLE', '\n', name, ':', Reflect.get(error, 'stack')));
+        // only way out of the recursion;
+        return custom;
+    }
+    return (0, exports.makeError)(origin.toUpperCase(), 'unknown ' + typeof error);
+};
+exports.makeError = makeError;
+/**
+ * @description - Will detect if the origin matches the handler.  call the handler when it does
+ *
+ * The handler is your
+ * @see {SdfCommand}
+ * @param {string} origin - the name of the handler
+ * @param {string} error - the native error
+ * @param {Function} [onMatch] - async friendly callback
+ */
+const detectOriginAndReturn = async (origin, error, onMatch) => {
+    let message;
+    let name;
+    if (typeof error === 'string') {
+        ({ name, message } = await Promise.resolve(error)
+            .then(() => JSON.parse(error))
+            .catch(() => {
+            // @ts-expect-error it's worht a shot e.g. "There was an error while executing... Details: { name: "blah"}
+            return JSON.parse(error.split(/\n/).pop());
+        })
+            .catch(() => ({ name: null, message: error })));
+    }
+    else {
+        message = error?._defaultMessage;
+    }
+    const handlerIsRelevant = (!name || `${name}`.includes(origin.toUpperCase())) && typeof onMatch === 'function';
+    return handlerIsRelevant
+        ? onMatch(message)
+        : error;
+};
+exports.detectOriginAndReturn = detectOriginAndReturn;
+//# sourceMappingURL=onErrorHelper.js.map

package/lib/pathHelpers.d.ts

@@ -0,0 +1,133 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/pathHelpers
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+export declare const CONSTANTS: {
+    TSCONFIG_SS21: string;
+    SDF_DEFAULT_ROOT: string;
+    SDF_TEMP_ROOT: string;
+    SDF_FILE_CABINET: string;
+    SDF_TEMP_ROOT_RGX: RegExp;
+};
+/**
+ * @description - have it or not
+ * @param filePath
+ * @returns {false|string}
+ */
+export declare const hasFile: (filePath: string | string[]) => Promise<string | false>;
+/**
+ * ⚠️⚠️⚠️⚠️⚠️ WARNING: this gets the root of this project and not the project using this as a dependency!
+ * @returns {string} e.g. /Users/jdoe/code/nsaccounts
+ */
+export declare const getRootOfProject: () => string;
+/**
+ * @description - for example:
+ * - a relative path and the current directory
+ * - the entire path and a SuiteScripts path that both have SuiteScripts in it
+ * @param path1 -- must be an absolute path
+ * @param path2 - can be a partial path, relative path or special SDK path e.g. /SuiteScripts
+ */
+export declare const combineOverLappingPaths: (path1: string, path2: string) => string;
+export declare const joinPaths: (...paths: string[]) => string;
+/**
+ *
+ * @param {string} [path]
+ * @returns {Promise<string>}
+ */
+export declare const getSuiteCloudConfigPath: (path?: string) => Promise<string>;
+/**
+ *
+ * @param {string} folder - the current place that you are. e.g process.cwd() or __dirname or whatever
+ * @param {boolean} [folderNameOnly] - where to strip off the folders e.g. 12345323
+ * @returns {string} e.g. /path/to/12346357
+ */
+export declare const getRootOfAccount: (folder: string, folderNameOnly?: boolean) => string;
+/**
+ * @description - If the provided path does not contain the reference then this will scan the descendants for the first one
+ * @param path
+ * @returns {Promise<string>}
+ */
+export declare const getFolderHoldingFileCabinetPlus: (path: string) => Promise<string>;
+/**
+ *
+ * @param {string} anyCabinetPathInAccount
+ * @param {string} [projectRoot]
+ * @returns {string} * @returns {string} e.g. 24365476/src
+ */
+export declare const getDifferenceFromProjectRootToFileCabinet: (anyCabinetPathInAccount: string, projectRoot?: string) => string;
+/**
+ * @description - same as path.relative
+ * @param projectJsonLocation
+ * @param projectRoot
+ */
+export declare const getRelativeOf: (projectJsonLocation: string, projectRoot: string) => string;
+/**
+ * @description - for common folders
+ * @param {string} type
+ * @param {string[]} extras
+ * @param {string} [target] - defaults to cwd
+ * @returns {string} - The full path
+ *
+ */
+export declare const getAccountDir: (type: "FileCabinet" | "SuiteScripts" | "Objects" | "Translations" | "AccountConfiguration" | "Templates" | "Web Site Hosting Files", extras: string[], target?: string) => Promise<string>;
+export declare const removeTempDirForSdf: (projectPath: string) => Promise<string>;
+/**
+ * @description
+ * @param {string[]} pathBits
+ */
+export declare const removeFile: (pathBits: string[]) => Promise<string>;
+/**
+ * @description - makes a `temp` directory in the same account root
+ * - no need to copy anything over
+ * @param {string} projectPath
+ * @returns {Promise<string>}
+ */
+export declare const makeTempDirForSdf: (projectPath: string) => Promise<string>;
+/**
+ * @description - Figures out the path
+ * - if you have a relative path then compare it against cwd
+ * - if you have an absolute path then check if it is actually a NetSuite project path
+ * -
+ */
+export declare const getAbsolutePath: (options: {
+    projectPath: string;
+    executionPath?: string;
+    filePath: string;
+}) => string;
+/**
+ * @description -
+ */
+export declare const getAccountFolders: (path: string) => Promise<string[]>;
+/**
+ * Recursively find directories whose names match a series of tests at each depth.
+ * @param {string} dir - The directory to start searching from.
+ * @param {*[]} tests - Current recursion depth (default is 0).
+ * @returns {Promise<string[]>} - An array of matching directory paths.
+ */
+export declare const findMatchingDirectories: (dir: string, tests: Array<{
+    test: (x: string) => boolean;
+}>) => Promise<string[]>;
+/**
+ * @description - Get the remaining path
+ * @param {string[]} paths
+ * @param {'SuiteScripts'} type -
+ * @param {Array<function|string|RegExp>} [tests] - functions or globs or regex to apply. Only `some` has to pass.
+ * @returns {Promise<string[]>}
+ */
+export declare const getAllFilesRecursively: (paths: string[], type: "SuiteScripts" | "Objects" | "SuiteApps" | "SuiteBundles", tests: Array<((x: string) => boolean) | string | RegExp>) => Promise<string[]>;
+/**
+ * @description -- you should convert first
+ * @param paths
+ */
+export declare const removeIllegalFileCabinetFiles: (paths: string[]) => string[];
+/**
+ * @description - A legal object file has only one extension '.xml'
+ * And the scriptid inside matches its file name. We cannot open files here
+ * @param paths
+ */
+export declare const removeIllegalObjectFiles: (paths: string[]) => string[];
+/**
+ * @description - e.g. ts to js
+ * @param paths
+ */
+export declare const convertFileExtensions: (paths: string[]) => string[];