@chargebee/chargebee-apps-shared 0.0.2

package/dist/libs/template-service.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateService = void 0;
+const path_1 = __importDefault(require("path"));
+const internal_logger_1 = require("../logger/internal-logger");
+/**
+ * Template service for managing templates across different CLI packages
+ */
+class TemplateService {
+    constructor(fileSystem, templatesDir) {
+        this.fileSystem = fileSystem;
+        this.templatesDir = templatesDir;
+    }
+    /**
+     * Validates template exists
+     * @param {string} template - Template name to validate
+     * @returns {boolean} True if template is valid
+     */
+    validateTemplate(template) {
+        const availableTemplates = this.getAvailableTemplates();
+        return availableTemplates.includes(template);
+    }
+    /**
+     * Validates app directory for conflicts
+     * @param {string} targetDir - Target directory path
+     * @param {string} appDir - Original app directory argument
+     * @param {string} template - Template name
+     * @returns {string[]} Array of conflicting files (empty if no conflicts)
+     */
+    validateAppDirectory(targetDir, appDir, template) {
+        if (!this.fileSystem.existsSync(targetDir)) {
+            return [];
+        }
+        if (appDir === '.') {
+            // When using current directory, check for conflicting files
+            const templatePath = path_1.default.join(this.templatesDir, template);
+            const templateFiles = this.getTemplateFiles(templatePath);
+            const existingFiles = this.fileSystem.readdirSync(targetDir);
+            return templateFiles.filter(file => existingFiles.includes(file));
+        }
+        else {
+            // For other directories, check if not empty
+            const files = this.fileSystem.readdirSync(targetDir);
+            if (files.length > 0) {
+                throw new Error(`Directory '${targetDir}' already exists and is not empty.`);
+            }
+            return [];
+        }
+    }
+    /**
+     * Gets a list of available templates from the templates directory
+     * @returns {string[]} Array of template names
+     */
+    getAvailableTemplates() {
+        if (!this.fileSystem.existsSync(this.templatesDir)) {
+            internal_logger_1.__logger.warn(`Templates directory not found: ${this.templatesDir}`);
+            return [];
+        }
+        const templates = this.fileSystem.readdirSync(this.templatesDir, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => dirent.name);
+        return templates;
+    }
+    /**
+     * Gets the full path to a specific template
+     * @param {string} template - Template name
+     * @returns {string} Full path to the template directory
+     */
+    getTemplatePath(template) {
+        return path_1.default.join(this.templatesDir, template);
+    }
+    /**
+     * Gets the templates directory path
+     * @returns {string} Path to the templates directory
+     */
+    getTemplatesDirectory() {
+        return this.templatesDir;
+    }
+    /**
+     * Recursively collects all files from a template directory
+     * @param {string} templatePath - Path to the template directory
+     * @returns {string[]} Array of file paths relative to template root
+     */
+    getTemplateFiles(templatePath) {
+        const files = [];
+        const collectFiles = (dir, basePath = '') => {
+            const items = this.fileSystem.readdirSync(dir);
+            for (const item of items) {
+                const sourcePath = path_1.default.join(dir, item);
+                const relativePath = path_1.default.join(basePath, item);
+                const stat = this.fileSystem.statSync(sourcePath);
+                if (stat.isDirectory()) {
+                    collectFiles(sourcePath, relativePath);
+                }
+                else {
+                    files.push(relativePath);
+                }
+            }
+        };
+        collectFiles(templatePath);
+        return files;
+    }
+    /**
+     * Recursively copies all files from template directory to target directory
+     * @param {string} templatePath - Source template directory path
+     * @param {string} targetPath - Target directory path
+     */
+    copyTemplateFiles(templatePath, targetPath) {
+        const items = this.fileSystem.readdirSync(templatePath);
+        for (const item of items) {
+            const sourcePath = path_1.default.join(templatePath, item);
+            const destPath = path_1.default.join(targetPath, item);
+            const stat = this.fileSystem.statSync(sourcePath);
+            if (stat.isDirectory()) {
+                this.fileSystem.mkdirSync(destPath, { recursive: true });
+                this.copyTemplateFiles(sourcePath, destPath);
+            }
+            else {
+                this.fileSystem.copyFileSync(sourcePath, destPath);
+            }
+        }
+    }
+    /**
+     * Prints a tree-like structure of the project directory
+     * @param {string} dir - Directory path to print structure for
+     * @param {string} [indent=''] - Current indentation level
+     */
+    printProjectStructure(dir, indent = '') {
+        const items = this.fileSystem.readdirSync(dir);
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            const itemPath = path_1.default.join(dir, item || '');
+            const stat = this.fileSystem.statSync(itemPath);
+            const isDirectory = stat.isDirectory();
+            const isLastItem = i === items.length - 1;
+            // Tree characters
+            const treeChar = isLastItem ? '└── ' : '├── ';
+            const nextIndent = isLastItem ? '    ' : '│   ';
+            // File/directory name
+            const name = isDirectory ? item + '/' : item;
+            const coloredName = name;
+            internal_logger_1.__logger.info(`${indent}${treeChar}${coloredName}`);
+            if (isDirectory) {
+                this.printProjectStructure(itemPath, indent + nextIndent);
+            }
+        }
+    }
+}
+exports.TemplateService = TemplateService;

