@chargebee/chargebee-apps-shared 0.0.2

package/dist/config/path-resolver.js

@@ -0,0 +1,247 @@
+"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.PathResolver = exports.PathType = void 0;
+const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("fs"));
+const environment_1 = require("./environment");
+/**
+ * Path type enum for different package paths
+ */
+var PathType;
+(function (PathType) {
+    /** Root directory of the CLI workspace */
+    PathType["CLI_ROOT"] = "CLI_ROOT";
+    /** Private application distribution directory */
+    PathType["PRIVATE_APP_DIST"] = "PRIVATE_APP_DIST";
+    /** Private application root directory */
+    PathType["PRIVATE_APP_ROOT"] = "PRIVATE_APP_ROOT";
+    /** Public libs templates directory */
+    PathType["PUBLIC_LIBS_TEMPLATES"] = "PUBLIC_LIBS_TEMPLATES";
+    /** Public libs UI web directory */
+    PathType["PUBLIC_LIBS_UI_WEB"] = "PUBLIC_LIBS_UI_WEB";
+})(PathType || (exports.PathType = PathType = {}));
+/**
+ * Path resolver class for resolving paths based on environment
+ * @class PathResolver
+ * @implements {IPathResolver}
+ *
+ * @description
+ * This class provides centralized path resolution for all packages in the CLI.
+ * It detects the environment (development vs production) and resolves paths accordingly:
+ * - In development: Uses workspace-relative paths
+ * - In production: Uses require.resolve to find installed packages
+ *
+ * This eliminates the need for try-catch error handling scattered across the codebase.
+ *
+ * @example
+ * ```typescript
+ * const pathResolver = new PathResolver();
+ * const templatesDir = pathResolver.getPublicLibsTemplatesDir();
+ * console.log(`Templates directory: ${templatesDir}`);
+ * ```
+ */
+class PathResolver {
+    constructor(envConfig) {
+        this.cliRoot = null;
+        this.envConfig = envConfig || new environment_1.EnvironmentConfig();
+    }
+    /**
+     * Resolves a path based on the path type and environment
+     * @param {PathType} pathType - Type of path to resolve
+     * @returns {string} Resolved path
+     * @throws {Error} If path cannot be resolved
+     */
+    resolvePath(pathType) {
+        switch (pathType) {
+            case PathType.CLI_ROOT:
+                return this.getCliRoot();
+            case PathType.PRIVATE_APP_DIST:
+                return this.getPrivateAppDistDir();
+            case PathType.PRIVATE_APP_ROOT:
+                return this.getPrivateAppRootDir();
+            case PathType.PUBLIC_LIBS_TEMPLATES:
+                return this.getPublicLibsTemplatesDir();
+            case PathType.PUBLIC_LIBS_UI_WEB:
+                return this.getPublicLibsUiWebDir();
+            default:
+                throw new Error(`Unknown path type: ${pathType}`);
+        }
+    }
+    /**
+     * Gets the CLI workspace root path
+     * @returns {string} Path to CLI workspace root
+     */
+    getCliRoot() {
+        if (this.cliRoot) {
+            return this.cliRoot;
+        }
+        if (this.envConfig.isDevelopment()) {
+            // Development: Find the project root by looking for package.json with workspaces
+            this.cliRoot = this.findProjectRootWithWorkspaces(__dirname);
+        }
+        else {
+            // Production: Use the package installation directory
+            // In production, packages are installed via npm and there's no workspace structure
+            this.cliRoot = path_1.default.resolve(__dirname, '../..');
+        }
+        return this.cliRoot;
+    }
+    /**
+     * Gets the private application distribution directory path
+     * @returns {string} Path to private application dist directory
+     */
+    getPrivateAppDistDir() {
+        if (this.envConfig.isDevelopment()) {
+            // Development: Use workspace path
+            const cliRoot = this.getCliRoot();
+            return path_1.default.join(cliRoot, 'packages', 'private-application', 'dist');
+        }
+        else {
+            // Production: Find the installed package
+            try {
+                const resolvedPath = require.resolve('@chargebee-private/chargebee-apps-private-application');
+                return path_1.default.dirname(resolvedPath);
+            }
+            catch (error) {
+                throw new Error('Failed to resolve private-application path. ' +
+                    'Ensure @chargebee-private/chargebee-apps-private-application is installed.');
+            }
+        }
+    }
+    /**
+     * Gets the private application root directory path
+     * @returns {string} Path to private application root directory
+     */
+    getPrivateAppRootDir() {
+        if (this.envConfig.isDevelopment()) {
+            // Development: Use workspace path
+            const cliRoot = this.getCliRoot();
+            return path_1.default.join(cliRoot, 'packages', 'private-application');
+        }
+        else {
+            // Production: Find the installed package root
+            try {
+                const packageJsonPath = require.resolve('@chargebee-private/chargebee-apps-private-application/package.json');
+                return path_1.default.dirname(packageJsonPath);
+            }
+            catch (error) {
+                throw new Error('Failed to resolve private-application root path. ' +
+                    'Ensure @chargebee-private/chargebee-apps-private-application is installed.');
+            }
+        }
+    }
+    /**
+     * Gets the public libs templates directory path
+     * @returns {string} Path to public libs templates directory
+     */
+    getPublicLibsTemplatesDir() {
+        if (this.envConfig.isDevelopment()) {
+            // Development: Use workspace path
+            const cliRoot = this.getCliRoot();
+            return path_1.default.join(cliRoot, 'packages', 'public-libs', 'templates');
+        }
+        else {
+            // Production: Find the installed package and get templates from package root
+            try {
+                const publicLibsPath = require.resolve('@chargebee/chargebee-apps-libs');
+                const packageRoot = path_1.default.dirname(path_1.default.dirname(publicLibsPath));
+                return path_1.default.join(packageRoot, 'templates');
+            }
+            catch (error) {
+                throw new Error('Failed to resolve public-libs templates path. ' +
+                    'Ensure @chargebee/chargebee-apps-libs is installed.');
+            }
+        }
+    }
+    /**
+     * Gets the public libs UI web directory path
+     * @returns {string} Path to public libs UI web directory
+     */
+    getPublicLibsUiWebDir() {
+        if (this.envConfig.isDevelopment()) {
+            // Development: Use workspace path
+            const cliRoot = this.getCliRoot();
+            return path_1.default.join(cliRoot, 'packages', 'public-libs', 'ui', 'web');
+        }
+        else {
+            // Production: Find the installed package and get UI from package root
+            try {
+                const publicLibsPath = require.resolve('@chargebee/chargebee-apps-libs');
+                const packageRoot = path_1.default.dirname(path_1.default.dirname(publicLibsPath));
+                return path_1.default.join(packageRoot, 'ui', 'web');
+            }
+            catch (error) {
+                throw new Error('Failed to resolve public-libs UI web path. ' +
+                    'Ensure @chargebee/chargebee-apps-libs is installed.');
+            }
+        }
+    }
+    /**
+     * Finds the project root by looking for package.json with workspaces
+     * @param {string} startDir - Directory to start searching from
+     * @returns {string} Path to project root
+     * @throws {Error} If project root cannot be found
+     * @private
+     */
+    findProjectRootWithWorkspaces(startDir) {
+        let currentDir = startDir;
+        const root = path_1.default.parse(currentDir).root;
+        while (currentDir !== root) {
+            const packageJsonPath = path_1.default.join(currentDir, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                try {
+                    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                    if (packageJson.workspaces) {
+                        return currentDir;
+                    }
+                }
+                catch (error) {
+                    // Continue searching if package.json is invalid
+                }
+            }
+            const parent = path_1.default.dirname(currentDir);
+            if (parent === currentDir) {
+                break;
+            }
+            currentDir = parent;
+        }
+        throw new Error('Could not find project root with workspaces');
+    }
+}
+exports.PathResolver = PathResolver;

