@fromeroc9/testform 1.0.3 → 1.0.4

package/dist/commands/plan.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCmd = void 0;
+exports.hashScenario = hashScenario;
+exports.calculatePlan = calculatePlan;
+const crypto_1 = require("crypto");
+const const_1 = require("../const");
+const chalk_1 = require("chalk");
+const resources_1 = require("../adapters/resources");
+const config_1 = require("../core/config");
+const parser_1 = require("../core/parser");
+const policy_1 = require("../core/policy");
+const state_1 = require("../core/state");
+const logger_1 = require("../logger");
+const fs_1 = require("fs");
+const refresh_1 = require("./refresh");
+const const_2 = require("../const");
+const utils_1 = require("../core/utils");
+const path_1 = require("path");
+/**
+ * Calculate the hash for a scenario (used for idempotency).
+ */
+function hashScenario(scenario) {
+    return (0, crypto_1.createHash)('sha256').update(JSON.stringify(scenario)).digest('hex');
+}
+/**
+ * Calculate a plan by comparing local .feature files against the state.
+ * This is a PURE READ-ONLY operation — state is never modified.
+ */
+async function calculatePlan(options) {
+    const { dir, scope, variables, statePath, backupPath, target, destroyPlan = false, refreshOnly = false, preLoadedState, lock = true, lockTimeout = '0s', replaceTargets, compactWarnings, testDirectory } = options;
+    const config = new config_1.Config(dir);
+    if (!Object.prototype.hasOwnProperty.call(const_2.SCOPE_CONFIG, scope)) {
+        throw new Error(`Invalid scope: ${scope}`);
+    }
+    const scopeCfg = const_2.SCOPE_CONFIG[scope];
+    const RESOURCE_TYPE = scopeCfg.resource;
+    const parseDir = testDirectory ? (0, path_1.join)(dir, testDirectory) : dir;
+    const parser = new parser_1.Parser(parseDir, variables);
+    const documents = parser.content();
+    const matchesScope = (s, scopeName) => {
+        if (!Object.prototype.hasOwnProperty.call(const_2.SCOPE_CONFIG, scopeName))
+            return false;
+        const cfg = const_2.SCOPE_CONFIG[scopeName];
+        return s.feature?.tags?.includes(cfg.tag) || s.uri.endsWith(cfg.ext);
+    };
+    // Only process scenarios that match the requested scope
+    let rawScenarios = documents.filter(s => matchesScope(s, scope));
+    const data = {
+        identity: config.getIdentity(scope),
+        fields: config.getFields(scope),
+    };
+    let filtered = parser.filter(rawScenarios, data, scope) || [];
+    if (target) {
+        filtered = filtered.filter(s => {
+            const id = s.custom?.identity ? `${s.uri}::${s.custom.identity}` : '';
+            return id === target || id.startsWith(`${target}::`) || id.endsWith(`/${target}`) || id.endsWith(target);
+        });
+    }
+    if (destroyPlan) {
+        // If destroy, we treat local scenarios as empty
+        // to force destruction of everything.
+        filtered = [];
+    }
+    // If refresh-only, policy scanning might not be relevant for empty local state, but we already filtered it.
+    const hasViolations = policy_1.policy.scanner(filtered, scope, false, compactWarnings);
+    if (hasViolations) {
+        const err = new Error("Please fix them before continuing.");
+        err.name = "Policy violations found";
+        throw err;
+    }
+    // Load state (read-only)
+    const state = preLoadedState || new state_1.State(dir, statePath, backupPath);
+    if (!preLoadedState) {
+        await state.init();
+        await state.acquireLock(lock, lockTimeout);
+    }
+    let resources = state.getResources(RESOURCE_TYPE);
+    if (target) {
+        resources = resources.filter(r => r.identity === target || r.identity.startsWith(`${target}::`) || r.identity.endsWith(`/${target}`) || r.identity.endsWith(target));
+    }
+    if (refreshOnly) {
+        return {
+            changes: [],
+            state,
+            hasChanges: false,
+        };
+    }
+    for (const res of resources) {
+        // Display refreshing text
+        const remoteIdPart = res.attributes.remoteId ? `[id=${res.attributes.remoteId}]` : '';
+        console.log((0, chalk_1.bold)(`${(0, utils_1.formatResourceAddress)(res.type, res.identity)}: Refreshing state... ${remoteIdPart}`));
+    }
+    console.log("");
+    // Build a lookup map for O(1) access by identity
+    const stateMap = new Map(resources.map(r => [r.identity, r]));
+    // Track which identities exist locally
+    const localIds = new Set();
+    const changes = [];
+    // Check for creates and updates
+    for (const scenario of filtered) {
+        let identity;
+        const rawIdentity = scenario.custom?.identity;
+        if (!rawIdentity)
+            continue;
+        if (rawIdentity.includes('::')) {
+            identity = rawIdentity;
+        }
+        else if (rawIdentity === scenario.uri) {
+            identity = rawIdentity;
+        }
+        else {
+            identity = `${scenario.uri}::${rawIdentity}`;
+        }
+        localIds.add(identity);
+        const localHash = hashScenario(scenario);
+        const existing = stateMap.get(identity);
+        const shouldForceReplace = replaceTargets
+            ? (Array.isArray(replaceTargets)
+                ? replaceTargets.some(t => identity === t || identity.startsWith(`${t}::`) || identity.endsWith(`/${t}`) || identity.endsWith(t))
+                : (identity === replaceTargets || identity.startsWith(`${replaceTargets}::`) || identity.endsWith(`/${replaceTargets}`) || identity.endsWith(replaceTargets)))
+            : false;
+        if (!existing) {
+            // New resource — needs to be created
+            changes.push({
+                action: 'add',
+                identity,
+                resourceType: RESOURCE_TYPE,
+                scenario,
+                localHash,
+            });
+        }
+        else if (existing.tainted || shouldForceReplace) {
+            // Tainted or forced replace resource — needs to be replaced
+            changes.push({
+                action: 'replace',
+                identity,
+                resourceType: RESOURCE_TYPE,
+                scenario,
+                remoteId: existing.attributes.remoteId,
+                issueNumber: existing.attributes.issueNumber,
+                localHash,
+                oldAttributes: existing.attributes,
+            });
+        }
+        else if (existing.attributes.localHash !== localHash) {
+            // Changed resource — needs to be updated
+            changes.push({
+                action: 'change',
+                identity,
+                resourceType: RESOURCE_TYPE,
+                scenario,
+                remoteId: existing.attributes.remoteId,
+                issueNumber: existing.attributes.issueNumber,
+                localHash,
+                oldAttributes: existing.attributes,
+            });
+        }
+        // If hashes match → synced, no action needed
+    }
+    // Check for destroys (in state but not in local files)
+    for (const res of resources) {
+        if (!localIds.has(res.identity)) {
+            // Create a minimal scenario from state for display
+            changes.push({
+                action: 'destroy',
+                identity: res.identity,
+                resourceType: RESOURCE_TYPE,
+                scenario: (scope === 'testrun' || scope === 'testplan') ? {
+                    uri: '(state)',
+                    feature: { tags: [], keyword: '', name: res.attributes.title, description: '', location: 0 },
+                    location: 0,
+                    keyword: '',
+                    name: res.attributes.title,
+                    description: '',
+                    steps: [],
+                    tags: Array.isArray(res.attributes.labels) ? res.attributes.labels : (res.attributes.labels ? String(res.attributes.labels).split(',') : []),
+                    custom: { identity: res.identity },
+                } : {
+                    uri: '(state)',
+                    feature: { tags: [], keyword: '', name: '', description: '', location: 0 },
+                    location: 0,
+                    keyword: '',
+                    name: res.attributes.title,
+                    description: '',
+                    steps: [],
+                    tags: res.attributes.labels,
+                    custom: { identity: res.identity },
+                },
+                remoteId: res.attributes.remoteId,
+                issueNumber: res.attributes.issueNumber,
+                localHash: res.attributes.localHash,
+            });
+        }
+    }
+    return { changes, hasChanges: changes.length > 0, state };
+}
+const planCmd = async (options) => {
+    const { dir = '.', verbose = false, scope, outPath, lock = true, lockTimeout = '0s', variables, isJson = false, detailedExitCode = false, statePath, backupPath, target, destroyPlan = false, refresh = true, refreshOnly = false, replaceTargets, parallelism, compactWarnings = false, testDirectory } = options;
+    const logger = new logger_1.Logger(verbose);
+    const stateObj = new state_1.State(dir, statePath, backupPath);
+    await stateObj.init();
+    await stateObj.acquireLock(lock, lockTimeout);
+    let plan;
+    try {
+        if (refresh && !destroyPlan) {
+            if (!isJson)
+                console.log(const_1.MSG_ACQUIRING_LOCK);
+            await (0, refresh_1.refreshState)({ dir, scope, state: stateObj, logger, silent: isJson, parallelismRaw: parallelism, target });
+        }
+        plan = await calculatePlan({
+            dir, scope, variables, statePath, backupPath, target, destroyPlan, refreshOnly, preLoadedState: stateObj, lock, lockTimeout, replaceTargets, compactWarnings, testDirectory
+        });
+        if (isJson) {
+            const planData = {
+                testform_version: const_2.VERSION_CLI,
+                scope: scope,
+                changes: plan.changes
+            };
+            console.log(JSON.stringify(planData, null, 2));
+        }
+        else {
+            resources_1.resource.summary(plan.changes, true, { state: plan.state, outPath });
+        }
+    }
+    finally {
+        await stateObj.releaseLock();
+    }
+    if (outPath) {
+        const path = require('path');
+        const resolvedOutPath = path.resolve(dir, outPath);
+        const planData = {
+            testform_version: const_2.VERSION_CLI,
+            scope: scope,
+            changes: plan.changes
+        };
+        try {
+            (0, fs_1.writeFileSync)(resolvedOutPath, JSON.stringify(planData, null, 2), 'utf-8');
+            console.log(`\nSaved the plan to: ${outPath}\n\nTo perform exactly these actions, run the following command to apply:\n    testform apply "${outPath}"`);
+        }
+        catch (e) {
+            logger.error(`Failed to write plan to ${resolvedOutPath}: ${e.message}`);
+        }
+    }
+    if (detailedExitCode) {
+        process.exitCode = plan.hasChanges ? 2 : 0;
+    }
+    return plan;
+};
+exports.planCmd = planCmd;

