bump-cli 2.9.12 → 2.10.1

package/dist/core/schemas/flower-schemas/v0.1/schema.json

@@ -54,7 +54,7 @@
                     "$ref": "#/definitions/schema"
                 },
                 "outputs": {
-                    "$ref": "#/definitions/schema"
+                    "$ref": "#/definitions/expressionMap"
                 },
                 "steps": {
                     "type": "array",
@@ -75,7 +75,7 @@
                     "type": "string"
                 },
                 "outputs": {
-                    "$ref": "#/definitions/schema"
+                    "$ref": "#/definitions/expressionMap"
                 },
                 "request": {
                     "type": "object",
@@ -83,13 +83,38 @@
                         "method": {
                             "type": "string"
                         },
-                        "query": {
-                            "$ref": "#/definitions/schema"
-                        },
                         "url": {
                             "type": "string"
+                        },
+                        "headers": {
+                            "$ref": "#/definitions/expressionMap"
+                        },
+                        "query": {
+                            "$ref": "#/definitions/expressionMap"
+                        },
+                        "body": {
+                            "$ref": "#/definitions/expressionMap"
                         }
                     }
+                },
+                "actions": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            {
+                                "$ref": "#/definitions/next"
+                            },
+                            {
+                                "$ref": "#/definitions/retry"
+                            },
+                            {
+                                "$ref": "#/definitions/goto"
+                            },
+                            {
+                                "$ref": "#/definitions/end"
+                            }
+                        ]
+                    }
                 }
             },
             "required": [
@@ -97,6 +122,122 @@
                 "request"
             ]
         },
