@devicecloud.dev/dcd 4.1.2-beta.1 → 4.1.3

package/dist/services/test-submission.service.d.ts

@@ -0,0 +1,41 @@
+import { IExecutionPlan } from './execution-plan.service';
+export interface TestSubmissionConfig {
+    androidApiLevel?: string;
+    androidDevice?: string;
+    appBinaryId: string;
+    cliVersion: string;
+    commonRoot: string;
+    continueOnFailure?: boolean;
+    debug?: boolean;
+    deviceLocale?: string;
+    env?: string[];
+    executionPlan: IExecutionPlan;
+    flowFile: string;
+    googlePlay?: boolean;
+    iOSDevice?: string;
+    iOSVersion?: string;
+    logger?: (message: string) => void;
+    maestroVersion: string;
+    metadata?: string[];
+    mitmHost?: string;
+    mitmPath?: string;
+    name?: string;
+    orientation?: string;
+    raw?: unknown;
+    report?: string;
+    retry?: number;
+    runnerType?: string;
+    showCrosshairs?: boolean;
+    skipChromeOnboarding?: boolean;
+}
+/**
+ * Service for building test submission form data
+ */
+export declare class TestSubmissionService {
+    /**
+     * Build FormData for test submission
+     * @param config Test submission configuration
+     * @returns FormData ready to be submitted to the API
+     */
+    buildTestFormData(config: TestSubmissionConfig): Promise<FormData>;
+}

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

@@ -0,0 +1,116 @@
+"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();
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const envObject = env.reduce((acc, cur) => {
+            const [key, ...value] = cur.split('=');
+            // handle case where value includes an equals sign
+            acc[key] = value.join('=');
+            return acc;
+        }, {});
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const metadataObject = metadata.reduce((acc, cur) => {
+            const [key, ...value] = cur.split('=');
+            // handle case where value includes an equals sign
+            acc[key] = value.join('=');
+            return acc;
+        }, {});
+        if (debug && logger && Object.keys(envObject).length > 0) {
+            logger(`DEBUG: Environment variables: ${JSON.stringify(envObject)}`);
+        }
+        if (debug && logger && Object.keys(metadataObject).length > 0) {
+            logger(`DEBUG: User metadata: ${JSON.stringify(metadataObject)}`);
+        }
+        if (debug && logger) {
+            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);
+        if (debug && logger) {
+            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(testFileNames.map((t) => t.replaceAll(commonRoot, '.').split(path.sep).join('/'))));
+        testFormData.set('flowMetadata', JSON.stringify(Object.fromEntries(Object.entries(flowMetadata).map(([key, value]) => [
+            key.replaceAll(commonRoot, '.').split(path.sep).join('/'),
+            value,
+        ]))));
+        testFormData.set('testFileOverrides', JSON.stringify(Object.fromEntries(Object.entries(flowOverrides).map(([key, value]) => [
+            key.replaceAll(commonRoot, '.').split(path.sep).join('/'),
+            value,
+        ]))));
+        testFormData.set('sequentialFlows', JSON.stringify(sequentialFlows.map((t) => t.replaceAll(commonRoot, '.').split(path.sep).join('/'))));
+        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));
+            if (debug && logger) {
+                logger(`DEBUG: Sending metadata to API: ${JSON.stringify(metadataPayload)}`);
+            }
+        }
+        if (androidApiLevel)
+            testFormData.set('androidApiLevel', androidApiLevel.toString());
+        if (androidDevice)
+            testFormData.set('androidDevice', androidDevice.toString());
+        if (iOSVersion)
+            testFormData.set('iOSVersion', iOSVersion.toString());
+        if (iOSDevice)
+            testFormData.set('iOSDevice', iOSDevice.toString());
+        if (name)
+            testFormData.set('name', name.toString());
+        if (runnerType)
+            testFormData.set('runnerType', runnerType.toString());
+        if (workspaceConfig)
+            testFormData.set('workspaceConfig', JSON.stringify(workspaceConfig));
+        return testFormData;
+    }
+}
+exports.TestSubmissionService = TestSubmissionService;

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

@@ -0,0 +1,31 @@
+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 debug - Enable debug logging
+     * @param 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,81 @@
+"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 debug - Enable debug logging
+     * @param 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;