package/dist/dependency/dependency-manager.d.ts

@@ -0,0 +1,66 @@
+import { CBFileSystem } from '../node/file-system';
+import { AllowedModule, Manifest } from '../types/common';
+/**
+ * DependencyManager handles isolated npm installations for user projects
+ * Public implementation for managing dependencies in development environment
+ */
+export declare class DependencyManager {
+    private installed;
+    private fileSystem;
+    constructor(fileSystem: CBFileSystem);
+    /**
+     * Ensures dependencies are installed for a user project
+     * @param {string} projectPath - Path to the user project directory
+     * @param {Manifest} manifest - The project manifest containing dependencies
+     * @returns {Promise<void>}
+     */
+    ensureDependencies(projectPath: string, manifest: Manifest): Promise<void>;
+    /**
+     * Creates a safe require function that uses isolated node_modules
+     * @param {string} projectPath - Path to the user project
+     * @param {AllowedModule[]} allowedModules - List of allowed modules
+     * @returns {Function} Safe require function
+     */
+    createIsolatedRequire(projectPath: string, allowedModules: AllowedModule[]): (moduleName: string) => any;
+    /**
+     * Creates or updates package.json for the project
+     * @param {string} packageJsonPath - Path to package.json
+     * @param {Record<string, string>} dependencies - Dependencies from manifest
+     */
+    protected createPackageJson(packageJsonPath: string, dependencies: Record<string, string>): Promise<void>;
+    /**
+     * Installs dependencies using npm
+     * @param {string} handlerPath - Path to the handler directory
+     */
+    protected installDependencies(handlerPath: string): Promise<void>;
+    /**
+     * Tries to load a CommonJS alternative for an ES module. This is a fallback for when the common JS is not the default export.
+     * @param moduleName - Name of the module to require
+     * @param resolvedModulePath - Path to the resolved module
+     * @returns
+     */
+    protected tryLoadCommonJSAlternative(moduleName: string, resolvedModulePath: string): any;
+    /**
+     * Gets the relative path require.
+     * @param moduleName - Name of the module to require
+     * @param handlerPath - Path to the handler directory
+     * @returns
+     */
+    protected getRelativePathRequire(moduleName: string, handlerPath: string): any;
+    /**
+     * Gets the generic dependency require. Unless there are special cases like ES modules, this should work for all dependencies.
+     * @param moduleName - Name of the module to require
+     * @param allowedModules - List of allowed modules
+     * @param nodeModulesPath - Path to the node_modules directory
+     * @returns
+     */
+    protected getGenericDependencyRequire(moduleName: string, allowedModules: AllowedModule[], nodeModulesPath: string): any;
+    /**
+     * Validates and gets the resolved path to the module.
+     * @param allowedModules - List of allowed modules
+     * @param nodeModulesPath - Path to the node_modules directory
+     * @param moduleName - Name of the module to validate
+     * @returns Path to the module
+     */
+    protected validateAndGetModulePath(allowedModules: AllowedModule[], nodeModulesPath: string, moduleName: string): string;
+}

