@devicecloud.dev/dcd 4.1.2 → 4.1.4

package/dist/services/test-submission.service.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestSubmissionService = void 0;
+const path = require("node:path");
+const methods_1 = require("../methods");
+const mimeTypeLookupByExtension = {
+    zip: 'application/zip',
+};
+/**
+ * Service for building test submission form data
+ */
+class TestSubmissionService {
+    /**
+     * Build FormData for test submission
+     * @param config Test submission configuration
+     * @returns FormData ready to be submitted to the API
+     */
+    async buildTestFormData(config) {
+        const { appBinaryId, flowFile, executionPlan, commonRoot, cliVersion, env = [], metadata = [], googlePlay = false, androidApiLevel, androidDevice, iOSVersion, iOSDevice, name, runnerType, maestroVersion, deviceLocale, orientation, mitmHost, mitmPath, retry, continueOnFailure = true, report, showCrosshairs, skipChromeOnboarding, raw, debug = false, logger, } = config;
+        const { allExcludeTags, allIncludeTags, flowMetadata, flowOverrides, flowsToRun: testFileNames, referencedFiles, sequence, workspaceConfig, } = executionPlan;
+        const { flows: sequentialFlows = [] } = sequence ?? {};
+        const testFormData = new FormData();
+        const envObject = this.parseKeyValuePairs(env);
+        const metadataObject = this.parseKeyValuePairs(metadata);
+        if (Object.keys(envObject).length > 0) {
+            this.logDebug(debug, logger, `DEBUG: Environment variables: ${JSON.stringify(envObject)}`);
+        }
+        if (Object.keys(metadataObject).length > 0) {
+            this.logDebug(debug, logger, `DEBUG: User metadata: ${JSON.stringify(metadataObject)}`);
+        }
+        this.logDebug(debug, logger, `DEBUG: Compressing files from path: ${flowFile}`);
+        const buffer = await (0, methods_1.compressFilesFromRelativePath)(flowFile?.endsWith('.yaml') || flowFile?.endsWith('.yml')
+            ? path.dirname(flowFile)
+            : flowFile, [
+            ...new Set([
+                ...referencedFiles,
+                ...testFileNames,
+                ...sequentialFlows,
+            ]),
+        ], commonRoot);
+        this.logDebug(debug, logger, `DEBUG: Compressed file size: ${buffer.length} bytes`);
+        const blob = new Blob([buffer], {
+            type: mimeTypeLookupByExtension.zip,
+        });
+        testFormData.set('file', blob, 'flowFile.zip');
+        testFormData.set('appBinaryId', appBinaryId);
+        testFormData.set('testFileNames', JSON.stringify(this.normalizePaths(testFileNames, commonRoot)));
+        testFormData.set('flowMetadata', JSON.stringify(this.normalizePathMap(flowMetadata, commonRoot)));
+        testFormData.set('testFileOverrides', JSON.stringify(this.normalizePathMap(flowOverrides, commonRoot)));
+        testFormData.set('sequentialFlows', JSON.stringify(this.normalizePaths(sequentialFlows, commonRoot)));
+        testFormData.set('env', JSON.stringify(envObject));
+        testFormData.set('googlePlay', googlePlay ? 'true' : 'false');
+        const configPayload = {
+            allExcludeTags,
+            allIncludeTags,
+            autoRetriesRemaining: retry,
+            continueOnFailure,
+            deviceLocale,
+            maestroVersion,
+            mitmHost,
+            mitmPath,
+            orientation,
+            raw: JSON.stringify(raw),
+            report,
+            showCrosshairs,
+            skipChromeOnboarding,
+            version: cliVersion,
+        };
+        testFormData.set('config', JSON.stringify(configPayload));
+        if (Object.keys(metadataObject).length > 0) {
+            const metadataPayload = { userMetadata: metadataObject };
+            testFormData.set('metadata', JSON.stringify(metadataPayload));
+            this.logDebug(debug, logger, `DEBUG: Sending metadata to API: ${JSON.stringify(metadataPayload)}`);
+        }
+        this.setOptionalFields(testFormData, {
+            androidApiLevel,
+            androidDevice,
+            iOSDevice,
+            iOSVersion,
+            name,
+            runnerType,
+        });
+        if (workspaceConfig) {
+            testFormData.set('workspaceConfig', JSON.stringify(workspaceConfig));
+        }
+        return testFormData;
+    }
+    logDebug(debug, logger, message) {
+        if (debug && logger) {
+            logger(message);
+        }
+    }
+    normalizeFilePath(filePath, commonRoot) {
+        return filePath.replaceAll(commonRoot, '.').split(path.sep).join('/');
+    }
+    normalizePathMap(map, commonRoot) {
+        return Object.fromEntries(Object.entries(map).map(([key, value]) => [
+            this.normalizeFilePath(key, commonRoot),
+            value,
+        ]));
+    }
+    normalizePaths(paths, commonRoot) {
+        return paths.map((p) => this.normalizeFilePath(p, commonRoot));
+    }
+    parseKeyValuePairs(pairs) {
+        // eslint-disable-next-line unicorn/no-array-reduce
+        return pairs.reduce((acc, cur) => {
+            const [key, ...value] = cur.split('=');
+            // handle case where value includes an equals sign
+            acc[key] = value.join('=');
+            return acc;
+        }, {});
+    }
+    setOptionalFields(formData, fields) {
+        for (const [key, value] of Object.entries(fields)) {
+            if (value) {
+                formData.set(key, value.toString());
+            }
+        }
+    }
+}
+exports.TestSubmissionService = TestSubmissionService;