package/dist/logger/cb-logger.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Interface for CBLogger to provide strong typing
+ * This interface defines the contract that both public and private logger implementations must follow
+ */
+export interface ICBLogger {
+    /**
+     * Logs an informational message
+     * @param args - The message arguments to log
+     */
+    info(...args: any[]): void;
+    /**
+     * Logs a warning message
+     * @param args - The message arguments to log
+     */
+    warn(...args: any[]): void;
+    /**
+     * Logs an error message
+     * @param args - The message arguments to log
+     */
+    error(...args: any[]): void;
+    /**
+     * Logs a debug message
+     * @param args - The message arguments to log
+     */
+    debug(...args: any[]): void;
+}
+/**
+ * Log levels enum for consistent logging across packages
+ */
+export declare enum LogLevel {
+    ERROR = "ERROR",
+    WARN = "WARN",
+    INFO = "INFO",
+    DEBUG = "DEBUG"
+}
+/**
+ * Safe console interface that provides controlled console methods
+ */
+export interface SafeConsole {
+    log: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    trace: () => void;
+    table: () => void;
+    time: () => void;
+    timeEnd: () => void;
+    timeLog: () => void;
+    count: () => void;
+    countReset: () => void;
+    group: () => void;
+    groupCollapsed: () => void;
+    groupEnd: () => void;
+    clear: () => void;
+}

package/dist/logger/cb-logger.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+/**
+ * Log levels enum for consistent logging across packages
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["ERROR"] = "ERROR";
+    LogLevel["WARN"] = "WARN";
+    LogLevel["INFO"] = "INFO";
+    LogLevel["DEBUG"] = "DEBUG";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));

package/dist/logger/internal-logger.d.ts

@@ -0,0 +1,81 @@
+import winston from 'winston';
+/**
+ * Configuration options for InternalLogger
+ */
+export interface InternalLoggerConfig {
+    /**
+     * Whether to use JSON format for logging (default: false)
+     */
+    useJsonFormat?: boolean;
+}
+/**
+ * Context options for child loggers
+ */
+export interface ChildLoggerContext {
+    /**
+     * Additional context to include in all log messages
+     */
+    [key: string]: any;
+}
+/**
+ * Winston-based InternalLogger provides logging capabilities for the Chargebee Apps CLI itself
+ * This is separate from the user-facing cb-logger and uses Winston for structured logging
+ * Shared implementation for both public and private CLI packages
+ */
+export declare class InternalLogger {
+    private logger;
+    private config;
+    constructor(config?: InternalLoggerConfig);
+    /**
+     * Creates a Winston logger instance with appropriate formatting
+     * @returns {winston.Logger} The configured Winston logger
+     */
+    private createWinstonLogger;
+    /**
+     * Creates JSON format for structured logging
+     * @returns {winston.Logform.Format} The JSON format
+     */
+    protected createJsonFormat(): winston.Logform.Format;
+    /**
+     * Creates text format for human-readable logging
+     * @returns {winston.Logform.Format} The text format
+     */
+    protected createTextFormat(): winston.Logform.Format;
+    /**
+     * Logs an informational message
+     * @param {...any} args - The message arguments to log
+     */
+    info(...args: any[]): void;
+    /**
+     * Logs a warning message
+     * @param {...any} args - The message arguments to log
+     */
+    warn(...args: any[]): void;
+    /**
+     * Logs an error message
+     * @param {...any} args - The message arguments to log
+     */
+    error(...args: any[]): void;
+    /**
+     * Logs a debug message
+     * @param {...any} args - The message arguments to log
+     */
+    debug(...args: any[]): void;
+    /**
+     * Logs a success message (alias for info with success indicator)
+     * @param {...any} args - The message arguments to log
+     */
+    success(...args: any[]): void;
+    /**
+     * Logs a failure message (alias for error with failure indicator)
+     * @param {...any} args - The message arguments to log
+     */
+    failure(...args: any[]): void;
+    /**
+     * Creates a child logger with additional context
+     * @param {ChildLoggerContext} context - Additional context to include in all log messages
+     * @returns {InternalLogger} A new InternalLogger instance with the child context
+     */
+    child(context: ChildLoggerContext): InternalLogger;
+}
+export declare const __logger: InternalLogger;