package/dist/dependency/dependency-manager.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyManager = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const internal_logger_1 = require("../logger/internal-logger");
+/**
+ * DependencyManager handles isolated npm installations for user projects
+ * Public implementation for managing dependencies in development environment
+ */
+class DependencyManager {
+    constructor(fileSystem) {
+        this.fileSystem = fileSystem;
+        this.installed = false;
+    }
+    /**
+     * Ensures dependencies are installed for a user project
+     * @param {string} projectPath - Path to the user project directory
+     * @param {Manifest} manifest - The project manifest containing dependencies
+     * @returns {Promise<void>}
+     */
+    async ensureDependencies(projectPath, manifest) {
+        if (!manifest.dependencies || Object.keys(manifest.dependencies).length === 0) {
+            internal_logger_1.__logger.debug('No dependencies to install');
+            return;
+        }
+        // Check if already installed
+        if (this.installed) {
+            internal_logger_1.__logger.debug('Dependencies already installed for this project');
+            return;
+        }
+        const handlerPath = path_1.default.join(projectPath, 'handler');
+        const packageJsonPath = path_1.default.join(handlerPath, 'package.json');
+        try {
+            // Create handler directory if it doesn't exist
+            if (!this.fileSystem.existsSync(handlerPath)) {
+                this.fileSystem.mkdirSync(handlerPath, { recursive: true });
+            }
+            // Create or update package.json
+            await this.createPackageJson(packageJsonPath, manifest.dependencies);
+            // Install dependencies
+            await this.installDependencies(handlerPath);
+            // Mark as installed
+            this.installed = true;
+            internal_logger_1.__logger.info(`Installed ${Object.keys(manifest.dependencies).length} dependencies for project`);
+        }
+        catch (error) {
+            const err = error;
+            internal_logger_1.__logger.error('Failed to install dependencies:', err.message);
+            throw new Error(`Dependency installation failed: ${err.message}`);
+        }
+    }
+    /**
+     * Creates a safe require function that uses isolated node_modules
+     * @param {string} projectPath - Path to the user project
+     * @param {AllowedModule[]} allowedModules - List of allowed modules
+     * @returns {Function} Safe require function
+     */
+    createIsolatedRequire(projectPath, allowedModules) {
+        const handlerPath = path_1.default.resolve(projectPath, 'handler');
+        const nodeModulesPath = path_1.default.join(handlerPath, 'node_modules');
+        return (moduleName) => {
+            // Check if the module is a relative path
+            if (moduleName.startsWith('./')) {
+                // Normalize the path to prevent path traversal attacks
+                return this.getRelativePathRequire(moduleName, handlerPath);
+            }
+            // Handle direct CommonJS paths (e.g., 'axios/dist/node/axios.cjs')
+            if (moduleName.includes('/')) {
+                // Extract the base module name
+                return this.getGenericDependencyRequire(moduleName, allowedModules, nodeModulesPath);
+            }
+            // Verify version if constraint is specified
+            const resolvedModulePath = this.validateAndGetModulePath(allowedModules, nodeModulesPath, moduleName);
+            try {
+                // Check if this is an ES module that loaded but doesn't have the expected interface
+                // This happens when ES modules export named exports instead of a default function
+                // Try to load the module and handle ES module issues with cjs (if available) else fallback to the ES module
+                return this.tryLoadCommonJSAlternative(moduleName, resolvedModulePath);
+            }
+            catch (error) {
+                const err = error;
+                throw new Error(`Failed to load module "${moduleName}": ${err.message}`);
+            }
+        };
+    }
+    /**
+     * Creates or updates package.json for the project
+     * @param {string} packageJsonPath - Path to package.json
+     * @param {Record<string, string>} dependencies - Dependencies from manifest
+     */
+    async createPackageJson(packageJsonPath, dependencies) {
+        const packageJson = {
+            dependencies: { ...dependencies }
+        };
+        const content = JSON.stringify(packageJson, null, 2);
+        this.fileSystem.writeFileSync(packageJsonPath, content);
+        internal_logger_1.__logger.debug('Created/updated package.json');
+    }
+    /**
+     * Installs dependencies using npm
+     * @param {string} handlerPath - Path to the handler directory
+     */
+    async installDependencies(handlerPath) {
+        try {
+            (0, child_process_1.execSync)('npm install --ignore-scripts --no-audit --no-fund --loglevel=error', {
+                cwd: handlerPath,
+                stdio: 'pipe',
+                timeout: 60000 // 60 second timeout
+            });
+            internal_logger_1.__logger.debug('npm install completed successfully');
+        }
+        catch (error) {
+            const err = error;
+            throw new Error(`npm install failed: ${err.message}`);
+        }
+    }
+    /**
+     * Tries to load a CommonJS alternative for an ES module. This is a fallback for when the common JS is not the default export.
+     * @param moduleName - Name of the module to require
+     * @param resolvedModulePath - Path to the resolved module
+     * @returns
+     */
+    tryLoadCommonJSAlternative(moduleName, resolvedModulePath) {
+        const module = require(resolvedModulePath);
+        if (module && typeof module === 'object' && module.__esModule && typeof module !== 'function') {
+            internal_logger_1.__logger.debug(`ES module detected for ${moduleName} (loaded but has named exports), looking for CommonJS alternative`);
+            const packageJsonPath = path_1.default.join(resolvedModulePath, 'package.json');
+            if (this.fileSystem.existsSync(packageJsonPath)) {
+                const packageJson = JSON.parse(this.fileSystem.readFileSync(packageJsonPath, 'utf8'));
+                // Try to find CommonJS export from package.json exports
+                if (packageJson.exports && packageJson.exports['.']) {
+                    const exports = packageJson.exports['.'];
+                    // Try direct require field
+                    if (exports.require) {
+                        const cjsPath = path_1.default.resolve(resolvedModulePath, exports.require);
+                        internal_logger_1.__logger.debug(`Trying CommonJS path: ${exports.require}`);
+                        return require(cjsPath);
+                    }
+                    // Try nested default.require (like axios)
+                    if (exports.default && exports.default.require) {
+                        const cjsPath = path_1.default.resolve(resolvedModulePath, exports.default.require);
+                        internal_logger_1.__logger.debug(`Trying default CommonJS path: ${exports.default.require}`);
+                        return require(cjsPath);
+                    }
+                }
+                // Try to find CommonJS entry point from main field
+                if (packageJson.main) {
+                    const mainPath = path_1.default.resolve(resolvedModulePath, packageJson.main);
+                    internal_logger_1.__logger.debug(`Trying main field: ${packageJson.main}`);
+                    return require(mainPath);
+                }
+            }
+            // If we can't find a CommonJS alternative, return the ES module as-is
+            internal_logger_1.__logger.error(`No CommonJS alternative found for ${moduleName}, using ES module as-is`);
+            return module;
+        }
+        return module;
+    }
+    /**
+     * Gets the relative path require.
+     * @param moduleName - Name of the module to require
+     * @param handlerPath - Path to the handler directory
+     * @returns
+     */
+    getRelativePathRequire(moduleName, handlerPath) {
+        const normalizedPath = path_1.default.normalize(moduleName);
+        // Check for any path traversal attempts after normalization
+        if (normalizedPath.includes('..')) {
+            throw new Error('Path traversal not allowed in relative imports');
+        }
+        // Resolve the path relative to handlerPath
+        const resolvedPath = path_1.default.resolve(handlerPath, normalizedPath);
+        // Validate that the resolved path is within the handlerPath directory
+        if (!resolvedPath.startsWith(handlerPath)) {
+            throw new Error('Relative import path resolves outside of handler directory');
+        }
+        // Check if the file exists and determine the correct path to require
+        let finalPath = resolvedPath;
+        if (!this.fileSystem.existsSync(resolvedPath)) {
+            const jsPath = resolvedPath + ".js";
+            if (this.fileSystem.existsSync(jsPath)) {
+                finalPath = jsPath; // Use the .js path that actually exists
+            }
+            else {
+                throw new Error(`File or module not found: ${moduleName}`);
+            }
+        }
+        return require(finalPath);
+    }
+    /**
+     * Gets the generic dependency require. Unless there are special cases like ES modules, this should work for all dependencies.
+     * @param moduleName - Name of the module to require
+     * @param allowedModules - List of allowed modules
+     * @param nodeModulesPath - Path to the node_modules directory
+     * @returns
+     */
+    getGenericDependencyRequire(moduleName, allowedModules, nodeModulesPath) {
+        const baseModuleName = moduleName.split('/')[0];
+        // Check if the base module is allowed
+        const allowedModule = allowedModules.find(module => module.name === baseModuleName);
+        if (!allowedModule) {
+            throw new Error(`Module "${baseModuleName}" is not allowed in this environment`);
+        }
+        // Check if the full path exists in project's node_modules
+        const fullModulePath = path_1.default.join(nodeModulesPath, moduleName);
+        if (!this.fileSystem.existsSync(fullModulePath)) {
+            throw new Error(`Module path "${moduleName}" is not installed. Please ensure dependencies are installed.`);
+        }
+        internal_logger_1.__logger.debug(`Loading CommonJS path: ${moduleName}`);
+        return require(path_1.default.resolve(fullModulePath));
+    }
+    /**
+     * Validates and gets the resolved path to the module.
+     * @param allowedModules - List of allowed modules
+     * @param nodeModulesPath - Path to the node_modules directory
+     * @param moduleName - Name of the module to validate
+     * @returns Path to the module
+     */
+    validateAndGetModulePath(allowedModules, nodeModulesPath, moduleName) {
+        // Check if module is installed in project's node_modules
+        const modulePath = path_1.default.join(nodeModulesPath, moduleName);
+        if (!this.fileSystem.existsSync(modulePath)) {
+            throw new Error(`Module "${moduleName}" is not installed. Please ensure dependencies are installed.`);
+        }
+        // Check if module is allowed
+        const allowedModule = allowedModules.find(module => module.name === moduleName);
+        if (!allowedModule) {
+            throw new Error(`Module "${moduleName}" is not allowed in this environment`);
+        }
+        if (allowedModule.version) {
+            try {
+                const packageJsonPath = path_1.default.join(modulePath, 'package.json');
+                const packageJson = JSON.parse(this.fileSystem.readFileSync(packageJsonPath, 'utf8'));
+                const installedVersion = packageJson.version;
+                if (!semver_1.default.satisfies(installedVersion, allowedModule.version)) {
+                    throw new Error(`Module "${moduleName}" version ${installedVersion} does not satisfy allowed version constraint ${allowedModule.version}`);
+                }
+                internal_logger_1.__logger.debug(`Module "${moduleName}" version ${installedVersion} satisfies constraint ${allowedModule.version}`);
+            }
+            catch (error) {
+                const err = error;
+                internal_logger_1.__logger.warn(`Warning: Could not verify version for module "${moduleName}":`, err.message);
+            }
+        }
+        else {
+            throw new Error(`Configuration error: Allowed module "${moduleName}" does not have a version constraint`);
+        }
+        // Fallback to the module path, might or might not work for some dependencies.
+        return path_1.default.resolve(modulePath);
+    }
+}
+exports.DependencyManager = DependencyManager;

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Error thrown when required installation parameters are missing.
+ * Carries the list of missing parameter names for API responses.
+ */
+export declare class MissingRequiredParamsError extends Error {
+    readonly missing: string[];
+    constructor(missing: string[]);
+}

