@devicecloud.dev/dcd 3.3.4-beta.3 → 3.3.5

package/dist/plan.js

@@ -37,53 +37,55 @@ async function checkDependencies(input) {
 }
 function filterFlowFiles(unfilteredFlowFiles, excludeFlows) {
     if (excludeFlows) {
-        return unfilteredFlowFiles.filter((file) => !excludeFlows.some((flow) => file.startsWith(path.resolve(flow))));
+        return unfilteredFlowFiles.filter((file) => !excludeFlows.some((flow) => path.normalize(file).startsWith(path.normalize(path.resolve(flow)))));
     }
     return unfilteredFlowFiles;
 }
 function getWorkspaceConfig(input, unfilteredFlowFiles) {
-    console.log('[getWorkspaceConfig] Input path:', input);
-    console.log('[getWorkspaceConfig] Unfiltered flow files:', unfilteredFlowFiles);
-    const configFilePath = unfilteredFlowFiles.find((file) => file === input + 'config.yaml' || file === input + 'config.yml');
-    console.log('[getWorkspaceConfig] Found config file path:', configFilePath);
+    const possibleConfigPaths = [
+        path.join(input, 'config.yaml'),
+        path.join(input, 'config.yml'),
+    ].map((p) => path.normalize(p));
+    const configFilePath = unfilteredFlowFiles.find((file) => possibleConfigPaths.includes(path.normalize(file)));
     const config = configFilePath
         ? (0, planMethods_1.readYamlFileAsJson)(configFilePath)
         : {};
-    console.log('[getWorkspaceConfig] Parsed config:', config);
     return config;
 }
 async function plan(input, includeTags, excludeTags, excludeFlows) {
-    if (!fs.existsSync(input)) {
-        throw new Error(`Flow path does not exist: ${path.resolve(input)}`);
+    const normalizedInput = path.normalize(input);
+    if (!fs.existsSync(normalizedInput)) {
+        throw new Error(`Flow path does not exist: ${path.resolve(normalizedInput)}`);
     }
-    if (fs.lstatSync(input).isFile()) {
-        if (input.endsWith('config.yaml') || input.endsWith('config.yml')) {
+    if (fs.lstatSync(normalizedInput).isFile()) {
+        if (normalizedInput.endsWith('config.yaml') ||
+            normalizedInput.endsWith('config.yml')) {
             throw new Error('If using config.yaml, pass the workspace folder path, not the config file');
         }
-        const checkedDependancies = await checkDependencies(input);
+        const checkedDependancies = await checkDependencies(normalizedInput);
         return {
-            flowsToRun: [input],
+            flowsToRun: [normalizedInput],
             referencedFiles: [...new Set(checkedDependancies)],
             totalFlowFiles: 1,
         };
     }
-    let unfilteredFlowFiles = await (0, planMethods_1.readDirectory)(input, planMethods_1.isFlowFile);
+    let unfilteredFlowFiles = await (0, planMethods_1.readDirectory)(normalizedInput, planMethods_1.isFlowFile);
     if (unfilteredFlowFiles.length === 0) {
-        throw new Error(`Flow directory does not contain any Flow files: ${path.resolve(input)}`);
+        throw new Error(`Flow directory does not contain any Flow files: ${path.resolve(normalizedInput)}`);
     }
     unfilteredFlowFiles = filterFlowFiles(unfilteredFlowFiles, excludeFlows);
-    const workspaceConfig = getWorkspaceConfig(input, unfilteredFlowFiles);
+    const workspaceConfig = getWorkspaceConfig(normalizedInput, unfilteredFlowFiles);
     if (workspaceConfig.flows) {
         const globs = workspaceConfig.flows.map((glob) => glob);
         const matchedFiles = await (0, glob_1.glob)(globs, {
-            cwd: input,
+            cwd: normalizedInput,
             nodir: true,
         });
         // overwrite the list of files with the globbed ones
         unfilteredFlowFiles = matchedFiles
             .filter((file) => file !== 'config.yaml' &&
             (file.endsWith('.yaml') || file.endsWith('.yml')))
-            .map((file) => path.resolve(input, file));
+            .map((file) => path.resolve(normalizedInput, file));
     }
     else {
         // workspace config has no flows, so we need to remove the config file from the test list
@@ -92,7 +94,7 @@ async function plan(input, includeTags, excludeTags, excludeFlows) {
     if (unfilteredFlowFiles.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(`Workspace does not contain any Flows: ${path.resolve(input)}`);
+            : new Error(`Workspace does not contain any Flows: ${path.resolve(normalizedInput)}`);
         throw error;
     }
     const configPerFlowFile = 
@@ -103,12 +105,10 @@ async function plan(input, includeTags, excludeTags, excludeFlows) {
         return acc;
     }, {});
     const allFiles = await Promise.all(unfilteredFlowFiles.map((filePath) => checkDependencies(filePath))).then((results) => [...new Set(results.flat())]);
-    console.log('Found include tags in workspace config', workspaceConfig.includeTags);
     const allIncludeTags = [
         ...includeTags,
         ...(workspaceConfig.includeTags || []),
     ];
-    console.log('Found exclude tags in workspace config', workspaceConfig.excludeTags);
     const allExcludeTags = [
         ...excludeTags,
         ...(workspaceConfig.excludeTags || []),

package/dist/planMethods.js

@@ -37,38 +37,20 @@ function isFlowFile(filePath) {
 const readYamlFileAsJson = (filePath) => {
     try {
         const normalizedPath = path.normalize(filePath);
-        console.log('[YAML Parser] Reading file:', normalizedPath);
         const yamlText = fs.readFileSync(normalizedPath, 'utf8');
-        console.log('[YAML Parser] File contents:', '\n' + yamlText);
         const result = yaml.load(yamlText);
-        console.log('[YAML Parser] Parsed result:', JSON.stringify(result, null, 2));
         // Ensure includeTags and excludeTags are always arrays if present
         if (result && typeof result === 'object') {
             if ('includeTags' in result && !Array.isArray(result.includeTags)) {
-                console.log('[YAML Parser] Converting includeTags to array:', {
-                    from: result.includeTags,
-                    to: result.includeTags ? [result.includeTags] : [],
-                });
                 result.includeTags = result.includeTags ? [result.includeTags] : [];
             }
             if ('excludeTags' in result && !Array.isArray(result.excludeTags)) {
-                console.log('[YAML Parser] Converting excludeTags to array:', {
-                    from: result.excludeTags,
-                    to: result.excludeTags ? [result.excludeTags] : [],
-                });
                 result.excludeTags = result.excludeTags ? [result.excludeTags] : [];
             }
         }
         return result;
     }
     catch (error) {
-        console.error('[YAML Parser] Error parsing file:', {
-            filePath,
-            normalizedPath: path.normalize(filePath),
-            errorName: error instanceof Error ? error.name : 'Unknown',
-            errorMessage: error instanceof Error ? error.message : String(error),
-            errorStack: error instanceof Error ? error.stack : undefined,
-        });
         throw new Error(`Error parsing YAML file ${filePath}: ${error}`);
     }
 };

package/oclif.manifest.json

@@ -398,5 +398,5 @@
       ]
     }
   },
-  "version": "3.3.4-beta.3"
+  "version": "3.3.5"
 }

package/package.json

@@ -80,7 +80,7 @@
     "test": "mocha --forbid-only \"test/**/*.test.ts\"",
     "version": "oclif readme && git add README.md"
   },
-  "version": "3.3.4-beta.3",
+  "version": "3.3.5",
   "bugs": {
     "url": "https://discord.gg/gm3mJwcNw8"
   },