@expo/build-tools 18.2.0 → 18.5.0

package/dist/utils/findMaestroPathsFlowsToExecuteAsync.js

@@ -1,184 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findMaestroPathsFlowsToExecuteAsync = findMaestroPathsFlowsToExecuteAsync;
-const results_1 = require("@expo/results");
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const node_fs_1 = require("node:fs");
-const path = __importStar(require("node:path"));
-const yaml = __importStar(require("yaml"));
-const zod_1 = require("zod");
-const FlowConfigSchema = zod_1.z.object({
-    name: zod_1.z.string().optional(),
-    tags: zod_1.z.array(zod_1.z.string()).optional(),
-});
-const WorkspaceConfigSchema = zod_1.z.object({
-    flows: zod_1.z.array(zod_1.z.string()).optional(),
-    executionOrder: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
-    includeTags: zod_1.z.array(zod_1.z.string()).optional(),
-    excludeTags: zod_1.z.array(zod_1.z.string()).optional(),
-});
-async function findMaestroPathsFlowsToExecuteAsync({ workingDirectory, flowPath, includeTags: _includeTags, excludeTags: _excludeTags, logger, }) {
-    const absoluteFlowPath = path.resolve(workingDirectory, flowPath);
-    // If it's a file, just return it (no validation needed)
-    const stat = await node_fs_1.promises.stat(absoluteFlowPath);
-    if (stat.isFile()) {
-        logger.info(`Found a file: ${path.relative(workingDirectory, absoluteFlowPath)}`);
-        return [absoluteFlowPath];
-    }
-    // It's a directory - discover flow files
-    logger.info(`Found a directory: ${path.relative(workingDirectory, absoluteFlowPath)}`);
-    // Check for workspace config
-    logger.info(`Searching for workspace config...`);
-    const workspaceConfig = await findAndParseWorkspaceConfigAsync({
-        dirPath: absoluteFlowPath,
-        workingDirectory,
-        logger,
-    });
-    logger.info(`Using workspace config: ${JSON.stringify(workspaceConfig)}`);
-    if (workspaceConfig?.executionOrder) {
-        logger.warn(`Execution order is not supported yet. Ignoring.`);
-    }
-    logger.info(`Searching for flow files...`);
-    const { flows } = await findAndParseFlowFilesAsync({
-        dirPath: absoluteFlowPath,
-        workingDirectory,
-        workspaceConfig,
-        logger,
-    });
-    if (flows.length === 0) {
-        logger.info(`No valid flow files found in: ${path.relative(workingDirectory, absoluteFlowPath)}`);
-        return [];
-    }
-    const includeTags = [...(_includeTags ?? []), ...(workspaceConfig?.includeTags ?? [])];
-    const excludeTags = [...(_excludeTags ?? []), ...(workspaceConfig?.excludeTags ?? [])];
-    if (includeTags.length === 0 && excludeTags.length === 0) {
-        logger.info(`No tags provided, returning all flows.`);
-        return flows.map(({ path }) => path);
-    }
-    logger.info(`Filtering flows by tags. Tags to include: ${JSON.stringify(includeTags)}. Tags to exclude: ${JSON.stringify(excludeTags) ?? 'none'}.`);
-    return flows
-        .filter(({ config, path: flowPath }) => {
-        const shouldInclude = matchesTags({
-            flowTags: config?.tags ?? [],
-            includeTags,
-            excludeTags,
-        });
-        logger.info(shouldInclude
-            ? `- ${path.relative(workingDirectory, flowPath)} matches tags, including.`
-            : `- ${path.relative(workingDirectory, flowPath)} does not match tags, excluding.`);
-        return shouldInclude;
-    })
-        .map(({ path }) => path);
-}
-async function findAndParseWorkspaceConfigAsync({ dirPath, workingDirectory, logger, }) {
-    const configPaths = await (0, fast_glob_1.default)(['config.yaml', 'config.yml'], {
-        cwd: dirPath,
-        absolute: true,
-    });
-    if (configPaths.length === 0) {
-        logger.info(`No workspace config found in: ${path.relative(workingDirectory, dirPath)}`);
-        return null;
-    }
-    for (const configPath of configPaths) {
-        try {
-            const content = await node_fs_1.promises.readFile(configPath, 'utf-8');
-            const configDoc = yaml.parse(content);
-            if (!configDoc) {
-                logger.warn(`No content found in workspace config: ${path.relative(workingDirectory, configPath)}`);
-                continue;
-            }
-            logger.info(`Using workspace config from: ${path.relative(workingDirectory, configPath)}`);
-            return WorkspaceConfigSchema.parse(configDoc);
-        }
-        catch (err) {
-            logger.warn({ err }, `Failed to parse workspace config: ${path.relative(workingDirectory, configPath)}`);
-            continue;
-        }
-    }
-    logger.info(`No valid workspace config found in: ${path.relative(workingDirectory, dirPath)}`);
-    return null;
-}
-async function findAndParseFlowFilesAsync({ workingDirectory, dirPath, workspaceConfig, logger, }) {
-    const flows = [];
-    // Determine flow patterns from config or use default
-    const flowPatterns = workspaceConfig?.flows ?? ['*'];
-    logger.info(`Using flow patterns: ${JSON.stringify(flowPatterns)}`);
-    // Use fast-glob to find matching files
-    const matchedFiles = await (0, fast_glob_1.default)(flowPatterns, {
-        cwd: dirPath,
-        absolute: true,
-        onlyFiles: true,
-        ignore: ['*/config.yaml', '*/config.yml'], // Skip workspace config files
-    });
-    logger.info(`Found ${matchedFiles.length} potential flow files`);
-    // Parse each matched file
-    for (const filePath of matchedFiles) {
-        // Skip non-YAML files
-        const ext = path.extname(filePath);
-        if (ext !== '.yaml' && ext !== '.yml') {
-            logger.info(`Skipping non-YAML file: ${path.relative(workingDirectory, filePath)}`);
-            continue;
-        }
-        const result = await (0, results_1.asyncResult)(parseFlowFile(filePath));
-        if (result.ok) {
-            logger.info(`Found flow file: ${path.relative(workingDirectory, filePath)}`);
-            flows.push({ config: result.value, path: filePath });
-        }
-        else {
-            logger.info({ err: result.reason }, `Skipping flow file: ${path.relative(workingDirectory, filePath)}`);
-        }
-    }
-    return { flows };
-}
-async function parseFlowFile(filePath) {
-    const content = await node_fs_1.promises.readFile(filePath, 'utf-8');
-    const documents = yaml.parseAllDocuments(content);
-    const configDoc = documents[0];
-    if (!configDoc) {
-        throw new Error(`No config section found in ${filePath}`);
-    }
-    return FlowConfigSchema.parse(configDoc.toJS());
-}
-function matchesTags({ flowTags, includeTags, excludeTags, }) {
-    // Include logic: if includeTags is empty OR flow has any of the include tags
-    const includeMatch = includeTags.length === 0 || includeTags.some(tag => flowTags.includes(tag));
-    // Exclude logic: if excludeTags is empty OR flow has none of the exclude tags
-    const excludeMatch = excludeTags.length === 0 || !excludeTags.some(tag => flowTags.includes(tag));
-    return includeMatch && excludeMatch;
-}