package/dist/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingRequiredParamsError = void 0;
+/**
+ * Error thrown when required installation parameters are missing.
+ * Carries the list of missing parameter names for API responses.
+ */
+class MissingRequiredParamsError extends Error {
+    constructor(missing) {
+        const params = missing.join(', ');
+        super(`Missing required parameter${missing.length > 1 ? 's' : ''}: ${params}`);
+        this.name = 'MissingRequiredParamsError';
+        this.missing = missing;
+        Object.setPrototypeOf(this, MissingRequiredParamsError.prototype);
+    }
+}
+exports.MissingRequiredParamsError = MissingRequiredParamsError;

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from './config/environment';
+export * from './errors';
+export * from './config/path-resolver';
+export * from './dependency/dependency-manager';
+export * from './libs/archive-service';
+export * from './libs/file-management-service';
+export * from './libs/iparams-service';
+export * from './libs/template-service';
+export * from './logger/cb-logger';
+export * from './logger/internal-logger';
+export * from './node/file-system';
+export * from './node/process';
+export * from './sandbox/sandbox-context';
+export * from './sandbox/sandbox-wrapper';
+export * from './types/common';
+export * from './validator/manifest-validator';
+export * from './validator/package-validator';
+export * from './validator/iparams-inputs-validator';
+export * from './validator/iparam-defns-validator';