package/dist/logger/internal-logger.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__logger = exports.InternalLogger = void 0;
+const cb_logger_1 = require("./cb-logger");
+const winston_1 = __importDefault(require("winston"));
+/**
+ * Winston-based InternalLogger provides logging capabilities for the Chargebee Apps CLI itself
+ * This is separate from the user-facing cb-logger and uses Winston for structured logging
+ * Shared implementation for both public and private CLI packages
+ */
+class InternalLogger {
+    constructor(config = {}) {
+        this.config = {
+            useJsonFormat: false,
+            ...config
+        };
+        this.logger = this.createWinstonLogger();
+    }
+    /**
+     * Creates a Winston logger instance with appropriate formatting
+     * @returns {winston.Logger} The configured Winston logger
+     */
+    createWinstonLogger() {
+        const logLevel = process.env['CB_LOG_LEVEL'] || cb_logger_1.LogLevel.INFO;
+        // Create custom format based on configuration
+        const customFormat = winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.errors({ stack: true }), this.config.useJsonFormat ? this.createJsonFormat() : this.createTextFormat());
+        return winston_1.default.createLogger({
+            level: logLevel.toLowerCase(),
+            format: customFormat,
+            transports: [
+                new winston_1.default.transports.Console({})
+            ]
+        });
+    }
+    /**
+     * Creates JSON format for structured logging
+     * @returns {winston.Logform.Format} The JSON format
+     */
+    createJsonFormat() {
+        return winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.printf((info) => {
+            const logEntry = {
+                timestamp: info['timestamp'],
+                level: info.level,
+                service: 'Internal',
+                message: info.message
+            };
+            // Include all additional context from child loggers
+            Object.keys(info).forEach(key => {
+                if (!['timestamp', 'level', 'message', 'stack'].includes(key)) {
+                    logEntry[key] = info[key];
+                }
+            });
+            if (info['stack']) {
+                logEntry.stack = info['stack'];
+            }
+            return JSON.stringify(logEntry);
+        }));
+    }
+    /**
+     * Creates text format for human-readable logging
+     * @returns {winston.Logform.Format} The text format
+     */
+    createTextFormat() {
+        return winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.colorize(), winston_1.default.format.printf((info) => {
+            const timestamp = info['timestamp'];
+            const level = info.level;
+            const service = 'Internal';
+            const message = info.message;
+            const stack = info['stack'] ? `\n${info['stack']}` : '';
+            // Build context string from additional properties
+            const contextParts = [];
+            Object.keys(info).forEach(key => {
+                if (!['timestamp', 'level', 'message', 'stack'].includes(key)) {
+                    contextParts.push(`${key}=${info[key]}`);
+                }
+            });
+            const contextStr = contextParts.length > 0 ? ` [${contextParts.join(', ')}]` : '';
+            return `${timestamp} [${level}] [${service}]${contextStr} ${message}${stack}`;
+        }));
+    }
+    /**
+     * Logs an informational message
+     * @param {...any} args - The message arguments to log
+     */
+    info(...args) {
+        const message = args.join(' ');
+        this.logger.info(message);
+    }
+    /**
+     * Logs a warning message
+     * @param {...any} args - The message arguments to log
+     */
+    warn(...args) {
+        const message = args.join(' ');
+        this.logger.warn(message);
+    }
+    /**
+     * Logs an error message
+     * @param {...any} args - The message arguments to log
+     */
+    error(...args) {
+        const message = args.join(' ');
+        this.logger.error(message);
+    }
+    /**
+     * Logs a debug message
+     * @param {...any} args - The message arguments to log
+     */
+    debug(...args) {
+        const message = args.join(' ');
+        this.logger.debug(message);
+    }
+    /**
+     * Logs a success message (alias for info with success indicator)
+     * @param {...any} args - The message arguments to log
+     */
+    success(...args) {
+        const message = args.join(' ');
+        this.logger.info(`✅ ${message}`);
+    }
+    /**
+     * Logs a failure message (alias for error with failure indicator)
+     * @param {...any} args - The message arguments to log
+     */
+    failure(...args) {
+        const message = args.join(' ');
+        this.logger.error(`❌ ${message}`);
+    }
+    /**
+     * Creates a child logger with additional context
+     * @param {ChildLoggerContext} context - Additional context to include in all log messages
+     * @returns {InternalLogger} A new InternalLogger instance with the child context
+     */
+    child(context) {
+        const childLogger = new InternalLogger(this.config);
+        // Create a Winston child logger with the provided context
+        childLogger.logger = this.logger.child(context);
+        return childLogger;
+    }
+}
+exports.InternalLogger = InternalLogger;
+// Create a singleton instance for default logger
+exports.__logger = new InternalLogger();

