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

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

@@ -0,0 +1,718 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createV1Routes = createV1Routes;
+const express_1 = __importDefault(require("express"));
+const functionEndpoints_1 = require("../../utils/functionEndpoints");
+const config_1 = require("../config");
+/**
+ * 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;
+}
+/**
+ * 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') || `${config_1.config.server.host}:${config_1.config.server.port}`;
+        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: '', // Not available in local app manifest
+            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') || `${config_1.config.server.host}:${config_1.config.server.port}`;
+        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: '', // Not available in local app manifest
+            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') || `${config_1.config.server.host}:${config_1.config.server.port}`;
+        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: '', // Not available in local app manifest
+            content_template_url: '' // Not available in local app manifest
+        };
+        const now = new Date().toISOString();
+        // 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
+            }
+        };
+        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, // Static installation ID for local development
+            app_id: app.manifest.meta.app_id,
+            version: app.manifest.meta.version,
+            account_id: 123, // Static account ID for local development
+            tracker_id: tracker_id, // Use the provided 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, // Static installation ID for local development
+                    app_id: app.manifest.meta.app_id,
+                    version: app.manifest.meta.version,
+                    account_id: 123, // Static account ID for local development
+                    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 form data with secret fields redacted (matches OCP behavior)
+            const formData = settingsStore.getRedactedFormData();
+            // 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 with secret fields redacted (matches OCP behavior)
+                const updatedFormData = settingsStore.getRedactedFormData();
+                // 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}/functions
+     * Lists functions with their invocation URLs for the installation
+     * Used by frontend to resolve dataSource function references
+     */
+    router.get("/:app_install_id/functions", (req, res) => {
+        const { app_install_id } = req.params;
+        // Validate app_install_id
+        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
+        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",
+                },
+            });
+        }
+        // Build function URL map
+        const protocol = req.secure ? "https" : "http";
+        const host = req.get("host") || "localhost:3000";
+        const baseUrl = `${protocol}://${host}`;
+        const functionEndpoints = (0, functionEndpoints_1.buildAllFunctionEndpoints)({
+            baseUrl,
+            appId: app.manifest.meta.app_id,
+            functions: app.manifest.functions || {},
+            getGuid: (functionId) => configStore.getFunctionGuid(functionId),
+        });
+        res.json({
+            function_endpoints: functionEndpoints,
+        });
+    });
+    /**
+     * 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