+        "action": {
+            "type": "object",
+            "required": [
+                "do"
+            ],
+            "properties": {
+                "id": {
+                    "type": "string"
+                },
+                "when": {
+                    "type": "string",
+                    "description": "A runtime expression conditioning this action"
+                },
+                "do": {
+                    "type": "string"
+                }
+            },
+            "discriminator": {
+                "propertyName": "do",
+                "mapping": {
+                    "next": "#/definitions/next",
+                    "retry": "#/definitions/retry",
+                    "goto": "#/definitions/goto",
+                    "end": "#/definitions/end"
+                }
+            }
+        },
+        "next": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/action"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "do": {
+                            "type": "string",
+                            "const": "next"
+                        }
+                    }
+                }
+            ]
+        },
+        "retry": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/action"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "do": {
+                            "type": "string",
+                            "const": "retry"
+                        },
+                        "wait": {
+                            "type": "integer",
+                            "description": "Number of seconds to wait",
+                            "default": 5
+                        },
+                        "max_retry": {
+                            "type": "integer",
+                            "description": "Maximum number of subsequent retries to execute",
+                            "default": 5
+                        }
+                    }
+                }
+            ]
+        },
+        "goto": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/action"
+                },
+                {
+                    "type": "object",
+                    "required": [
+                        "step"
+                    ],
+                    "properties": {
+                        "do": {
+                            "type": "string",
+                            "const": "goto"
+                        },
+                        "step": {
+                            "type": "string",
+                            "description": "The target step ID to jump to"
+                        }
+                    }
+                }
+            ]
+        },
+        "end": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/action"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "do": {
+                            "type": "string",
+                            "const": "end"
+                        }
+                    }
+                }
+            ]
+        },
+        "expressionMap": {
+            "type": "object",
+            "description": "A map of names to runtime expressions.",
+            "additionalProperties": {
+                "type": "string",
+                "description": "A runtime expression."
+            }
+        },
         "schema": {
             "allOf": [
                 {

package/dist/core/workflow-deploy.js

@@ -28,9 +28,8 @@ export class WorkflowDeploy {
     }
     async run(workflowDefinition, mcpServer, token) {
         let version;
-        const request = {
-            definition: workflowDefinition.rawDefinition,
-        };
+        const [definition, references] = await workflowDefinition.extractDefinition();
+        const request = { definition, references };
         // eslint-disable-next-line prefer-const
         version = await this.createWorkflowVersion(mcpServer, request, token);
         return version;

package/dist/definition.d.ts

@@ -1,9 +1,10 @@
 import { JSONSchema4, JSONSchema4Array, JSONSchema4Object, JSONSchema6, JSONSchema6Object, JSONSchema7 } from 'json-schema';
-type SpecSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
+type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 declare class SupportedFormat {
-    static readonly asyncapi: Record<string, SpecSchema>;
-    static readonly flower: Record<string, SpecSchema>;
-    static readonly openapi: Record<string, SpecSchema>;
+    static readonly arazzo: Record<string, JSONSchema>;
+    static readonly asyncapi: Record<string, JSONSchema>;
+    static readonly flower: Record<string, JSONSchema>;
+    static readonly openapi: Record<string, JSONSchema>;
 }
 declare class API {
     readonly definition: APIDefinition;
@@ -13,30 +14,38 @@ declare class API {
     readonly references: APIReference[];
     readonly specName?: string;
     readonly version?: string;
-    constructor(location: string, values: SpecSchema);
+    constructor(location: string, data: Record<string, JSONSchemaWithRaw>);
+    static isArazzo(definition: JSONSchema4Object | JSONSchema6Object): definition is Arazzo;
     static isAsyncAPI(definition: JSONSchema4Object | JSONSchema6Object): definition is AsyncAPI;
     static isFlower(definition: JSONSchema4Object | JSONSchema6Object): definition is Flower;
     static isOpenAPI(definition: JSONSchema4Object | JSONSchema6Object): definition is OpenAPI;
     static isOpenAPIOverlay(definition: JSONSchema4Object | JSONSchema6Object): definition is OpenAPIOverlay;
+    static isSupportedFormat(definition: JSONSchema4Object | JSONSchema6Object): definition is APIDefinition;
     static load(path: string): Promise<API>;
     applyOverlay(overlayPath: string): Promise<void>;
     extractDefinition(outputPath?: string, overlays?: string[] | undefined): Promise<[string, APIReference[]]>;
-    getSpec(definition: APIDefinition): SpecSchema | undefined;
+    getSpec(definition: APIDefinition): JSONSchema | undefined;
     getSpecName(definition: APIDefinition): string | undefined;
     getVersion(definition: APIDefinition): string | undefined;
     guessFormat(output?: string): string;
     isMainRefPath(path: string): boolean;
-    resolveContent(values: SpecSchema): [string, APIDefinition];
-    resolveRelativeLocation(absPath: string): string;
     serializeDefinition(outputPath?: string): string;
     versionWithoutPatch(): string;
+    private _resolveArazzoSourceDescriptions;
+    private _resolveContentFrom;
+    private _resolveRelativeLocation;
     private url;
 }
+type JSONSchemaWithRaw = {
+    readonly parsed?: JSONSchema4 | JSONSchema4Object | JSONSchema6 | JSONSchema6Object | string;
+    readonly raw?: string;
+};
 type APIReference = {
     content: string;
     location: string;
+    name?: string;
 };
-type APIDefinition = AsyncAPI | Flower | OpenAPI | OpenAPIOverlay;
+type APIDefinition = Arazzo | AsyncAPI | Flower | OpenAPI | OpenAPIOverlay;
 type InfoObject = {
     readonly description?: string;
     readonly title: string;
@@ -59,4 +68,8 @@ type AsyncAPI = {
 type Flower = {
     readonly flower: string;
 } & JSONSchema4Object;
+type Arazzo = {
+    readonly arazzo: string;
+    readonly info: InfoObject;
+} & JSONSchema4Object;
 export { API, APIDefinition, OpenAPI, OpenAPIOverlay, SupportedFormat };

package/dist/definition.js

@@ -5,9 +5,11 @@ import { parseWithPointers, safeStringify } from '@stoplight/yaml';
 import debug from 'debug';
 import { default as nodePath } from 'node:path';
 import { Overlay } from './core/overlay.js';
+import arazzoSchemas from './core/schemas/arazzo-schemas/index.js';
 import flowerSchemas from './core/schemas/flower-schemas/index.js';
 import openapiSchemas from './core/schemas/oas-schemas/index.js';
 class SupportedFormat {
+    static arazzo = arazzoSchemas.schemas;
     static asyncapi = {
         '2.0': asyncapi.schemas['2.0.0'],
         '2.1': asyncapi.schemas['2.1.0'],
@@ -17,15 +19,8 @@ class SupportedFormat {
         '2.5': asyncapi.schemas['2.5.0'],
         '2.6': asyncapi.schemas['2.6.0'],
     };
-    static flower = {
-        '0.1': flowerSchemas.schemas['0.1'],
-    };
-    static openapi = {
-        '2.0': openapiSchemas.schemas['2.0'],
-        '3.0': openapiSchemas.schemas['3.0'],
-        '3.1': openapiSchemas.schemas['3.1'],
-        '3.2': openapiSchemas.schemas['3.2'],
-    };
+    static flower = flowerSchemas.schemas;
+    static openapi = openapiSchemas.schemas;
 }
 class UnsupportedFormat extends CLIError {
     constructor(message = '') {
@@ -46,10 +41,10 @@ class API {
     references;
     specName;
     version;
-    constructor(location, values) {
+    constructor(location, data) {
         this.location = location;
-        this.references = [];
-        const [raw, parsed] = this.resolveContent(values);
+        const [raw, parsed, references] = this._resolveContentFrom(data);
+        this.references = references || [];
         this.rawDefinition = raw;
         this.definition = parsed;
         this.specName = this.getSpecName(parsed);
@@ -58,6 +53,9 @@ class API {
             throw new UnsupportedFormat(`${this.specName} ${this.version}`);
         }
     }
+    static isArazzo(definition) {
+        return 'arazzo' in definition;
+    }
     static isAsyncAPI(definition) {
         return 'asyncapi' in definition;
     }
@@ -70,6 +68,13 @@ class API {
     static isOpenAPIOverlay(definition) {
         return 'overlay' in definition;
     }
+    static isSupportedFormat(definition) {
+        return (API.isArazzo(definition) ||
+            API.isAsyncAPI(definition) ||
+            API.isFlower(definition) ||
+            API.isOpenAPI(definition) ||
+            API.isOpenAPIOverlay(definition));
+    }
     static async load(path) {
         const { json, text, yaml } = getJsonSchemaRefParserDefaultOptions().parse;
         // Not sure why the lib types the parser as potentially
@@ -114,8 +119,17 @@ class API {
             },
         })
             .then(($refs) => {
-            const values = $refs.values();
-            return new API(path, values);
+            // JSON schema refs parser lib doesn't type the output of this
+            // method well (it types it as a generic JSON schema) where as
+            // it builds a Map of string (the path/URLs of each reference)
+            // to JSONSchema (the reference value)
+            //
+            // We also change the reference values in our custom parsers
+            // defined above to include the raw values which gets “widen”
+            // by the lib. We thus need to force the type output to a more
+            // precise type.
+            const data = $refs.values();
+            return new API(path, data);
         })
             .catch((error) => {
             throw new CLIError(error);
@@ -147,59 +161,68 @@ class API {
             }
             /* eslint-enable no-await-in-loop */
         }
+        if (API.isArazzo(this.definition)) {
+            await this._resolveArazzoSourceDescriptions();
+        }
         const references = [];
         for (let i = 0; i < this.references.length; i++) {
-            const reference = this.references[i];
-            references.push({
-                content: reference.content,
-                location: reference.location,
-            });
+            const { content, location, name } = this.references[i];
+            references.push({ content, location, name });
         }
         return [this.serializeDefinition(outputPath), references];
     }
     getSpec(definition) {
+        if (API.isArazzo(definition)) {
+            return SupportedFormat.arazzo[this.versionWithoutPatch()];
+        }
         if (API.isAsyncAPI(definition)) {
             return SupportedFormat.asyncapi[this.versionWithoutPatch()];
         }
-        if (API.isOpenAPIOverlay(definition)) {
-            return { overlay: { type: 'string' } };
-        }
         if (API.isFlower(definition)) {
             return SupportedFormat.flower[this.versionWithoutPatch()];
         }
         if (API.isOpenAPI(definition)) {
             return SupportedFormat.openapi[this.versionWithoutPatch()];
         }
+        if (API.isOpenAPIOverlay(definition)) {
+            return { overlay: { type: 'string' } };
+        }
         return undefined;
     }
     getSpecName(definition) {
+        if (API.isArazzo(definition)) {
+            return 'Arazzo';
+        }
         if (API.isAsyncAPI(definition)) {
             return 'AsyncAPI';
         }
         if (API.isFlower(definition)) {
             return 'Flower';
         }
-        if (API.isOpenAPIOverlay(definition)) {
-            return 'OpenAPIOverlay';
-        }
         if (API.isOpenAPI(definition)) {
             return 'OpenAPI';
         }
+        if (API.isOpenAPIOverlay(definition)) {
+            return 'OpenAPIOverlay';
+        }
         return undefined;
     }
     getVersion(definition) {
+        if (API.isArazzo(definition)) {
+            return definition.arazzo;
+        }
         if (API.isAsyncAPI(definition)) {
             return definition.asyncapi;
         }
         if (API.isFlower(definition)) {
             return definition.flower;
         }
-        if (API.isOpenAPIOverlay(definition)) {
-            return definition.overlay;
-        }
         if (API.isOpenAPI(definition)) {
             return (definition.openapi || definition.swagger);
         }
+        if (API.isOpenAPIOverlay(definition)) {
+            return definition.overlay;
+        }
         return undefined;
     }
     guessFormat(output) {
@@ -215,52 +238,6 @@ class API {
             .join(nodePath?.posix?.sep ?? '/');
         return path === this.location || path === resolvedAbsLocation;
     }
-    resolveContent(values) {
-        let mainReference = { parsed: {}, raw: '' };
-        for (const [absPath, reference] of Object.entries(values)) {
-            if (this.isMainRefPath(absPath)) {
-                // $refs.values is not properly typed so we need to force it
-                // with the resulting type of our custom defined parser
-                mainReference = reference;
-            }
-            else {
-                // $refs.values is not properly typed so we need to force it
-                // with the resulting type of our custom defined parser
-                const { raw } = reference;
-                if (!raw) {
-                    throw new UnsupportedFormat(`Reference ${absPath} is empty`);
-                }
-                this.references.push({
-                    content: raw,
-                    location: this.resolveRelativeLocation(absPath),
-                });
-            }
-        }
-        const { parsed, raw } = mainReference;
-        if (!parsed || !raw || !(parsed instanceof Object) || !('info' in parsed || 'flower' in parsed)) {
-            debug('bump-cli:definition')(`Main location (${this.location}) not found or empty (within ${JSON.stringify(Object.keys(values))})`);
-            throw new UnsupportedFormat('Definition needs to be a valid Object');
-        }
-        if (!API.isOpenAPI(parsed) && !API.isAsyncAPI(parsed) && !API.isOpenAPIOverlay(parsed) && !API.isFlower(parsed)) {
-            throw new UnsupportedFormat();
-        }
-        return [raw, parsed];
-    }
-    /* Resolve reference absolute paths to the main api location when possible */
-    resolveRelativeLocation(absPath) {
-        const definitionUrl = this.url();
-        const refUrl = this.url(absPath);
-        if ((refUrl.hostname === '' && // filesystem path
-            (/^\//.test(absPath) || // Unix style
-                /^[A-Za-z]+:[/\\]/.test(absPath))) || // Windows style
-            (/^https?:\/\//.test(absPath) && definitionUrl.hostname === refUrl.hostname) // Same domain URLs
-        ) {
-            const relativeLocation = nodePath.relative(nodePath.dirname(this.location), absPath);
-            debug('bump-cli:definition')(`Resolved relative $ref location: ${relativeLocation}`);
-            return relativeLocation;
-        }
-        return absPath;
-    }
     serializeDefinition(outputPath) {
         if (this.overlayedDefinition) {
             const { comments } = parseWithPointers(this.rawDefinition, { attachComments: true });
@@ -278,6 +255,84 @@ class API {
         const [major, minor] = this.version.split('.', 3);
         return `${major}.${minor}`;
     }
+    async _resolveArazzoSourceDescriptions() {
+        if (!API.isArazzo(this.definition)) {
+            debug('bump-cli:definition')('This is not an Arazzo definition, no source descriptions to resolve');
+        }
+        else if (this.definition.sourceDescriptions) {
+            const sources = this.definition.sourceDescriptions;
+            for (const { name, type: sourceType, url: location } of sources) {
+                if (sourceType === 'openapi') {
+                    const relativeLocation = this._resolveRelativeLocation(location);
+                    /* eslint-disable no-await-in-loop */
+                    const api = await API.load(relativeLocation);
+                    const [content] = await api.extractDefinition();
+                    /* eslint-enable no-await-in-loop */
+                    this.references.push({ content, location: relativeLocation, name });
+                }
+                else {
+                    debug('bump-cli:definition')(`Arazzo source description of type ${sourceType} is not yet supported.`);
+                }
+            }
+        }
+        else {
+            debug('bump-cli:definition')("Arazzo definition doesn't have any sourceDescriptions");
+        }
+    }
+    _resolveContentFrom(data) {
+        let definition;
+        let rawDefinition;
+        const references = [];
+        // data contains all refs as a map of paths/URLs and their
+        // correspond values
+        for (const [absPath, reference] of Object.entries(data)) {
+            if (this.isMainRefPath(absPath)) {
+                ;
+                ({ parsed: definition, raw: rawDefinition } = reference);
+            }
+            else {
+                if (!reference.raw) {
+                    throw new UnsupportedFormat(`Reference ${absPath} is empty`);
+                }
+                references.push({
+                    content: reference.raw,
+                    location: this._resolveRelativeLocation(absPath),
+                });
+            }
+        }
+        if (!definition ||
+            !rawDefinition ||
+            !(definition instanceof Object) ||
+            !('info' in definition || 'flower' in definition)) {
+            debug('bump-cli:definition')(`Main location (${this.location}) not found or empty (within ${JSON.stringify(Object.keys(data))})`);
+            throw new UnsupportedFormat('Definition needs to be a valid Object');
+        }
+        if (!API.isSupportedFormat(definition)) {
+            throw new UnsupportedFormat();
+        }
+        return [rawDefinition, definition, references];
+    }
+    /* Resolve reference paths to the main api location when possible */
+    _resolveRelativeLocation(path) {
+        const definitionUrl = this.url();
+        const refUrl = this.url(path);
+        const unixStyle = /^\//.test(path);
+        const windowsStyle = /^[A-Za-z]+:[/\\]/.test(path);
+        const isUrl = /^https?:\/\//.test(path);
+        // Guard: Absolute URL on different domain we return an untouched
+        // path
+        if (isUrl && definitionUrl.hostname !== refUrl.hostname) {
+            return path;
+        }
+        const isAbsolutePath = refUrl.hostname === '' && (unixStyle || windowsStyle);
+        // Absolute path or URL on **same domain**
+        const isAbsolute = isAbsolutePath || isUrl;
+        const relativeLocation = isAbsolute
+            ? nodePath.relative(nodePath.dirname(this.location), path)
+            : nodePath.join(nodePath.dirname(this.location), path);
+        debug('bump-cli:definition')(`Resolved relative $ref location: ${relativeLocation}`);
+        return relativeLocation;
+    }
     url(location = this.location) {
         try {
             return new URL(location);

package/dist/index.d.ts

@@ -8,7 +8,7 @@ export declare const COMMANDS: {
     overlay: typeof Overlay;
     preview: typeof Preview;
 };
-export { DiffResponse, PreviewResponse, VersionResponse, WithDiff } from './api/models.js';
+export { PreviewResponse, VersionResponse, WithDiff } from './api/models.js';
 export { default as Deploy } from './commands/deploy.js';
 export { default as Preview } from './commands/preview.js';
 export * as Diff from './core/diff.js';

package/oclif.manifest.json

@@ -301,5 +301,5 @@
       "strict": true
     }
   },
-  "version": "2.9.12"
+  "version": "2.10.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bump-cli",
-  "description": "The Bump CLI is used to interact with your API documentation hosted on Bump.sh by using the API of developers.bump.sh",
-  "version": "2.9.12",
+  "description": "The Bump CLI is used to interact with your API documentation hosted on Bump.sh by using the APIs of developers.bump.sh",
+  "version": "2.10.1",
   "author": "Paul Bonaud <paulr@bump.sh>",
   "bin": {
     "bump": "./bin/run.js"
@@ -14,9 +14,9 @@
     "@types/debug": "^4.1.12",
     "@types/jsonpath": "^0.2.4",
     "@types/mocha": "^10",
-    "@types/node": "^24",
-    "@types/sinon": "^17.0.3",
-    "@typescript-eslint/eslint-plugin": "^8.13.0",
+    "@types/node": "^25",
+    "@types/sinon": "^21.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.61.1",
     "chai": "^6.2.2",
     "eslint": "^8",
     "eslint-config-oclif": "^5",
@@ -92,7 +92,7 @@
   "dependencies": {
     "@apidevtools/json-schema-ref-parser": "^11.7.2",
     "@asyncapi/specs": "^6.8.0",
-    "@clack/prompts": "^0.11.0",
+    "@clack/prompts": "^1.0.0",
     "@oclif/core": "^4",
     "@oclif/plugin-help": "^6",
     "@oclif/plugin-warn-if-update-available": "^3.1.20",
@@ -103,6 +103,6 @@
     "debug": "^4.3.7",
     "jsonpathly": "^3.0.0",
     "mergician": "^2.0.2",
-    "open": "^10.1.0"
+    "open": "^11.0.0"
   }
 }