package/dist/node/file-system.d.ts

@@ -0,0 +1,66 @@
+import fs, { Stats } from 'fs';
+/**
+ * FileSystem interface provides a strongly-typed abstraction
+ * over common Node.js filesystem operations.
+ */
+export interface CBFileSystem {
+    /** Checks whether a given path exists on the filesystem. */
+    existsSync: (path: string) => boolean;
+    /** Reads the contents of a directory and returns an array of entries. */
+    readdirSync: (path: string, options?: any) => any[];
+    /** Creates a new directory, optionally allowing recursive creation. */
+    mkdirSync: (path: string, options?: {
+        recursive: boolean;
+    }) => void;
+    /** Deletes a file at the given path. */
+    unlinkSync: (path: string) => void;
+    /** Removes a directory at the given path. */
+    rmdirSync: (path: string) => void;
+    /** Returns stats for a given path, including directory check and size. */
+    statSync: (path: string) => {
+        isDirectory: () => boolean;
+        size: number;
+    };
+    /** Creates a writable stream to a file at the given path. */
+    createWriteStream: (path: string) => NodeJS.WritableStream;
+    /** Reads a file's contents as a string with specified encoding. */
+    readFileSync: (path: string, encoding: string) => string;
+    /** Writes string data to a file at the given path. */
+    writeFileSync: (path: string, data: string) => void;
+    /** Copies a file from source to destination. */
+    copyFileSync: (src: string, dest: string) => void;
+    /** Returns stats for a given path, including symbolic link check. */
+    lstatSync: (path: string) => Stats;
+    /** Renames a file or directory. */
+    renameSync: (oldPath: string, newPath: string) => void;
+    /** Copies a file or directory from source to destination. */
+    cpSync: (src: string, dest: string, options?: {
+        recursive: boolean;
+    }) => void;
+}
+/**
+ * FileSystemService provides a class-based implementation of the FileSystem interface.
+ * Use this for dependency injection for all the filesystem operations, and for testing we can use custom implemenatation if needed.
+ */
+export declare class FileSystemService implements CBFileSystem {
+    existsSync(path: string): boolean;
+    readdirSync(path: string, options?: any): any[];
+    mkdirSync(path: string, options?: {
+        recursive: boolean;
+    }): void;
+    unlinkSync(path: string): void;
+    rmdirSync(path: string): void;
+    statSync(path: string): {
+        isDirectory: () => boolean;
+        size: number;
+    };
+    createWriteStream(path: string): fs.WriteStream;
+    readFileSync(path: string, encoding: string): string;
+    writeFileSync(path: string, data: string): void;
+    copyFileSync(src: string, dest: string): void;
+    lstatSync(path: string): Stats;
+    renameSync(oldPath: string, newPath: string): void;
+    cpSync(src: string, dest: string, options?: {
+        recursive: boolean;
+    }): void;
+}

