@tenonhq/sincronia-core 0.0.8 → 0.0.9

package/dist/FileUtils.js

@@ -0,0 +1,232 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./constants", "fs", "path", "./config"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.writeFileForce = exports.writeSNFileForce = exports.writeSNFileIfNotExists = exports.writeBuildFile = exports.summarizeFile = exports.encodedPathsToFilePaths = exports.isValidPath = exports.splitEncodedPaths = exports.getPathsInPath = exports.isDirectory = exports.toAbsolutePath = exports.getFileContextFromPath = exports.getBuildExt = exports.isUnderPath = exports.appendToPath = exports.pathExists = exports.createDirRecursively = exports.writeSNFileCurry = exports.writeManifestFile = exports.SNFileExists = void 0;
+    const constants_1 = require("./constants");
+    const fs_1 = __importStar(require("fs"));
+    const path_1 = __importDefault(require("path"));
+    const ConfigManager = __importStar(require("./config"));
+    const SNFileExists = (parentDirPath) => async (file) => {
+        try {
+            const files = await fs_1.promises.readdir(parentDirPath);
+            const reg = new RegExp(`${file.name}\..*$`);
+            return !!files.find((f) => reg.test(f));
+        }
+        catch (e) {
+            return false;
+        }
+    };
+    exports.SNFileExists = SNFileExists;
+    const writeManifestFile = async (man) => {
+        return fs_1.promises.writeFile(ConfigManager.getManifestPath(), JSON.stringify(man, null, 2));
+    };
+    exports.writeManifestFile = writeManifestFile;
+    const writeSNFileCurry = (checkExists) => async (file, parentPath) => {
+        let { name, type, content = "" } = file;
+        // content can sometimes be null
+        if (!content) {
+            content = "";
+        }
+        const write = async () => {
+            const fullPath = path_1.default.join(parentPath, `${name}.${type}`);
+            return await fs_1.promises.writeFile(fullPath, content);
+        };
+        if (checkExists) {
+            const exists = await (0, exports.SNFileExists)(parentPath)(file);
+            if (!exists) {
+                await write();
+            }
+        }
+        else {
+            write();
+        }
+    };
+    exports.writeSNFileCurry = writeSNFileCurry;
+    const createDirRecursively = async (path) => {
+        await fs_1.promises.mkdir(path, { recursive: true });
+    };
+    exports.createDirRecursively = createDirRecursively;
+    const pathExists = async (path) => {
+        try {
+            await fs_1.promises.access(path, fs_1.default.constants.F_OK);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    };
+    exports.pathExists = pathExists;
+    const appendToPath = (prefix) => (suffix) => path_1.default.join(prefix, suffix);
+    exports.appendToPath = appendToPath;
+    /**
+     * Detects if a path is under a parent directory
+     * @param parentPath full path to parent directory
+     * @param potentialChildPath full path to child directory
+     */
+    const isUnderPath = (parentPath, potentialChildPath) => {
+        const parentTokens = parentPath.split(path_1.default.sep);
+        const childTokens = potentialChildPath.split(path_1.default.sep);
+        return parentTokens.every((token, index) => token === childTokens[index]);
+    };
+    exports.isUnderPath = isUnderPath;
+    const getFileExtension = (filePath) => {
+        try {
+            return "." + path_1.default.basename(filePath).split(".").slice(1).join(".");
+        }
+        catch (e) {
+            return "";
+        }
+    };
+    const getBuildExt = (table, recordName, field) => {
+        const manifest = ConfigManager.getManifest();
+        if (!manifest) {
+            throw new Error("Failed to retrieve manifest");
+        }
+        const files = manifest.tables[table].records[recordName].files;
+        const file = files.find((f) => f.name === field);
+        if (!file) {
+            throw new Error("Unable to find file");
+        }
+        return file.type;
+    };
+    exports.getBuildExt = getBuildExt;
+    const getTargetFieldFromPath = (filePath, table, ext) => {
+        return table === "sys_atf_step"
+            ? "inputs.script"
+            : path_1.default.basename(filePath, ext);
+    };
+    const getFileContextFromPath = (filePath) => {
+        const ext = getFileExtension(filePath);
+        const [tableName, recordName] = path_1.default
+            .dirname(filePath)
+            .split(path_1.default.sep)
+            .slice(-2);
+        const targetField = getTargetFieldFromPath(filePath, tableName, ext);
+        const manifest = ConfigManager.getManifest();
+        if (!manifest) {
+            throw new Error("No manifest has been loaded!");
+        }
+        const { tables, scope } = manifest;
+        try {
+            const { records } = tables[tableName];
+            const record = records[recordName];
+            const { files, sys_id } = record;
+            const field = files.find((file) => file.name === targetField);
+            if (!field) {
+                return undefined;
+            }
+            return {
+                filePath,
+                ext,
+                sys_id,
+                name: recordName,
+                scope,
+                tableName,
+                targetField,
+            };
+        }
+        catch (e) {
+            return undefined;
+        }
+    };
+    exports.getFileContextFromPath = getFileContextFromPath;
+    const toAbsolutePath = (p) => path_1.default.isAbsolute(p) ? p : path_1.default.join(process.cwd(), p);
+    exports.toAbsolutePath = toAbsolutePath;
+    const isDirectory = async (p) => {
+        const stats = await fs_1.promises.stat(p);
+        return stats.isDirectory();
+    };
+    exports.isDirectory = isDirectory;
+    const getPathsInPath = async (p) => {
+        if (!(0, exports.isUnderPath)(ConfigManager.getSourcePath(), p) &&
+            !(0, exports.isUnderPath)(ConfigManager.getBuildPath(), p)) {
+            return [];
+        }
+        const isDir = await (0, exports.isDirectory)(p);
+        if (!isDir) {
+            return [p];
+        }
+        else {
+            const childPaths = await fs_1.promises.readdir(p);
+            const pathPromises = childPaths.map((childPath) => (0, exports.getPathsInPath)(path_1.default.resolve(p, childPath)));
+            const stackedPaths = await Promise.all(pathPromises);
+            return stackedPaths.flat();
+        }
+    };
+    exports.getPathsInPath = getPathsInPath;
+    const splitEncodedPaths = (encodedPaths) => encodedPaths.split(constants_1.PATH_DELIMITER).filter((p) => p && p !== "");
+    exports.splitEncodedPaths = splitEncodedPaths;
+    const isValidPath = async (path) => {
+        return (0, exports.pathExists)(path);
+    };
+    exports.isValidPath = isValidPath;
+    const encodedPathsToFilePaths = async (encodedPaths) => {
+        const pathSplits = (0, exports.splitEncodedPaths)(encodedPaths);
+        const validChecks = await Promise.all(pathSplits.map(exports.isValidPath));
+        const validSplits = pathSplits.filter((_, index) => validChecks[index]);
+        const splitPaths = await Promise.all(validSplits.map(exports.getPathsInPath));
+        const deDupedPaths = splitPaths.flat().reduce((acc, cur) => {
+            acc.add(cur);
+            return acc;
+        }, new Set());
+        return Array.from(deDupedPaths);
+    };
+    exports.encodedPathsToFilePaths = encodedPathsToFilePaths;
+    const summarizeFile = (ctx) => {
+        const { tableName, name: recordName, sys_id } = ctx;
+        return `${tableName}/${recordName}/${sys_id}`;
+    };
+    exports.summarizeFile = summarizeFile;
+    const writeBuildFile = async (folderPath, newPath, fileContents) => {
+        try {
+            await fs_1.promises.access(folderPath, fs_1.default.constants.F_OK);
+        }
+        catch (e) {
+            await fs_1.promises.mkdir(folderPath, { recursive: true });
+        }
+        try {
+            await fs_1.promises.writeFile(newPath, fileContents);
+        }
+        catch (e) {
+            throw e;
+        }
+    };
+    exports.writeBuildFile = writeBuildFile;
+    exports.writeSNFileIfNotExists = (0, exports.writeSNFileCurry)(true);
+    exports.writeSNFileForce = (0, exports.writeSNFileCurry)(false);
+    exports.writeFileForce = fs_1.promises.writeFile;
+});

