bump-cli 2.8.4 → 2.9.1

package/{lib → dist}/core/diff.js

@@ -1,107 +1,123 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Diff = void 0;
-const tslib_1 = require("tslib");
-const errors_1 = require("@oclif/errors");
-const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
-const definition_1 = require("../definition");
-const api_1 = require("../api");
-class Diff {
-    constructor(config) {
-        this._config = config;
-    }
-    async run(file1, file2, documentation, hub, branch, token, format, expires) {
-        let diffVersion = undefined;
-        if (file2 && (!documentation || !token)) {
-            diffVersion = await this.createDiff(file1, file2, expires);
-        }
-        else {
-            if (!documentation || !token) {
-                throw new Error('Please login to bump (with documentation & token) when using a single file argument');
-            }
-            diffVersion = await this.createVersion(file1, documentation, token, hub, branch);
-            if (file2) {
-                diffVersion = await this.createVersion(file2, documentation, token, hub, branch, diffVersion && diffVersion.id);
-            }
-        }
-        if (diffVersion) {
-            return await this.waitResult(diffVersion, token, {
-                timeout: Diff.TIMEOUT,
-                format,
-            });
-        }
-        else {
-            return undefined;
-        }
-    }
-    get bumpClient() {
-        if (!this._bump)
-            this._bump = new api_1.BumpApi(this._config);
-        return this._bump;
+import { CLIError } from '@oclif/core/errors';
+import debug from 'debug';
+import { API } from '../definition.js';
+export class Diff {
+    // 120 seconds = 2 minutes
+    static TIMEOUT = 120;
+    _bump;
+    constructor(bumpClient) {
+        this._bump = bumpClient;
     }
     get pollingPeriod() {
-        return 1000;
+        return process.env.BUMP_POLLING_PERIOD ? Number(process.env.BUMP_POLLING_PERIOD) : 1000;
     }
     async createDiff(file1, file2, expires) {
-        const api = await definition_1.API.load(file1);
+        const api = await API.load(file1);
         const [previous_definition, previous_references] = api.extractDefinition();
-        const api2 = await definition_1.API.load(file2);
+        const api2 = await API.load(file2);
         const [definition, references] = api2.extractDefinition();
         const request = {
+            definition,
+            expires_at: expires,
             previous_definition,
             previous_references,
-            definition,
             references,
-            expires_at: expires,
         };
-        const response = await this.bumpClient.postDiff(request);
+        const response = await this._bump.postDiff(request);
         switch (response.status) {
-            case 201:
+            case 201: {
                 this.d(`Diff created with ID ${response.data.id}`);
                 this.d(response.data);
                 return response.data;
                 break;
-            case 204:
+            }
+            case 204: {
                 break;
+            }
         }
-        return;
     }
     async createVersion(file, documentation, token, hub, branch_name, previous_version_id = undefined) {
-        const api = await definition_1.API.load(file);
+        const api = await API.load(file);
         const [definition, references] = api.extractDefinition();
         const request = {
+            branch_name,
+            definition,
             documentation,
             hub,
-            definition,
+            previous_version_id,
             references,
             unpublished: true,
-            previous_version_id,
-            branch_name,
         };
-        const response = await this.bumpClient.postVersion(request, token);
+        const response = await this._bump.postVersion(request, token);
         switch (response.status) {
-            case 201:
+            case 201: {
                 this.d(`Unpublished version created with ID ${response.data.id}`);
                 return response.data;
                 break;
-            case 204:
+            }
+            case 204: {
                 break;
+            }
         }
-        return;
     }
-    async waitResult(result, token, opts) {
-        let pollingResponse = undefined;
-        if (this.isVersion(result) && token) {
-            pollingResponse = await this.bumpClient.getVersion(result.id, token);
+    // Function signature type taken from @types/debug
+    // Debugger(formatter: any, ...args: any[]): void;
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    d(formatter, ...args) {
+        return debug(`bump-cli:core:diff`)(formatter, ...args);
+    }
+    extractDiff(versionWithDiff) {
+        // TODO: return a real diff_id in the GET /version API
+        return {
+            breaking: versionWithDiff.diff_breaking,
+            details: versionWithDiff.diff_details,
+            id: versionWithDiff.id,
+            markdown: versionWithDiff.diff_markdown,
+            public_url: versionWithDiff.diff_public_url,
+            text: versionWithDiff.diff_summary,
+        };
+    }
+    isVersion(result) {
+        return result.doc_public_url !== undefined;
+    }
+    isVersionWithDiff(result) {
+        const { diff_details, diff_markdown, diff_summary } = result;
+        return (diff_summary || diff_markdown || diff_details) !== undefined;
+    }
+    async pollingDelay() {
+        await this.delay(this.pollingPeriod);
+    }
+    async run(file1, file2, documentation, hub, branch, token, format, expires) {
+        let diffVersion;
+        if (file2 && (!documentation || !token)) {
+            diffVersion = await this.createDiff(file1, file2, expires);
         }
         else {
-            pollingResponse = await this.bumpClient.getDiff(result.id, opts.format);
+            if (!documentation || !token) {
+                throw new Error('Please login to bump (with documentation & token) when using a single file argument');
+            }
+            diffVersion = await this.createVersion(file1, documentation, token, hub, branch);
+            if (file2) {
+                diffVersion = await this.createVersion(file2, documentation, token, hub, branch, diffVersion && diffVersion.id);
+            }
         }
+        if (diffVersion) {
+            return this.waitResult(diffVersion, token, {
+                format,
+                timeout: Diff.TIMEOUT,
+            });
+        }
+        return undefined;
+    }
+    async waitResult(result, token, opts) {
+        const pollingResponse = await (this.isVersion(result) && token
+            ? this._bump.getVersion(result.id, token)
+            : this._bump.getDiff(result.id, opts.format));
         if (opts.timeout <= 0) {
-            throw new errors_1.CLIError('We were unable to compute your documentation diff. Sorry about that. Please try again later. If the error persists, please contact support at https://bump.sh.');
+            throw new CLIError('We were unable to compute your documentation diff. Sorry about that. Please try again later. If the error persists, please contact support at https://bump.sh.');
         }
         switch (pollingResponse.status) {
-            case 200:
+            case 200: {
                 let diff = pollingResponse.data;
                 if (this.isVersionWithDiff(diff)) {
                     diff = this.extractDiff(diff);
@@ -110,48 +126,22 @@ class Diff {
                 this.d(diff);
                 return diff;
                 break;
-            case 202:
+            }
+            case 202: {
                 this.d('Waiting 1 sec before next poll');
                 await this.pollingDelay();
-                return await this.waitResult(result, token, {
-                    timeout: opts.timeout - 1,
+                return this.waitResult(result, token, {
                     format: opts.format,
+                    timeout: opts.timeout - 1,
                 });
                 break;
+            }
         }
         return {};
     }
-    async pollingDelay() {
-        return await this.delay(this.pollingPeriod);
-    }
     async delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    // Function signature type taken from @types/debug
-    // Debugger(formatter: any, ...args: any[]): void;
-    /* eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any */
-    d(formatter, ...args) {
-        return (0, debug_1.default)(`bump-cli:core:diff`)(formatter, ...args);
-    }
-    isVersion(result) {
-        return result.doc_public_url !== undefined;
-    }
-    isVersionWithDiff(result) {
-        const { diff_summary, diff_markdown, diff_details } = result;
-        return (diff_summary || diff_markdown || diff_details) !== undefined;
-    }
-    extractDiff(versionWithDiff) {
-        // TODO: return a real diff_id in the GET /version API
-        return {
-            id: versionWithDiff.id,
-            public_url: versionWithDiff.diff_public_url,
-            text: versionWithDiff.diff_summary,
-            markdown: versionWithDiff.diff_markdown,
-            details: versionWithDiff.diff_details,
-            breaking: versionWithDiff.diff_breaking,
-        };
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
     }
 }
-exports.Diff = Diff;
-// 120 seconds = 2 minutes
-Diff.TIMEOUT = 120;

package/{lib → dist}/core/overlay.d.ts

@@ -1,5 +1,5 @@
-import { APIDefinition, OpenAPIOverlay } from '../definition';
+import { APIDefinition, OpenAPIOverlay } from '../definition.js';
 export declare class Overlay {
-    run(spec: APIDefinition, overlay: OpenAPIOverlay): APIDefinition;
     d(formatter: any, ...args: any[]): void;
+    run(spec: APIDefinition, overlay: OpenAPIOverlay): APIDefinition;
 }

package/{lib → dist}/core/overlay.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Overlay = void 0;
-const tslib_1 = require("tslib");
-const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
-const jsonpath_1 = (0, tslib_1.__importDefault)(require("jsonpath"));
-const mergician_1 = (0, tslib_1.__importDefault)(require("mergician"));
-class Overlay {
+import debug from 'debug';
+/* eslint-disable-next-line import/default */
+import jsonpath from 'jsonpath';
+import { mergician } from 'mergician';
+export class Overlay {
     // WIP @github.com/lornajane/openapi-overlays-js
     //
     // I couldn't get the upstream lib to be imported properly due to
@@ -13,31 +10,40 @@ class Overlay {
     // from github.com/lornajane/openapi-overlays-js and has been
     // adapted to make our Typescript build happy.
     //
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    d(formatter, ...args) {
+        return debug(`bump-cli:core:overlay`)(formatter, ...args);
+    }
+    // Function signature type taken from @types/debug
+    // Debugger(formatter: any, ...args: any[]): void;
     // If you make any changes here, PLEASE ALSO MAKE THEM UPSTREAM.
     run(spec, overlay) {
         // Use jsonpath.apply to do the changes
-        if (overlay.actions && overlay.actions.length >= 1)
-            overlay.actions.forEach((a) => {
+        if (overlay.actions && overlay.actions.length > 0)
+            for (const a of overlay.actions) {
                 const action = a;
                 if (!action.target) {
                     process.stderr.write('Action with a missing target\n');
-                    return;
+                    continue;
                 }
                 const target = action.target;
                 // Is it a remove?
-                if (action.hasOwnProperty('remove')) {
+                if (Object.hasOwn(action, 'remove')) {
+                    /* eslint-disable-next-line no-constant-condition */
                     while (true) {
-                        const path = jsonpath_1.default.paths(spec, target);
-                        if (path.length == 0) {
+                        const path = jsonpath.paths(spec, target);
+                        if (path.length === 0) {
                             break;
                         }
-                        const parent = jsonpath_1.default.parent(spec, target);
-                        const thingToRemove = path[0][path[0].length - 1];
-                        if (Array.isArray(parent)) {
-                            parent.splice(thingToRemove, 1);
-                        }
-                        else {
-                            delete parent[thingToRemove];
+                        const parent = jsonpath.parent(spec, target);
+                        const thingToRemove = path[0].at(-1);
+                        if (thingToRemove !== undefined) {
+                            if (Array.isArray(parent)) {
+                                parent.splice(thingToRemove, 1);
+                            }
+                            else {
+                                delete parent[thingToRemove];
+                            }
                         }
                     }
                 }
@@ -45,7 +51,7 @@ class Overlay {
                     try {
                         // It must be an update
                         // Deep merge objects using a module (built-in spread operator is only shallow)
-                        const merger = (0, mergician_1.default)({ appendArrays: true });
+                        const merger = mergician({ appendArrays: true });
                         if (target === '$') {
                             // You can't actually merge an update on a root object
                             // target with the jsonpath lib, this is just us merging
@@ -53,34 +59,23 @@ class Overlay {
                             spec = merger(spec, action.update);
                         }
                         else {
-                            jsonpath_1.default.apply(spec, target, (chunk) => {
+                            jsonpath.apply(spec, target, (chunk) => {
                                 if (typeof chunk === 'object' && typeof action.update === 'object') {
                                     if (Array.isArray(chunk) && Array.isArray(action.update)) {
-                                        return chunk.concat(action.update);
+                                        return [...chunk, ...action.update];
                                     }
-                                    else {
-                                        return merger(chunk, action.update);
-                                    }
-                                }
-                                else {
-                                    return action.update;
+                                    return merger(chunk, action.update);
                                 }
+                                return action.update;
                             });
                         }
                     }
-                    catch (ex) {
-                        process.stderr.write(`Error applying overlay: ${ex.message}\n`);
-                        //return chunk
+                    catch (error) {
+                        process.stderr.write(`Error applying overlay: ${error.message}\n`);
+                        // return chunk
                     }
                 }
-            });
+            }
         return spec;
     }
-    // Function signature type taken from @types/debug
-    // Debugger(formatter: any, ...args: any[]): void;
-    /* eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any */
-    d(formatter, ...args) {
-        return (0, debug_1.default)(`bump-cli:core:overlay`)(formatter, ...args);
-    }
 }
-exports.Overlay = Overlay;

package/{lib → dist}/core/utils/file.d.ts

@@ -1,13 +1,13 @@
-declare type FileDescription = {
-    value: string;
-    label: string;
+type FileDescription = {
     filename: string;
+    label: string;
+    value: string;
 };
 export declare const isDir: (path: string) => boolean;
 export declare class File {
     protected static readonly supportedFormats: string[];
-    static listValidConventionFiles(path: string, regex: RegExp): FileDescription[];
     static listInvalidConventionFiles(path: string, regex: RegExp): FileDescription[];
+    static listValidConventionFiles(path: string, regex: RegExp): FileDescription[];
     private static listValidFormatFiles;
 }
 export {};

package/dist/core/utils/file.js

@@ -0,0 +1,36 @@
+import { readdirSync, statSync } from 'node:fs';
+import { basename, extname } from 'node:path';
+export const isDir = (path) => {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+export class File {
+    static supportedFormats = ['.yml', '.yaml', '.json'];
+    static listInvalidConventionFiles(path, regex) {
+        return File.listValidFormatFiles(path).filter(({ filename }) => {
+            return !regex.test(filename);
+        });
+    }
+    static listValidConventionFiles(path, regex) {
+        return File.listValidFormatFiles(path).filter(({ filename }) => {
+            return regex.test(filename);
+        });
+    }
+    static listValidFormatFiles(path) {
+        return readdirSync(path)
+            .filter((file) => {
+            return File.supportedFormats.includes(extname(file));
+        })
+            .map((file) => {
+            return {
+                filename: basename(file, extname(file)),
+                label: basename(file),
+                value: file,
+            };
+        });
+    }
+}

package/dist/core/utils/prompts.d.ts

@@ -0,0 +1 @@
+export declare const confirm: (message?: string) => Promise<boolean>;

package/dist/core/utils/prompts.js

@@ -0,0 +1,13 @@
+import * as p from '@clack/prompts';
+import { ExitError } from '@oclif/core/errors';
+export const confirm = async (message = 'Continue?') => {
+    const prompt = await p.group({
+        shouldContinue: () => p.confirm({ message }),
+    }, {
+        onCancel() {
+            p.cancel('Cancelled.');
+            throw new ExitError(1);
+        },
+    });
+    return prompt.shouldContinue;
+};

package/{lib → dist}/definition.d.ts

@@ -1,57 +1,58 @@
-import $RefParser from '@apidevtools/json-schema-ref-parser';
-import { JSONSchema4, JSONSchema4Object, JSONSchema4Array, JSONSchema6, JSONSchema6Object, JSONSchema7 } from 'json-schema';
-declare type SpecSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
+import { JSONSchema4, JSONSchema4Array, JSONSchema4Object, JSONSchema6, JSONSchema6Object, JSONSchema7 } from 'json-schema';
+type SpecSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 declare class SupportedFormat {
-    static readonly openapi: Record<string, SpecSchema>;
     static readonly asyncapi: Record<string, SpecSchema>;
+    static readonly openapi: Record<string, SpecSchema>;
 }
 declare class API {
-    readonly location: string;
-    readonly rawDefinition: string;
     readonly definition: APIDefinition;
+    readonly location: string;
     overlayedDefinition: APIDefinition | undefined;
+    readonly rawDefinition: string;
     readonly references: APIReference[];
-    readonly version: string;
-    readonly specName: string;
     readonly spec?: SpecSchema;
-    constructor(location: string, $refs: $RefParser.$Refs);
+    readonly specName: string;
+    readonly version: string;
+    constructor(location: string, values: SpecSchema);
+    static isAsyncAPI(definition: JSONSchema4Object | JSONSchema6Object): definition is AsyncAPI;
+    static isOpenAPI(definition: JSONSchema4Object | JSONSchema6Object): definition is OpenAPI;
+    static isOpenAPIOverlay(definition: JSONSchema4Object | JSONSchema6Object): definition is OpenAPIOverlay;
+    static load(path: string): Promise<API>;
+    applyOverlay(overlayPath: string): Promise<void>;
+    extractDefinition(outputPath?: string): [string, APIReference[]];
     getSpec(definition: APIDefinition): SpecSchema;
     getSpecName(definition: APIDefinition): string;
     getVersion(definition: APIDefinition): string;
     guessFormat(output?: string): string;
-    versionWithoutPatch(): string;
+    isMainRefPath(path: string): boolean;
+    resolveContent(values: SpecSchema): [string, APIDefinition];
     resolveRelativeLocation(absPath: string): string;
-    resolveContent($refs: $RefParser.$Refs): [string, APIDefinition];
     serializeDefinition(outputPath?: string): string;
-    static isOpenAPI(definition: JSONSchema4Object | JSONSchema6Object): definition is OpenAPI;
-    static isAsyncAPI(definition: JSONSchema4Object | JSONSchema6Object): definition is AsyncAPI;
-    static isOpenAPIOverlay(definition: JSONSchema4Object | JSONSchema6Object): definition is OpenAPIOverlay;
-    extractDefinition(outputPath?: string): [string, APIReference[]];
-    applyOverlay(overlayPath: string): Promise<void>;
-    static load(path: string): Promise<API>;
+    versionWithoutPatch(): string;
+    private url;
 }
-declare type APIReference = {
-    location: string;
+type APIReference = {
     content: string;
+    location: string;
 };
-declare type APIDefinition = OpenAPI | AsyncAPI | OpenAPIOverlay;
-declare type InfoObject = {
+type APIDefinition = AsyncAPI | OpenAPI | OpenAPIOverlay;
+type InfoObject = {
+    readonly description?: string;
     readonly title: string;
     readonly version: string;
-    readonly description?: string;
 };
-declare type OpenAPI = JSONSchema4Object & {
+type OpenAPI = {
+    readonly info: InfoObject;
     readonly openapi?: string;
     readonly swagger?: string;
+} & JSONSchema4Object;
+type OpenAPIOverlay = {
+    readonly actions: JSONSchema4Array;
     readonly info: InfoObject;
-};
-declare type OpenAPIOverlay = JSONSchema4Object & {
     readonly overlay: string;
-    readonly info: InfoObject;
-    readonly actions: JSONSchema4Array;
-};
-declare type AsyncAPI = JSONSchema4Object & {
+} & JSONSchema4Object;
+type AsyncAPI = {
     readonly asyncapi: string;
     readonly info: InfoObject;
-};
+} & JSONSchema4Object;
 export { API, APIDefinition, OpenAPIOverlay, SupportedFormat };