@chargebee/chargebee-apps-libs 0.0.2

package/dist/logger/cb-public-logger.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CBPublicLogger = void 0;
+exports.createSafeConsole = createSafeConsole;
+exports.createCBPublicLogger = createCBPublicLogger;
+const chargebee_apps_shared_1 = require("@chargebee/chargebee-apps-shared");
+const path_1 = __importDefault(require("path"));
+const winston_1 = __importDefault(require("winston"));
+/**
+ * Public logger implementation for local development
+ * This logger provides controlled logging capabilities for sandboxed code execution
+ * with correlation context and formatted output using Winston
+ */
+class CBPublicLogger {
+    constructor(fileSystem, process, userCodeDir) {
+        this.userCodeDir = userCodeDir || process.cwd();
+        this.fileSystem = fileSystem;
+        this.process = process;
+        this.logger = this.createWinstonLogger();
+    }
+    /**
+     * Creates a Winston logger with console and file transports
+     * @returns {winston.Logger} Configured Winston logger instance
+     */
+    createWinstonLogger() {
+        // Get current log level from environment
+        const currentLogLevel = this.process.env['CB_LOG_LEVEL'] || chargebee_apps_shared_1.LogLevel.INFO;
+        try {
+            // Use the user code directory (where the logs should be stored)
+            const logsDir = path_1.default.join(this.userCodeDir, 'logs');
+            const logFilePath = path_1.default.join(logsDir, 'cb.log');
+            // Create logs directory if it doesn't exist
+            if (!this.fileSystem.existsSync(logsDir)) {
+                this.fileSystem.mkdirSync(logsDir, { recursive: true });
+            }
+            // Clear the log file on each run by writing an empty string
+            this.fileSystem.writeFileSync(logFilePath, '');
+            // Create transports
+            const transports = [
+                // Console transport for development output
+                new winston_1.default.transports.Console({
+                    level: currentLogLevel.toLowerCase(),
+                    format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.colorize(), winston_1.default.format.errors({ stack: true }), winston_1.default.format.printf((info) => {
+                        return this.formatMessage(info);
+                    }))
+                }),
+                // Single file transport for all logs
+                new winston_1.default.transports.File({
+                    filename: logFilePath,
+                    level: currentLogLevel.toLowerCase(),
+                    format: winston_1.default.format.combine(winston_1.default.format.errors({ stack: true }), winston_1.default.format.printf((info) => {
+                        return this.formatMessage(info);
+                    }))
+                })
+            ];
+            return winston_1.default.createLogger({
+                level: currentLogLevel.toLowerCase(),
+                format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.errors({ stack: true })),
+                transports
+            });
+        }
+        catch (error) {
+            // Fallback to console if Winston initialization fails
+            chargebee_apps_shared_1.__logger.error('Failed to initialize Winston logger:', error);
+            // Return a minimal logger that just logs to console
+            return winston_1.default.createLogger({
+                level: currentLogLevel.toLowerCase(),
+                transports: [
+                    new winston_1.default.transports.Console({
+                        format: winston_1.default.format.simple()
+                    })
+                ]
+            });
+        }
+    }
+    /**
+     * Logs an info message
+     * @param {...any[]} args - The message arguments to log
+     */
+    info(...args) {
+        this.logger.info(args.join(' '));
+    }
+    /**
+     * Logs a warning message
+     * @param {...any[]} args - The message arguments to log
+     */
+    warn(...args) {
+        this.logger.warn(args.join(' '));
+    }
+    /**
+     * Logs an error message
+     * @param {...any[]} args - The message arguments to log
+     */
+    error(...args) {
+        this.logger.error(args.join(' '));
+    }
+    /**
+     * Logs a debug message
+     * @param {...any[]} args - The message arguments to log
+     */
+    debug(...args) {
+        this.logger.debug(args.join(' '));
+    }
+    /**
+     * Formats a message with timestamp and level
+     * @param {winston.Logform.TransformableInfo} info - The log info
+     * @returns {string} The formatted message
+     */
+    formatMessage(info) {
+        const timestamp = info['timestamp'];
+        const level = info.level;
+        const message = info.message;
+        const context = chargebee_apps_shared_1.sandboxContext.getCurrentContext();
+        const eventId = context?.eventId || 'unknown';
+        const eventType = context?.eventType || 'unknown';
+        return `${timestamp} [${level}] [${eventId}] [${eventType}] ${message}`;
+    }
+}
+exports.CBPublicLogger = CBPublicLogger;
+/**
+ * Creates a safe console object that uses the logger
+ * @param {ICBLogger} logger - The logger instance to use
+ * @returns {SafeConsole} A safe console object
+ */
+function createSafeConsole(logger) {
+    return Object.freeze({
+        log: (...args) => logger.info(...args),
+        info: (...args) => logger.info(...args),
+        warn: (...args) => logger.warn(...args),
+        error: (...args) => logger.error(...args),
+        debug: (...args) => logger.debug(...args),
+        // Disable potentially dangerous console methods
+        trace: () => { },
+        table: () => { },
+        time: () => { },
+        timeEnd: () => { },
+        timeLog: () => { },
+        count: () => { },
+        countReset: () => { },
+        group: () => { },
+        groupCollapsed: () => { },
+        groupEnd: () => { },
+        clear: () => { }
+    });
+}
+/**
+ * Creates a new CBPublicLogger instance for a specific user code directory
+ * @param {CBFileSystem} fileSystem - The filesystem implementation to use
+ * @param {CBProcess} process - The process implementation to use
+ * @param {string} userCodeDir - The user code directory where logs should be stored
+ * @returns {CBPublicLogger} A new CBPublicLogger instance
+ */
+function createCBPublicLogger(fileSystem, process, userCodeDir) {
+    return new CBPublicLogger(fileSystem, process, userCodeDir);
+}

