@chargebee/chargebee-apps-libs 0.0.1

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.1",
+  "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.1",
+    "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

package/templates/serverless-node-starter-app/README.md

@@ -0,0 +1,290 @@
+# Serverless Node.js App Template
+
+This is a serverless Node.js application template that demonstrates how to build and test serverless functions with event-driven architecture. This template provides a foundation for creating scalable serverless applications with built-in testing capabilities.
+
+## Features
+
+- **Event-Driven Architecture**: Configure multiple event handlers in `manifest.json`
+- **Handler Functions**: Implement your business logic in `handler.js`
+- **Test Data**: Sample event data for local development and testing
+- **Local Testing UI**: Interactive web interface to test your handlers
+- **Logging**: Built-in logging system for debugging and monitoring
+
+## How It Works
+
+1. **Event Configuration**: The `manifest.json` file maps event types to their corresponding handler functions
+2. **Handler Implementation**: Each event type has its handler function in `handler.js`
+3. **Test Data**: Sample JSON files in `test_data/` folder match your event names (e.g., `onCustomerCreate.json`)
+4. **Local Testing**: Use the CLI tool to start a local testing server with a web UI
+5. **Interactive Testing**: Select event types from the dropdown and click "Test Data" to execute handlers
+6. **Real-time Logs**: View execution logs directly in your terminal
+
+## Quick Start
+
+1. **Create your app**: `chargebee-apps create <app_directory>`
+2. **Navigate to app**: `cd <app_directory>`
+3. **Configure API keys** (optional): Edit `.env` file and replace placeholder values with your Chargebee API keys
+4. **Start local server**: `chargebee-apps run <app_directory>`
+5. **Open browser**: Visit `http://localhost:15000`
+6. **Test handlers**: Select an event type and click "Test Data"
+7. **View logs**: Check your terminal for execution output
+8. **Package your app**: `chargebee-apps package <app_directory>`
+
+## Project Structure
+
+```
+├── handler/handler.js  # Main serverless function handler
+├── test_data/          # Test data directory
+├── types/types.d.ts    # Recognised types that can be used as JSDoc inside handler function
+├── .env                # Environment variables (API keys)
+├── jsconfig.json       # JS config for dev
+├── manifest.json       # Project configuration
+└── README.md           # Read me file
+```
+
+## Configuration
+
+### Manifest.json
+
+The `manifest.json` file is the core configuration file for your serverless application. It defines:
+
+1. **Event Handlers**: Maps Chargebee webhook events to your handler functions
+2. **Application Metadata**: Basic information about your application
+3. **Dependencies**: Custom npm packages your application requires
+
+#### Basic Structure
+
+```json
+{
+  "name": "my-app",
+  "version": "1.0.0",
+  "description": "A custom app",
+  "events": {
+    "customer_created": {
+      "handler": "customerCreateHandler"
+    },
+    "subscription_created": {
+      "handler": "subscriptionCreatedHandler"
+    },
+    "invoice_generated": {
+      "handler": "invoiceGeneratedHandler"
+    }
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "axios": "^1.6.0"
+  }
+}
+```
+
+#### Event Handler Configuration
+
+Each event in the `events` object maps a Chargebee webhook event to a handler function:
+
+```json
+{
+  "events": {
+    "customer_created": {
+      "handler": "customerCreateHandler"
+    }
+  }
+}
+```
+
+The handler function must be exported from `handler/handler.js`. Each handler receives a single `payload` argument; use `payload.event` to access the event data:
+
+```javascript
+// handler/handler.js
+module.exports = {
+  customerCreateHandler: function(/** @type {import('../types/types.d.ts').HandlerPayload} */payload) {
+    // Your business logic here
+    console.log('Customer created:', payload.event.content.customer.email);
+    
+    // Example: Send welcome email
+    const customerEmail = payload.event.content.customer.email;
+    const customerName = payload.event.content.customer.first_name;
+    
+    // You can use custom dependencies here
+    const moment = require('moment');
+    const welcomeMessage = `Welcome ${customerName}! You joined on ${moment().format('MMMM Do YYYY')}`;
+    
+    console.log(welcomeMessage);
+  }
+};
+```
+
+#### Custom Dependencies
+
+You can add custom npm packages to your application by including them in the `dependencies` section:
+
+```json
+{
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "axios": "^1.6.0",
+    "uuid": "^9.0.0"
+  }
+}
+```
+
+Then use them in your handler functions:
+
+```javascript
+// handler/handler.js
+const _ = require('lodash');
+const axios = require('axios');
+const moment = require('moment');
+const { v4: uuidv4 } = require('uuid');
+
+module.exports = {
+  customerCreateHandler: function(/** @type {import('../types/types.d.ts').HandlerPayload} */payload) {
+    // Use lodash for data manipulation
+    const customerData = _.pick(payload.event.content.customer, ['email', 'first_name', 'last_name']);
+    
+    // Generate unique ID
+    const customerId = uuidv4();
+    
+    // Make HTTP requests
+    axios.post('https://api.example.com/customers', {
+      id: customerId,
+      ...customerData,
+      created_at: moment().toISOString()
+    }).then(response => {
+      console.log('Customer synced to external system:', response.data);
+    }).catch(error => {
+      console.error('Failed to sync customer:', error.message);
+    });
+  },
+  
+  subscriptionCreatedHandler: function(/** @type {import('../types/types.d.ts').HandlerPayload} */payload) {
+    // Use moment for date formatting
+    const subscriptionDate = moment(payload.event.content.subscription.created_at * 1000);
+    const formattedDate = subscriptionDate.format('MMMM Do YYYY, h:mm:ss a');
+    
+    console.log(`New subscription created on ${formattedDate}`);
+    
+    // Use lodash for data validation
+    const requiredFields = ['id', 'customer_id', 'plan_id'];
+    const missingFields = _.difference(requiredFields, Object.keys(payload.event.content.subscription));
+    
+    if (missingFields.length > 0) {
+      console.warn('Missing subscription fields:', missingFields);
+    }
+  }
+};
+```
+
+#### Supported Event Types
+Chargebee Apps supports all the event types that are provided in the Chargebee's [documentation](https://apidocs.chargebee.com/docs/api/events#event_types).
+
+### Environment Variables
+
+The CLI exposes **only these three** variables via `process.env`; no other environment variables are available to your handlers:
+
+| Variable | Description |
+|----------|-------------|
+| `MKPLC_CB_READ_ONLY_API` | Chargebee read-only API key |
+| `MKPLC_CB_READ_WRITE_API` | Chargebee read-write API key |
+| `MKPLC_SITE_DOMAIN` | Chargebee site domain |
+
+- **Production:** The system provides these values at runtime. You do not configure them in production.
+- **Local development:** You must provide these values in the `.env` file so your handlers can run locally.
+
+#### Setting up .env for local development
+
+1. **Open the `.env` file** in your project root
+2. **Replace the placeholder values** with your actual Chargebee API keys:
+
+```env
+# Replace these with your actual Chargebee API keys
+MKPLC_CB_READ_ONLY_API=your_read_only_api_key_here
+MKPLC_CB_READ_WRITE_API=your_read_write_api_key_here
+MKPLC_SITE_DOMAIN=yousite123
+```
+
+#### Using these variables in your handlers
+
+Access them through the `process.env` object in your handler functions:
+
+```javascript
+// handler/handler.js
+module.exports = {
+  customerCreateHandler: async function(/** @type {import('../types/types.d.ts').HandlerPayload} */payload) {
+    // Access your API keys
+    const readOnlyApiKey = process.env.MKPLC_CB_READ_ONLY_API;
+    const readWriteApiKey = process.env.MKPLC_CB_READ_WRITE_API;
+
+    if (!readOnlyApiKey || !readWriteApiKey) {
+      console.error('API keys not configured. Please check your .env file.');
+      return;
+    }
+
+    // Use the API keys for Chargebee API calls
+    console.log('Using API keys for Chargebee integration');
+
+    const Chargebee = require('chargebee');
+    const chargebee = new Chargebee({
+      site: process.env.MKPLC_SITE_DOMAIN,
+      apiKey: process.env.MKPLC_CB_READ_ONLY_API
+    });
+
+    const result = await chargebee.customer.retrieve(payload.event.content.customer.id);
+    console.log(result.customer);
+  }
+};
+```
+
+#### Security Notes
+
+- **Never commit real API keys** to version control
+- The `.env` file in this template contains placeholder values
+- Replace the placeholder values with your actual API keys before testing
+- Keep your API keys secure and don't share them publicly
+
+## Local Testing
+
+Use the CLI tool to test your functions locally with an interactive web interface:
+
+```bash
+# Start the testing server on a specific port
+chargebee-apps run <app_directory> --port <port>
+# Example:
+chargebee-apps run ./sample_app_v0 --port 16000
+
+# Open http://localhost:16000 in your browser
+# Select event types from the dropdown and click "Test Data" to execute handlers
+# View real-time logs in your terminal
+```
+
+## Testing
+
+Test data files are located in the `test_data/` directory. Each file is named after its corresponding event type (e.g., `customer_created.json`, `customer_updated.json`). These JSON files contain sample event data that you can use to test your handlers during local development.
+
+The test data structure should match the expected input format for your handler functions. You can modify these files to test different scenarios or add new test data files for additional event types.
+
+## Packaging
+
+The package command bundles your serverless application into a zip file for deployment.
+
+### Basic Usage
+
+```bash
+# Package with default name (app directory name)
+chargebee-apps package <app_directory>
+
+# Package with custom name
+chargebee-apps package <app_directory> --name my-app-v1.0.0
+```
+
+### Examples
+
+```bash
+# Package current directory
+chargebee-apps package .
+
+# Package specific directory
+chargebee-apps package ./my-app
+
+# Package with versioned name
+chargebee-apps package ./my-app --name my-app-v1.0.0
+```

