@devicecloud.dev/dcd 0.0.1-alpha.0 → 0.0.1-alpha.3

package/README.md

@@ -5,14 +5,14 @@ One line swap out for Maestro Cloud
 
 Install:
 ```sh-session
-$ npm install -g @devicecloud/dcd
+$ npm install -g @devicecloud.dev/dcd
 ```
 
 Use:
-```sh
+```sh-session
 # maestro cloud --apiKey <apiKey> <appFile> .myFlows/
 
-dcd cloud --apiKey <apiKey> <appFile> .myFlows/
+$ dcd cloud --apiKey <apiKey> <appFile> .myFlows/
 ```
 
 See full documentation: [Docs](https://docs.devicecloud.dev)

package/dist/commands/cloud.d.ts

@@ -1,7 +1,7 @@
 import { Command } from '@oclif/core';
 export default class Cloud extends Command {
     static args: {
-        firstFile: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        firstFile: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
         secondFile: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
@@ -13,6 +13,7 @@ export default class Cloud extends Command {
         appBinaryId: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         appFile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         env: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        flows: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         iOSVersion: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/cloud.js

@@ -1,12 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
+const archiver = require("archiver");
 const promises_1 = require("node:fs/promises");
+const node_stream_1 = require("node:stream");
+const plan_1 = require("../plan");
 const mimeTypeLookupByExtension = {
     apk: 'application/vnd.android.package-archive',
     yaml: 'application/x-yaml',
     zip: 'application/zip',
 };
+const PERMITTED_EXTENSIONS = new Set([
+    'yml',
+    'yaml',
+    'png',
+    'jpg',
+    'jpeg',
+    'gif',
+    'mp4',
+    'js',
+]);
 const typeSafeFetch = async (baseUrl, path, init) => {
     const res = await fetch(baseUrl + path, init);
     if (!res.ok) {
@@ -14,13 +27,44 @@ const typeSafeFetch = async (baseUrl, path, init) => {
     }
     return res.json();
 };
+const toBuffer = async (archive) => {
+    const chunks = [];
+    const writable = new node_stream_1.Writable();
+    writable._write = (chunk, _, callback) => {
+        // save to array to concatenate later
+        chunks.push(chunk);
+        callback();
+    };
+    // pipe to writable
+    archive.pipe(writable);
+    await archive.finalize();
+    // once done, concatenate chunks
+    return Buffer.concat(chunks);
+};
+const compress = async (sourceDir) => {
+    // const output = createWriteStream(zipTargetPath);
+    const archive = archiver('zip', {
+        zlib: { level: 9 },
+    });
+    archive.on('error', (err) => {
+        throw err;
+    });
+    // archive.pipe(output);
+    archive.directory(sourceDir, false, (data) => {
+        if (PERMITTED_EXTENSIONS.has(data.name.split('.').pop())) {
+            return data;
+        }
+        return false;
+    });
+    const buffer = await toBuffer(archive);
+    return buffer;
+};
 class Cloud extends core_1.Command {
     static args = {
         firstFile: core_1.Args.string({
             description: 'The binary file of the app to run your flow against, e.g. app.apk for android or app.zip for ios',
             hidden: true,
             name: 'App file',
-            required: true,
         }),
         secondFile: core_1.Args.string({
             description: 'The flow file to run against the app, e.g. test.yaml',
@@ -34,12 +78,14 @@ class Cloud extends core_1.Command {
         androidApiLevel: core_1.Flags.integer({
             aliases: ['android-api-level'],
             description: 'Android API level to run your flow against',
+            options: ['32', '33', '34'],
         }),
         apiKey: core_1.Flags.string({ aliases: ['api-key'], description: 'API key' }),
         apiUrl: core_1.Flags.string({
             aliases: ['api-url'],
             default: 'https://api.devicecloud.dev',
             description: 'API base URL',
+            hidden: true,
         }),
         appBinaryId: core_1.Flags.string({
             aliases: ['app-binary-id'],
@@ -55,42 +101,47 @@ class Cloud extends core_1.Command {
             description: 'One or more environment variables to inject into your Flows',
             multiple: true,
         }),
+        flows: core_1.Flags.string({
+            aliases: ['flows'],
+            description: 'The path to the flow file or folder containing your Flows',
+        }),
         iOSVersion: core_1.Flags.string({
             aliases: ['ios-version'],
             description: 'iOS version to run your flow against',
+            options: ['16.4', '17.2'],
         }),
     };
     async run() {
         const { args, flags } = await this.parse(Cloud);
-        const { apiKey, apiUrl, appBinaryId, ...rest } = flags;
+        const { apiKey, apiUrl, appBinaryId, appFile, env, flows, ...rest } = flags;
         console.log({ args });
         const { firstFile, secondFile } = args;
         let finalBinaryId = appBinaryId;
-        const appFile = firstFile;
-        let flowFile = secondFile;
+        const finalAppFile = appFile ?? firstFile;
+        let flowFile = flows ?? secondFile;
         if (appBinaryId) {
             if (secondFile) {
                 throw new Error('You cannot provide both an appBinaryId and a binary file');
             }
-            flowFile = firstFile;
-            this.log(`you want to run the flow ${flowFile} against the binary with id ${appBinaryId} with the following flags: ${JSON.stringify(flags)}`);
+            flowFile = flows ?? firstFile;
+            this.log(`you want to run the flow(s) ${flowFile} against the binary with id ${appBinaryId} with the following flags: ${JSON.stringify(flags)}`);
         }
         else {
-            if (!appFile.endsWith('.apk') && !appFile.endsWith('.zip')) {
-                throw new Error('App file must be a .apk or .zip file');
-            }
-            if (!(flowFile && appFile)) {
+            if (!(flowFile && finalAppFile)) {
                 throw new Error('You must provide a flow file and an app binary id');
             }
-            this.log(`you want to run the flow ${flowFile} against the app ${appFile} with the following flags: ${JSON.stringify(flags)}`);
+            if (!finalAppFile.endsWith('.apk') && !finalAppFile.endsWith('.zip')) {
+                throw new Error('App file must be a .apk or .zip file');
+            }
+            this.log(`you want to run the flow(s) ${flowFile} against the app ${finalAppFile} with the following flags: ${JSON.stringify(flags)}`);
         }
         if (!finalBinaryId) {
             const binaryFormData = new FormData();
-            const binaryBlob = new Blob([await (0, promises_1.readFile)(appFile)], {
-                type: mimeTypeLookupByExtension[appFile.split('.').pop()],
+            const binaryBlob = new Blob([await (0, promises_1.readFile)(finalAppFile)], {
+                type: mimeTypeLookupByExtension[finalAppFile.split('.').pop()],
             });
-            console.log(mimeTypeLookupByExtension[appFile.split('.').pop()]);
-            binaryFormData.set('file', binaryBlob, appFile);
+            console.log(mimeTypeLookupByExtension[finalAppFile.split('.').pop()]);
+            binaryFormData.set('file', binaryBlob, finalAppFile);
             const options = {
                 body: binaryFormData,
                 headers: { 'x-app-api-key': apiKey },
@@ -102,13 +153,44 @@ class Cloud extends core_1.Command {
             this.log(message);
             finalBinaryId = binaryId;
         }
+        const testFileNames = [];
+        let flowFileDirectory = flowFile;
+        if (flowFile?.endsWith('/')) {
+            try {
+                const executionPlan = await (0, plan_1.plan)(flowFile, [], []);
+                for (const file of executionPlan.flowsToRun) {
+                    testFileNames.push(file);
+                }
+                for (const file of executionPlan.sequence?.flows ?? []) {
+                    // todo: handle continueOnFailure and other sequence properties
+                    testFileNames.push(file);
+                }
+                console.log(executionPlan);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
+        else {
+            // we are working with a single file
+            flowFileDirectory = flowFile.split('/').slice(0, -1).join('/');
+            testFileNames.push(flowFile.split('/').pop());
+        }
         const testFormData = new FormData();
-        const blob = new Blob([await (0, promises_1.readFile)(flowFile)], {
-            type: mimeTypeLookupByExtension[flowFile.split('.').pop()],
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const envObject = (env ?? []).reduce((acc, cur) => {
+            const [key, value] = cur.split('=');
+            acc[key] = value;
+            return acc;
+        }, {});
+        const buffer = await compress(flowFileDirectory);
+        const blob = new Blob([buffer], {
+            type: mimeTypeLookupByExtension.zip,
         });
-        testFormData.set('file', blob, flowFile);
+        testFormData.set('file', blob, 'flowFile.zip');
         testFormData.set('appBinaryId', finalBinaryId);
-        testFormData.set('testFileName', flowFile);
+        testFormData.set('testFileNames', JSON.stringify(testFileNames));
+        testFormData.set('env', JSON.stringify(envObject));
         for (const [key, value] of Object.entries(rest)) {
             if (value) {
                 testFormData.set(key, value);

package/dist/plan.d.ts

@@ -0,0 +1,10 @@
+interface IExecutionPlan {
+    flowsToRun: string[];
+    sequence?: IFlowSequence | null;
+}
+interface IFlowSequence {
+    continueOnFailure?: boolean;
+    flows: string[];
+}
+export declare function plan(input: string, includeTags: string[], excludeTags: string[]): Promise<IExecutionPlan>;
+export {};

package/dist/plan.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plan = void 0;
+const globToRegExp = require("glob-to-regexp");
+const yaml = require("js-yaml");
+const fs = require("node:fs");
+const path = require("node:path");
+function getFlowsToRunInSequence(paths, flowOrder) {
+    if (flowOrder.length === 0)
+        return [];
+    const orderSet = new Set(flowOrder);
+    const namesInOrder = Object.keys(paths).filter((key) => orderSet.has(key));
+    if (namesInOrder.length === 0)
+        return [];
+    const result = [...orderSet].filter((item) => namesInOrder.includes(item));
+    if (result.length === 0) {
+        throw new Error(`Could not find flows needed for execution in order: ${[...orderSet]
+            .filter((item) => !namesInOrder.includes(item))
+            .join(', ')}`);
+    }
+    else if (flowOrder
+        .slice(0, result.length)
+        .every((value, index) => value === result[index])) {
+        return result.map((item) => paths[item]);
+    }
+    else {
+        return [];
+    }
+}
+function isFlowFile(filePath) {
+    return filePath.endsWith('.yaml') || filePath.endsWith('.yml');
+}
+const readYamlFileAsJson = (filePath) => {
+    const yamlText = fs.readFileSync(filePath, 'utf8');
+    return yaml.load(yamlText);
+};
+const readConfigFromYamlFileAsJson = (filePath) => {
+    const yamlText = fs.readFileSync(filePath, 'utf8');
+    if (yamlText.includes('\n---\n')) {
+        const yamlTexts = yamlText.split('\n---\n');
+        const config = yaml.load(yamlTexts[0]);
+        if (Object.keys(config).filter((key) => key === 'appId').length > 1) {
+            return config;
+        }
+    }
+    return null;
+};
+async function walk(dir, filterFunction) {
+    const readDirResult = await fs.promises.readdir(dir);
+    const files = await Promise.all(readDirResult.map(async (file) => {
+        const filePath = path.join(dir, file);
+        const stats = await fs.promises.stat(filePath);
+        if (stats.isDirectory())
+            return walk(filePath);
+        if (stats.isFile())
+            if (filterFunction) {
+                if (filterFunction(filePath))
+                    return filePath;
+            }
+            else {
+                return filePath;
+            }
+    }));
+    return files.flat().filter(Boolean);
+}
+async function plan(input, includeTags, excludeTags) {
+    if (!fs.existsSync(input)) {
+        throw new Error(`Flow path does not exist: ${path.resolve(input)}`);
+    }
+    if (fs.lstatSync(input).isFile()) {
+        return { flowsToRun: [input] };
+    }
+    let unfilteredFlowFiles = await walk(input, isFlowFile);
+    if (unfilteredFlowFiles.length === 0) {
+        throw new Error(`Flow directory does not contain any Flow files: ${path.resolve(input)}`);
+    }
+    const configFilePath = unfilteredFlowFiles.find((file) => file.endsWith('config.yaml') || file.endsWith('config.yml'));
+    if (configFilePath)
+        unfilteredFlowFiles = unfilteredFlowFiles.filter((file) => file !== configFilePath);
+    const cleanPath = path.normalize(input);
+    const relativeFilePaths = unfilteredFlowFiles.map((file) => file.replace(cleanPath, ''));
+    const topLevelFlowFiles = relativeFilePaths.filter((file) => !file.includes('/'));
+    const workspaceConfig = configFilePath
+        ? readYamlFileAsJson(configFilePath)
+        : {};
+    let unsortedFlowFiles = topLevelFlowFiles;
+    if (workspaceConfig.flows) {
+        const matchers = workspaceConfig.flows.map((glob) => glob === '*' ? /^((?!\/).)*$/ : globToRegExp(glob));
+        unsortedFlowFiles = relativeFilePaths.filter((filePath) => matchers.some((matcher) => matcher.test(filePath)));
+    }
+    if (unsortedFlowFiles.length === 0) {
+        const error = workspaceConfig.flows
+            ? new Error(`Flow inclusion pattern(s) did not match any Flow files:\n${workspaceConfig.flows.join('\n')}`)
+            : new Error(`Top-level directory does not contain any Flows: ${path.resolve(input)}`);
+        throw error;
+    }
+    // eslint-disable-next-line unicorn/no-array-reduce
+    const configPerFlowFile = unsortedFlowFiles.reduce((acc, filePath) => {
+        acc[filePath] = readConfigFromYamlFileAsJson(cleanPath + filePath);
+        return acc;
+    }, {});
+    const allIncludeTags = [
+        ...includeTags,
+        ...(workspaceConfig.includeTags || []),
+    ];
+    const allExcludeTags = [
+        ...excludeTags,
+        ...(workspaceConfig.excludeTags || []),
+    ];
+    const allFlows = unsortedFlowFiles.filter((filePath) => {
+        const config = configPerFlowFile[filePath];
+        const tags = config?.tags || [];
+        return ((allIncludeTags.length === 0 ||
+            tags.some((tag) => allIncludeTags.includes(tag))) &&
+            (allExcludeTags.length === 0 ||
+                !tags.some((tag) => allExcludeTags.includes(tag))));
+    });
+    if (allFlows.length === 0) {
+        throw new Error(`Include / Exclude tags did not match any Flows:\n\nInclude Tags:\n${allIncludeTags.join('\n')}\n\nExclude Tags:\n${allExcludeTags.join('\n')}`);
+    }
+    // eslint-disable-next-line unicorn/no-array-reduce
+    const pathsByName = allFlows.reduce((acc, filePath) => {
+        const config = configPerFlowFile[filePath];
+        acc[config?.name || path.parse(filePath).name] = filePath;
+        return acc;
+    }, {});
+    const flowsToRunInSequence = workspaceConfig.executionOrder?.flowsOrder
+        ?.map((flowOrder) => getFlowsToRunInSequence(pathsByName, [flowOrder]))
+        .flat() || [];
+    const normalFlows = allFlows.filter((flow) => !flowsToRunInSequence.includes(flow));
+    // for (const filePath of allFlows) {
+    //   const commands = YamlCommandReader.readCommands(filePath).filter(
+    //     (command) => command.addMediaCommand,
+    //   );
+    //   const mediaPaths = commands.flatMap(
+    //     (command) => command.addMediaCommand.mediaPaths,
+    //   );
+    //   YamlCommandsPathValidator.validatePathsExistInWorkspace(
+    //     input,
+    //     filePath,
+    //     mediaPaths,
+    //   );
+    // }
+    return {
+        flowsToRun: normalFlows,
+        sequence: {
+            continueOnFailure: workspaceConfig.executionOrder?.continueOnFailure,
+            flows: flowsToRunInSequence,
+        },
+    };
+}
+exports.plan = plan;

package/oclif.manifest.json

@@ -6,8 +6,7 @@
         "firstFile": {
           "description": "The binary file of the app to run your flow against, e.g. app.apk for android or app.zip for ios",
           "hidden": true,
-          "name": "firstFile",
-          "required": true
+          "name": "firstFile"
         },
         "secondFile": {
           "description": "The flow file to run against the app, e.g. test.yaml",
@@ -28,6 +27,11 @@
           "name": "androidApiLevel",
           "hasDynamicHelp": false,
           "multiple": false,
+          "options": [
+            "32",
+            "33",
+            "34"
+          ],
           "type": "option"
         },
         "apiKey": {
@@ -45,6 +49,7 @@
             "api-url"
           ],
           "description": "API base URL",
+          "hidden": true,
           "name": "apiUrl",
           "default": "https://api.devicecloud.dev",
           "hasDynamicHelp": false,
@@ -82,6 +87,16 @@
           "multiple": true,
           "type": "option"
         },
+        "flows": {
+          "aliases": [
+            "flows"
+          ],
+          "description": "The path to the flow file or folder containing your Flows",
+          "name": "flows",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "iOSVersion": {
           "aliases": [
             "ios-version"
@@ -90,6 +105,10 @@
           "name": "iOSVersion",
           "hasDynamicHelp": false,
           "multiple": false,
+          "options": [
+            "16.4",
+            "17.2"
+          ],
           "type": "option"
         }
       },
@@ -109,5 +128,5 @@
       ]
     }
   },
-  "version": "0.0.1-alpha.0"
+  "version": "0.0.1-alpha.3"
 }

package/package.json

@@ -10,13 +10,19 @@
     "@oclif/plugin-not-found": "^3.0.10",
     "@oclif/plugin-plugins": "^4",
     "@oclif/plugin-update": "^4.1.11",
-    "@oclif/plugin-warn-if-update-available": "^3.0.10"
+    "@oclif/plugin-warn-if-update-available": "^3.0.10",
+    "archiver": "^6.0.1",
+    "glob-to-regexp": "^0.4.1",
+    "js-yaml": "^4.1.0"
   },
   "description": "Better cloud maestro testing",
   "devDependencies": {
     "@oclif/prettier-config": "^0.2.1",
     "@oclif/test": "^3",
+    "@types/archiver": "^6.0.2",
     "@types/chai": "^4",
+    "@types/glob-to-regexp": "^0.4.4",
+    "@types/js-yaml": "^4.0.9",
     "@types/mocha": "^9.0.0",
     "chai": "^4",
     "eslint": "^8.56.0",
@@ -68,15 +74,17 @@
     "test": "mocha --forbid-only \"test/**/*.test.ts\"",
     "version": "oclif readme && git add README.md"
   },
-  "version": "0.0.1-alpha.0",
+  "version": "0.0.1-alpha.3",
   "bugs": {
     "url": "https://discord.gg/GzZBHcUJ"
   },
   "keywords": [
-    "oclif"
+    "devicecloud",
+    "devicecloud.dev",
+    "dcd",
+    "cloud",
+    "maestro",
+    "testing"
   ],
-  "types": "dist/index.d.ts",
-  "directories": {
-    "test": "test"
-  }
-}
+  "types": "dist/index.d.ts"
+}