@scalar/openapi-parser 0.25.4 → 0.25.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @scalar/openapi-parser
 
+## 0.25.6
+
+### Patch Changes
+
+- [#8520](https://github.com/scalar/scalar/pull/8520): Normalize trailing `+` in path template parameter names during path-parameter validation so `{name+}` matches a declared `name` path parameter.
+
+## 0.25.5
+
+### Patch Changes
+
+- [#8466](https://github.com/scalar/scalar/pull/8466): chore: new build pipeline
+
 ## 0.25.4
 
 ### Patch Changes

package/dist/configuration/index.js

@@ -1,26 +1,26 @@
-import Swagger20 from "../schemas/v2.0/schema.js";
-import OpenApi30 from "../schemas/v3.0/schema.js";
-import OpenApi31 from "../schemas/v3.1/schema.js";
-import OpenApi32 from "../schemas/v3.2/schema.js";
-const OpenApiSpecifications = {
-  "2.0": Swagger20,
-  "3.0": OpenApi30,
-  "3.1": OpenApi31,
-  "3.2": OpenApi32
+import Swagger20 from '../schemas/v2.0/schema.js';
+import OpenApi30 from '../schemas/v3.0/schema.js';
+import OpenApi31 from '../schemas/v3.1/schema.js';
+import OpenApi32 from '../schemas/v3.2/schema.js';
+/**
+ * A list of the supported OpenAPI specifications
+ */
+export const OpenApiSpecifications = {
+    '2.0': Swagger20,
+    '3.0': OpenApi30,
+    '3.1': OpenApi31,
+    '3.2': OpenApi32,
 };
-const OpenApiVersions = Object.keys(OpenApiSpecifications);
-const ERRORS = {
-  EMPTY_OR_INVALID: "Can't find JSON, YAML or filename in data.",
-  OPENAPI_VERSION_NOT_SUPPORTED: "Can't find supported Swagger/OpenAPI version in the provided document, version must be a string.",
-  INVALID_REFERENCE: "Can't resolve reference: %s",
-  EXTERNAL_REFERENCE_NOT_FOUND: "Can't resolve external reference: %s",
-  SELF_REFERENCE: "Can't resolve reference to itself: %s",
-  FILE_DOES_NOT_EXIST: "File does not exist: %s",
-  NO_CONTENT: "No content found"
+export const OpenApiVersions = Object.keys(OpenApiSpecifications);
+/**
+ * List of error messages used in the Validator
+ */
+export const ERRORS = {
+    EMPTY_OR_INVALID: "Can't find JSON, YAML or filename in data.",
+    OPENAPI_VERSION_NOT_SUPPORTED: "Can't find supported Swagger/OpenAPI version in the provided document, version must be a string.",
+    INVALID_REFERENCE: "Can't resolve reference: %s",
+    EXTERNAL_REFERENCE_NOT_FOUND: "Can't resolve external reference: %s",
+    SELF_REFERENCE: "Can't resolve reference to itself: %s",
+    FILE_DOES_NOT_EXIST: 'File does not exist: %s',
+    NO_CONTENT: 'No content found',
 };
-export {
-  ERRORS,
-  OpenApiSpecifications,
-  OpenApiVersions
-};
-//# sourceMappingURL=index.js.map

package/dist/index.js

@@ -1,45 +1,24 @@
-import {
-  escapeJsonPointer
-} from "@scalar/json-magic/helpers/escape-json-pointer";
-import {
-  upgradeFromTwoToThree
-} from "@scalar/openapi-upgrader/2.0-to-3.0";
-import {
-  upgradeFromThreeToThreeOne
-} from "@scalar/openapi-upgrader/3.0-to-3.1";
-import { dereference } from "./utils/dereference.js";
-import { filter } from "./utils/filter.js";
-import { isJson } from "./utils/is-json.js";
-import { isYaml } from "./utils/is-yaml.js";
-import { join } from "./utils/join/index.js";
-import { load } from "./utils/load/index.js";
-import { normalize } from "./utils/normalize.js";
-import { openapi } from "./utils/openapi/openapi.js";
-import { toJson } from "./utils/to-json.js";
-import { toYaml } from "./utils/to-yaml.js";
-import { sanitize } from "./utils/transform/sanitize.js";
-import { traverse } from "./utils/traverse.js";
-import { unescapeJsonPointer } from "./utils/unescape-json-pointer.js";
-import { upgrade } from "./utils/upgrade.js";
-import { validate } from "./utils/validate.js";
-export {
-  dereference,
-  escapeJsonPointer,
-  filter,
-  isJson,
-  isYaml,
-  join,
-  load,
-  normalize,
-  openapi,
-  sanitize,
-  toJson,
-  toYaml,
-  traverse,
-  unescapeJsonPointer,
-  upgrade,
-  upgradeFromThreeToThreeOne,
-  upgradeFromTwoToThree,
-  validate
-};
-//# sourceMappingURL=index.js.map
+export { 
+/** @deprecated Please import from @scalar/json-magic/helpers/escape-json-pointer instead */
+escapeJsonPointer, } from '@scalar/json-magic/helpers/escape-json-pointer';
+export { 
+/** @deprecated Please import from @scalar/openapi-upgrader/2.0-to-3.0 instead */
+upgradeFromTwoToThree, } from '@scalar/openapi-upgrader/2.0-to-3.0';
+export { 
+/** @deprecated Please import from @scalar/openapi-upgrader/3.0-to-3.1 instead */
+upgradeFromThreeToThreeOne, } from '@scalar/openapi-upgrader/3.0-to-3.1';
+export { dereference } from './utils/dereference.js';
+export { filter } from './utils/filter.js';
+export { isJson } from './utils/is-json.js';
+export { isYaml } from './utils/is-yaml.js';
+export { join } from './utils/join/index.js';
+export { load } from './utils/load/index.js';
+export { normalize } from './utils/normalize.js';
+export { openapi } from './utils/openapi/openapi.js';
+export { toJson } from './utils/to-json.js';
+export { toYaml } from './utils/to-yaml.js';
+export { sanitize } from './utils/transform/sanitize.js';
+export { traverse } from './utils/traverse.js';
+export { unescapeJsonPointer } from './utils/unescape-json-pointer.js';
+export { upgrade } from './utils/upgrade.js';
+export { validate } from './utils/validate.js';

package/dist/lib/Validator/Validator.js

@@ -1,116 +1,133 @@
-import Ajv, {} from "ajv";
-import Ajv2020 from "ajv/dist/2020.js";
-import Ajv04 from "ajv-draft-04";
-import addFormats from "ajv-formats";
-import { ERRORS, OpenApiSpecifications, OpenApiVersions } from "../../configuration/index.js";
-import { details as getOpenApiVersion } from "../../utils/details.js";
-import { resolveReferences } from "../../utils/resolve-references.js";
-import { transformErrors } from "../../utils/transform-errors.js";
-import { validatePathParameters } from "../../utils/validate-path-parameters.js";
+import Ajv, {} from 'ajv';
+import Ajv2020 from 'ajv/dist/2020.js';
+import Ajv04 from 'ajv-draft-04';
+import addFormats from 'ajv-formats';
+import { ERRORS, OpenApiSpecifications, OpenApiVersions } from '../../configuration/index.js';
+import { details as getOpenApiVersion } from '../../utils/details.js';
+import { resolveReferences } from '../../utils/resolve-references.js';
+import { transformErrors } from '../../utils/transform-errors.js';
+import { validatePathParameters } from '../../utils/validate-path-parameters.js';
+/**
+ * Configure available JSON Schema versions
+ */
 const jsonSchemaVersions = {
-  "http://json-schema.org/draft-04/schema#": Ajv04,
-  "http://json-schema.org/draft-07/schema#": Ajv,
-  "https://json-schema.org/draft/2020-12/schema": Ajv2020
+    'http://json-schema.org/draft-04/schema#': Ajv04,
+    'http://json-schema.org/draft-07/schema#': Ajv,
+    'https://json-schema.org/draft/2020-12/schema': Ajv2020,
 };
-class Validator {
-  version;
-  static supportedVersions = OpenApiVersions;
-  // Object with function *or* object { errors: string }
-  ajvValidators = {};
-  errors;
-  specificationVersion;
-  specificationType;
-  specification;
-  /**
-   * Checks whether a specification is valid and all references can be resolved.
-   */
-  validate(filesystem, options) {
-    const entrypoint = filesystem.find((file) => file.isEntrypoint);
-    const specification = entrypoint?.specification;
-    this.specification = specification;
-    if (this.specification?.info && !this.specification.info.version) {
-      this.specification.info.version = "0.0.1";
-    }
-    try {
-      if (specification === void 0 || specification === null) {
-        if (options?.throwOnError) {
-          throw new Error(ERRORS.EMPTY_OR_INVALID);
+export class Validator {
+    version;
+    static supportedVersions = OpenApiVersions;
+    // Object with function *or* object { errors: string }
+    ajvValidators = {};
+    errors;
+    specificationVersion;
+    specificationType;
+    specification;
+    /**
+     * Checks whether a specification is valid and all references can be resolved.
+     */
+    validate(filesystem, options) {
+        const entrypoint = filesystem.find((file) => file.isEntrypoint);
+        const specification = entrypoint?.specification;
+        // TODO: How does this work with a filesystem?
+        this.specification = specification;
+        // TODO: defaulting info.version to keep parser compatible with the previous one
+        // we should bubble this error up and not throw on it
+        if (this.specification?.info && !this.specification.info.version) {
+            this.specification.info.version = '0.0.1';
         }
-        return {
-          valid: false,
-          errors: transformErrors(specification, ERRORS.EMPTY_OR_INVALID)
-        };
-      }
-      const { version, specificationType, specificationVersion } = getOpenApiVersion(specification);
-      this.version = version;
-      this.specificationVersion = specificationVersion;
-      this.specificationType = specificationType;
-      if (!version) {
-        if (options?.throwOnError) {
-          throw new Error(ERRORS.OPENAPI_VERSION_NOT_SUPPORTED);
+        try {
+            // AnyObject is empty or invalid
+            if (specification === undefined || specification === null) {
+                if (options?.throwOnError) {
+                    throw new Error(ERRORS.EMPTY_OR_INVALID);
+                }
+                return {
+                    valid: false,
+                    errors: transformErrors(specification, ERRORS.EMPTY_OR_INVALID),
+                };
+            }
+            // Meta data about the specification
+            const { version, specificationType, specificationVersion } = getOpenApiVersion(specification);
+            this.version = version;
+            this.specificationVersion = specificationVersion;
+            this.specificationType = specificationType;
+            // AnyObject is not supported
+            if (!version) {
+                if (options?.throwOnError) {
+                    throw new Error(ERRORS.OPENAPI_VERSION_NOT_SUPPORTED);
+                }
+                return {
+                    valid: false,
+                    errors: transformErrors(specification, ERRORS.OPENAPI_VERSION_NOT_SUPPORTED),
+                };
+            }
+            // Get the correct OpenAPI validator
+            const validateSchema = this.getAjvValidator(version);
+            const schemaResult = validateSchema(specification);
+            // Error handling
+            if (validateSchema.errors) {
+                if (validateSchema.errors.length > 0) {
+                    if (options?.throwOnError) {
+                        throw new Error(validateSchema.errors[0].message);
+                    }
+                    return {
+                        valid: false,
+                        errors: transformErrors(specification, validateSchema.errors),
+                    };
+                }
+            }
+            // Check if the references are valid
+            const resolvedReferences = resolveReferences(filesystem, options);
+            const semanticErrors = validatePathParameters(resolvedReferences.schema);
+            const errors = [...resolvedReferences.errors, ...semanticErrors];
+            return {
+                valid: schemaResult && resolvedReferences.valid && semanticErrors.length === 0,
+                errors,
+                schema: resolvedReferences.schema,
+            };
         }
-        return {
-          valid: false,
-          errors: transformErrors(specification, ERRORS.OPENAPI_VERSION_NOT_SUPPORTED)
-        };
-      }
-      const validateSchema = this.getAjvValidator(version);
-      const schemaResult = validateSchema(specification);
-      if (validateSchema.errors) {
-        if (validateSchema.errors.length > 0) {
-          if (options?.throwOnError) {
-            throw new Error(validateSchema.errors[0].message);
-          }
-          return {
-            valid: false,
-            errors: transformErrors(specification, validateSchema.errors)
-          };
+        catch (error) {
+            // Something went horribly wrong!
+            if (options?.throwOnError) {
+                throw error;
+            }
+            return {
+                valid: false,
+                errors: transformErrors(specification, error.message ?? error),
+            };
         }
-      }
-      const resolvedReferences = resolveReferences(filesystem, options);
-      const semanticErrors = validatePathParameters(resolvedReferences.schema);
-      const errors = [...resolvedReferences.errors, ...semanticErrors];
-      return {
-        valid: schemaResult && resolvedReferences.valid && semanticErrors.length === 0,
-        errors,
-        schema: resolvedReferences.schema
-      };
-    } catch (error) {
-      if (options?.throwOnError) {
-        throw error;
-      }
-      return {
-        valid: false,
-        errors: transformErrors(specification, error.message ?? error)
-      };
-    }
-  }
-  /**
-   * Ajv JSON schema validator
-   */
-  getAjvValidator(version) {
-    if (this.ajvValidators[version]) {
-      return this.ajvValidators[version];
     }
-    const schema = OpenApiSpecifications[version];
-    const AjvClass = jsonSchemaVersions[schema.$schema];
-    const ajv = new AjvClass({
-      // Ajv is a bit too strict in its strict validation of OpenAPI schemas.
-      // Switch strict mode off.
-      strict: false,
-      // Enable discriminator support for better oneOf error messages
-      discriminator: true,
-      // Show all errors, not just the first one
-      allErrors: true
-    });
-    addFormats(ajv);
-    if (version === "3.1" || version === "3.2") {
-      ajv.addFormat("media-range", true);
+    /**
+     * Ajv JSON schema validator
+     */
+    getAjvValidator(version) {
+        // Schema loaded already
+        if (this.ajvValidators[version]) {
+            return this.ajvValidators[version];
+        }
+        // Load OpenAPI Schema
+        const schema = OpenApiSpecifications[version];
+        // Load JSON Schema
+        const AjvClass = jsonSchemaVersions[schema.$schema];
+        // Get the correct Ajv validator
+        const ajv = new AjvClass({
+            // Ajv is a bit too strict in its strict validation of OpenAPI schemas.
+            // Switch strict mode off.
+            strict: false,
+            // Enable discriminator support for better oneOf error messages
+            discriminator: true,
+            // Show all errors, not just the first one
+            allErrors: true,
+        });
+        // Register formats
+        // https://ajv.js.org/packages/ajv-formats.html#formats
+        addFormats(ajv);
+        // OpenAPI 3.1 and 3.2 uses media-range format
+        if (version === '3.1' || version === '3.2') {
+            ajv.addFormat('media-range', true);
+        }
+        return (this.ajvValidators[version] = ajv.compile(schema));
     }
-    return this.ajvValidators[version] = ajv.compile(schema);
-  }
 }
-export {
-  Validator
-};
-//# sourceMappingURL=Validator.js.map

package/dist/plugins/fetch-urls/fetch-urls.js

@@ -1,40 +1,41 @@
-const fetchUrlsDefaultConfiguration = {
-  limit: 20
+export const fetchUrlsDefaultConfiguration = {
+    limit: 20,
 };
-const fetchUrls = (customConfiguration) => {
-  let numberOfRequests = 0;
-  const configuration = {
-    ...fetchUrlsDefaultConfiguration,
-    ...customConfiguration
-  };
-  return {
-    check(value) {
-      if (typeof value !== "string") {
-        return false;
-      }
-      if (!value.startsWith("http://") && !value.startsWith("https://")) {
-        return false;
-      }
-      return true;
-    },
-    async get(value) {
-      if (configuration?.limit !== false && numberOfRequests >= configuration?.limit) {
-        console.warn(`[fetchUrls] Maximum number of requests reeached (${configuration?.limit}), skipping request`);
-        return void 0;
-      }
-      try {
-        numberOfRequests++;
-        const response = await (configuration?.fetch ? configuration.fetch(value) : fetch(value));
-        return await response.text();
-      } catch (error) {
-        console.error("[fetchUrls]", error.message, `(${value})`);
-        return void 0;
-      }
-    }
-  };
+export const fetchUrls = (customConfiguration) => {
+    // State
+    let numberOfRequests = 0;
+    // Configuration
+    const configuration = {
+        ...fetchUrlsDefaultConfiguration,
+        ...customConfiguration,
+    };
+    return {
+        check(value) {
+            // Not a string
+            if (typeof value !== 'string') {
+                return false;
+            }
+            // Not http/https
+            if (!value.startsWith('http://') && !value.startsWith('https://')) {
+                return false;
+            }
+            return true;
+        },
+        async get(value) {
+            // Limit ht enumber of requests
+            if (configuration?.limit !== false && numberOfRequests >= configuration?.limit) {
+                console.warn(`[fetchUrls] Maximum number of requests reeached (${configuration?.limit}), skipping request`);
+                return undefined;
+            }
+            try {
+                numberOfRequests++;
+                const response = await (configuration?.fetch ? configuration.fetch(value) : fetch(value));
+                return await response.text();
+            }
+            catch (error) {
+                console.error('[fetchUrls]', error.message, `(${value})`);
+                return undefined;
+            }
+        },
+    };
 };
-export {
-  fetchUrls,
-  fetchUrlsDefaultConfiguration
-};
-//# sourceMappingURL=fetch-urls.js.map

package/dist/plugins/fetch-urls/index.js

@@ -1,6 +1 @@
-import { fetchUrls, fetchUrlsDefaultConfiguration } from "./fetch-urls.js";
-export {
-  fetchUrls,
-  fetchUrlsDefaultConfiguration
-};
-//# sourceMappingURL=index.js.map
+export { fetchUrls, fetchUrlsDefaultConfiguration } from './fetch-urls.js';

package/dist/plugins/read-files/index.js

@@ -1,5 +1 @@
-import { readFiles } from "./read-files.js";
-export {
-  readFiles
-};
-//# sourceMappingURL=index.js.map
+export { readFiles } from './read-files.js';

package/dist/plugins/read-files/read-files.js

@@ -1,52 +1,54 @@
-import fs from "node:fs";
-import { dirname, join } from "node:path";
-import { ERRORS } from "../../configuration/index.js";
-import { isJson } from "../../utils/is-json.js";
-import { isYaml } from "../../utils/is-yaml.js";
-const readFiles = () => {
-  return {
-    check(value) {
-      if (typeof value !== "string") {
-        return false;
-      }
-      if (value.startsWith("http://") || value.startsWith("https://")) {
-        return false;
-      }
-      if (value.includes("\n")) {
-        return false;
-      }
-      if (isJson(value)) {
-        return false;
-      }
-      if (isYaml(value)) {
-        return false;
-      }
-      return true;
-    },
-    get(value) {
-      if (!fs.existsSync(value)) {
-        throw new Error(ERRORS.FILE_DOES_NOT_EXIST.replace("%s", value));
-      }
-      try {
-        return fs.readFileSync(value, "utf-8");
-      } catch (error) {
-        console.error("[readFiles]", error);
-        return false;
-      }
-    },
-    resolvePath(value, reference) {
-      const dir = dirname(value);
-      return join(dir, reference);
-    },
-    getDir(value) {
-      return dirname(value);
-    },
-    getFilename(value) {
-      return value.split("/").pop();
-    }
-  };
+import fs from 'node:fs';
+import { dirname, join } from 'node:path';
+import { ERRORS } from '../../configuration/index.js';
+import { isJson } from '../../utils/is-json.js';
+import { isYaml } from '../../utils/is-yaml.js';
+export const readFiles = () => {
+    return {
+        check(value) {
+            // Not a string
+            if (typeof value !== 'string') {
+                return false;
+            }
+            // URL
+            if (value.startsWith('http://') || value.startsWith('https://')) {
+                return false;
+            }
+            // Line breaks
+            if (value.includes('\n')) {
+                return false;
+            }
+            // JSON
+            if (isJson(value)) {
+                return false;
+            }
+            // YAML (run through YAML.parse)
+            if (isYaml(value)) {
+                return false;
+            }
+            return true;
+        },
+        get(value) {
+            if (!fs.existsSync(value)) {
+                throw new Error(ERRORS.FILE_DOES_NOT_EXIST.replace('%s', value));
+            }
+            try {
+                return fs.readFileSync(value, 'utf-8');
+            }
+            catch (error) {
+                console.error('[readFiles]', error);
+                return false;
+            }
+        },
+        resolvePath(value, reference) {
+            const dir = dirname(value);
+            return join(dir, reference);
+        },
+        getDir(value) {
+            return dirname(value);
+        },
+        getFilename(value) {
+            return value.split('/').pop();
+        },
+    };
 };
-export {
-  readFiles
-};
-//# sourceMappingURL=read-files.js.map