package/templates/serverless-node-starter-app/handler/handler.js

@@ -0,0 +1,34 @@
+/**
+ * Serverless function handlers
+ * Each handler receives a single payload argument with payload.event
+ */
+module.exports = {
+
+  /**
+   * Handles customer_created events
+   * @param {import('../types/types.d.ts').HandlerPayload} payload 
+   */
+  customerCreateHandler: function(/** @type {import('../types/types.d.ts').HandlerPayload} */payload) {
+    console.log('Processing customer_created event');
+    console.log('Customer created for email: ', payload.event.content.customer.email);
+  },
+
+  /**
+   * Handles subscription_created events
+   * @param {import('../types/types.d.ts').HandlerPayload} payload
+   */
+  subscriptionCreatedHandler: function(/** @type {import('../types/types.d.ts').HandlerPayload} */payload) {
+    console.log('Processing subscription_created event');
+    console.log('Subscription created for email: ', payload.event.content.customer.email);
+  },
+
+  /**
+   * Handles invoice_generated events
+   * @param {import('../types/types.d.ts').HandlerPayload} payload
+   */
+  invoiceGeneratedHandler: function(/** @type {import('../types/types.d.ts').HandlerPayload} */payload) {
+    console.log('Processing invoice_generated event');
+    console.log('Invoice status: ', payload.event.content.invoice.status);
+  }
+  
+};

package/templates/serverless-node-starter-app/jsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "checkJs": true,
+    "resolveJsonModule": true,
+    "strict": false,
+    "noImplicitAny": false,
+    "noImplicitReturns": true,
+    "noImplicitThis": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": false,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./*"],
+      "@handler/*": ["./handler/*"],
+      "@types/*": ["./types/*"],
+      "@test_data/*": ["./test_data/*"]
+    },
+    "typeRoots": ["./types", "./node_modules/@types"]
+  },
+  "include": [
+    "**/*.js",
+    "**/*.d.ts",
+    "**/*.json"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "*.min.js"
+  ]
+} 

package/templates/serverless-node-starter-app/manifest.json

@@ -0,0 +1,15 @@
+{
+  "name": "<your-app-name>",
+  "description": "<your-app-description>",
+  "events": {
+    "customer_created": {
+      "handler": "customerCreateHandler"
+    },
+    "subscription_created": {
+      "handler": "subscriptionCreatedHandler"
+    },
+    "invoice_generated": {
+      "handler": "invoiceGeneratedHandler"
+    }
+  }
+}