package/dist/sandbox/public-sandbox-wrapper.d.ts

@@ -0,0 +1,41 @@
+import { AllowedModule, CBFileSystem, DependencyManager, ExecutionResult, HandlerPayload, ICBLogger, ISandboxWrapper, ManifestValidator, PackageValidator, SandboxEnvironment } from '@chargebee/chargebee-apps-shared';
+/**
+ * PublicSandboxWrapper provides a secure environment for executing user-provided NodeJS code
+ * Public implementation for local development environment
+ */
+export declare class PublicSandboxWrapper implements ISandboxWrapper {
+    private allowedModules;
+    private manifestValidator;
+    private packageValidator;
+    private fileSystem;
+    private dependencyManager;
+    constructor(allowedModules: AllowedModule[], fileSystem: CBFileSystem, packageValidator: PackageValidator, dependencyManager: DependencyManager, manifestValidator: ManifestValidator);
+    /**
+     * Creates a safe require function that uses isolated node_modules
+     * @param {string} projectPath - Path to the user project
+     * @returns {Function} Safe require function
+     */
+    createSafeRequire(projectPath: string): (moduleName: string) => any;
+    /**
+     * Loads environment variables from .env file in the project directory
+     * @param {string} projectPath - Path to the user project
+     * @returns {Record<string, string>} Environment variables object
+     */
+    private loadEnvironmentVariables;
+    /**
+     * Creates a secure sandbox environment for code execution
+     * @param {string} projectPath - Path to the user project
+     * @param {HandlerPayload} payload - Handler payload (event + iparams) to expose to user code
+     * @param {ICBLogger} sessionLogger - Logger instance for this server session
+     * @returns {SandboxEnvironment} The sandbox environment object
+     */
+    createSandbox(projectPath: string, payload: HandlerPayload, sessionLogger: ICBLogger): SandboxEnvironment;
+    /**
+     * Executes user-provided code in a secure sandbox environment.
+     * @param userCodePath - Path to the directory containing user code
+     * @param payload - Handler payload (event + iparams) to pass to the user handler
+     * @param sessionLogger - The logger instance for this server session
+     * @returns {Promise<ExecutionResult>} Execution result with success status and data/error
+     */
+    execute(userCodePath: string, payload: HandlerPayload, sessionLogger: ICBLogger): Promise<ExecutionResult>;
+}

package/dist/sandbox/public-sandbox-wrapper.js

