@suitegeezus/suitecloud-stacker 25.2.127

package/lib/compileHelper.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/compileHelper
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runJestTest = exports.getAllTestFiles = exports.makeJestConfig = exports.generateTsConfigFromList = exports.previewFile = exports.compileTsConfig = exports.hasTsConfig = void 0;
+const fs = require("node:fs/promises");
+const nodePath = require("node:path");
+const pathHelpers = require("./pathHelpers");
+const cp = require("node:child_process");
+const promptHelpers = require("./promptHelpers");
+/**
+ * @description
+ * @returns {string|void}
+ */
+const hasTsConfig = async () => {
+    const path = nodePath.join(process.cwd(), 'tsconfig.json');
+    return fs.access(path, fs.constants.R_OK)
+        .then(() => path)
+        .catch(() => { });
+};
+exports.hasTsConfig = hasTsConfig;
+/**
+ * @description - Trigger a compile of TypeScript according to the local config file
+ * @param configFile
+ */
+const compileTsConfig = async (configFile) => {
+    const fileName = configFile || './tsconfig.json';
+    // build tsc
+    console.log('building tsc');
+    return new Promise((ok, no) => {
+        process.stdout.write(promptHelpers.goColor('SUBTLE', '\nRunning compile'));
+        const tsc = cp.spawn('npx', ['tsc', '-p', `${fileName}`], {
+            cwd: process.cwd(),
+            // combination of getting all the data without tripping up the parent error state
+            stdio: [
+                'inherit',
+                'inherit',
+                'pipe'
+            ]
+        });
+        tsc.stderr.on('data', (e) => {
+            process.stdout.write(e);
+        });
+        tsc.on('close', (e) => {
+            if (e)
+                ok(e);
+            ok(0);
+        });
+    });
+};
+exports.compileTsConfig = compileTsConfig;
+/**
+ * @param path
+ * @returns {string} - contents
+ */
+const previewFile = async (path) => fs.readFile(path, { encoding: 'utf8' });
+exports.previewFile = previewFile;
+/**
+ * @description - takes a list of files and create a TS config.  JS files becomes TS only if they exist.
+ * - relative paths will be used
+ * @param {string[]} jsPaths - could be a list of paths from deploy.xml or not.
+ * @param {string} [rootConfigFile='tsconfig.ss21.json'] - defaults to tsconfig.ss21.json
+ * @returns {{config:string; files: string[]}} - path of the new tsconfig file
+ */
+const generateTsConfigFromList = async (jsPaths, overwriteConfig, rootConfigFile) => {
+    const rootConfig = nodePath.join(pathHelpers.getRootOfAccount(process.cwd()), rootConfigFile || pathHelpers.CONSTANTS.TSCONFIG_SS21);
+    // verify the projects root tsconfig exists (or complain)
+    try {
+        await fs.access(rootConfig, fs.constants.R_OK);
+    }
+    catch (err) {
+        throw new Error('Root config ' + rootConfig + ' does not exist');
+    }
+    const pathToRoot = nodePath.relative(process.cwd(), nodePath.dirname(rootConfig));
+    const uniqueList = new Set();
+    jsPaths.map(async (path) => {
+        // only care about ts or js
+        if (!/\.[jt]s$/.test(path))
+            return;
+        let candidate = /^\.+\//.test(path)
+            ? nodePath.join(process.cwd(), path).replace(/\.js$/, 'ts')
+            : path.replace(/^.*(\bSuiteScripts\b.*)\.[tj]s$/, '$1.js');
+        let fileExists = false;
+        if (/\.js$/.test(path)) {
+            fileExists = await fs.access(candidate).then(() => true).catch(() => false);
+        }
+        else {
+            fileExists = true;
+        }
+        if (fileExists)
+            uniqueList.add(candidate.replace(process.cwd(), '.'));
+    });
+    const uniqueListAsArray = [...uniqueList];
+    let newConfigPath = null;
+    if (overwriteConfig) {
+        newConfigPath = nodePath.join(process.cwd(), 'tsconfig.json');
+        // extract existing info
+        {
+            const tsconfig = (await fs.readFile(newConfigPath, { encoding: 'utf-8' })
+                .then((j) => JSON.parse(j))
+                .catch(() => ({ extends: undefined, files: undefined })));
+            // update the files
+            await fs.writeFile(newConfigPath, JSON.stringify({
+                ...tsconfig,
+                extends: tsconfig.extends,
+                files: [
+                    ...uniqueListAsArray,
+                    // write a relative entry to the root types e.g."../../../../../types/*.d.ts",
+                    nodePath.join(nodePath.relative(process.cwd(), pathHelpers.getRootOfAccount(process.cwd())), 'types', '*.d.ts')
+                ]
+            }, null, 2), { encoding: 'utf-8' });
+        }
+    }
+    return { config: newConfigPath, files: uniqueListAsArray };
+};
+exports.generateTsConfigFromList = generateTsConfigFromList;
+/**
+ * @description
+ */
+const makeJestConfig = async () => {
+    const jestFilePath = nodePath.join(process.cwd(), 'jest.config.js');
+    await fs.access(jestFilePath, fs.constants.R_OK).catch(() => {
+        process.stdout.write(promptHelpers.goColor('SUBTLE', 'Creating Jest File'));
+        return fs.writeFile(jestFilePath, [
+            `// this file was created by SDF. You do not need to have this file checked`,
+            `const {makeJest} = require('#root/sdf/lib/makeJest.js');`,
+            `module.exports = makeJest();`
+        ].join('\n'), { encoding: 'utf8' });
+    });
+};
+exports.makeJestConfig = makeJestConfig;
+/**
+ * @description
+ */
+const getAllTestFiles = async () => fs.readdir(process.cwd(), { recursive: true }).then((list) => {
+    return list.filter((f) => /\.test\.js$/.test(f)).map((f) => nodePath.join(process.cwd(), f));
+});
+exports.getAllTestFiles = getAllTestFiles;
+/**
+ * @description - we might be running tests OR we might be testing files
+ * @param {string[]} jsFilesToTest - Get the list of files from a dryrun
+ * @param {boolean} allowMissing - whether to require tests or not
+ */
+const runJestTest = async (jsFilesToTest, allowMissing) => {
+    const jsOnly = jsFilesToTest.filter((js) => /\.js$/.test(js));
+    if (jsOnly.length === 0)
+        return 0;
+    // const jsFilesToTest = await getEveryJsTestFromTheDeployXml([deployXmlPath]);
+    const jestArgs = ['--clearMocks']; //'--ci']; // '--clearCache'];
+    if (!jsFilesToTest.includes('ALL')) {
+        // if the list are just files
+        jestArgs.push('--findRelatedTests');
+        jestArgs.push(...jsOnly);
+        if (allowMissing)
+            jestArgs.push('--passWithNoTests');
+    }
+    else {
+        if (allowMissing)
+            jestArgs.push('--passWithNoTests');
+        // jestArgs.push('./**/*.js');
+        // the list is test.js files
+    }
+    process.stdout.write(promptHelpers.goColor('WARN', '\nRunning tests', jestArgs, '\n'));
+    const p = process;
+    return new Promise((ok, no) => {
+        const jest = cp.spawn('npx', ['jest',
+            //'--showConfig'
+            ...jestArgs
+        ], {
+            cwd: process.cwd(),
+            // combination of getting all the data without tripping up the parent error state
+            stdio: [
+                'inherit',
+                'inherit',
+                'pipe'
+            ],
+            shell: true,
+        });
+        jest.stderr.on('data', (e) => {
+            const dString = e.toString();
+            if (/Running all tests instead/m.test(dString)) {
+                throw new Error('invalid test pattern');
+            }
+            p.stdout.write(e);
+        });
+        jest.on('close', (e) => {
+            if (e)
+                no(e);
+            ok(0);
+        });
+    });
+};
+exports.runJestTest = runJestTest;
+//# sourceMappingURL=compileHelper.js.map