package/dist/Logger.js

@@ -0,0 +1,87 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "winston", "chalk"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.logger = void 0;
+    const winston_1 = __importStar(require("winston"));
+    const chalk_1 = __importDefault(require("chalk"));
+    class SincLogger {
+        constructor() {
+            this.logger = winston_1.default.createLogger(this.genLoggerOpts());
+        }
+        setLogLevel(level) {
+            this.logger = winston_1.default.createLogger(this.genLoggerOpts(level));
+        }
+        getLogLevel() {
+            return this.logger.level;
+        }
+        genLoggerOpts(level = "info") {
+            return {
+                format: winston_1.format.printf(info => {
+                    return `${info.message}`;
+                }),
+                level,
+                transports: [new winston_1.transports.Console()]
+            };
+        }
+        info(text) {
+            this.logger.info(chalk_1.default.blue(text));
+        }
+        error(text) {
+            this.logger.error(chalk_1.default.red(text));
+        }
+        warn(text) {
+            this.logger.warn(chalk_1.default.yellow(text));
+        }
+        success(text) {
+            this.logger.info(chalk_1.default.green(text));
+        }
+        verbose(text) {
+            this.logger.verbose(text);
+        }
+        debug(text) {
+            this.logger.debug(text);
+        }
+        silly(text) {
+            this.logger.silly(text);
+        }
+        getInternalLogger() {
+            return this.logger;
+        }
+    }
+    const loggerInst = new SincLogger();
+    exports.logger = loggerInst;
+});

