@dev-blinq/cucumber-js 1.0.36 → 1.0.37-stage

package/bin/download-install.js

@@ -1,9 +1,14 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable no-console */
+/* eslint-disable no-undef */
 const { argv } = require('node:process')
 const fs = require('fs')
 const path = require('path')
 const JSZip = require('jszip')
 const { mkdirSync, writeFileSync } = require('node:fs')
 const axios = require('axios').default
+const tunnel = require('tunnel')
+
 let token = null
 let extractPath = null
 const getSSoUrl = () => {
@@ -12,17 +17,40 @@ const getSSoUrl = () => {
       return 'http://localhost:5000/api/auth'
     case 'dev':
       return 'https://dev.api.blinq.io/api/auth'
+    case 'stage':
+      return 'https://stage.api.blinq.io/api/auth'
     default:
       return 'https://api.blinq.io/api/auth'
   }
 }
 
+const getProxy = () => {
+  if (!process.env.PROXY) {
+    return null
+  }
+
+  const proxy = process.env.PROXY
+  const url = new URL(proxy)
+  const proxyObject = {
+    host: url.hostname,
+    port: Number(url.port),
+  }
+
+  const { username, password } = url
+
+  if (username && password) {
+    proxyObject.proxyAuth = `${username}:${password}`
+  }
+  return tunnel.httpsOverHttp({ proxy: proxyObject })
+}
 const getWorkSpaceUrl = () => {
   switch (process.env.NODE_ENV_BLINQ) {
     case 'local':
       return 'http://localhost:6000/api/workspace'
     case 'dev':
       return 'https://dev.api.blinq.io/api/workspace'
+    case "stage":
+      return 'https://stage.api.blinq.io/api/workspace'
     default:
       return 'https://api.blinq.io/api/workspace'
   }
@@ -77,26 +105,34 @@ const dirExists = (path) => {
 }
 const ssoUrl = getSSoUrl()
 
+const getProjectByAccessKey = async (access_key) => {
+  const accessKeyUrl = `${ssoUrl}/getProjectByAccessKey`
+  const response = await axios.post(accessKeyUrl, {
+    access_key,
+    httpAgent: getProxy(),
+    proxy: false,
+  })
+  if (response.status !== 200) {
+    console.error('Error: Invalid access key')
+    process.exit(1)
+  }
+  return response.data
+};
+
 const downloadAndInstall = async (extractPath, token) => {
   if (!dirExists(extractPath)) {
     fs.mkdirSync(extractPath, { recursive: true })
   }
   try {
-    const accessKeyUrl = `${ssoUrl}/getProjectByAccessKey`
-    const response = await axios.post(accessKeyUrl, {
-      access_key: token,
-    })
-    if(response.status !== 200){
-      console.error('Error: Invalid access key')
-      process.exit(1)
-    }
+    const data = await getProjectByAccessKey(token)
 
     const workspaceUrl = getWorkSpaceUrl() + '/pull-workspace'
-
     const res = await axios.get(workspaceUrl, {
       params: {
-        projectId: response.data.project._id,
+        projectId: data.project._id,
       },
+      httpAgent: getProxy(),
+      proxy: false,
       responseType: 'arraybuffer',
       headers: {
         Authorization: `Bearer ${token}`,
@@ -104,6 +140,11 @@ const downloadAndInstall = async (extractPath, token) => {
       },
     })
 
+    if (res.status !== 200) {
+      console.error('Error: Unable to fetch workspace')
+      process.exit(1)
+    }
+
     const zip = await JSZip.loadAsync(res.data)
     for (const filename of Object.keys(zip.files)) {
       const fileData = zip.files[filename]

package/lib/api/console_logger.d.ts

@@ -1,12 +1,12 @@
-/// <reference types="node" />
-import { Writable } from 'stream';
-import { ILogger } from '../logger';
-export declare class ConsoleLogger implements ILogger {
-    private stream;
-    private debugEnabled;
-    private console;
-    constructor(stream: Writable, debugEnabled: boolean);
-    debug(...content: any[]): void;
-    error(...content: any[]): void;
-    warn(...content: any[]): void;
-}
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { ILogger } from '../logger';
+export declare class ConsoleLogger implements ILogger {
+    private stream;
+    private debugEnabled;
+    private console;
+    constructor(stream: Writable, debugEnabled: boolean);
+    debug(...content: any[]): void;
+    error(...content: any[]): void;
+    warn(...content: any[]): void;
+}

package/lib/api/console_logger.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsoleLogger = void 0;
-const console_1 = require("console");
-class ConsoleLogger {
-    constructor(stream, debugEnabled) {
-        this.stream = stream;
-        this.debugEnabled = debugEnabled;
-        this.console = new console_1.Console(this.stream);
-    }
-    debug(...content) {
-        if (this.debugEnabled) {
-            this.console.debug(...content);
-        }
-    }
-    error(...content) {
-        this.console.error(...content);
-    }
-    warn(...content) {
-        this.console.warn(...content);
-    }
-}
-exports.ConsoleLogger = ConsoleLogger;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const console_1 = require("console");
+class ConsoleLogger {
+    constructor(stream, debugEnabled) {
+        this.stream = stream;
+        this.debugEnabled = debugEnabled;
+        this.console = new console_1.Console(this.stream);
+    }
+    debug(...content) {
+        if (this.debugEnabled) {
+            this.console.debug(...content);
+        }
+    }
+    error(...content) {
+        this.console.error(...content);
+    }
+    warn(...content) {
+        this.console.warn(...content);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
 //# sourceMappingURL=console_logger.js.map

package/lib/api/convert_configuration.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
-import { IConfiguration } from '../configuration';
-import { IRunConfiguration } from './types';
-export declare function convertConfiguration(flatConfiguration: IConfiguration, env: NodeJS.ProcessEnv): Promise<IRunConfiguration>;
+/// <reference types="node" />
+import { IConfiguration } from '../configuration';
+import { IRunConfiguration } from './types';
+export declare function convertConfiguration(flatConfiguration: IConfiguration, env: NodeJS.ProcessEnv): Promise<IRunConfiguration>;

package/lib/api/convert_configuration.js

@@ -1,66 +1,66 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertConfiguration = void 0;
-const configuration_1 = require("../configuration");
-async function convertConfiguration(flatConfiguration, env) {
-    return {
-        sources: {
-            paths: flatConfiguration.paths,
-            defaultDialect: flatConfiguration.language,
-            names: flatConfiguration.name,
-            tagExpression: flatConfiguration.tags,
-            order: flatConfiguration.order,
-        },
-        support: {
-            requireModules: flatConfiguration.requireModule,
-            requirePaths: flatConfiguration.require,
-            importPaths: flatConfiguration.import,
-        },
-        runtime: {
-            dryRun: flatConfiguration.dryRun,
-            failFast: flatConfiguration.failFast,
-            filterStacktraces: !flatConfiguration.backtrace,
-            parallel: flatConfiguration.parallel,
-            retry: flatConfiguration.retry,
-            retryTagFilter: flatConfiguration.retryTagFilter,
-            strict: flatConfiguration.strict,
-            worldParameters: flatConfiguration.worldParameters,
-        },
-        formats: convertFormats(flatConfiguration, env),
-        runName: flatConfiguration.runName,
-    };
-}
-exports.convertConfiguration = convertConfiguration;
-function convertFormats(flatConfiguration, env) {
-    var _a, _b;
-    const splitFormats = flatConfiguration.format.map((item) => configuration_1.OptionSplitter.split(item));
-    return {
-        stdout: (_b = (_a = [...splitFormats].reverse().find(([, target]) => !target)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : 'progress',
-        files: splitFormats
-            .filter(([, target]) => !!target)
-            .reduce((mapped, [type, target]) => {
-            return {
-                ...mapped,
-                [target]: type,
-            };
-        }, {}),
-        publish: makePublishConfig(flatConfiguration, env),
-        options: flatConfiguration.formatOptions,
-    };
-}
-function makePublishConfig(flatConfiguration, env) {
-    const enabled = isPublishing(flatConfiguration, env);
-    if (!enabled) {
-        return false;
-    }
-    return {
-        url: env.CUCUMBER_PUBLISH_URL,
-        token: env.CUCUMBER_PUBLISH_TOKEN,
-    };
-}
-function isPublishing(flatConfiguration, env) {
-    return (flatConfiguration.publish ||
-        (0, configuration_1.isTruthyString)(env.CUCUMBER_PUBLISH_ENABLED) ||
-        env.CUCUMBER_PUBLISH_TOKEN !== undefined);
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertConfiguration = void 0;
+const configuration_1 = require("../configuration");
+async function convertConfiguration(flatConfiguration, env) {
+    return {
+        sources: {
+            paths: flatConfiguration.paths,
+            defaultDialect: flatConfiguration.language,
+            names: flatConfiguration.name,
+            tagExpression: flatConfiguration.tags,
+            order: flatConfiguration.order,
+        },
+        support: {
+            requireModules: flatConfiguration.requireModule,
+            requirePaths: flatConfiguration.require,
+            importPaths: flatConfiguration.import,
+        },
+        runtime: {
+            dryRun: flatConfiguration.dryRun,
+            failFast: flatConfiguration.failFast,
+            filterStacktraces: !flatConfiguration.backtrace,
+            parallel: flatConfiguration.parallel,
+            retry: flatConfiguration.retry,
+            retryTagFilter: flatConfiguration.retryTagFilter,
+            strict: flatConfiguration.strict,
+            worldParameters: flatConfiguration.worldParameters,
+        },
+        formats: convertFormats(flatConfiguration, env),
+        runName: flatConfiguration.runName,
+    };
+}
+exports.convertConfiguration = convertConfiguration;
+function convertFormats(flatConfiguration, env) {
+    var _a, _b;
+    const splitFormats = flatConfiguration.format.map((item) => configuration_1.OptionSplitter.split(item));
+    return {
+        stdout: (_b = (_a = [...splitFormats].reverse().find(([, target]) => !target)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : 'progress',
+        files: splitFormats
+            .filter(([, target]) => !!target)
+            .reduce((mapped, [type, target]) => {
+            return {
+                ...mapped,
+                [target]: type,
+            };
+        }, {}),
+        publish: makePublishConfig(flatConfiguration, env),
+        options: flatConfiguration.formatOptions,
+    };
+}
+function makePublishConfig(flatConfiguration, env) {
+    const enabled = isPublishing(flatConfiguration, env);
+    if (!enabled) {
+        return false;
+    }
+    return {
+        url: env.CUCUMBER_PUBLISH_URL,
+        token: env.CUCUMBER_PUBLISH_TOKEN,
+    };
+}
+function isPublishing(flatConfiguration, env) {
+    return (flatConfiguration.publish ||
+        (0, configuration_1.isTruthyString)(env.CUCUMBER_PUBLISH_ENABLED) ||
+        env.CUCUMBER_PUBLISH_TOKEN !== undefined);
+}
 //# sourceMappingURL=convert_configuration.js.map

package/lib/api/environment.d.ts

@@ -1,2 +1,2 @@
-import { IRunEnvironment } from './types';
-export declare function mergeEnvironment(provided: IRunEnvironment): Required<IRunEnvironment>;
+import { IRunEnvironment } from './types';
+export declare function mergeEnvironment(provided: IRunEnvironment): Required<IRunEnvironment>;

package/lib/api/environment.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeEnvironment = void 0;
-function mergeEnvironment(provided) {
-    return Object.assign({}, {
-        cwd: process.cwd(),
-        stdout: process.stdout,
-        stderr: process.stderr,
-        env: process.env,
-        debug: false,
-    }, provided);
-}
-exports.mergeEnvironment = mergeEnvironment;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeEnvironment = void 0;
+function mergeEnvironment(provided) {
+    return Object.assign({}, {
+        cwd: process.cwd(),
+        stdout: process.stdout,
+        stderr: process.stderr,
+        env: process.env,
+        debug: false,
+    }, provided);
+}
+exports.mergeEnvironment = mergeEnvironment;
 //# sourceMappingURL=environment.js.map

package/lib/api/formatters.d.ts

@@ -1,20 +1,20 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IFormatterStream } from '../formatter';
-import { EventEmitter } from 'events';
-import { EventDataCollector } from '../formatter/helpers';
-import { ISupportCodeLibrary } from '../support_code_library_builder/types';
-import { IRunOptionsFormats } from './types';
-import { ILogger } from '../logger';
-export declare function initializeFormatters({ env, cwd, stdout, logger, onStreamError, eventBroadcaster, eventDataCollector, configuration, supportCodeLibrary, }: {
-    env: NodeJS.ProcessEnv;
-    cwd: string;
-    stdout: IFormatterStream;
-    stderr: IFormatterStream;
-    logger: ILogger;
-    onStreamError: () => void;
-    eventBroadcaster: EventEmitter;
-    eventDataCollector: EventDataCollector;
-    configuration: IRunOptionsFormats;
-    supportCodeLibrary: ISupportCodeLibrary;
-}): Promise<() => Promise<void>>;
+/// <reference types="node" />
+/// <reference types="node" />
+import { IFormatterStream } from '../formatter';
+import { EventEmitter } from 'events';
+import { EventDataCollector } from '../formatter/helpers';
+import { ISupportCodeLibrary } from '../support_code_library_builder/types';
+import { IRunOptionsFormats } from './types';
+import { ILogger } from '../logger';
+export declare function initializeFormatters({ env, cwd, stdout, logger, onStreamError, eventBroadcaster, eventDataCollector, configuration, supportCodeLibrary, }: {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    stdout: IFormatterStream;
+    stderr: IFormatterStream;
+    logger: ILogger;
+    onStreamError: () => void;
+    eventBroadcaster: EventEmitter;
+    eventDataCollector: EventDataCollector;
+    configuration: IRunOptionsFormats;
+    supportCodeLibrary: ISupportCodeLibrary;
+}): Promise<() => Promise<void>>;

package/lib/api/formatters.js

@@ -1,61 +1,61 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeFormatters = void 0;
-const util_1 = require("util");
-const builder_1 = __importDefault(require("../formatter/builder"));
-const fs_1 = __importDefault(require("mz/fs"));
-const path_1 = __importDefault(require("path"));
-const mkdirp_1 = require("mkdirp");
-async function initializeFormatters({ env, cwd, stdout, logger, onStreamError, eventBroadcaster, eventDataCollector, configuration, supportCodeLibrary, }) {
-    async function initializeFormatter(stream, target, type) {
-        stream.on('error', (error) => {
-            logger.error(error.message);
-            onStreamError();
-        });
-        const typeOptions = {
-            env,
-            cwd,
-            eventBroadcaster,
-            eventDataCollector,
-            log: stream.write.bind(stream),
-            parsedArgvOptions: configuration.options,
-            stream,
-            cleanup: stream === stdout
-                ? async () => await Promise.resolve()
-                : (0, util_1.promisify)(stream.end.bind(stream)),
-            supportCodeLibrary,
-        };
-        if (type === 'progress-bar' && !stream.isTTY) {
-            logger.warn(`Cannot use 'progress-bar' formatter for output to '${target}' as not a TTY. Switching to 'progress' formatter.`);
-            type = 'progress';
-        }
-        return await builder_1.default.build(type, typeOptions);
-    }
-    const formatters = [];
-    formatters.push(await initializeFormatter(stdout, 'stdout', configuration.stdout));
-    const streamPromises = [];
-    Object.entries(configuration.files).forEach(([target, type]) => {
-        streamPromises.push((async (target, type) => {
-            const absoluteTarget = path_1.default.resolve(cwd, target);
-            try {
-                await (0, mkdirp_1.mkdirp)(path_1.default.dirname(absoluteTarget));
-            }
-            catch (error) {
-                logger.warn('Failed to ensure directory for formatter target exists');
-            }
-            const stream = fs_1.default.createWriteStream(null, {
-                fd: await fs_1.default.open(absoluteTarget, 'w'),
-            });
-            formatters.push(await initializeFormatter(stream, target, type));
-        })(target, type));
-    });
-    await Promise.all(streamPromises);
-    return async function () {
-        await Promise.all(formatters.map(async (f) => await f.finished()));
-    };
-}
-exports.initializeFormatters = initializeFormatters;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeFormatters = void 0;
+const util_1 = require("util");
+const builder_1 = __importDefault(require("../formatter/builder"));
+const fs_1 = __importDefault(require("mz/fs"));
+const path_1 = __importDefault(require("path"));
+const mkdirp_1 = require("mkdirp");
+async function initializeFormatters({ env, cwd, stdout, logger, onStreamError, eventBroadcaster, eventDataCollector, configuration, supportCodeLibrary, }) {
+    async function initializeFormatter(stream, target, type) {
+        stream.on('error', (error) => {
+            logger.error(error.message);
+            onStreamError();
+        });
+        const typeOptions = {
+            env,
+            cwd,
+            eventBroadcaster,
+            eventDataCollector,
+            log: stream.write.bind(stream),
+            parsedArgvOptions: configuration.options,
+            stream,
+            cleanup: stream === stdout
+                ? async () => await Promise.resolve()
+                : (0, util_1.promisify)(stream.end.bind(stream)),
+            supportCodeLibrary,
+        };
+        if (type === 'progress-bar' && !stream.isTTY) {
+            logger.warn(`Cannot use 'progress-bar' formatter for output to '${target}' as not a TTY. Switching to 'progress' formatter.`);
+            type = 'progress';
+        }
+        return await builder_1.default.build(type, typeOptions);
+    }
+    const formatters = [];
+    formatters.push(await initializeFormatter(stdout, 'stdout', configuration.stdout));
+    const streamPromises = [];
+    Object.entries(configuration.files).forEach(([target, type]) => {
+        streamPromises.push((async (target, type) => {
+            const absoluteTarget = path_1.default.resolve(cwd, target);
+            try {
+                await (0, mkdirp_1.mkdirp)(path_1.default.dirname(absoluteTarget));
+            }
+            catch (error) {
+                logger.warn('Failed to ensure directory for formatter target exists');
+            }
+            const stream = fs_1.default.createWriteStream(null, {
+                fd: await fs_1.default.open(absoluteTarget, 'w'),
+            });
+            formatters.push(await initializeFormatter(stream, target, type));
+        })(target, type));
+    });
+    await Promise.all(streamPromises);
+    return async function () {
+        await Promise.all(formatters.map(async (f) => await f.finished()));
+    };
+}
+exports.initializeFormatters = initializeFormatters;
 //# sourceMappingURL=formatters.js.map

package/lib/api/gherkin.d.ts

@@ -1,21 +1,21 @@
-import { Envelope, GherkinDocument, IdGenerator, Location, ParseError, Pickle } from '@cucumber/messages';
-import { ISourcesCoordinates } from './types';
-import { ILogger } from '../logger';
-interface PickleWithDocument {
-    gherkinDocument: GherkinDocument;
-    location: Location;
-    pickle: Pickle;
-}
-export declare function getFilteredPicklesAndErrors({ newId, cwd, logger, unexpandedFeaturePaths, featurePaths, coordinates, onEnvelope, }: {
-    newId: IdGenerator.NewId;
-    cwd: string;
-    logger: ILogger;
-    unexpandedFeaturePaths: string[];
-    featurePaths: string[];
-    coordinates: ISourcesCoordinates;
-    onEnvelope?: (envelope: Envelope) => void;
-}): Promise<{
-    filteredPickles: PickleWithDocument[];
-    parseErrors: ParseError[];
-}>;
-export {};
+import { Envelope, GherkinDocument, IdGenerator, Location, ParseError, Pickle } from '@cucumber/messages';
+import { ISourcesCoordinates } from './types';
+import { ILogger } from '../logger';
+interface PickleWithDocument {
+    gherkinDocument: GherkinDocument;
+    location: Location;
+    pickle: Pickle;
+}
+export declare function getFilteredPicklesAndErrors({ newId, cwd, logger, unexpandedFeaturePaths, featurePaths, coordinates, onEnvelope, }: {
+    newId: IdGenerator.NewId;
+    cwd: string;
+    logger: ILogger;
+    unexpandedFeaturePaths: string[];
+    featurePaths: string[];
+    coordinates: ISourcesCoordinates;
+    onEnvelope?: (envelope: Envelope) => void;
+}): Promise<{
+    filteredPickles: PickleWithDocument[];
+    parseErrors: ParseError[];
+}>;
+export {};