package/lib/deleteProjectJson.d.ts

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

package/lib/deleteProjectJson.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @file sdf/lib/deleteProjectJson.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const nodePath = require("node:path");
+const process = require("node:process");
+const fs = require("node:fs");
+const deleteProjectJson = () => {
+    const projectJsonPath = nodePath.join(process.cwd(), 'project.json');
+    fs.accessSync(projectJsonPath, fs.constants.W_OK);
+    // if we get here we have write access
+    fs.rmSync(projectJsonPath, { force: true });
+};
+module.exports = deleteProjectJson;
+//# sourceMappingURL=deleteProjectJson.js.map

package/lib/deployFileHelper.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/deployFileHelper
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @param {string} path
+ * @returns {Promise<string|void>}
+ */
+export declare const hasDeployXml: (path?: string) => Promise<string | void>;
+/**
+ * @param path
+ * @returns {string} - contents
+ */
+export declare const previewFile: (path: string) => Promise<string>;
+/**
+
+ */
+export declare const removeFile: (path: string) => Promise<boolean>;
+/**
+ * @description - list of files from this path and deeper
+ * @param path
+ */
+export declare const listDeployXmlFiles: (path: string) => Promise<string[]>;
+/**
+ * @description - Promotes a deploy.xml as-is
+ * @param fromBits
+ * @param toBits
+ */
+export declare const promoteDeployXmlFile: (fromBits: string[]) => Promise<boolean>;
+/**
+ *
+ * @param content
+ * @param pathBits
+ */
+export declare const createDeployXmlFile: (content: string, pathBits: string[]) => Promise<void>;
+/**
+ *
+ * @param fromBits
+ * @param callback - A function that will provide the unglobbed deploy.xml. If it returns false then deployment will be halted
+ * @returns {}
+ */
+export declare const expandAndPromoteDeployXmlFile: (fromBits: string[], callback: ((content: string) => (Promise<boolean> | boolean))) => Promise<boolean>;
+/**
+ *
+ * @param innerXmlPath e.g. ~/FileCabinet/
+ * @param {string} projectPath
+ * @returns {Promise<string>}
+ */
+export declare const getRealPathofInnerXmlPath: (innerXmlPath: string, projectPath?: string) => Promise<string>;
+/**
+ *
+ * @param suiteScripts
+ * @param objects
+ * @returns {string} - the xml content
+ */
+export declare const makeDeployXmlString: (suiteScripts: string[], objects: string[]) => string;
+/**
+ * @descripton
+ * ```xml
+ *  <!-- for case number demo for client td2978513 -->
+ * <deploy>
+ *     <files>
+ *         <path>~/FileCabinet/SuiteScripts/Apps/demo/utils/utils.js</path>
+ *         <!--<path>~/FileCabinet/SuiteScripts/Apps/demo/entry/example.js</path> -->
+ *         <path>~/FileCabinet/SuiteScripts/Apps/demo/docs/*</path>
+ *     </files>
+ *     <objects>
+ *         <path>~/Objects/</path>
+ *     </objects>
+ * </deploy>
+ * ```
+ * @param {string} projectPath - to the src folder
+ * @param {string} relativePath
+ * @param {string} type
+ * @returns {Promise<string[]>}
+ */
+export declare const extractFilePathsFromDeployXmlFile: (projectPath: string, relativePath: string, type: "SuiteScripts" | "Objects") => Promise<string[]>;