@@ -0,0 +1,208 @@
+"use strict";
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicSandboxWrapper = void 0;
+const chargebee_apps_shared_1 = require("@chargebee/chargebee-apps-shared");
+const path_1 = __importDefault(require("path"));
+const vm_1 = __importDefault(require("vm"));
+const dotenv = __importStar(require("dotenv"));
+const cb_public_logger_1 = require("../logger/cb-public-logger");
+/**
+ * PublicSandboxWrapper provides a secure environment for executing user-provided NodeJS code
+ * Public implementation for local development environment
+ */
+class PublicSandboxWrapper {
+    constructor(allowedModules, fileSystem, packageValidator, dependencyManager, manifestValidator) {
+        this.fileSystem = fileSystem;
+        this.packageValidator = packageValidator;
+        this.dependencyManager = dependencyManager;
+        this.allowedModules = allowedModules;
+        this.manifestValidator = manifestValidator;
+    }
+    /**
+     * Creates a safe require function that uses isolated node_modules
+     * @param {string} projectPath - Path to the user project
+     * @returns {Function} Safe require function
+     */
+    createSafeRequire(projectPath) {
+        return this.dependencyManager.createIsolatedRequire(projectPath, this.allowedModules);
+    }
+    /**
+     * Loads environment variables from .env file in the project directory
+     * @param {string} projectPath - Path to the user project
+     * @returns {Record<string, string>} Environment variables object
+     */
+    loadEnvironmentVariables(projectPath) {
+        const envPath = path_1.default.join(projectPath, '.env');
+        const envVars = {};
+        try {
+            // Load .env file if it exists
+            const result = dotenv.config({ path: envPath });
+            if (result.parsed) {
+                // Only include MKPLC_CB_READ_ONLY_API and MKPLC_CB_READ_WRITE_API keys
+                if (result.parsed['MKPLC_CB_READ_ONLY_API']) {
+                    envVars['MKPLC_CB_READ_ONLY_API'] = result.parsed['MKPLC_CB_READ_ONLY_API'];
+                }
+                if (result.parsed['MKPLC_CB_READ_WRITE_API']) {
+                    envVars['MKPLC_CB_READ_WRITE_API'] = result.parsed['MKPLC_CB_READ_WRITE_API'];
+                }
+                if (result.parsed['MKPLC_SITE_DOMAIN']) {
+                    envVars['MKPLC_SITE_DOMAIN'] = result.parsed['MKPLC_SITE_DOMAIN'];
+                }
+                else {
+                    envVars['MKPLC_SITE_DOMAIN'] = '';
+                }
+            }
+        }
+        catch (error) {
+            chargebee_apps_shared_1.__logger.debug(`Failed to load .env file from ${envPath}: ${error}`);
+        }
+        return envVars;
+    }
+    /**
+     * Creates a secure sandbox environment for code execution
+     * @param {string} projectPath - Path to the user project
+     * @param {HandlerPayload} payload - Handler payload (event + iparams) to expose to user code
+     * @param {ICBLogger} sessionLogger - Logger instance for this server session
+     * @returns {SandboxEnvironment} The sandbox environment object
+     */
+    createSandbox(projectPath, payload, sessionLogger) {
+        const moduleObj = { exports: {} };
+        const exportsObj = moduleObj.exports;
+        // Load environment variables from .env file
+        const envVars = this.loadEnvironmentVariables(projectPath);
+        const hasIparams = Object.prototype.hasOwnProperty.call(payload, 'iparams');
+        const safePayload = Object.freeze(hasIparams
+            ? { event: payload.event, iparams: payload.iparams ?? {} }
+            : { event: payload.event });
+        return {
+            // Controlled logging
+            console: (0, cb_public_logger_1.createSafeConsole)(sessionLogger),
+            // Read-only payload (event + iparams) for handler(payload)
+            payload: safePayload,
+            // Safe async primitives
+            setTimeout,
+            clearTimeout,
+            setImmediate,
+            clearImmediate,
+            // CommonJS emulation
+            module: moduleObj,
+            exports: exportsObj,
+            // Controlled module access
+            require: this.createSafeRequire(projectPath),
+            // Limited process access
+            process: {
+                cwd: () => process.cwd(),
+                env: envVars,
+                nextTick: process.nextTick
+            },
+            // Prevent escape hatches
+            global: undefined,
+            Buffer: undefined,
+            __dirname: undefined,
+            __filename: undefined
+        };
+    }
+    /**
+     * Executes user-provided code in a secure sandbox environment.
+     * @param userCodePath - Path to the directory containing user code
+     * @param payload - Handler payload (event + iparams) to pass to the user handler
+     * @param sessionLogger - The logger instance for this server session
+     * @returns {Promise<ExecutionResult>} Execution result with success status and data/error
+     */
+    async execute(userCodePath, payload, sessionLogger) {
+        try {
+            chargebee_apps_shared_1.__logger.debug(`Executing user code from: ${userCodePath}`);
+            // Check if required files exist.
+            this.packageValidator.validateHandlerExists(userCodePath);
+            this.packageValidator.validateManifestExists(userCodePath);
+            // Validate manifest file.
+            const manifestPath = path_1.default.join(userCodePath, 'manifest.json');
+            const manifest = this.manifestValidator.validateAndGetManifestFile(manifestPath);
+            // Load user code
+            const eventType = payload.event.event_type;
+            const eventConfig = manifest.events[eventType];
+            if (!eventConfig) {
+                throw new Error(`No handler configured for event type: ${eventType}`);
+            }
+            const handler = eventConfig.handler;
+            const handlerPath = path_1.default.join(userCodePath, 'handler', 'handler.js');
+            const userCode = this.fileSystem.readFileSync(handlerPath, 'utf8');
+            // Create execution context
+            const contextData = {
+                eventId: payload.event.id || 'unknown',
+                eventType: payload.event.event_type || 'unknown',
+            };
+            return await chargebee_apps_shared_1.sandboxContext.run(contextData, async () => {
+                const sandbox = this.createSandbox(userCodePath, payload, sessionLogger);
+                const vmContext = vm_1.default.createContext(sandbox);
+                // Execute user code and run handler with single payload argument
+                const executeCode = `
+					(async function() {
+						"use strict";
+						try {
+							${userCode}
+							const handler = module.exports["${handler}"];
+							if (typeof handler !== 'function') {
+								throw new Error('Handler function "${handler}" not found in handler.js');
+							}
+							return await handler(payload);
+						} catch (error) {
+							console.error(error.stack ? error.stack : error);
+							throw error;
+						}
+					})()
+				`;
+                await vm_1.default.runInContext(executeCode, vmContext, {
+                    timeout: 15000, // 15 second timeout
+                    displayErrors: true
+                });
+                return { success: true, statusCode: 200 };
+            });
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: `${err.message}`,
+                stack: err.stack || undefined
+            };
+        }
+    }
+}
+exports.PublicSandboxWrapper = PublicSandboxWrapper;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@chargebee/chargebee-apps-libs",
+  "version": "0.0.2",
+  "description": "Public library implementations for Chargebee Apps CLI",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "templates",
+    "config",
+    "ui",
+    "LICENSE",
+    "SECURITY.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist && rm -rf coverage",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:unit": "jest --testPathPattern=tests/unit",
+    "minify": "esbuild 'dist/**/*.js' --minify --platform=node --outdir=dist --allow-overwrite"
+  },
+  "dependencies": {
+    "@chargebee/chargebee-apps-shared": "0.0.2",
+    "dotenv": "^16.3.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^24.3.0",
+    "@types/dotenv": "^8.2.0",
+    "esbuild": "^0.28.1",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}

package/templates/serverless-node-starter-app/.env

@@ -0,0 +1,4 @@
+# Only these three variables are supported. Replace values for local development only. Do not add new vars.
+MKPLC_CB_READ_ONLY_API=REPLACE_WITH_READ_ONLY_API_KEY
+MKPLC_CB_READ_WRITE_API=REPLACE_WITH_READ_WRITE_API_KEY
+MKPLC_SITE_DOMAIN=REPLACE_WITH_SITE_DOMAIN