@amritk/lint 0.3.2 → 0.3.3

package/dist/rules/openapi/functions/oas-example-value.js

@@ -1,31 +1,28 @@
-import { isObject } from './helpers.js';
-// OpenAPI 3.2 Example Object exclusivity (MUST-level, per the spec's field
-// table). The `value`/`externalValue` pair is intentionally omitted here — the
-// 3.x-wide `oas3-examples-value-or-externalValue` rule already covers it, so we
-// only police the constraints introduced with the new `dataValue` /
-// `serializedValue` fields to avoid double-reporting.
+import { isObject } from "./helpers.js";
 const EXAMPLE_EXCLUSIONS = [
-    // dataValue MUST NOT accompany value.
-    { field: 'dataValue', conflicts: ['value'] },
-    // serializedValue MUST NOT accompany value or externalValue.
-    { field: 'serializedValue', conflicts: ['value', 'externalValue'] },
+  // dataValue MUST NOT accompany value.
+  { field: "dataValue", conflicts: ["value"] },
+  // serializedValue MUST NOT accompany value or externalValue.
+  { field: "serializedValue", conflicts: ["value", "externalValue"] }
 ];
-/** Flags forbidden field combinations on an OpenAPI 3.2 Example Object. */
-export const oasExampleValue = (example, _options, context) => {
-    if (!isObject(example))
-        return [];
-    const results = [];
-    for (const { field, conflicts } of EXAMPLE_EXCLUSIONS) {
-        if (example[field] === undefined)
-            continue;
-        for (const other of conflicts) {
-            if (example[other] !== undefined) {
-                results.push({
-                    message: `"${field}" must not be used together with "${other}"`,
-                    path: [...context.path, other],
-                });
-            }
-        }
+const oasExampleValue = (example, _options, context) => {
+  if (!isObject(example))
+    return [];
+  const results = [];
+  for (const { field, conflicts } of EXAMPLE_EXCLUSIONS) {
+    if (example[field] === void 0)
+      continue;
+    for (const other of conflicts) {
+      if (example[other] !== void 0) {
+        results.push({
+          message: `"${field}" must not be used together with "${other}"`,
+          path: [...context.path, other]
+        });
+      }
     }
-    return results;
+  }
+  return results;
+};
+export {
+  oasExampleValue
 };

package/dist/rules/openapi/functions/oas-mutually-exclusive.js

@@ -1,20 +1,16 @@
-import { isObject } from './helpers.js';
-/**
- * Flags objects that carry more than one of a set of mutually exclusive
- * properties. OpenAPI 3.1's License Object, for example, defines `identifier`
- * (SPDX) as "mutually exclusive of the url field" — neither, or exactly one, is
- * allowed, but not both.
- */
-export const oasMutuallyExclusive = (input, options, context) => {
-    if (!isObject(input))
-        return [];
-    const present = (options?.properties ?? []).filter((property) => input[property] !== undefined);
-    if (present.length <= 1)
-        return [];
-    // The first present property is the "anchor"; flag every later one as the conflict.
-    const [anchor, ...conflicts] = present;
-    return conflicts.map((property) => ({
-        message: `"${property}" must not be used together with "${anchor}" (mutually exclusive)`,
-        path: [...context.path, property],
-    }));
+import { isObject } from "./helpers.js";
+const oasMutuallyExclusive = (input, options, context) => {
+  if (!isObject(input))
+    return [];
+  const present = (options?.properties ?? []).filter((property) => input[property] !== void 0);
+  if (present.length <= 1)
+    return [];
+  const [anchor, ...conflicts] = present;
+  return conflicts.map((property) => ({
+    message: `"${property}" must not be used together with "${anchor}" (mutually exclusive)`,
+    path: [...context.path, property]
+  }));
+};
+export {
+  oasMutuallyExclusive
 };

package/dist/rules/openapi/functions/oas-no-nullable.js

@@ -1,22 +1,14 @@
-import { isObject } from './helpers.js';
-/**
- * Flags a Schema Object's `nullable` keyword, removed in OpenAPI 3.1+ (JSON
- * Schema 2020-12 uses a `"null"` type instead). Targets the *parent* of a
- * `nullable` key (`$..nullable^`) rather than `$..nullable` directly, which fixes
- * two problems with the naive `then: falsy` approach:
- *   - a property literally named `nullable` (`properties: { nullable: {...} }`)
- *     is no longer flagged, because there the `nullable` value is a Schema Object,
- *     not the boolean keyword, and
- *   - `nullable: false` is flagged too (a boolean of either value counts as the
- *     keyword being present), so the migration fixer can drop it.
- */
-export const oasNoNullable = (parent, _options, context) => {
-    if (!isObject(parent) || typeof parent['nullable'] !== 'boolean')
-        return [];
-    return [
-        {
-            message: 'nullable is not available in OpenAPI 3.1 or later; use a "null" type instead.',
-            path: [...context.path, 'nullable'],
-        },
-    ];
+import { isObject } from "./helpers.js";
+const oasNoNullable = (parent, _options, context) => {
+  if (!isObject(parent) || typeof parent["nullable"] !== "boolean")
+    return [];
+  return [
+    {
+      message: 'nullable is not available in OpenAPI 3.1 or later; use a "null" type instead.',
+      path: [...context.path, "nullable"]
+    }
+  ];
+};
+export {
+  oasNoNullable
 };

package/dist/rules/openapi/functions/oas-op-form-data-consume-check.js

@@ -1,21 +1,23 @@
-import { isObject } from './helpers.js';
-/** Validates OpenAPI v2 formData operations declare a compatible `consumes`. */
-export const oasOpFormDataConsumeCheck = (operation, _options, context) => {
-    if (!isObject(operation))
-        return [];
-    const params = Array.isArray(operation['parameters']) ? operation['parameters'] : [];
-    const hasFormData = params.some((param) => isObject(param) && param['in'] === 'formData');
-    if (!hasFormData)
-        return [];
-    const consumes = Array.isArray(operation['consumes']) ? operation['consumes'] : [];
-    const ok = consumes.some((type) => type === 'application/x-www-form-urlencoded' || type === 'multipart/form-data');
-    if (!ok) {
-        return [
-            {
-                message: 'Operations with formData parameters must consume application/x-www-form-urlencoded or multipart/form-data',
-                path: [...context.path, 'consumes'],
-            },
-        ];
-    }
+import { isObject } from "./helpers.js";
+const oasOpFormDataConsumeCheck = (operation, _options, context) => {
+  if (!isObject(operation))
     return [];
+  const params = Array.isArray(operation["parameters"]) ? operation["parameters"] : [];
+  const hasFormData = params.some((param) => isObject(param) && param["in"] === "formData");
+  if (!hasFormData)
+    return [];
+  const consumes = Array.isArray(operation["consumes"]) ? operation["consumes"] : [];
+  const ok = consumes.some((type) => type === "application/x-www-form-urlencoded" || type === "multipart/form-data");
+  if (!ok) {
+    return [
+      {
+        message: "Operations with formData parameters must consume application/x-www-form-urlencoded or multipart/form-data",
+        path: [...context.path, "consumes"]
+      }
+    ];
+  }
+  return [];
+};
+export {
+  oasOpFormDataConsumeCheck
 };

package/dist/rules/openapi/functions/oas-op-id-unique.js

@@ -1,29 +1,29 @@
-import { isObject, OPERATION_METHODS } from './helpers.js';
-/** Ensures `operationId` values are unique across the document. */
-export const oasOpIdUnique = (paths, _options, context) => {
-    if (!isObject(paths))
-        return [];
-    const seen = new Set();
-    const results = [];
-    for (const [path, item] of Object.entries(paths)) {
-        if (!isObject(item))
-            continue;
-        for (const [method, operation] of Object.entries(item)) {
-            // Only real operations carry an `operationId`; an `x-`extension object with
-            // an `operationId`-looking key would otherwise create a phantom duplicate.
-            if (!OPERATION_METHODS.has(method) || !isObject(operation))
-                continue;
-            const id = operation['operationId'];
-            if (typeof id !== 'string')
-                continue;
-            if (seen.has(id)) {
-                results.push({
-                    message: `operationId "${id}" must be unique`,
-                    path: [...context.path, path, method, 'operationId'],
-                });
-            }
-            seen.add(id);
-        }
+import { isObject, OPERATION_METHODS } from "./helpers.js";
+const oasOpIdUnique = (paths, _options, context) => {
+  if (!isObject(paths))
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const [path, item] of Object.entries(paths)) {
+    if (!isObject(item))
+      continue;
+    for (const [method, operation] of Object.entries(item)) {
+      if (!OPERATION_METHODS.has(method) || !isObject(operation))
+        continue;
+      const id = operation["operationId"];
+      if (typeof id !== "string")
+        continue;
+      if (seen.has(id)) {
+        results.push({
+          message: `operationId "${id}" must be unique`,
+          path: [...context.path, path, method, "operationId"]
+        });
+      }
+      seen.add(id);
     }
-    return results;
+  }
+  return results;
+};
+export {
+  oasOpIdUnique
 };

package/dist/rules/openapi/functions/oas-op-params.js

@@ -1,46 +1,40 @@
-import { isObject } from './helpers.js';
-/**
- * Validates an operation's `parameters` array, mirroring Spectral's `oasOpParams`:
- * flags duplicate `name`+`in` combinations, and — for OpenAPI 2.0, where the body
- * is a parameter — flags more than one `in: body` parameter (even with different
- * names) as well as mixing `in: body` with `in: formData`. `$ref` entries are
- * skipped because their real `name`/`in` is only known after resolution.
- */
-export const oasOpParams = (params, _options, context) => {
-    if (!Array.isArray(params))
-        return [];
-    const results = [];
-    const seen = new Set();
-    const bodyIndices = [];
-    const formDataIndices = [];
-    params.forEach((param, index) => {
-        if (!isObject(param) || '$ref' in param)
-            return;
-        if (param['name'] !== undefined && param['in'] !== undefined) {
-            const key = `${String(param['in'])}:${String(param['name'])}`;
-            if (seen.has(key)) {
-                results.push({
-                    message: `Duplicate parameter "${String(param['name'])}" in "${String(param['in'])}"`,
-                    path: [...context.path, index],
-                });
-            }
-            seen.add(key);
-        }
-        if (param['in'] === 'body')
-            bodyIndices.push(index);
-        else if (param['in'] === 'formData')
-            formDataIndices.push(index);
-    });
-    // OAS2 allows at most one body parameter, and body and formData are mutually
-    // exclusive within a single operation.
-    if (bodyIndices.length > 0 && formDataIndices.length > 0) {
-        results.push({ message: 'Operation must not have both "in:body" and "in:formData" parameters' });
-    }
-    for (let i = 1; i < bodyIndices.length; i++) {
+import { isObject } from "./helpers.js";
+const oasOpParams = (params, _options, context) => {
+  if (!Array.isArray(params))
+    return [];
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const bodyIndices = [];
+  const formDataIndices = [];
+  params.forEach((param, index) => {
+    if (!isObject(param) || "$ref" in param)
+      return;
+    if (param["name"] !== void 0 && param["in"] !== void 0) {
+      const key = `${String(param["in"])}:${String(param["name"])}`;
+      if (seen.has(key)) {
         results.push({
-            message: 'Operation must not have more than a single instance of the "in:body" parameter',
-            path: [...context.path, bodyIndices[i]],
+          message: `Duplicate parameter "${String(param["name"])}" in "${String(param["in"])}"`,
+          path: [...context.path, index]
         });
+      }
+      seen.add(key);
     }
-    return results;
+    if (param["in"] === "body")
+      bodyIndices.push(index);
+    else if (param["in"] === "formData")
+      formDataIndices.push(index);
+  });
+  if (bodyIndices.length > 0 && formDataIndices.length > 0) {
+    results.push({ message: 'Operation must not have both "in:body" and "in:formData" parameters' });
+  }
+  for (let i = 1; i < bodyIndices.length; i++) {
+    results.push({
+      message: 'Operation must not have more than a single instance of the "in:body" parameter',
+      path: [...context.path, bodyIndices[i]]
+    });
+  }
+  return results;
+};
+export {
+  oasOpParams
 };

package/dist/rules/openapi/functions/oas-op-security-defined.js

@@ -1,44 +1,45 @@
-import { isObject, OPERATION_METHODS } from './helpers.js';
-/** Walks `path` into `root`, returning the nested value or undefined. */
+import { isObject, OPERATION_METHODS } from "./helpers.js";
 const getIn = (root, path) => {
-    let current = root;
-    for (const key of path) {
-        if (!isObject(current))
-            return undefined;
-        current = current[key];
-    }
-    return current;
+  let current = root;
+  for (const key of path) {
+    if (!isObject(current))
+      return void 0;
+    current = current[key];
+  }
+  return current;
 };
-/** Validates that every referenced security scheme is defined. */
-export const oasOpSecurityDefined = (root, options, context) => {
-    if (!isObject(root))
-        return [];
-    const schemes = getIn(root, options?.schemesPath ?? []);
-    const defined = new Set(isObject(schemes) ? Object.keys(schemes) : []);
-    const results = [];
-    const check = (security, path) => {
-        if (!Array.isArray(security))
-            return;
-        security.forEach((requirement, index) => {
-            if (!isObject(requirement))
-                return;
-            for (const name of Object.keys(requirement)) {
-                if (!defined.has(name)) {
-                    results.push({ message: `Security scheme "${name}" is not defined`, path: [...path, index, name] });
-                }
-            }
-        });
-    };
-    check(root['security'], [...context.path, 'security']);
-    const paths = isObject(root['paths']) ? root['paths'] : {};
-    for (const [path, item] of Object.entries(paths)) {
-        if (!isObject(item))
-            continue;
-        for (const [method, operation] of Object.entries(item)) {
-            if (OPERATION_METHODS.has(method) && isObject(operation)) {
-                check(operation['security'], [...context.path, 'paths', path, method, 'security']);
-            }
+const oasOpSecurityDefined = (root, options, context) => {
+  if (!isObject(root))
+    return [];
+  const schemes = getIn(root, options?.schemesPath ?? []);
+  const defined = new Set(isObject(schemes) ? Object.keys(schemes) : []);
+  const results = [];
+  const check = (security, path) => {
+    if (!Array.isArray(security))
+      return;
+    security.forEach((requirement, index) => {
+      if (!isObject(requirement))
+        return;
+      for (const name of Object.keys(requirement)) {
+        if (!defined.has(name)) {
+          results.push({ message: `Security scheme "${name}" is not defined`, path: [...path, index, name] });
         }
+      }
+    });
+  };
+  check(root["security"], [...context.path, "security"]);
+  const paths = isObject(root["paths"]) ? root["paths"] : {};
+  for (const [path, item] of Object.entries(paths)) {
+    if (!isObject(item))
+      continue;
+    for (const [method, operation] of Object.entries(item)) {
+      if (OPERATION_METHODS.has(method) && isObject(operation)) {
+        check(operation["security"], [...context.path, "paths", path, method, "security"]);
+      }
     }
-    return results;
+  }
+  return results;
+};
+export {
+  oasOpSecurityDefined
 };

package/dist/rules/openapi/functions/oas-op-success-response.js

@@ -1,16 +1,14 @@
-import { isObject } from './helpers.js';
-// A success response is any 2xx/3xx status code, or a `2XX`/`3XX` wildcard (3.x).
-// `default` is intentionally NOT counted — it can carry any status, including an
-// error, so it does not prove the operation has a success response (this matches
-// Spectral, which counts only codes in the [200, 400) range plus the wildcards).
+import { isObject } from "./helpers.js";
 const SUCCESS_CODE = /^[23](\d\d|XX)$/;
-/** Ensures every operation declares at least one 2xx or 3xx response. */
-export const oasOpSuccessResponse = (responses) => {
-    if (!isObject(responses))
-        return [];
-    const hasSuccess = Object.keys(responses).some((code) => SUCCESS_CODE.test(code));
-    if (!hasSuccess) {
-        return [{ message: 'Operation must define at least one 2xx or 3xx response' }];
-    }
+const oasOpSuccessResponse = (responses) => {
+  if (!isObject(responses))
     return [];
+  const hasSuccess = Object.keys(responses).some((code) => SUCCESS_CODE.test(code));
+  if (!hasSuccess) {
+    return [{ message: "Operation must define at least one 2xx or 3xx response" }];
+  }
+  return [];
+};
+export {
+  oasOpSuccessResponse
 };

package/dist/rules/openapi/functions/oas-path-param.js

@@ -1,106 +1,85 @@
-import { isObject, OPERATION_METHODS } from './helpers.js';
-// Path template parameters, e.g. `{id}`. Matches Spectral's grammar so matrix
-// (`{;id}`), optional (`{id?}`), and explode (`{id*}`) markers are stripped off
-// the captured name before comparison.
+import { isObject, OPERATION_METHODS } from "./helpers.js";
 const PATH_TEMPLATE = /(\{;?\??[a-zA-Z0-9_-]+\*?\})/g;
-const namedPathParam = (param) => param['in'] === 'path' && typeof param['name'] === 'string' ? param['name'] : undefined;
-/**
- * Records a single `in: path` definition, emitting Spectral's `required: true`
- * and duplicate-definition findings. Returns the parameter name when it is the
- * first definition seen (so the caller registers it as usable), else undefined.
- */
+const namedPathParam = (param) => param["in"] === "path" && typeof param["name"] === "string" ? param["name"] : void 0;
 const recordPathParam = (param, definitionPath, seen, results) => {
-    const name = namedPathParam(param);
-    if (name === undefined)
-        return undefined;
-    if (param['required'] !== true) {
+  const name = namedPathParam(param);
+  if (name === void 0)
+    return void 0;
+  if (param["required"] !== true) {
+    results.push({
+      message: `Path parameter "${name}" must have a "required" property that is set to "true"`,
+      path: definitionPath
+    });
+  }
+  if (name in seen) {
+    results.push({ message: `Path parameter "${name}" must not be defined multiple times`, path: definitionPath });
+    return void 0;
+  }
+  return name;
+};
+const oasPathParam = (paths, _options, context) => {
+  if (!isObject(paths))
+    return [];
+  const results = [];
+  for (const [path, item] of Object.entries(paths)) {
+    if (!isObject(item))
+      continue;
+    const templates = [];
+    for (const match of path.matchAll(PATH_TEMPLATE)) {
+      const name = match[0].replace(/[{}?*;]/g, "");
+      if (templates.includes(name)) {
         results.push({
-            message: `Path parameter "${name}" must have a "required" property that is set to "true"`,
-            path: definitionPath,
+          message: `Path "${path}" must not use parameter "{${name}}" more than once`,
+          path: [...context.path, path]
         });
+      } else {
+        templates.push(name);
+      }
     }
-    if (name in seen) {
-        results.push({ message: `Path parameter "${name}" must not be defined multiple times`, path: definitionPath });
-        return undefined;
+    const topParams = {};
+    if (Array.isArray(item["parameters"])) {
+      item["parameters"].forEach((param, index) => {
+        if (!isObject(param))
+          return;
+        const definitionPath = [...context.path, path, "parameters", index];
+        const name = recordPathParam(param, definitionPath, topParams, results);
+        if (name !== void 0)
+          topParams[name] = definitionPath;
+      });
     }
-    return name;
-};
-/**
- * Validates path templating per operation, mirroring Spectral's `oasPathParam`.
- * For each operation on a path it checks that (a) every `{template}` in the path
- * has a matching `in: path` definition, (b) every `in: path` definition is used
- * in the template, (c) path parameters carry `required: true`, (d) a template is
- * not repeated in the path key, and (e) a parameter is not defined twice. Path
- * Item level parameters are merged with the operation's own parameters. Runs on
- * the resolved document (the rule is `resolved: true`), so `$ref`d parameters are
- * already inlined.
- */
-export const oasPathParam = (paths, _options, context) => {
-    if (!isObject(paths))
-        return [];
-    const results = [];
-    for (const [path, item] of Object.entries(paths)) {
-        if (!isObject(item))
-            continue;
-        // (d) Templates declared in the path key, deduplicated (a repeat is an error).
-        const templates = [];
-        for (const match of path.matchAll(PATH_TEMPLATE)) {
-            const name = match[0].replace(/[{}?*;]/g, '');
-            if (templates.includes(name)) {
-                results.push({
-                    message: `Path "${path}" must not use parameter "{${name}}" more than once`,
-                    path: [...context.path, path],
-                });
-            }
-            else {
-                templates.push(name);
-            }
-        }
-        // Path Item level parameters apply to every operation on the path.
-        const topParams = {};
-        if (Array.isArray(item['parameters'])) {
-            item['parameters'].forEach((param, index) => {
-                if (!isObject(param))
-                    return;
-                const definitionPath = [...context.path, path, 'parameters', index];
-                const name = recordPathParam(param, definitionPath, topParams, results);
-                if (name !== undefined)
-                    topParams[name] = definitionPath;
-            });
+    for (const [method, operation] of Object.entries(item)) {
+      if (method === "parameters" || !OPERATION_METHODS.has(method) || !isObject(operation))
+        continue;
+      const operationPath = [...context.path, path, method];
+      const operationParams = {};
+      if (Array.isArray(operation["parameters"])) {
+        operation["parameters"].forEach((param, index) => {
+          if (!isObject(param))
+            return;
+          const definitionPath = [...operationPath, "parameters", index];
+          const name = recordPathParam(param, definitionPath, operationParams, results);
+          if (name !== void 0)
+            operationParams[name] = definitionPath;
+        });
+      }
+      const defined = { ...topParams, ...operationParams };
+      for (const [name, definitionPath] of Object.entries(defined)) {
+        if (definitionPath && !templates.includes(name)) {
+          results.push({ message: `Parameter "${name}" must be used in path "${path}"`, path: definitionPath });
         }
-        for (const [method, operation] of Object.entries(item)) {
-            if (method === 'parameters' || !OPERATION_METHODS.has(method) || !isObject(operation))
-                continue;
-            const operationPath = [...context.path, path, method];
-            // Each operation is evaluated against its own params plus the shared path-item ones.
-            const operationParams = {};
-            if (Array.isArray(operation['parameters'])) {
-                operation['parameters'].forEach((param, index) => {
-                    if (!isObject(param))
-                        return;
-                    const definitionPath = [...operationPath, 'parameters', index];
-                    const name = recordPathParam(param, definitionPath, operationParams, results);
-                    if (name !== undefined)
-                        operationParams[name] = definitionPath;
-                });
-            }
-            const defined = { ...topParams, ...operationParams };
-            // (b) Every defined `in: path` parameter must appear in the path template.
-            for (const [name, definitionPath] of Object.entries(defined)) {
-                if (definitionPath && !templates.includes(name)) {
-                    results.push({ message: `Parameter "${name}" must be used in path "${path}"`, path: definitionPath });
-                }
-            }
-            // (a) Every `{template}` must have a matching definition on the operation.
-            for (const name of templates) {
-                if (!(name in defined)) {
-                    results.push({
-                        message: `Operation must define path parameter "{${name}}" as expected by path "${path}"`,
-                        path: operationPath,
-                    });
-                }
-            }
+      }
+      for (const name of templates) {
+        if (!(name in defined)) {
+          results.push({
+            message: `Operation must define path parameter "{${name}}" as expected by path "${path}"`,
+            path: operationPath
+          });
         }
+      }
     }
-    return results;
+  }
+  return results;
+};
+export {
+  oasPathParam
 };