package/lib/deployFileHelper.js

@@ -0,0 +1,249 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/deployFileHelper
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFilePathsFromDeployXmlFile = exports.makeDeployXmlString = exports.getRealPathofInnerXmlPath = exports.expandAndPromoteDeployXmlFile = exports.createDeployXmlFile = exports.promoteDeployXmlFile = exports.listDeployXmlFiles = exports.removeFile = exports.previewFile = exports.hasDeployXml = void 0;
+const fs = require("node:fs/promises");
+const nodePath = require("node:path");
+const pathHelpers = require("./pathHelpers");
+/**
+ * @param {string} path
+ * @returns {Promise<string|void>}
+ */
+const hasDeployXml = async (path) => {
+    const fcPath = await pathHelpers.getFolderHoldingFileCabinetPlus(path || process.cwd());
+    const newPath = nodePath.join(fcPath, 'deploy.xml');
+    return fs.access(newPath, fs.constants.R_OK)
+        .then(() => newPath)
+        .catch(() => {
+    });
+};
+exports.hasDeployXml = hasDeployXml;
+/**
+ * @param path
+ * @returns {string} - contents
+ */
+const previewFile = async (path) => fs.readFile(path, { encoding: 'utf8' });
+exports.previewFile = previewFile;
+/**
+
+ */
+const removeFile = async (path) => fs.rm(path)
+    .then(() => true)
+    .catch(() => false);
+exports.removeFile = removeFile;
+/**
+ * @description - list of files from this path and deeper
+ * @param path
+ */
+const listDeployXmlFiles = async (path) => {
+    const list = await fs.readdir(path, { recursive: true });
+    return list.filter((f) => (nodePath.basename(f).startsWith('deploy') && nodePath.basename(f).endsWith('.xml')));
+};
+exports.listDeployXmlFiles = listDeployXmlFiles;
+/**
+ * @description - Promotes a deploy.xml as-is
+ * @param fromBits
+ * @param toBits
+ */
+const promoteDeployXmlFile = async (fromBits) => {
+    const from = nodePath.join(...fromBits);
+    if (!from.endsWith('.xml'))
+        throw new Error('Even temporary deployXml files must have a .xml extension');
+    const fcPath = await pathHelpers.getFolderHoldingFileCabinetPlus(process.cwd());
+    const to = nodePath.join(fcPath, 'deploy.xml');
+    return fs.cp(from, to)
+        .then(() => true)
+        .catch(() => false);
+};
+exports.promoteDeployXmlFile = promoteDeployXmlFile;
+/**
+ *
+ * @param content
+ * @param pathBits
+ */
+const createDeployXmlFile = async (content, pathBits) => {
+    console.log(nodePath.join(...pathBits));
+    return fs.writeFile(nodePath.join(...pathBits), content, { encoding: 'utf-8' });
+};
+exports.createDeployXmlFile = createDeployXmlFile;
+/**
+ *
+ * @param fromBits
+ * @param callback - A function that will provide the unglobbed deploy.xml. If it returns false then deployment will be halted
+ * @returns {}
+ */
+const expandAndPromoteDeployXmlFile = async (fromBits, callback) => {
+    const from = nodePath.join(...fromBits);
+    if (!from.endsWith('.xml'))
+        throw new Error('Even temporary deployXml files must have a .xml extension');
+    const fcPath = await pathHelpers.getFolderHoldingFileCabinetPlus(process.cwd());
+    const to = nodePath.join(fcPath, 'deploy.xml');
+    const content = await fs.readFile(from, { encoding: 'utf-8' });
+    // transform files
+    const transformed = '';
+    // transform objects
+    const answer = await callback(content);
+    if (answer !== true)
+        return false;
+    //
+    return await fs.writeFile(to, transformed, { encoding: 'utf-8' })
+        .then(() => true)
+        .catch(() => false);
+};
+exports.expandAndPromoteDeployXmlFile = expandAndPromoteDeployXmlFile;
+/**
+ *
+ * @param innerXmlPath e.g. ~/FileCabinet/
+ * @param {string} projectPath
+ * @returns {Promise<string>}
+ */
+const getRealPathofInnerXmlPath = async (innerXmlPath, projectPath) => {
+    const fcPath = await pathHelpers.getFolderHoldingFileCabinetPlus(projectPath || process.cwd());
+    return nodePath.join(fcPath, innerXmlPath.replace(/^.*\b(FileCabinet.*\.js).*$/, '$1'));
+};
+exports.getRealPathofInnerXmlPath = getRealPathofInnerXmlPath;
+/**
+ *
+ * @param suiteScripts
+ * @param objects
+ * @returns {string} - the xml content
+ */
+const makeDeployXmlString = (suiteScripts, objects) => {
+    const files = [];
+    const objectPaths = [];
+    const padding = [4, ' '];
+    if (suiteScripts.length > 0) {
+        files.push('<files>');
+        files.push(...suiteScripts.map((f) => `${''.padStart(...padding)}<path>~/FileCabinet/SuiteScripts/${f.replace(/^.*SuiteScripts\b\//, '')}</path>`));
+        files.push('</files>');
+    }
+    if (objects.length > 0) {
+        objectPaths.push('<objects>');
+        objectPaths.push(...objects.map((f) => `${''.padStart(...padding)}<path>~/Objects/${f.replace(/^.*Objects\b\//, '')}</path>`));
+        objectPaths.push('</objects>');
+    }
+    return [
+        '<!-- generated output from globs -->',
+        '<deploy>',
+        ...files.map((f) => `${''.padStart(...padding)}${f}`),
+        ...objectPaths.map((o) => `${''.padStart(...padding)}${o}`),
+        '</deploy>'
+    ].join('\n');
+};
+exports.makeDeployXmlString = makeDeployXmlString;
+/**
+ * @description -
+ * {
+ *     "type": "tag",
+ *     "tagName": "deploy",
+ *     "closing": false,
+ *     "attributes": {},
+ *     "raw": "<deploy>"
+ *   },
+ * @param xml
+ */
+const tokenizeXML = (xml) => {
+    const tokens = [];
+    // Regex explanation:
+    // 1. <!--([\s\S]*?)--> matches XML comments.
+    // 2. <\s*(\/?)([a-zA-Z0-9_:-]+)([^>]*?)> matches tags:
+    //    - (\/?) captures an optional leading slash (closing tag indicator)
+    //    - ([a-zA-Z0-9_:-]+) captures the tag name.
+    //    - ([^>]*?) captures any attributes (not further processed here)
+    const regex = /<!--([\s\S]*?)-->|<\s*(\/?)([a-zA-Z0-9_:-]+)([^>]*?)>/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = regex.exec(xml)) !== null) {
+        // Capture any text between the previous match and the current match.
+        if (match.index > lastIndex) {
+            const text = xml.substring(lastIndex, match.index).trim();
+            if (text) {
+                tokens.push({ type: "text", content: text });
+            }
+        }
+        // If the first capturing group is defined, it's a comment.
+        if (match[1] !== undefined) {
+            tokens.push({ type: "comment", content: match[1].trim() });
+        }
+        else {
+            // Otherwise it's a tag.
+            const closing = match[2] === "/";
+            const tagName = match[3];
+            // For simplicity, attributes are not parsed in this example.
+            const attributes = {};
+            tokens.push({
+                type: "tag",
+                tagName,
+                closing,
+                attributes,
+                // Optionally include the raw tag string
+                raw: match[0].trim()
+            });
+        }
+        // Update lastIndex to capture text after this token.
+        lastIndex = regex.lastIndex;
+    }
+    // If there's any trailing text after the last tag, capture it.
+    if (lastIndex < xml.length) {
+        const text = xml.substring(lastIndex).trim();
+        if (text) {
+            tokens.push({ type: "text", content: text });
+        }
+    }
+    // @ts-expect-error
+    return tokens;
+};
+// Example usage:
+const xmlString = `<!-- for case number demo for client td2978513 -->
+<deploy>
+    <files>
+        <path>~/FileCabinet/SuiteScripts/Apps/demo/utils/utils.js</path>
+        <!--<path>~/FileCabinet/SuiteScripts/Apps/demo/entry/example.js</path> -->
+        <path>~/FileCabinet/SuiteScripts/Apps/demo/docs/*</path>
+    </files>
+    <!--
+    <objects>
+        <path>~/Objects/</path>
+    </objects>
+    -->
+</deploy>`;
+/**
+ * @descripton
+ * ```xml
+ *  <!-- for case number demo for client td2978513 -->
+ * <deploy>
+ *     <files>
+ *         <path>~/FileCabinet/SuiteScripts/Apps/demo/utils/utils.js</path>
+ *         <!--<path>~/FileCabinet/SuiteScripts/Apps/demo/entry/example.js</path> -->
+ *         <path>~/FileCabinet/SuiteScripts/Apps/demo/docs/*</path>
+ *     </files>
+ *     <objects>
+ *         <path>~/Objects/</path>
+ *     </objects>
+ * </deploy>
+ * ```
+ * @param {string} projectPath - to the src folder
+ * @param {string} relativePath
+ * @param {string} type
+ * @returns {Promise<string[]>}
+ */
+const extractFilePathsFromDeployXmlFile = async (projectPath, relativePath, type) => {
+    const path = pathHelpers.combineOverLappingPaths(projectPath, relativePath);
+    await fs.access(path, fs.constants.R_OK);
+    const contents = await fs.readFile(path, { encoding: 'utf-8' });
+    const replacer = type === 'Objects'
+        ? [/^.*(.\bObjects\b.*)$/, '$1']
+        : [/^.*(.\bSuiteScripts\b.*)$/, '$1'];
+    // remove comments first
+    const tokenized = tokenizeXML(contents).flatMap((x) => ((x.type === 'text' && typeof x?.content === 'string' && x?.content.includes(type))
+        // content always exists when type === 'text'
+        ? [x.content.replace(...replacer)]
+        : []));
+    // console.log(tokenized);
+    return tokenized;
+};
+exports.extractFilePathsFromDeployXmlFile = extractFilePathsFromDeployXmlFile;
+//# sourceMappingURL=deployFileHelper.js.map