package/dist/PluginManager.js

@@ -0,0 +1,125 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./config", "fs", "path"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const ConfigManager = __importStar(require("./config"));
+    const fs_1 = __importDefault(require("fs"));
+    const path_1 = __importDefault(require("path"));
+    const fsp = fs_1.default.promises;
+    class PluginManager {
+        constructor() {
+            this.pluginRules = [];
+        }
+        async loadPluginConfig() {
+            let conf = ConfigManager.getConfig();
+            if (conf && conf.rules) {
+                this.pluginRules = conf.rules;
+            }
+        }
+        determinePlugins(context) {
+            let plugins = [];
+            for (let rule of this.pluginRules) {
+                let reg = rule.match;
+                if (reg.test(context.filePath)) {
+                    plugins = rule.plugins;
+                    //only match first rule
+                    break;
+                }
+            }
+            return plugins;
+        }
+        async runPlugins(plugins, context, content) {
+            try {
+                let output = content;
+                for (let pConfig of plugins) {
+                    let pluginPath = path_1.default.join(ConfigManager.getRootDir(), "node_modules", pConfig.name);
+                    let plugin = await (__syncRequire ? Promise.resolve(`${pluginPath}`).then(s => __importStar(require(s))) : new Promise((resolve_1, reject_1) => { require([pluginPath], resolve_1, reject_1); }).then(__importStar));
+                    let results = await plugin.run(context, output, pConfig.options);
+                    if (!results.success) {
+                        return {
+                            success: false,
+                            content: "",
+                        };
+                    }
+                    output = results.output;
+                }
+                return {
+                    success: true,
+                    content: output,
+                };
+            }
+            catch (e) {
+                throw e;
+            }
+        }
+        async processFile(context, content) {
+            const plugins = this.determinePlugins(context);
+            if (plugins.length > 0) {
+                try {
+                    const pluginResults = await this.runPlugins(plugins, context, content);
+                    if (pluginResults.success) {
+                        return pluginResults.content;
+                    }
+                    else {
+                        throw new Error(`Failed to build ${context.tableName}=>${context.sys_id}!`);
+                    }
+                }
+                catch (e) {
+                    throw e;
+                }
+            }
+            else {
+                return content;
+            }
+        }
+        async getFinalFileContents(context, processFile = true) {
+            const { filePath } = context;
+            try {
+                const contents = await fsp.readFile(filePath, "utf-8");
+                if (processFile) {
+                    await this.loadPluginConfig();
+                    return await this.processFile(context, contents);
+                }
+                return contents;
+            }
+            catch (e) {
+                throw e;
+            }
+        }
+    }
+    exports.default = new PluginManager();
+});

package/dist/Watcher.js

@@ -0,0 +1,54 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "chokidar", "./logMessages", "lodash", "./FileUtils", "./appUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.stopWatching = exports.startWatching = void 0;
+    const chokidar_1 = __importDefault(require("chokidar"));
+    const logMessages_1 = require("./logMessages");
+    const lodash_1 = require("lodash");
+    const FileUtils_1 = require("./FileUtils");
+    const appUtils_1 = require("./appUtils");
+    const DEBOUNCE_MS = 300;
+    let pushQueue = [];
+    let watcher = undefined;
+    const processQueue = (0, lodash_1.debounce)(async () => {
+        if (pushQueue.length > 0) {
+            //dedupe pushes
+            const toProcess = Array.from(new Set([...pushQueue]));
+            pushQueue = [];
+            const fileContexts = toProcess
+                .map(FileUtils_1.getFileContextFromPath)
+                .filter((ctx) => !!ctx);
+            const buildables = (0, appUtils_1.groupAppFiles)(fileContexts);
+            const updateResults = await (0, appUtils_1.pushFiles)(buildables);
+            updateResults.forEach((res, index) => {
+                (0, logMessages_1.logFilePush)(fileContexts[index], res);
+            });
+        }
+    }, DEBOUNCE_MS);
+    function startWatching(directory) {
+        watcher = chokidar_1.default.watch(directory);
+        watcher.on("change", fileChanged);
+    }
+    exports.startWatching = startWatching;
+    async function fileChanged(path) {
+        pushQueue.push(path);
+        processQueue();
+    }
+    function stopWatching() {
+        if (watcher) {
+            watcher.close();
+        }
+    }
+    exports.stopWatching = stopWatching;
+});