package/dist/index.js

@@ -0,0 +1,36 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Export all shared interfaces and types
+__exportStar(require("./config/environment"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./config/path-resolver"), exports);
+__exportStar(require("./dependency/dependency-manager"), exports);
+__exportStar(require("./libs/archive-service"), exports);
+__exportStar(require("./libs/file-management-service"), exports);
+__exportStar(require("./libs/iparams-service"), exports);
+__exportStar(require("./libs/template-service"), exports);
+__exportStar(require("./logger/cb-logger"), exports);
+__exportStar(require("./logger/internal-logger"), exports);
+__exportStar(require("./node/file-system"), exports);
+__exportStar(require("./node/process"), exports);
+__exportStar(require("./sandbox/sandbox-context"), exports);
+__exportStar(require("./sandbox/sandbox-wrapper"), exports);
+__exportStar(require("./types/common"), exports);
+__exportStar(require("./validator/manifest-validator"), exports);
+__exportStar(require("./validator/package-validator"), exports);
+__exportStar(require("./validator/iparams-inputs-validator"), exports);
+__exportStar(require("./validator/iparam-defns-validator"), exports);

package/dist/libs/archive-service.d.ts

@@ -0,0 +1,21 @@
+import { CBFileSystem } from "../node/file-system";
+/**
+ * Archive service for managing zip file creation and extraction
+ */
+export declare class ArchiveService {
+    private fileSystem;
+    constructor(fileSystem: CBFileSystem);
+    /**
+     * Creates the zip package
+     * @param {string[]} files - Array of files to package
+     * @param {string} appDir - The application directory
+     * @param {string} outputPath - The output path for the package
+     */
+    createZipPackage(files: string[], appDir: string, outputPath: string): Promise<void>;
+    /**
+     * Extract zip file to specified directory using yauzl
+     * @param {string} zipFilePath - Path to the zip file
+     * @param {string} extractDir - Directory to extract contents to
+     */
+    extractZipFile(zipFilePath: string, extractDir: string): Promise<void>;
+}