package/dist/commands/refresh.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * @fileoverview `testform refresh` command.
+ *
+ * Synchronizes the local state file against the remote GitHub repository
+ * by checking each tracked issue's current status and updating or removing
+ * stale state entries.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshCmd = exports.refreshState = void 0;
+const chalk_1 = require("chalk");
+const github_1 = require("../adapters/github");
+const config_1 = require("../core/config");
+const state_1 = require("../core/state");
+const logger_1 = require("../logger");
+const notify_1 = require("../notify");
+const const_1 = require("../const");
+const refreshState = async (options) => {
+    const { dir, scope, state, logger, silent = false, parallelismRaw, target } = options;
+    if (!Object.prototype.hasOwnProperty.call(const_1.SCOPE_RESOURCE_MAP, scope)) {
+        throw new Error(`Invalid scope: ${scope}`);
+    }
+    const resourceType = const_1.SCOPE_RESOURCE_MAP[scope];
+    let resources = state.getResources(resourceType);
+    if (target) {
+        resources = resources.filter(r => r.identity === target || r.identity.startsWith(`${target}::`) || r.identity.endsWith(`/${target}`) || r.identity.endsWith(target));
+    }
+    if (resources.length === 0) {
+        await state.save();
+        if (!silent)
+            console.log('No resources in state to refresh.');
+        return;
+    }
+    const config = new config_1.Config(dir);
+    const ghConfig = config.getGitHub();
+    if (!ghConfig) {
+        if (!silent) {
+            notify_1.notify.push({
+                type: 'error',
+                title: 'GitHub configuration not found',
+                detail: [const_1.ERR_GITHUB_CONFIG_NOT_FOUND],
+                close: true,
+            });
+        }
+        return;
+    }
+    const github = new github_1.GitHubAdapter(ghConfig);
+    let refreshed = 0;
+    let removed = 0;
+    const parallelism = parallelismRaw ? parseInt(String(parallelismRaw), 10) || 10 : 10;
+    for (let i = 0; i < resources.length; i += parallelism) {
+        const batch = resources.slice(i, i + parallelism);
+        await Promise.all(batch.map(async (res) => {
+            const remoteId = res.attributes.remoteId ?? '';
+            const { formatResourceAddress } = require('../core/utils');
+            if (!silent)
+                console.log(`${formatResourceAddress(res.type, res.identity)}: Refreshing state... ${(0, chalk_1.dim)(`[id=${remoteId}]`)}`);
+            try {
+                if (!res.attributes.issueNumber) {
+                    if (!silent)
+                        console.log((0, chalk_1.yellow)(`  ${res.identity}: No issue number — removing from state`));
+                    state.removeResource(res.identity);
+                    removed++;
+                    return;
+                }
+                const issue = await github.getIssue(res.attributes.issueNumber);
+                if (!issue) {
+                    if (!silent)
+                        console.log((0, chalk_1.red)(`  ${res.identity}: Issue #${res.attributes.issueNumber} not found — removing from state`));
+                    state.removeResource(res.identity);
+                    removed++;
+                }
+                else {
+                    let driftDetected = false;
+                    // Sync title
+                    if (res.attributes.title !== issue.title) {
+                        res.attributes.title = issue.title;
+                        driftDetected = true;
+                    }
+                    // Helper to compare string arrays case-insensitively
+                    const arraysEqual = (a = [], b = []) => {
+                        if (a.length !== b.length)
+                            return false;
+                        const sortedA = [...a].sort();
+                        const sortedB = [...b].sort();
+                        return sortedA.every((val, index) => val === sortedB[index]);
+                    };
+                    const remoteLabels = issue.labels ?? [];
+                    const localLabels = Array.isArray(res.attributes.labels) ? res.attributes.labels : (res.attributes.labels ? String(res.attributes.labels).split(',') : []);
+                    if (!arraysEqual(localLabels, remoteLabels)) {
+                        res.attributes.labels = remoteLabels;
+                        driftDetected = true;
+                    }
+                    const remoteAssignees = issue.assignees ?? [];
+                    const localAssignees = Array.isArray(res.attributes.assignees) ? res.attributes.assignees : (res.attributes.assignees ? String(res.attributes.assignees).split(',') : []);
+                    if (!arraysEqual(localAssignees, remoteAssignees)) {
+                        res.attributes.assignees = remoteAssignees;
+                        driftDetected = true;
+                    }
+                    const remoteMilestone = issue.milestone ?? '';
+                    const localMilestone = String(res.attributes.milestone ?? '');
+                    if (localMilestone !== remoteMilestone) {
+                        res.attributes.milestone = remoteMilestone;
+                        driftDetected = true;
+                    }
+                    // Fetch custom fields
+                    if (issue.node_id) {
+                        const remoteCustomFields = await github.getProjectItemFields(issue.node_id);
+                        const localCustomFields = res.attributes.custom_fields || {};
+                        // Check all local custom fields to see if they changed or were cleared on remote
+                        for (const localKey of Object.keys(localCustomFields)) {
+                            // Find the remote value (case insensitive match)
+                            const remoteKeyMatch = Object.keys(remoteCustomFields).find(k => k.toLowerCase() === localKey.toLowerCase());
+                            const remoteVal = remoteKeyMatch ? remoteCustomFields[remoteKeyMatch] : '';
+                            const localVal = String(Object.prototype.hasOwnProperty.call(localCustomFields, localKey) ? localCustomFields[localKey] : '');
+                            // Clean prefix '@' if present for comparison
+                            const cleanLocalVal = localVal.startsWith('@') ? localVal.substring(1).toLowerCase() : localVal.toLowerCase();
+                            const cleanRemoteVal = remoteVal.toLowerCase();
+                            if (cleanLocalVal !== cleanRemoteVal) {
+                                Object.assign(localCustomFields, { [localKey]: remoteVal });
+                                driftDetected = true;
+                            }
+                        }
+                        res.attributes.custom_fields = localCustomFields;
+                    }
+                    if (driftDetected) {
+                        // Invalidate localHash to force a plan diff
+                        res.attributes.localHash = 'drift_detected';
+                        state.upsertResource(res);
+                    }
+                    refreshed++;
+                }
+            }
+            catch (error) {
+                if (!silent) {
+                    notify_1.notify.push({
+                        type: 'warning',
+                        title: `Failed to refresh ${res.identity}: ${error.message}`,
+                        detail: [],
+                    });
+                }
+            }
+        }));
+    }
+    await state.save();
+    if (!silent) {
+        console.log('');
+        console.log((0, chalk_1.green)((0, chalk_1.bold)(`Refresh complete! ${refreshed} resource(s) refreshed, ${removed} removed.`)));
+    }
+};
+exports.refreshState = refreshState;
+const refreshCmd = async (options) => {
+    const { dir = '.', verbose = false, scope, lock = true, lockTimeout = '0s', statePath, backupPath, parallelismRaw, compactWarnings, target } = options;
+    const logger = new logger_1.Logger(verbose);
+    const stateObj = new state_1.State(dir, statePath, backupPath);
+    await stateObj.init();
+    await stateObj.acquireLock(lock, lockTimeout);
+    try {
+        await (0, exports.refreshState)({ dir, scope, state: stateObj, logger, silent: false, parallelismRaw, target });
+    }
+    finally {
+        await stateObj.releaseLock();
+    }
+};
+exports.refreshCmd = refreshCmd;