package/lib/handleRootProjectJson.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/readDefaultsFromRootProjectJson
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description -
+ * @param {string[]} defaults
+ * @returns {Record<string,any>} - any defaults that were stored in the root project.json
+ */
+export declare const readDefaultsFromJson: (defaults: Array<string | "certificateid" | "privatekeypath">) => Record<string, any>;

package/lib/handleRootProjectJson.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/readDefaultsFromRootProjectJson
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDefaultsFromJson = void 0;
+const projectJson = {};
+try {
+    require('#root/project.json');
+}
+catch (e) {
+}
+/**
+ * @description -
+ * @param {string[]} defaults
+ * @returns {Record<string,any>} - any defaults that were stored in the root project.json
+ */
+const readDefaultsFromJson = (defaults) => {
+    return defaults.reduce((pj, property) => {
+        if (!Reflect.has(projectJson, property))
+            return pj;
+        return {
+            ...pj,
+            [property]: projectJson[property],
+        };
+    }, {});
+};
+exports.readDefaultsFromJson = readDefaultsFromJson;
+//# sourceMappingURL=handleRootProjectJson.js.map

package/lib/isProd.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @file sdf/lib/isProd.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+declare const isProd: {
+    (acct: string): boolean;
+    default: /*elided*/ any;
+};
+export = isProd;

package/lib/isProd.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @file sdf/lib/isProd.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const isProd = /**
+ * @description - guess at whether it is prod
+ * @param {string} acct
+ * @returns {boolean}
+ */ (acct) => /^(td)?\d+$/i.test(acct);
+isProd.default = isProd;
+module.exports = isProd;
+//# sourceMappingURL=isProd.js.map

package/lib/logHelper.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/logHelper
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+export declare const useSdfLog: (command: string) => Promise<string>;

package/lib/logHelper.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/logHelper
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSdfLog = void 0;
+const useSdfLog = async (command) => {
+    const newDate = new Date().toISOString();
+    return `./logs/sdflog.${command.replace(':', '_')}${newDate}.txt`; // //`logs/sdflog.${now}.txt`,
+};
+exports.useSdfLog = useSdfLog;
+//# sourceMappingURL=logHelper.js.map

package/lib/logger.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file sdf/lib/logger.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+declare const logger: (messages: any[]) => void;
+export = logger;

package/lib/logger.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @file sdf/lib/logger.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const logger = (messages) => {
+    console.log(...messages);
+};
+module.exports = logger;
+//# sourceMappingURL=logger.js.map

package/lib/makeDeployXml.d.ts

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