@cbnventures/nova 0.15.4 → 0.16.1

package/build/src/cli/utility/initialize.js

@@ -1122,7 +1122,7 @@ export class CliUtilityInitialize {
                 return 'back';
             }
             if (menuOutputResult.action['kind'] === 'add') {
-                const result = await CliUtilityInitialize.promptWorkflowsForm(undefined, 'create', workflows);
+                const result = await CliUtilityInitialize.promptWorkflowsForm(undefined, 'create', workflows, config);
                 if (result['action'] === 'back') {
                     continue;
                 }
@@ -1142,7 +1142,7 @@ export class CliUtilityInitialize {
                     continue;
                 }
                 const workflowToEdit = workflows[workflowIndex];
-                const workflowResult = await CliUtilityInitialize.promptWorkflowsForm(workflowToEdit, 'update', workflows);
+                const workflowResult = await CliUtilityInitialize.promptWorkflowsForm(workflowToEdit, 'update', workflows, config);
                 if (workflowResult['action'] === 'back') {
                     continue;
                 }
@@ -1189,11 +1189,13 @@ export class CliUtilityInitialize {
             }
         }
     }
-    static async promptWorkflowsForm(workflow, mode, workflows) {
+    static async promptWorkflowsForm(workflow, mode, workflows, config) {
         const existingTemplate = (workflow !== undefined && typeof workflow['template'] === 'string') ? workflow['template'] : '';
         const existingSuffix = (workflow !== undefined && typeof workflow['suffix'] === 'string') ? workflow['suffix'] : '';
         const existingTriggers = (workflow !== undefined && Array.isArray(workflow['triggers']) === true) ? workflow['triggers'] : [];
         const existingDependsOn = (workflow !== undefined && Array.isArray(workflow['depends-on']) === true) ? workflow['depends-on'] : [];
+        const existingTargets = (workflow !== undefined && Array.isArray(workflow['targets']) === true) ? workflow['targets'] : [];
+        const existingScopes = (workflow !== undefined && Array.isArray(workflow['scopes']) === true) ? workflow['scopes'] : [];
         const templateChoices = libWorkflowTemplatesMetadata.map((entry) => ({
             title: entry['name'],
             description: entry['description'],
@@ -1278,6 +1280,18 @@ export class CliUtilityInitialize {
             }
             const triggersOutputResult = triggersOutput['result'];
             selectedTriggers = (Array.isArray(triggersOutputResult.triggers) === true) ? triggersOutputResult.triggers : [];
+            const scheduleVariants = selectedTriggers.filter((trigger) => trigger.startsWith('schedule-'));
+            if (scheduleVariants.length > 1) {
+                Logger.customize({
+                    name: 'CliUtilityInitialize.promptWorkflowsForm',
+                    purpose: 'validation',
+                    padTop: 1,
+                    padBottom: 1,
+                }).error(`Only one ${chalk.cyan('schedule-*')} trigger may be selected. Please try again.`);
+                return {
+                    action: 'back',
+                };
+            }
         }
         let selectedDependsOn = undefined;
         if (selectedTriggers.some((trigger) => trigger.startsWith('workflow-run')) === true) {
@@ -1310,9 +1324,213 @@ export class CliUtilityInitialize {
             }
         }
         const matchedMetadata = libWorkflowTemplatesMetadata.find((entry) => entry['name'] === selectedTemplate);
+        const workspaceKeys = Object.keys(config['workspaces'] ?? {});
+        const selectedTargets = [...existingTargets];
+        if (matchedMetadata !== undefined && matchedMetadata['supportsTargets'] === true) {
+            const targetsMetadata = matchedMetadata['targets'] ?? {};
+            const availableTargetTypes = Object.keys(targetsMetadata);
+            while (true) {
+                const targetMenuChoices = [];
+                for (let i = 0; i < selectedTargets.length; i += 1) {
+                    const currentTarget = selectedTargets[i];
+                    if (currentTarget === undefined) {
+                        continue;
+                    }
+                    const currentTargetType = currentTarget['type'];
+                    const currentTargetWorkingDir = currentTarget['workingDir'];
+                    targetMenuChoices.push({
+                        title: `${chalk.yellow.bold('[EDIT]')} ${currentTargetType} → ${currentTargetWorkingDir}`,
+                        value: {
+                            kind: 'edit',
+                            index: i,
+                        },
+                    });
+                    targetMenuChoices.push({
+                        title: `${chalk.red.bold('[REMOVE]')} ${currentTargetType} → ${currentTargetWorkingDir}`,
+                        value: {
+                            kind: 'remove',
+                            index: i,
+                        },
+                    });
+                }
+                targetMenuChoices.push({
+                    title: 'Add target',
+                    value: {
+                        kind: 'add',
+                    },
+                });
+                targetMenuChoices.push({
+                    title: 'Done',
+                    value: {
+                        kind: 'done',
+                    },
+                });
+                const targetMenuOutput = await CliUtilityInitialize.promptWithCancel({
+                    type: 'select',
+                    name: 'targetAction',
+                    message: (selectedTargets.length > 0) ? 'Select a target to manage.' : 'No targets added yet. Choose an option.',
+                    choices: targetMenuChoices,
+                });
+                if (targetMenuOutput['cancelled'] === true) {
+                    return {
+                        action: 'back',
+                    };
+                }
+                const targetMenuOutputResult = targetMenuOutput['result'];
+                const targetMenuAction = targetMenuOutputResult.targetAction;
+                if (targetMenuAction['kind'] === 'done') {
+                    break;
+                }
+                if (targetMenuAction['kind'] === 'remove') {
+                    const targetToRemoveIndex = targetMenuAction['index'];
+                    if (targetToRemoveIndex >= 0 && targetToRemoveIndex < selectedTargets.length) {
+                        selectedTargets.splice(targetToRemoveIndex, 1);
+                    }
+                    continue;
+                }
+                if (targetMenuAction['kind'] === 'add' || targetMenuAction['kind'] === 'edit') {
+                    const targetEditIndex = (targetMenuAction['kind'] === 'edit') ? targetMenuAction['index'] : -1;
+                    const targetToEdit = (targetEditIndex >= 0) ? selectedTargets[targetEditIndex] : undefined;
+                    const targetTypeInitial = (targetToEdit !== undefined) ? availableTargetTypes.indexOf(targetToEdit['type']) : 0;
+                    const targetTypeChoices = availableTargetTypes.map((availableTargetType) => ({
+                        title: availableTargetType,
+                        value: availableTargetType,
+                    }));
+                    const targetTypeOutput = await CliUtilityInitialize.promptWithCancel({
+                        type: 'select',
+                        name: 'targetType',
+                        message: 'Select a target type.',
+                        choices: targetTypeChoices,
+                        initial: (targetTypeInitial >= 0) ? targetTypeInitial : 0,
+                    });
+                    if (targetTypeOutput['cancelled'] === true) {
+                        continue;
+                    }
+                    const targetTypeOutputResult = targetTypeOutput['result'];
+                    const selectedTargetType = targetTypeOutputResult.targetType;
+                    const targetWorkingDirInitial = (targetToEdit !== undefined) ? workspaceKeys.indexOf(targetToEdit['workingDir']) : 0;
+                    const targetWorkingDirChoices = workspaceKeys.map((workspaceKey) => ({
+                        title: workspaceKey,
+                        value: workspaceKey,
+                    }));
+                    const targetWorkingDirOutput = await CliUtilityInitialize.promptWithCancel({
+                        type: 'select',
+                        name: 'targetWorkingDir',
+                        message: 'Select a working directory.',
+                        choices: targetWorkingDirChoices,
+                        initial: (targetWorkingDirInitial >= 0) ? targetWorkingDirInitial : 0,
+                    });
+                    if (targetWorkingDirOutput['cancelled'] === true) {
+                        continue;
+                    }
+                    const targetWorkingDirOutputResult = targetWorkingDirOutput['result'];
+                    const selectedTargetWorkingDir = targetWorkingDirOutputResult.targetWorkingDir;
+                    const targetIsDuplicate = selectedTargets.some((selectedTarget, selectedTargetIndex) => {
+                        if (selectedTargetIndex === targetEditIndex) {
+                            return false;
+                        }
+                        return selectedTarget['type'] === selectedTargetType && selectedTarget['workingDir'] === selectedTargetWorkingDir;
+                    });
+                    if (targetIsDuplicate === true) {
+                        Logger.customize({
+                            name: 'CliUtilityInitialize.promptWorkflowsForm',
+                            purpose: 'validation',
+                            padTop: 1,
+                            padBottom: 1,
+                        }).error(`Target ${chalk.cyan(`${selectedTargetType} → ${selectedTargetWorkingDir}`)} already exists.`);
+                        continue;
+                    }
+                    let selectedTargetNeeds = undefined;
+                    const targetToEditExistingNeeds = (targetToEdit !== undefined && Array.isArray(targetToEdit['needs']) === true) ? targetToEdit['needs'] : [];
+                    const targetNeedsChoices = selectedTargets
+                        .filter((candidate, candidateIndex) => {
+                        return candidate['type'] === selectedTargetType
+                            && candidateIndex !== targetEditIndex
+                            && candidate['workingDir'] !== selectedTargetWorkingDir;
+                    })
+                        .map((candidate) => ({
+                        title: candidate['workingDir'],
+                        value: candidate['workingDir'],
+                        selected: targetToEditExistingNeeds.includes(candidate['workingDir']),
+                    }));
+                    if (targetNeedsChoices.length > 0) {
+                        const targetNeedsOutput = await CliUtilityInitialize.promptWithCancel({
+                            type: 'multiselect',
+                            name: 'targetNeeds',
+                            message: 'Select targets this must wait for before publishing (optional).',
+                            choices: targetNeedsChoices,
+                        });
+                        if (targetNeedsOutput['cancelled'] === true) {
+                            continue;
+                        }
+                        const targetNeedsOutputResult = targetNeedsOutput['result'];
+                        selectedTargetNeeds = (Array.isArray(targetNeedsOutputResult.targetNeeds) === true && targetNeedsOutputResult.targetNeeds.length > 0) ? targetNeedsOutputResult.targetNeeds : undefined;
+                    }
+                    const newTarget = {
+                        type: selectedTargetType,
+                        workingDir: selectedTargetWorkingDir,
+                    };
+                    if (selectedTargetNeeds !== undefined) {
+                        Reflect.set(newTarget, 'needs', selectedTargetNeeds);
+                    }
+                    if (targetEditIndex >= 0) {
+                        Reflect.set(selectedTargets, targetEditIndex, newTarget);
+                    }
+                    else {
+                        selectedTargets.push(newTarget);
+                    }
+                    continue;
+                }
+            }
+        }
+        let selectedScopes = [];
+        if (matchedMetadata !== undefined && matchedMetadata['supportsScopes'] === true) {
+            const lockedPaths = new Set(selectedTargets.map((selectedTarget) => selectedTarget['workingDir']));
+            const extraWorkspaceKeys = workspaceKeys.filter((workspaceKey) => lockedPaths.has(workspaceKey) === false);
+            selectedScopes = [...lockedPaths];
+            if (extraWorkspaceKeys.length > 0) {
+                const scopeChoices = extraWorkspaceKeys.map((workspaceKey) => ({
+                    title: workspaceKey,
+                    value: workspaceKey,
+                    selected: existingScopes.includes(workspaceKey),
+                }));
+                const scopesOutput = await CliUtilityInitialize.promptWithCancel({
+                    type: 'multiselect',
+                    name: 'scopes',
+                    message: 'Select any EXTRA workspaces to check and build for this workflow.',
+                    choices: scopeChoices,
+                });
+                if (scopesOutput['cancelled'] === true) {
+                    return {
+                        action: 'back',
+                    };
+                }
+                const scopesOutputResult = scopesOutput['result'];
+                const extraScopes = (Array.isArray(scopesOutputResult.scopes) === true) ? scopesOutputResult.scopes : [];
+                for (const extraScope of extraScopes) {
+                    if (selectedScopes.includes(extraScope) === false) {
+                        selectedScopes.push(extraScope);
+                    }
+                }
+            }
+        }
         const settings = {};
         if (matchedMetadata !== undefined) {
-            const variableEntries = Object.entries(matchedMetadata['variables']);
+            const mergedVariables = { ...matchedMetadata['variables'] };
+            for (const selectedTarget of selectedTargets) {
+                const targetType = selectedTarget['type'];
+                const targetMetadata = matchedMetadata['targets'] ?? {};
+                const targetVariables = (targetMetadata[targetType] !== undefined) ? targetMetadata[targetType]['variables'] : {};
+                const targetVarEntries = Object.entries(targetVariables);
+                for (const entry of targetVarEntries) {
+                    const targetVarKey = entry[0];
+                    const targetVarValue = entry[1];
+                    if (mergedVariables[targetVarKey] === undefined) {
+                        Reflect.set(mergedVariables, targetVarKey, targetVarValue);
+                    }
+                }
+            }
+            const variableEntries = Object.entries(mergedVariables);
             for (const variableEntry of variableEntries) {
                 const variableName = variableEntry[0];
                 const variableConfig = variableEntry[1];
@@ -1370,6 +1588,12 @@ export class CliUtilityInitialize {
         if (selectedDependsOn !== undefined) {
             Reflect.set(resolvedWorkflow, 'depends-on', selectedDependsOn);
         }
+        if (selectedTargets.length > 0) {
+            Reflect.set(resolvedWorkflow, 'targets', selectedTargets);
+        }
+        if (selectedScopes.length > 0) {
+            Reflect.set(resolvedWorkflow, 'scopes', selectedScopes);
+        }
         if (Object.keys(settings).length > 0) {
             resolvedWorkflow.settings = settings;
         }