@fromeroc9/testform 1.0.2 → 1.0.4

package/dist/core/backends/s3.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3Backend = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const crypto_1 = require("crypto");
+const const_1 = require("../../const");
+class S3Backend {
+    config;
+    workspace;
+    s3;
+    dynamo;
+    originalKey;
+    constructor(config, workspace = 'default') {
+        this.config = config;
+        this.workspace = workspace;
+        const clientConfig = { region: config.region || process.env.AWS_REGION || 'us-east-1' };
+        if (config.profile === 'local') {
+            clientConfig.endpoint = config.region && config.region.startsWith('http') ? config.region : 'http://localhost:4566';
+            clientConfig.region = process.env.AWS_REGION || 'us-east-1';
+            clientConfig.forcePathStyle = true;
+            clientConfig.credentials = {
+                accessKeyId: 'test',
+                secretAccessKey: 'test'
+            };
+        }
+        // Profiles are usually handled by the SDK automatically if AWS_PROFILE is set,
+        // or through credential providers, but for simplicity we rely on the default provider chain.
+        this.s3 = new client_s3_1.S3Client(clientConfig);
+        if (config.dynamodb_table) {
+            this.dynamo = new client_dynamodb_1.DynamoDBClient(clientConfig);
+        }
+        this.config.key = this.config.key || const_1.FILE_STATE;
+        this.originalKey = this.config.key;
+        if (this.workspace !== 'default') {
+            this.config.key = `env:/${this.workspace}/${this.originalKey}`;
+        }
+    }
+    async exists() {
+        try {
+            await this.s3.send(new client_s3_1.HeadObjectCommand({ Bucket: this.config.bucket, Key: this.config.key }));
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async read() {
+        try {
+            const command = new client_s3_1.GetObjectCommand({
+                Bucket: this.config.bucket,
+                Key: this.config.key,
+            });
+            const response = await this.s3.send(command);
+            const raw = await response.Body?.transformToString();
+            if (!raw) {
+                return this.emptyState();
+            }
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            if (err instanceof client_s3_1.NoSuchKey || err.name === 'NoSuchKey' || err.Code === 'NoSuchKey') {
+                return this.emptyState();
+            }
+            throw err;
+        }
+    }
+    async write(state) {
+        const command = new client_s3_1.PutObjectCommand({
+            Bucket: this.config.bucket,
+            Key: this.config.key,
+            Body: JSON.stringify(state, null, 2),
+            ContentType: 'application/json',
+        });
+        await this.s3.send(command);
+    }
+    async lock(timeoutRaw) {
+        if (!this.dynamo || !this.config.dynamodb_table) {
+            // If no dynamodb table is configured, locking is bypassed (or purely optimistic).
+            return true;
+        }
+        const timeoutMatch = timeoutRaw.match(/^(\d+)s$/);
+        const timeoutMs = timeoutMatch ? parseInt(timeoutMatch[1], 10) * 1000 : 0;
+        const start = Date.now();
+        const lockId = (0, crypto_1.randomUUID)();
+        const item = {
+            LockID: { S: this.config.bucket + '/' + this.config.key },
+            Info: { S: JSON.stringify({
+                    id: lockId,
+                    operation: 'Operation',
+                    who: process.env.USER || 'unknown',
+                    created: new Date().toISOString()
+                }) }
+        };
+        while (true) {
+            try {
+                // Try to acquire lock
+                await this.dynamo.send(new client_dynamodb_1.PutItemCommand({
+                    TableName: this.config.dynamodb_table,
+                    Item: item,
+                    ConditionExpression: 'attribute_not_exists(LockID)'
+                }));
+                return true;
+            }
+            catch (err) {
+                if (err instanceof client_dynamodb_1.ConditionalCheckFailedException || err.name === 'ConditionalCheckFailedException') {
+                    if (Date.now() - start >= timeoutMs) {
+                        return false;
+                    }
+                    await new Promise(r => setTimeout(r, 1000));
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    async unlock() {
+        if (!this.dynamo || !this.config.dynamodb_table)
+            return true;
+        try {
+            await this.dynamo.send(new client_dynamodb_1.DeleteItemCommand({
+                TableName: this.config.dynamodb_table,
+                Key: { LockID: { S: this.config.bucket + '/' + this.config.key } }
+            }));
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async forceUnlock(lockId) {
+        if (!this.dynamo || !this.config.dynamodb_table) {
+            return { success: false, error: 'DynamoDB locking is not configured for this backend.' };
+        }
+        try {
+            const response = await this.dynamo.send(new client_dynamodb_1.GetItemCommand({
+                TableName: this.config.dynamodb_table,
+                Key: { LockID: { S: this.config.bucket + '/' + this.config.key } }
+            }));
+            if (!response.Item || !response.Item.Info) {
+                return { success: false, error: 'No lock exists for the given state.' };
+            }
+            const info = JSON.parse(response.Item.Info.S);
+            if (info.id !== lockId) {
+                return { success: false, currentLockId: info.id };
+            }
+            await this.dynamo.send(new client_dynamodb_1.DeleteItemCommand({
+                TableName: this.config.dynamodb_table,
+                Key: { LockID: { S: this.config.bucket + '/' + this.config.key } }
+            }));
+            return { success: true };
+        }
+        catch (e) {
+            return { success: false, error: `Failed to force unlock: ${e.message}` };
+        }
+    }
+    async isLocked() {
+        if (!this.dynamo || !this.config.dynamodb_table)
+            return false;
+        try {
+            const response = await this.dynamo.send(new client_dynamodb_1.GetItemCommand({
+                TableName: this.config.dynamodb_table,
+                Key: { LockID: { S: this.config.bucket + '/' + this.config.key } }
+            }));
+            return !!response.Item;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    emptyState() {
+        return {
+            version: const_1.VERSION_STATE,
+            serial: 0,
+            lineage: (0, crypto_1.randomUUID)(),
+            lastSync: '',
+            resources: [],
+        };
+    }
+    async listWorkspaces() {
+        const workspaces = new Set(['default']);
+        try {
+            const { ListObjectsV2Command } = await import('@aws-sdk/client-s3');
+            const command = new ListObjectsV2Command({
+                Bucket: this.config.bucket,
+                Prefix: 'env:/'
+            });
+            const response = await this.s3.send(command);
+            if (response.Contents) {
+                for (const item of response.Contents) {
+                    if (item.Key) {
+                        const match = item.Key.match(/^env:\/([^\/]+)\//);
+                        if (match) {
+                            workspaces.add(match[1]);
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Ignore error and just return what we have (fallback to local knowledge basically)
+        }
+        return Array.from(workspaces);
+    }
+    async deleteWorkspace(name) {
+        if (name === 'default')
+            return false;
+        try {
+            const { DeleteObjectCommand } = await import('@aws-sdk/client-s3');
+            const targetKey = `env:/${name}/${this.originalKey}`;
+            const command = new DeleteObjectCommand({
+                Bucket: this.config.bucket,
+                Key: targetKey
+            });
+            await this.s3.send(command);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+exports.S3Backend = S3Backend;

package/dist/core/command-context.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * @fileoverview Shared command context factory.
+ *
+ * Centralizes the repetitive boilerplate of initializing State, acquiring
+ * the state lock, loading configuration, and constructing a GitHubAdapter.
+ * Every command that needs GitHub access should use `createCommandContext()`
+ * instead of repeating this pattern inline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandContext = createCommandContext;
+const github_1 = require("../adapters/github");
+const config_1 = require("./config");
+const state_1 = require("./state");
+const logger_1 = require("../logger");
+const notify_1 = require("../notify");
+const const_1 = require("../const");
+/**
+ * Creates a fully initialized command context.
+ *
+ * Initializes the state file, acquires the lock, loads the testform.json
+ * configuration, and constructs an authenticated GitHubAdapter. Returns `null`
+ * (and emits an error notification) if GitHub configuration is missing unless
+ * `silent` is set.
+ *
+ * @param options - Context creation options.
+ * @returns Initialized context, or `null` if GitHub config is absent.
+ *
+ * @example
+ * const ctx = await createCommandContext({ dir, verbose, lock, lockTimeout });
+ * if (!ctx) return;
+ * try {
+ *     await ctx.github.createIssue({ ... });
+ * } finally {
+ *     await ctx.state.releaseLock();
+ * }
+ */
+async function createCommandContext(options = {}) {
+    const { dir = '.', verbose = false, statePath, backupPath, lock = true, lockTimeout = '0s', silent = false, } = options;
+    const logger = new logger_1.Logger(verbose);
+    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 null;
+    }
+    const state = new state_1.State(dir, statePath, backupPath);
+    await state.init();
+    await state.acquireLock(lock, lockTimeout);
+    const github = new github_1.GitHubAdapter(ghConfig);
+    return { state, github, config, logger };
+}

package/dist/core/config.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const const_1 = require("../const");
+const notify_1 = require("../notify");
+class Config {
+    dir;
+    config = {};
+    constructor(dir) {
+        this.dir = dir;
+        this.required();
+    }
+    resolve() {
+        let currentDir = (0, path_1.resolve)(this.dir);
+        const rootDir = (0, path_1.resolve)('/');
+        while (currentDir !== rootDir) {
+            const configPath = (0, path_1.resolve)(currentDir, const_1.FILE_CONFIG);
+            if ((0, fs_1.existsSync)(configPath)) {
+                return configPath;
+            }
+            const parentDir = (0, path_1.resolve)(currentDir, '..');
+            if (parentDir === currentDir)
+                break;
+            currentDir = parentDir;
+        }
+        const cwd = (0, path_1.resolve)(process.cwd(), const_1.FILE_CONFIG);
+        return (0, fs_1.existsSync)(cwd) ? cwd : null;
+    }
+    load(resolve) {
+        const raw = (0, fs_1.readFileSync)(resolve, "utf-8");
+        this.config = JSON.parse(raw);
+        return this.config;
+    }
+    getConfig() {
+        return this.config;
+    }
+    getGitHub() {
+        const github = this.config.github;
+        if (!github)
+            return undefined;
+        return {
+            owner: github.owner,
+            repository: github.repository,
+            projectId: github.projectId || github.project_id,
+            tokenEnv: github.tokenEnv || github.token_env || 'GITHUB_TOKEN'
+        };
+    }
+    getBackend() {
+        return this.config.backend;
+    }
+    getIdentity(scope) {
+        const scopeConf = this.config.scope && Object.prototype.hasOwnProperty.call(this.config.scope, scope) ? this.config.scope[scope] : undefined;
+        const id = scopeConf?.identity;
+        if (scope == "testcase")
+            return id ?? "tc-*";
+        if (scope == "testrun")
+            return id ?? "tr-*";
+        if (scope == "testplan")
+            return id ?? "tp-*";
+    }
+    getConvention(scope) {
+        const globalConf = this.config.scope && Object.prototype.hasOwnProperty.call(this.config.scope, 'global') ? this.config.scope['global'] : undefined;
+        const scopeConf = this.config.scope && Object.prototype.hasOwnProperty.call(this.config.scope, scope) ? this.config.scope[scope] : undefined;
+        // Merge convention: scope overrides global
+        if (!globalConf?.convention && !scopeConf?.convention)
+            return undefined;
+        return {
+            ...(globalConf?.convention || {}),
+            ...(scopeConf?.convention || {})
+        };
+    }
+    getReportMapping(key) {
+        return this.config.report_mapping ? this.config.report_mapping[key] : undefined;
+    }
+    getFields(scope) {
+        const globalConf = this.config.scope && Object.prototype.hasOwnProperty.call(this.config.scope, 'global') ? this.config.scope['global'] : undefined;
+        const globalFields = globalConf?.fields ?? [];
+        const scopeConf = this.config.scope && Object.prototype.hasOwnProperty.call(this.config.scope, scope) ? this.config.scope[scope] : undefined;
+        const scopeFields = scopeConf?.fields ?? [];
+        // Merge fields, giving precedence to scope-specific fields
+        const fieldMap = new Map();
+        for (const f of globalFields) {
+            if (f.name)
+                fieldMap.set(f.name.toLowerCase(), f);
+        }
+        for (const f of scopeFields) {
+            if (f.name)
+                fieldMap.set(f.name.toLowerCase(), f);
+        }
+        return Array.from(fieldMap.values());
+    }
+    required() {
+        const resolve = this.resolve();
+        if (!resolve) {
+            notify_1.notify.push({
+                type: 'error',
+                title: 'No configuration files',
+                detail: [
+                    'Plan requires configuration to be present. Planning without a configuration would mark everything for',
+                    'destruction, which is normally not what is desired. If you would like to destroy everything, run plan with the',
+                    `-destroy option. Otherwise, create a ${const_1.TITLE_APP} configuration file (.json file) and try again.`
+                ],
+                close: true
+            });
+        }
+        const config = this.load(resolve);
+        const version = config.version ?? "";
+        if (version == null) {
+            notify_1.notify.push({
+                type: 'error',
+                title: `${const_1.FILE_CONFIG} is missing the "version" field`,
+                detail: [`Add a "version" field to your ${const_1.FILE_CONFIG} file and rerun init.`],
+                close: true
+            });
+        }
+        if (version !== const_1.VERSION_CONFIG) {
+            notify_1.notify.push({
+                type: 'error',
+                title: `configuration version mismatch`,
+                detail: [
+                    `Found version "${this.config.version}", but expected "${const_1.VERSION_CONFIG}".`,
+                    `Update ${const_1.FILE_CONFIG} to version ${const_1.VERSION_CONFIG} and rerun init.`,
+                ],
+                close: true
+            });
+        }
+    }
+}
+exports.Config = Config;

package/dist/core/credentials.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Credentials = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+class Credentials {
+    credsPath;
+    constructor() {
+        const home = (0, os_1.homedir)();
+        const configDir = (0, path_1.join)(home, '.testform.d');
+        if (!(0, fs_1.existsSync)(configDir)) {
+            (0, fs_1.mkdirSync)(configDir, { recursive: true });
+        }
+        this.credsPath = (0, path_1.join)(configDir, 'credentials.json');
+    }
+    load() {
+        if (!(0, fs_1.existsSync)(this.credsPath)) {
+            return { credentials: {} };
+        }
+        try {
+            const raw = (0, fs_1.readFileSync)(this.credsPath, 'utf8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return { credentials: {} };
+        }
+    }
+    save(data) {
+        (0, fs_1.writeFileSync)(this.credsPath, JSON.stringify(data, null, 2), 'utf8');
+    }
+    getToken(hostname = 'github.com') {
+        const data = this.load();
+        return data.credentials?.[hostname]?.token;
+    }
+    setToken(hostname = 'github.com', token) {
+        const data = this.load();
+        if (!data.credentials)
+            data.credentials = {};
+        data.credentials[hostname] = { token };
+        this.save(data);
+    }
+    removeToken(hostname = 'github.com') {
+        const data = this.load();
+        if (data.credentials?.[hostname]) {
+            delete data.credentials[hostname];
+            this.save(data);
+            return true;
+        }
+        return false;
+    }
+}
+exports.Credentials = Credentials;

package/dist/core/parser.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * @fileoverview Parser facade.
+ *
+ * Provides a unified interface to the specialized Gherkin parsers.
+ * Delegates parsing and filtering logic based on the requested scope
+ * to maintain backward compatibility with existing commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const base_parser_1 = require("./parsers/base-parser");
+const testcase_parser_1 = require("./parsers/testcase-parser");
+const testrun_parser_1 = require("./parsers/testrun-parser");
+const testplan_parser_1 = require("./parsers/testplan-parser");
+/**
+ * Minimal concrete implementation of BaseParser to handle reading
+ * and formatting feature files before filtering.
+ */
+class ReaderParser extends base_parser_1.BaseParser {
+    filter(scenarios) {
+        return scenarios;
+    }
+}
+class Parser {
+    dir;
+    variables;
+    reader;
+    constructor(dir, variables) {
+        this.dir = dir;
+        this.variables = variables;
+        this.reader = new ReaderParser(dir, variables);
+    }
+    /**
+     * Reads and parses all feature files in the directory.
+     * @returns Raw, un-filtered parser scenarios.
+     */
+    content() {
+        return this.reader.content();
+    }
+    /**
+     * Filters and enriches raw scenarios based on the given scope and DSL test config.
+     */
+    filter(scenarios, test, scope) {
+        let delegate;
+        switch (scope) {
+            case 'testcase':
+                delegate = new testcase_parser_1.TestcaseParser(this.dir, this.variables);
+                break;
+            case 'testrun':
+                delegate = new testrun_parser_1.TestrunParser(this.dir, this.variables);
+                break;
+            case 'testplan':
+                delegate = new testplan_parser_1.TestplanParser(this.dir, this.variables);
+                break;
+            default:
+                // Fallback to testcase parser logic for unknown scopes
+                delegate = new testcase_parser_1.TestcaseParser(this.dir, this.variables);
+        }
+        return delegate.filter(scenarios, test, scope);
+    }
+}
+exports.Parser = Parser;