test-bdk-cli 1.0.5 → 1.0.7

package/dist/commands/run.js

@@ -38,6 +38,7 @@ const http = __importStar(require("http"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const localstore_1 = require("../lib/localstore");
 function registerRun(program) {
     program
         .command('run [source]')
@@ -56,8 +57,71 @@ function registerRun(program) {
             console.error(`manifest.json not found in ${sourceDir}`);
             process.exit(1);
         }
-        // Create a simple HTTP server
+        // Initialize LocalStore for local database operations
+        const localStore = new localstore_1.LocalStore(path.join(sourceDir, '.bdk/localstore'));
+        // Handler for database operations
+        const handleDBRequest = (operation, key, value) => {
+            try {
+                switch (operation) {
+                    case 'set':
+                        return localStore.store(key, value);
+                    case 'get':
+                        return localStore.fetch(key);
+                    case 'update':
+                        return localStore.update(key, value);
+                    case 'delete':
+                        return localStore.delete(key);
+                    default:
+                        throw new Error(`Unknown database operation: ${operation}`);
+                }
+            }
+            catch (error) {
+                console.error(`[DB] ERROR (${operation} ${key}): ${error.message}`);
+                throw error;
+            }
+        };
+        // Create HTTP server
         const server = http.createServer((req, res) => {
+            var _a;
+            // Add CORS headers
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            // Handle OPTIONS requests
+            if (req.method === 'OPTIONS') {
+                res.writeHead(200);
+                res.end();
+                return;
+            }
+            // Handle database API requests
+            if (((_a = req.url) === null || _a === void 0 ? void 0 : _a.startsWith('/api/db')) && req.method === 'POST') {
+                let body = '';
+                req.on('data', (chunk) => {
+                    body += chunk.toString();
+                });
+                req.on('error', (error) => {
+                    console.error(`[DB] Request error:`, error);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: false, error: 'Request error' }));
+                });
+                req.on('end', () => {
+                    try {
+                        if (!body)
+                            throw new Error('Empty request body');
+                        const payload = JSON.parse(body);
+                        const result = handleDBRequest(payload.operation, payload.key, payload.value);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: true, data: result }));
+                    }
+                    catch (error) {
+                        console.error(`[DB] Error:`, error);
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: false, error: error.message }));
+                    }
+                });
+                return;
+            }
+            // Handle static file requests
             let filePath = req.url || '/';
             if (filePath === '/') {
                 filePath = '/assets/iframe.html';
@@ -123,6 +187,7 @@ function registerRun(program) {
             console.log(`✅ Dev server started on http://localhost:${port} (env=${env})`);
             console.log(`📁 Serving from: ${sourceDir}`);
             console.log(`📄 Iframe: http://localhost:${port}/assets/iframe.html`);
+            console.log(`💾 Database: Local storage at ${localStore.getFilePath()}`);
             console.log(`\nPress Ctrl+C to stop the server\n`);
             // Open browser if --open flag is set
             if (opts.open) {

package/dist/lib/localstore.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * BoldDesk LocalStore - Persistent local data storage during development
+ *
+ * Similar to Freshdesk FDK's DataStore (lib/utils/data.js)
+ * Stores key-value data in .bolddesk/localstore JSON file
+ *
+ * Key Format: '1234' or '1234:{jiraId:9878}' (first part is the key)
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * LocalStore class for managing persistent local storage
+ * Mirrors Freshdesk's DataStore functionality
+ */
+class LocalStore {
+    constructor(filePath = '.bdk/localstore') {
+        this.data = {};
+        this.filePath = filePath;
+        this.ensureStore();
+    }
+    /**
+     * Ensure localstore folder and file exist
+     * Creates folder and file if they don't exist
+     * Handles case where folder is deleted mid-operation
+     */
+    ensureStore() {
+        const folder = path.dirname(this.filePath);
+        try {
+            // Create folder if it doesn't exist
+            if (!fs.existsSync(folder)) {
+                fs.mkdirSync(folder, { recursive: true });
+            }
+            // Create file if it doesn't exist
+            if (!fs.existsSync(this.filePath)) {
+                fs.writeFileSync(this.filePath, JSON.stringify({}));
+            }
+        }
+        catch (error) {
+            console.error(`[LocalStore] Error in ensureStore: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Validate key format and constraints
+     * - Max 60 characters
+     * - Cannot be empty
+     * - Alphanumeric, dash, underscore, colon allowed
+     */
+    validateKey(key) {
+        if (!key || typeof key !== 'string') {
+            throw new Error('The key cannot be blank');
+        }
+    }
+    /**
+     * Read localstore file from disk
+     * Returns parsed JSON object
+     * Returns empty object on error
+     */
+    readLocalStore() {
+        try {
+            if (!fs.existsSync(this.filePath)) {
+                return {};
+            }
+            const content = fs.readFileSync(this.filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (e) {
+            console.error(`[LocalStore] Error reading file: ${e.message}`);
+            return {};
+        }
+    }
+    /**
+     * Write localstore file to disk
+     * Pretty-prints JSON for human readability
+     * Recreates folder if it was deleted
+     */
+    writeLocalStore(data) {
+        try {
+            const folder = path.dirname(this.filePath);
+            // Explicitly ensure folder exists before writing
+            if (!fs.existsSync(folder)) {
+                fs.mkdirSync(folder, { recursive: true });
+            }
+            // Write the file
+            fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            console.error(`[LocalStore] Error writing file: ${e.message}`);
+            throw e;
+        }
+    }
+    /**
+     * Store operation - SET key/value
+     * Stores data as-is without modification
+     *
+     * @param key Storage key (e.g., 'ticket-001')
+     * @param data Value to store (JSON object)
+     * @returns { Created: true }
+     */
+    store(key, data) {
+        this.validateKey(key);
+        this.ensureStore();
+        const localStoreData = this.readLocalStore();
+        localStoreData[key] = data;
+        this.writeLocalStore(localStoreData);
+        return { Created: true };
+    }
+    /**
+     * Fetch operation - GET key/value
+     * Retrieves stored data for a key
+     *
+     * @param key Storage key to retrieve
+     * @returns Stored data or undefined if not found
+     */
+    fetch(key) {
+        const localStoreData = this.readLocalStore();
+        return localStoreData[key];
+    }
+    /**
+     * Update operation - PATCH key with new values
+     * Merges attributes with existing data
+     *
+     * @param key Storage key to update
+     * @param attributes Object with fields to merge
+     * @returns { Updated: true }
+     */
+    update(key, attributes) {
+        this.validateKey(key);
+        this.ensureStore();
+        const localStoreData = this.readLocalStore();
+        const existingRecord = localStoreData[key];
+        if (!existingRecord) {
+            throw new Error(`Record not found for key: ${key}`);
+        }
+        localStoreData[key] = { ...existingRecord, ...attributes };
+        this.writeLocalStore(localStoreData);
+        return { Updated: true };
+    }
+    /**
+     * Delete operation - DELETE key
+     * Similar to Freshdesk DataStore.delete()
+     *
+     * @param key Storage key to delete
+     * @returns { Deleted: true }
+     */
+    delete(key) {
+        this.ensureStore();
+        const localStoreData = this.readLocalStore();
+        delete localStoreData[key];
+        this.writeLocalStore(localStoreData);
+        return { Deleted: true };
+    }
+    /**
+     * Get the file path to localstore
+     */
+    getFilePath() {
+        return this.filePath;
+    }
+    /**
+     * Get all stored data (for debugging)
+     */
+    getAll() {
+        return this.readLocalStore();
+    }
+    /**
+     * Clear all data from localstore
+     */
+    clear() {
+        this.writeLocalStore({});
+    }
+}
+exports.LocalStore = LocalStore;

package/dist/lib/package.js

@@ -129,6 +129,19 @@ async function validatePkg(appPath) {
                     errors.push(`settings.fields[${fieldLabel}]: 'type' is required for each field object.`);
                 }
             });
+            // ── Rule: settings.fields key uniqueness ──
+            const seenKeys = new Map();
+            settings.fields.forEach((field, index) => {
+                if (field && typeof field.key === 'string' && field.key.trim() !== '') {
+                    const key = field.key.trim();
+                    if (seenKeys.has(key)) {
+                        errors.push(`settings.fields: duplicate key "${key}" found at index ${index} (first used at index ${seenKeys.get(key)}). Each field key must be unique.`);
+                    }
+                    else {
+                        seenKeys.set(key, index);
+                    }
+                }
+            });
         }
         // ── Rule: enablePermission / enableReadPermission / enableWritePermission ──
         // If enablePermission is true  → at least one of enableReadPermission or enableWritePermission must be true.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-bdk-cli",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "test CLI",
   "author": "@BoldDesk",
   "bin": {
@@ -61,7 +61,10 @@
       "/src/"
     ],
     "transform": {
-      "^.+\\.tsx?$": ["ts-jest", {}]
+      "^.+\\.tsx?$": [
+        "ts-jest",
+        {}
+      ]
     }
   }
 }