package/dist/services/version.service.d.ts

@@ -0,0 +1,32 @@
+import { CompatibilityData } from '../utils/compatibility';
+/**
+ * Service for handling version validation and checking
+ */
+export declare class VersionService {
+    /**
+     * Check npm registry for the latest published version of the CLI
+     * @returns Latest version string or null if check fails
+     */
+    checkLatestCliVersion(): Promise<null | string>;
+    /**
+     * Compare two semantic version strings
+     * @param current - Current version
+     * @param latest - Latest version
+     * @returns true if current is older than latest
+     */
+    isOutdated(current: string, latest: string): boolean;
+    /**
+     * Resolve and validate Maestro version against API compatibility data
+     * @param requestedVersion - Version requested by user (or undefined for default)
+     * @param compatibilityData - API compatibility data
+     * @param options - Configuration options
+     * @param options.debug - Enable debug logging
+     * @param options.logger - Optional logger function
+     * @returns Validated Maestro version string
+     * @throws Error if version is not supported
+     */
+    resolveMaestroVersion(requestedVersion: string | undefined, compatibilityData: CompatibilityData, options?: {
+        debug?: boolean;
+        logger?: (message: string) => void;
+    }): string;
+}

package/dist/services/version.service.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionService = void 0;
+const node_child_process_1 = require("node:child_process");
+/**
+ * Service for handling version validation and checking
+ */
+class VersionService {
+    /**
+     * Check npm registry for the latest published version of the CLI
+     * @returns Latest version string or null if check fails
+     */
+    async checkLatestCliVersion() {
+        try {
+            const latestVersion = (0, node_child_process_1.execSync)('npm view @devicecloud.dev/dcd version', {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim();
+            return latestVersion;
+        }
+        catch {
+            // Silently fail - version check is informational only
+            return null;
+        }
+    }
+    /**
+     * Compare two semantic version strings
+     * @param current - Current version
+     * @param latest - Latest version
+     * @returns true if current is older than latest
+     */
+    isOutdated(current, latest) {
+        const currentParts = current.split('.').map(Number);
+        const latestParts = latest.split('.').map(Number);
+        for (let i = 0; i < 3; i++) {
+            if (currentParts[i] < latestParts[i])
+                return true;
+            if (currentParts[i] > latestParts[i])
+                return false;
+        }
+        return false;
+    }
+    /**
+     * Resolve and validate Maestro version against API compatibility data
+     * @param requestedVersion - Version requested by user (or undefined for default)
+     * @param compatibilityData - API compatibility data
+     * @param options - Configuration options
+     * @param options.debug - Enable debug logging
+     * @param options.logger - Optional logger function
+     * @returns Validated Maestro version string
+     * @throws Error if version is not supported
+     */
+    resolveMaestroVersion(requestedVersion, compatibilityData, options) {
+        const { debug = false, logger } = options || {};
+        const log = logger || console.log;
+        const { supportedVersions, defaultVersion, latestVersion } = compatibilityData.maestro;
+        // Resolve "latest" to actual latest version from API
+        let resolvedVersion = requestedVersion;
+        if (requestedVersion === 'latest') {
+            resolvedVersion = latestVersion;
+            if (debug) {
+                log(`DEBUG: Resolved "latest" to ${latestVersion}`);
+            }
+        }
+        else if (!requestedVersion) {
+            resolvedVersion = defaultVersion;
+            if (debug) {
+                log(`DEBUG: Using default Maestro version ${defaultVersion}`);
+            }
+        }
+        // Validate Maestro version
+        if (!supportedVersions.includes(resolvedVersion)) {
+            throw new Error(`Maestro version ${resolvedVersion} is not supported. Supported versions: ${supportedVersions.join(', ')}`);
+        }
+        if (debug) {
+            log(`DEBUG: Maestro version validated: ${resolvedVersion}`);
+            log(`DEBUG: Supported Maestro versions: ${supportedVersions.join(', ')}`);
+        }
+        return resolvedVersion;
+    }
+}
+exports.VersionService = VersionService;