@optimizely/ocp-local-env 1.0.0-beta.4

package/dist/src/server/api/v1.js

@@ -0,0 +1,711 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createV1Routes = void 0;
+const express_1 = __importDefault(require("express"));
+/**
+ * Create v1 API routes matching the REST API documentation
+ */
+function createV1Routes(app, watcher, configStore, lifecycleExecutor, settingsStore) {
+    const router = express_1.default.Router();
+    // Import individual v1 route modules
+    router.use('/apps', createAppsRoutes(app, watcher, configStore));
+    router.use("/accounts", createAccountsRoutes(app, watcher, configStore, lifecycleExecutor, settingsStore));
+    router.use('/installs', createInstallsRoutes(app, watcher, configStore, settingsStore, lifecycleExecutor));
+    // Data syncs endpoint
+    router.get('/data-syncs', (req, res) => {
+        // Accept query parameters but don't use them for now
+        const { tracker_id, sort_field, sort_direction, offset, limit } = req.query;
+        // Return empty array as requested
+        res.json({
+            dataSyncItems: []
+        });
+    });
+    return router;
+}
+exports.createV1Routes = createV1Routes;
+/**
+ * Create apps-specific routes for /v1/apps
+ */
+function createAppsRoutes(app, watcher, configStore) {
+    const router = express_1.default.Router();
+    /**
+     * GET /v1/apps
+     * Lists running app versions
+     */
+    router.get('/', (req, res) => {
+        const { tracker_id, include_manifest_json, categories, installed } = req.query;
+        // Get server URL from request
+        const protocol = req.secure ? 'https' : 'http';
+        const host = req.get('host') || 'localhost:3000';
+        const serverUrl = `${protocol}://${host}`;
+        // Build app metadata
+        const metadata = {
+            categories: app.manifest.meta.categories || [],
+            display_name: app.manifest.meta.display_name,
+            summary: app.manifest.meta.summary || '',
+            overview_url: `${serverUrl}/assets/overview.md`,
+            support_url: app.manifest.meta.support_url || '',
+            logo_url: `${serverUrl}/assets/logo.svg`,
+            icon_url: `${serverUrl}/assets/icon.svg`,
+            vendor: app.manifest.meta.vendor || '',
+            contact_email: app.manifest.meta.contact_email || '',
+            settings_url: `${serverUrl}/assets/settings.yml`,
+            content_settings_url: '',
+            content_template_url: '' // Not available in local app manifest
+        };
+        const now = new Date().toISOString();
+        // Check installation status from config store
+        const isInstalled = configStore.isInstalled();
+        // Build the app result
+        const appResult = {
+            id: {
+                app_id: app.manifest.meta.app_id,
+                version: app.manifest.meta.version
+            },
+            metadata: metadata,
+            installed: isInstalled,
+            installed_at: isInstalled ? now : undefined,
+            created_at: now,
+            updated_at: now,
+            installed_version: isInstalled ? app.manifest.meta.version : undefined,
+            manifest_json: include_manifest_json === 'true' ? JSON.stringify(app.manifest) : '',
+            install_id: isInstalled ? 1 : undefined // Static install ID for local development
+        };
+        // Apply filters if provided
+        let results = [appResult];
+        // Filter by categories if specified
+        if (categories) {
+            const categoryFilters = Array.isArray(categories) ? categories : [categories];
+            const appCategories = app.manifest.meta.categories || [];
+            const hasMatchingCategory = categoryFilters.some(cat => appCategories.includes(cat));
+            if (!hasMatchingCategory) {
+                results = [];
+            }
+        }
+        // Filter by installed status if specified
+        if (installed !== undefined) {
+            const isInstalledFilter = installed === 'true';
+            if (isInstalledFilter !== isInstalled) {
+                results = [];
+            }
+        }
+        // Return the results
+        res.json({
+            results: results
+        });
+    });
+    /**
+     * GET /v1/apps/{app_id}
+     * Fetches details of a specific app
+     */
+    router.get('/:app_id', (req, res) => {
+        const { app_id } = req.params;
+        const { tracker_id } = req.query;
+        // Get server URL from request
+        const protocol = req.secure ? 'https' : 'http';
+        const host = req.get('host') || 'localhost:3000';
+        const serverUrl = `${protocol}://${host}`;
+        // Check if the requested app_id matches our local app
+        if (app_id !== app.manifest.meta.app_id) {
+            return res.status(404).json({
+                error: {
+                    message: `App with id '${app_id}' not found`,
+                    code: 'APP_NOT_FOUND'
+                }
+            });
+        }
+        // Build app version metadata from manifest
+        const metadata = {
+            categories: app.manifest.meta.categories || [],
+            display_name: app.manifest.meta.display_name,
+            summary: app.manifest.meta.summary || '',
+            overview_url: `${serverUrl}/assets/overview.md`,
+            support_url: app.manifest.meta.support_url || '',
+            logo_url: `${serverUrl}/assets/logo.svg`,
+            icon_url: `${serverUrl}/assets/icon.svg`,
+            vendor: app.manifest.meta.vendor || '',
+            contact_email: app.manifest.meta.contact_email || '',
+            settings_url: `${serverUrl}/assets/settings.yml`,
+            content_settings_url: '',
+            content_template_url: '' // Not available in local app manifest
+        };
+        const now = new Date().toISOString();
+        // Check installation status from config store
+        const isInstalled = configStore.isInstalled();
+        // Return app details according to the API specification
+        const response = {
+            app: {
+                id: {
+                    app_id: app.manifest.meta.app_id,
+                    version: app.manifest.meta.version
+                },
+                metadata: metadata,
+                installed: isInstalled,
+                installed_at: isInstalled ? now : undefined,
+                installed_version: isInstalled ? app.manifest.meta.version : undefined,
+                created_at: now,
+                updated_at: now
+            }
+        };
+        res.json(response);
+    });
+    /**
+     * GET /v1/apps/{app_id}/versions/{version}
+     * Fetches details of a specific app version
+     */
+    router.get('/:app_id/versions/:version', (req, res) => {
+        const { app_id, version } = req.params;
+        // Get server URL from request
+        const protocol = req.secure ? 'https' : 'http';
+        const host = req.get('host') || 'localhost:3000';
+        const serverUrl = `${protocol}://${host}`;
+        // Check if the requested app_id and version match our local app
+        if (app_id !== app.manifest.meta.app_id || version !== app.manifest.meta.version) {
+            return res.status(404).json({
+                error: {
+                    message: `App version '${app_id}@${version}' not found`,
+                    code: 'APP_VERSION_NOT_FOUND'
+                }
+            });
+        }
+        // Build app version metadata from manifest
+        const metadata = {
+            categories: app.manifest.meta.categories || [],
+            display_name: app.manifest.meta.display_name,
+            summary: app.manifest.meta.summary || '',
+            overview_url: `${serverUrl}/assets/overview.md`,
+            support_url: app.manifest.meta.support_url || '',
+            logo_url: `${serverUrl}/assets/logo.svg`,
+            icon_url: `${serverUrl}/assets/icon.svg`,
+            vendor: app.manifest.meta.vendor || '',
+            contact_email: app.manifest.meta.contact_email || '',
+            settings_url: `${serverUrl}/assets/settings.yml`,
+            content_settings_url: '',
+            content_template_url: '' // Not available in local app manifest
+        };
+        const now = new Date().toISOString();
+        // Build channel information if available
+        let channelInfo = null;
+        if (app.manifest.channel) {
+            channelInfo = {
+                type: app.manifest.channel.type,
+                options: app.manifest.channel.options || {
+                    prepare: false,
+                    template_preview: false
+                },
+                targeting: app.manifest.channel.targeting === 'dynamic' ?
+                    { dynamic: true, targets: [] } :
+                    { dynamic: false, targets: [] },
+                delivery: {
+                    batch_size: app.manifest.channel.delivery?.batch_size || 100,
+                    concurrent_batches: app.manifest.channel.delivery?.concurrent_batches || 5,
+                    rate_limits: app.manifest.channel.delivery?.rate_limits?.map(limit => ({
+                        count: limit.count,
+                        period: limit.period,
+                        unit: limit.unit === 'minute' ? 2 : limit.unit === 'hour' ? 3 : limit.unit === 'day' ? 4 : 1,
+                        grouping: limit.grouping === 'app' ? 1 : 2 // Convert to enum
+                    })) || []
+                },
+                metrics: {
+                    delivery: app.manifest.channel.metrics?.delivery || [],
+                    engagement: app.manifest.channel.metrics?.engagement || [],
+                    attributable: app.manifest.channel.metrics?.attributable || [],
+                    disengagement: app.manifest.channel.metrics?.disengagement || [],
+                    reachability: app.manifest.channel.metrics?.reachability || []
+                }
+            };
+        }
+        // Return app version details according to the API specification
+        const response = {
+            app_version: {
+                id: {
+                    app_id: app.manifest.meta.app_id,
+                    version: app.manifest.meta.version
+                },
+                metadata: metadata,
+                created_at: now,
+                updated_at: now,
+                ...(channelInfo && { channel: channelInfo })
+            }
+        };
+        res.json(response);
+    });
+    return router;
+}
+/**
+ * Create accounts-specific routes for /v1/accounts
+ */
+function createAccountsRoutes(app, watcher, configStore, lifecycleExecutor, settingsStore) {
+    const router = express_1.default.Router();
+    /**
+     * GET /v1/accounts/{tracker_id}/installs
+     * Lists apps installed in an account
+     */
+    router.get("/:tracker_id/installs", (req, res) => {
+        const { tracker_id } = req.params;
+        const { categories, includes_features } = req.query;
+        const now = new Date().toISOString();
+        // Check installation status from config store
+        const isInstalled = configStore.isInstalled();
+        // If not installed, return empty array
+        if (!isInstalled) {
+            return res.json({
+                installations: [],
+            });
+        }
+        // Build the installation object for the local app
+        const installation = {
+            id: 1,
+            app_id: app.manifest.meta.app_id,
+            version: app.manifest.meta.version,
+            account_id: 123,
+            tracker_id: tracker_id,
+            app_instance_id: `${app.manifest.meta.app_id}-local-instance`,
+            created_at: now,
+            updated_at: now,
+        };
+        // Apply filters if provided
+        let installations = [installation];
+        // Filter by categories if specified
+        if (categories) {
+            const categoryFilters = Array.isArray(categories)
+                ? categories
+                : [categories];
+            const appCategories = app.manifest.meta.categories || [];
+            const hasMatchingCategory = categoryFilters.some((cat) => appCategories.includes(cat));
+            if (!hasMatchingCategory) {
+                installations = [];
+            }
+        }
+        // Filter by features if specified (1=DESTINATION_APP, 2=SOURCE_APP)
+        if (includes_features) {
+            const featureFilters = Array.isArray(includes_features)
+                ? includes_features
+                : [includes_features];
+            const hasDestinations = app.manifest.destinations &&
+                Object.keys(app.manifest.destinations).length > 0;
+            const hasSources = app.manifest.sources && Object.keys(app.manifest.sources).length > 0;
+            const hasMatchingFeature = featureFilters.some((feature) => {
+                return ((feature === "1" && hasDestinations) ||
+                    (feature === "2" && hasSources));
+            });
+            if (!hasMatchingFeature) {
+                installations = [];
+            }
+        }
+        // Return the installations
+        res.json({
+            installations: installations,
+        });
+    });
+    /**
+     * POST /v1/accounts/{tracker_id}/installs
+     * Installs an AppVersion to an account
+     */
+    router.post("/:tracker_id/installs", async (req, res) => {
+        const { tracker_id } = req.params;
+        let { app_id, version } = req.body;
+        // Validate request body
+        if (!app_id) {
+            return res.status(400).json({
+                error: {
+                    message: "app_id is required",
+                    code: "INVALID_REQUEST",
+                },
+            });
+        }
+        if (!version) {
+            version = app.manifest.meta.version;
+        }
+        // Check if the requested app matches our local app
+        if (app_id !== app.manifest.meta.app_id ||
+            version !== app.manifest.meta.version) {
+            return res.status(404).json({
+                error: {
+                    message: `App version '${app_id}@${version}' not found`,
+                    code: "APP_VERSION_NOT_FOUND",
+                },
+            });
+        }
+        // Check if already installed
+        if (configStore.isInstalled()) {
+            return res.status(409).json({
+                error: {
+                    message: "App is already installed",
+                    code: "ALREADY_INSTALLED",
+                },
+            });
+        }
+        try {
+            // Execute the onInstall lifecycle method
+            const lifecycleResult = await lifecycleExecutor.executeInstall();
+            if (lifecycleResult.success) {
+                // Mark app as installed in config store
+                configStore.setInstalled(true);
+                const now = new Date().toISOString();
+                // Return installation record
+                const installation = {
+                    id: 1,
+                    app_id: app.manifest.meta.app_id,
+                    version: app.manifest.meta.version,
+                    account_id: 123,
+                    tracker_id: tracker_id,
+                    app_instance_id: `${app.manifest.meta.app_id}-local-instance`,
+                    created_at: now,
+                    updated_at: now,
+                };
+                res.json({
+                    app_installation: installation,
+                });
+            }
+            else {
+                // Installation failed - return error with lifecycle logs
+                res.status(500).json({
+                    error: {
+                        message: "Installation failed during lifecycle execution",
+                        code: "LIFECYCLE_EXECUTION_FAILED",
+                        details: {
+                            logs: lifecycleResult.logs,
+                            error: lifecycleResult.error,
+                            executionTime: lifecycleResult.executionTime,
+                        },
+                    },
+                });
+            }
+        }
+        catch (error) {
+            // Unexpected error during installation
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            res.status(500).json({
+                error: {
+                    message: `Installation failed: ${errorMessage}`,
+                    code: "INSTALLATION_ERROR",
+                },
+            });
+        }
+    });
+    /**
+     * DELETE /v1/accounts/{tracker_id}/installs/{app_id}
+     * Uninstalls an AppVersion from an account
+     */
+    router.delete("/:tracker_id/installs/:app_id", async (req, res) => {
+        const { tracker_id, app_id } = req.params;
+        // Check if the requested app matches our local app
+        if (app_id !== app.manifest.meta.app_id) {
+            return res.status(404).json({
+                error: {
+                    message: `App with id '${app_id}' not found`,
+                    code: "APP_NOT_FOUND",
+                },
+            });
+        }
+        // Check if app is installed
+        if (!configStore.isInstalled()) {
+            return res.status(404).json({
+                error: {
+                    message: "App is not installed",
+                    code: "NOT_INSTALLED",
+                },
+            });
+        }
+        try {
+            // Execute the onUninstall lifecycle method
+            const lifecycleResult = await lifecycleExecutor.executeUninstall();
+            if (lifecycleResult.success) {
+                // Mark app as not installed in config store
+                configStore.setInstalled(false);
+                // Clear all settings data
+                settingsStore.clearSettings();
+                // Clear function GUIDs
+                configStore.clearFunctionGuids();
+                // Return 200 OK as specified in the API documentation
+                res.status(200).send({});
+            }
+            else {
+                // Uninstall failed - return error with lifecycle logs
+                res.status(500).json({
+                    error: {
+                        message: "Uninstall failed during lifecycle execution",
+                        code: "LIFECYCLE_EXECUTION_FAILED",
+                        details: {
+                            logs: lifecycleResult.logs,
+                            error: lifecycleResult.error,
+                            executionTime: lifecycleResult.executionTime,
+                        },
+                    },
+                });
+            }
+        }
+        catch (error) {
+            // Unexpected error during uninstall
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            res.status(500).json({
+                error: {
+                    message: `Uninstall failed: ${errorMessage}`,
+                    code: "UNINSTALL_ERROR",
+                },
+            });
+        }
+    });
+    return router;
+}
+/**
+ * Create installs-specific routes for /v1/installs
+ */
+function createInstallsRoutes(app, watcher, configStore, settingsStore, lifecycleExecutor) {
+    const router = express_1.default.Router();
+    /**
+     * GET /v1/installs/{app_install_id}/settings
+     * Gets stored app secrets for a setup form
+     */
+    router.get("/:app_install_id/settings", (req, res) => {
+        const { app_install_id } = req.params;
+        // Validate app_install_id (should be numeric for our implementation)
+        const installId = parseInt(app_install_id, 10);
+        if (isNaN(installId)) {
+            return res.status(400).json({
+                error: {
+                    message: "app_install_id must be a valid number",
+                    code: "INVALID_INSTALL_ID",
+                },
+            });
+        }
+        // Check if app is installed (for local dev, we use install ID 1)
+        if (!configStore.isInstalled()) {
+            return res.status(404).json({
+                error: {
+                    message: "App installation not found",
+                    code: "INSTALLATION_NOT_FOUND",
+                },
+            });
+        }
+        // For local development, we only support install ID 1
+        if (installId !== 1) {
+            return res.status(404).json({
+                error: {
+                    message: `Installation with ID ${installId} not found`,
+                    code: "INSTALLATION_NOT_FOUND",
+                },
+            });
+        }
+        try {
+            // Get sections from settings.yml
+            const sections = settingsStore.getSections();
+            const formData = {};
+            // For each section, get the stored values from local settings store
+            sections.forEach((sectionName) => {
+                const sectionSettings = settingsStore.getSectionSettings(sectionName);
+                formData[sectionName] = sectionSettings;
+            });
+            // Convert to JSON string
+            const formDataJson = JSON.stringify(formData);
+            // Return settings according to API specification
+            res.json({
+                form_data_json: formDataJson,
+                error: null, // No error if successful
+            });
+        }
+        catch (error) {
+            // Return error response
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            res.json({
+                form_data_json: "{}",
+                error: {
+                    message: errorMessage,
+                },
+            });
+        }
+    });
+    /**
+     * POST /v1/installs/{app_install_id}/settings
+     * Submits app settings form and calls onSettingsForm lifecycle method
+     */
+    router.post("/:app_install_id/settings", async (req, res) => {
+        const { app_install_id } = req.params;
+        const { form_page, action, form_data_json } = req.body;
+        // Validate app_install_id (should be numeric for our implementation)
+        const installId = parseInt(app_install_id, 10);
+        if (isNaN(installId)) {
+            return res.status(400).json({
+                error: {
+                    message: "app_install_id must be a valid number",
+                    code: "INVALID_INSTALL_ID",
+                },
+            });
+        }
+        // Check if app is installed (for local dev, we use install ID 1)
+        if (!configStore.isInstalled()) {
+            return res.status(404).json({
+                error: {
+                    message: "App installation not found",
+                    code: "INSTALLATION_NOT_FOUND",
+                },
+            });
+        }
+        // For local development, we only support install ID 1
+        if (installId !== 1) {
+            return res.status(404).json({
+                error: {
+                    message: `Installation with ID ${installId} not found`,
+                    code: "INSTALLATION_NOT_FOUND",
+                },
+            });
+        }
+        // Validate required fields
+        if (!form_page) {
+            return res.status(400).json({
+                error: {
+                    message: "section is required",
+                    code: "INVALID_REQUEST",
+                },
+            });
+        }
+        if (!action) {
+            return res.status(400).json({
+                error: {
+                    message: "action is required",
+                    code: "INVALID_REQUEST",
+                },
+            });
+        }
+        try {
+            // Parse form_data_json if it's a string
+            let formData;
+            if (typeof form_data_json === "string") {
+                try {
+                    formData = JSON.parse(form_data_json);
+                }
+                catch (e) {
+                    formData = {};
+                }
+            }
+            else {
+                formData = form_data_json || {};
+            }
+            // Execute the onSettingsForm lifecycle method first
+            const lifecycleResult = await lifecycleExecutor.executeSettingsForm(form_page, action, formData);
+            if (lifecycleResult.success) {
+                // Get the lifecycle result which should be in the format: { result: LifecycleSettingsResponse, data: FormData }
+                const lifecycleData = lifecycleResult.result;
+                // Extract the response component from the lifecycle result
+                let settingsResponse = {};
+                if (lifecycleData && typeof lifecycleData === "object") {
+                    settingsResponse = lifecycleData.result || {};
+                }
+                // Get the updated form data from settings store (always return fresh data)
+                const sections = settingsStore.getSections();
+                const updatedFormData = {};
+                sections.forEach((sectionName) => {
+                    const sectionSettings = settingsStore.getSectionSettings(sectionName);
+                    updatedFormData[sectionName] = sectionSettings;
+                });
+                // Return response in the format expected by the REST API (matching AnduinServer.submitForm)
+                res.json({
+                    form_data_json: JSON.stringify(updatedFormData),
+                    response_json: JSON.stringify(settingsResponse),
+                });
+            }
+            else {
+                // Lifecycle execution failed
+                res.status(500).json({
+                    error: {
+                        message: "Settings form processing failed during lifecycle execution",
+                        code: "LIFECYCLE_EXECUTION_FAILED",
+                        details: {
+                            logs: lifecycleResult.logs,
+                            error: lifecycleResult.error,
+                            executionTime: lifecycleResult.executionTime,
+                        },
+                    },
+                });
+            }
+        }
+        catch (error) {
+            // Unexpected error during settings form processing
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            res.status(500).json({
+                error: {
+                    message: `Settings form processing failed: ${errorMessage}`,
+                    code: "SETTINGS_FORM_ERROR",
+                },
+            });
+        }
+    });
+    /**
+     * GET /v1/installs/{app_install_id}/canUninstall
+     * Checks if an app installation can be uninstalled
+     */
+    router.get("/:app_install_id/canUninstall", async (req, res) => {
+        const { app_install_id } = req.params;
+        // Validate app_install_id (should be numeric for our implementation)
+        const installId = parseInt(app_install_id, 10);
+        if (isNaN(installId)) {
+            return res.status(400).json({
+                error: {
+                    message: "app_install_id must be a valid number",
+                    code: "INVALID_INSTALL_ID",
+                },
+            });
+        }
+        // Check if app is installed (for local dev, we use install ID 1)
+        if (!configStore.isInstalled()) {
+            return res.status(404).json({
+                error: {
+                    message: "App installation not found",
+                    code: "INSTALLATION_NOT_FOUND",
+                },
+            });
+        }
+        // For local development, we only support install ID 1
+        if (installId !== 1) {
+            return res.status(404).json({
+                error: {
+                    message: `Installation with ID ${installId} not found`,
+                    code: "INSTALLATION_NOT_FOUND",
+                },
+            });
+        }
+        try {
+            // Execute the canUninstall lifecycle method
+            const lifecycleResult = await lifecycleExecutor.executeCanUninstall();
+            if (lifecycleResult.success) {
+                // Parse the result from the lifecycle method
+                const canUninstallResult = lifecycleResult.result;
+                // Return the response in the expected format
+                res.json({
+                    uninstallable: canUninstallResult?.uninstallable || false,
+                    message: canUninstallResult?.message,
+                });
+            }
+            else {
+                // Lifecycle execution failed - return error response
+                res.status(500).json({
+                    error: {
+                        message: "Failed to check uninstall status during lifecycle execution",
+                        code: "LIFECYCLE_EXECUTION_FAILED",
+                        details: {
+                            logs: lifecycleResult.logs,
+                            error: lifecycleResult.error,
+                            executionTime: lifecycleResult.executionTime,
+                        },
+                    },
+                });
+            }
+        }
+        catch (error) {
+            // Unexpected error during canUninstall check - return error response
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            res.status(500).json({
+                error: {
+                    message: `Error checking uninstall status: ${errorMessage}`,
+                    code: "CAN_UNINSTALL_ERROR",
+                },
+            });
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=v1.js.map