package/dist/node/file-system.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemService = void 0;
+const fs_1 = __importDefault(require("fs"));
+/**
+ * FileSystemService provides a class-based implementation of the FileSystem interface.
+ * Use this for dependency injection for all the filesystem operations, and for testing we can use custom implemenatation if needed.
+ */
+class FileSystemService {
+    existsSync(path) {
+        return fs_1.default.existsSync(path);
+    }
+    readdirSync(path, options) {
+        return fs_1.default.readdirSync(path, options);
+    }
+    mkdirSync(path, options) {
+        fs_1.default.mkdirSync(path, options);
+    }
+    unlinkSync(path) {
+        fs_1.default.unlinkSync(path);
+    }
+    rmdirSync(path) {
+        fs_1.default.rmdirSync(path);
+    }
+    statSync(path) {
+        return fs_1.default.statSync(path);
+    }
+    createWriteStream(path) {
+        return fs_1.default.createWriteStream(path);
+    }
+    readFileSync(path, encoding) {
+        return fs_1.default.readFileSync(path, encoding);
+    }
+    writeFileSync(path, data) {
+        fs_1.default.writeFileSync(path, data);
+    }
+    copyFileSync(src, dest) {
+        fs_1.default.copyFileSync(src, dest);
+    }
+    lstatSync(path) {
+        return fs_1.default.lstatSync(path);
+    }
+    renameSync(oldPath, newPath) {
+        try {
+            fs_1.default.renameSync(oldPath, newPath);
+        }
+        catch (err) {
+            if (err.code === 'EXDEV') {
+                // Cross-device rename (e.g. Docker overlay filesystem) — fall back to copy + delete
+                try {
+                    fs_1.default.cpSync(oldPath, newPath, { recursive: true });
+                    fs_1.default.rmSync(oldPath, { recursive: true, force: true });
+                }
+                catch (copyErr) {
+                    try {
+                        fs_1.default.rmSync(newPath, { recursive: true, force: true });
+                    }
+                    catch {
+                        // best-effort cleanup; ignore errors
+                    }
+                    throw copyErr;
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    cpSync(src, dest, options) {
+        fs_1.default.cpSync(src, dest, options);
+    }
+}
+exports.FileSystemService = FileSystemService;

package/dist/node/process.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Process interface provides a typed abstraction over common Node.js
+ * process-level operations.
+ *
+ * It covers process lifecycle control, environment variables,
+ * current working directory management, and event handling.
+ */
+export interface CBProcess {
+    /** Changes the current working directory */
+    chdir: (path: string) => void;
+    /** Terminates the Node.js process */
+    exit: (code?: number) => never;
+    /** Returns the current working directory */
+    cwd: () => string;
+    /** Access to environment variables */
+    env: NodeJS.ProcessEnv;
+    /** Registers an event listener */
+    on: (event: string, listener: (...args: any[]) => void) => void;
+}
+/**
+   * ProcessService provides a class-based implementation of the Process interface.
+   * Use this for dependency injection for all the process operations, and for testing we can use custom implemenatation if needed.
+   */
+export declare class ProcessService implements CBProcess {
+    chdir(path: string): void;
+    cwd(): string;
+    exit(code?: number): never;
+    on(event: string, listener: (...args: any[]) => void): void;
+    get env(): NodeJS.ProcessEnv;
+}

package/dist/node/process.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessService = void 0;
+/**
+   * ProcessService provides a class-based implementation of the Process interface.
+   * Use this for dependency injection for all the process operations, and for testing we can use custom implemenatation if needed.
+   */
+class ProcessService {
+    chdir(path) {
+        process.chdir(path);
+    }
+    cwd() {
+        return process.cwd();
+    }
+    exit(code) {
+        process.exit(code);
+    }
+    on(event, listener) {
+        process.on(event, listener);
+    }
+    get env() {
+        return process.env;
+    }
+}
+exports.ProcessService = ProcessService;

package/dist/sandbox/sandbox-context.d.ts

@@ -0,0 +1,37 @@
+export interface ContextData {
+    eventId: string;
+    eventType: string;
+}
+export interface ExecutionContext extends ContextData {
+    startTime: string;
+}
+/**
+ * SandboxContext manages the execution context for sandboxed code execution
+ * using AsyncLocalStorage to maintain correlation between event and site information
+ */
+export declare class SandboxContext {
+    private asyncLocalStorage;
+    constructor();
+    /**
+     * Creates a new execution context with event and site information
+     * @param {Object} contextData - The context data containing event and site information
+     * @param {string} contextData.eventId - The unique identifier for the event
+     * @param {string} contextData.eventType - The type of the event (e.g., 'customer_created')
+     * @param {string} contextData.site - The site/tenant identifier in Chargebee
+     * @param {Function} callback - The function to execute within this context
+     * @returns {Promise<any>} The result of the callback execution
+     */
+    run(contextData: ContextData, callback: () => Promise<any>): Promise<any>;
+    /**
+     * Gets the current execution context
+     * @returns {Object|null} The current context or null if not in an execution context
+     */
+    getCurrentContext(): ExecutionContext | undefined;
+    /**
+     * Checks if there is an active execution context
+     * @returns {boolean} True if there is an active context, false otherwise
+     */
+    hasContext(): boolean;
+}
+export declare const sandboxContext: SandboxContext;
+export default sandboxContext;