api-quality-spectral-ruleset 1.5.0-beta.3 → 1.5.0

package/apq-spectral.yaml

@@ -40,6 +40,11 @@ functions:
   - apq-string-parameter-integrity
   - apq-example-schema-types
   - apq-standard-response-schema
+  - apq-allowed-http-verbs
+  - apq-url-naming-convention
+  - apq-mandatory-response-codes
+  - apq-rate-limit-response
+  - apq-forbidden-query-format
 extends:
   - spectral:asyncapi
   - spectral:oas
@@ -117,12 +122,14 @@ rules:
         function: truthy
   apiq:OAR008:
     description: "HTTP verbs not encouraged."
-    message: "OAR008: Only the REST standard verbs are allowed (POST, GET, PUT, PATCH and DELETE)."
+    message: "{{error}}"
     documentationUrl: "https://github.com/apiaddicts/apquality-spectral/blob/main/docs/resources/OAR008.md"
     severity: error
-    given: "$.paths[*][head,options,trace]"
+    given: "$.paths[*]"
     then:
-      function: falsy
+      function: apq-allowed-http-verbs
+      functionOptions:
+        allowed-verbs: "get,post,put,delete,patch"
   apiq:OAR009:
     description: "Default request media type should be defined for operations."
     message: "OAR009: Default request media type is mandatory."
@@ -138,18 +145,21 @@ rules:
     given: "$.paths[*][get,post,put,patch,delete]"
     then:
       function: apq-response-media-type
+      functionOptions:
+        default-media-type: "application/json"
+        media-type-exceptions: "-"
   apiq:OAR011:
-    description: "URLs should follow the specified naming convention: all literal path segments must be in kebab-case."
-    message: "OAR011: The resource names with more than two words must be compliant with the standard naming convention (kebab-case)."
+    description: "URLs should follow the configured naming convention (default kebab-case): all literal path segments must comply."
+    message: "{{error}}"
     documentationUrl: "https://github.com/apiaddicts/apquality-spectral/blob/main/docs/resources/OAR011.md"
     severity: error
     given:
       - "$.paths[*]~"
       - "$.servers[*].url"
     then:
-      function: pattern
+      function: apq-url-naming-convention
       functionOptions:
-        match: "^(https?:\\/\\/[^\\/]+)?(\\/(?:[a-z0-9]+(?:-[a-z0-9]+)*|\\{[^}]+\\}))*\\/?$"
+        naming-convention: "kebab-case"
   apiq:OAR012:
     description: "Path params, query params, object names and property names should follow the configured naming convention. You can configure snake_case (default), kebab-case, camelCase or UpperCamelCase"
     message: "OAR012: Path params, query params, object names and property names must follow the configured naming convention."
@@ -215,7 +225,7 @@ rules:
     then:
       function: apq-alternate-paths
       functionOptions:
-        except: ["me", "get", "search", "delete"]
+        exclude_patterns: "get,me,search,delete"
   apiq:OAR018:
     description: Operation not recommended for resource path depending on HTTP verb
     message: "OAR018: Operation not recommended for resource path: {{path}} ({{verb}})"
@@ -355,12 +365,16 @@ rules:
       field: "headers.Location.schema.type"
       function: truthy
   apiq:OAR028:
-    description: "$filter must be defined as a query parameter in all collection operations (excluding detail endpoints and health checks)."
-    message: "OAR028: $filter must be defined as a query parameter in this operation."
+    description: "$filter must be defined as a query parameter in the collection GET operations selected by the configured paths."
+    message: "{{error}}"
     severity: warn
-    given: "$.paths[?(!@property.match(/\\/me(\\/|$)/) && !@property.match(/\\/\\{[^}]+\\}$/) && !@property.match(/status|health|ping/))].get"
+    given: "$.paths"
     then:
-      function: apq-has-filter-query-param
+      function: apq-collection-query-param-required
+      functionOptions:
+        parameterName: "$filter"
+        paths: "/examples"
+        pathValidationStrategy: "/include"
   apiq:OAR029:
     description: "A response not compliant with the standard may cause application issues."
     message: "{{error}}"
@@ -398,13 +412,13 @@ rules:
         validateProperty: true
   apiq:OAR032:
     description: "Ambiguous path parts not encouraged."
-    message: "OAR032: When reading a URL, it must be possible to interpret which resources it is referring to in a concrete way. Ambiguous names in resources must be avoided."
+    message: "{{error}}"
     severity: error
     given: "$.paths.*~"
     then:
       function: apq-check-ambiguous-path
       functionOptions:
-        ambiguous-words: "elements,instances,resources,values,terms,objects,items"
+        ambiguous-names: "elementos,instancias,recursos,valores,terminos,objetos,articulos,elements,instances,resources,values,terms,objects,items"
   apiq:OAR033:
     description: "Request operation parameters must not include forbidden headers (Accept, Content-Type, Authorization). Note: This validates REQUEST headers, not response headers (see OAR053/114 for response header validation)."
     message: "OAR033: The request header parameter '{{value}}' is not allowed in operations."
@@ -695,75 +709,59 @@ rules:
         path-exclusions: "/status"
   apiq:OAR061:
     description: "Ensure get have mandatory response codes"
-    message: "OAR061: Ensure get have the mandatory response codes"
+    message: "{{error}}"
     severity: error
-    given: "$.paths[?(@property !== '/status')].get.responses"
+    given: "$.paths[*][get]"
     then:
-      function: schema
+      function: apq-mandatory-response-codes
       functionOptions:
-        schema:
-          oneOf:
-          - required: ['200']
-          - required: ['202']
-          - required: ['206']
-            not:
-              required: ['201', '204']
+        mandatory-response-codes: "200, 202, 206"
+        paths: "/status, /another"
+        pathValidationStrategy: "/exclude"
   apiq:OAR062:
     description: "Ensure post have mandatory response codes"
-    message: "OAR062: Ensure post have the mandatory response codes"
+    message: "{{error}}"
     severity: error
-    given: "$.paths[?(@property !== '/status')].post.responses"
+    given: "$.paths[*][post]"
     then:
-      function: schema
+      function: apq-mandatory-response-codes
       functionOptions:
-        schema:
-          oneOf:
-          - required: ['200']
-          - required: ['201']
-          - required: ['202']
-          - required: ['204']
-          - required: ['206']
+        mandatory-response-codes: "200, 201, 202, 204, 206"
+        paths: "/status, /another"
+        pathValidationStrategy: "/exclude"
   apiq:OAR063:
     description: "Ensure put have mandatory response codes"
-    message: "OAR063: Ensure put have the mandatory response codes"
+    message: "{{error}}"
     severity: error
-    given: "$.paths[?(@property !== '/status')].put.responses"
+    given: "$.paths[*][put]"
     then:
-      function: schema
+      function: apq-mandatory-response-codes
       functionOptions:
-        schema:
-          oneOf:
-          - required: ['200']
-          - required: ['202']
-          - required: ['204']
-          - required: ['206']
+        mandatory-response-codes: "200, 202, 204, 206"
+        paths: "/status, /another"
+        pathValidationStrategy: "/exclude"
   apiq:OAR064:
     description: "Ensure patch have mandatory response codes"
-    message: "OAR064: Ensure patch have the mandatory response codes"
+    message: "{{error}}"
     severity: error
-    given: "$.paths[?(@property !== '/status')].patch.responses"
+    given: "$.paths[*][patch]"
     then:
-      function: schema
+      function: apq-mandatory-response-codes
       functionOptions:
-        schema:
-          oneOf:
-          - required: ['200']
-          - required: ['202']
-          - required: ['204']
-          - required: ['206']
+        mandatory-response-codes: "200, 202, 204, 206"
+        paths: "/status, /another"
+        pathValidationStrategy: "/exclude"
   apiq:OAR065:
     description: "Ensure delete have mandatory response codes"
-    message: "OAR065: Ensure delete have the mandatory response codes"
+    message: "{{error}}"
     severity: error
-    given: "$.paths[?(@property !== '/status')].delete.responses"
+    given: "$.paths[*][delete]"
     then:
-      function: schema
+      function: apq-mandatory-response-codes
       functionOptions:
-        schema:
-          oneOf:
-          - required: ['200']
-          - required: ['202']
-          - required: ['204']
+        mandatory-response-codes: "200, 202, 204"
+        paths: "/status, /another"
+        pathValidationStrategy: "/exclude"
   apiq:OAR066:
     description: "RequestBody and Responses schema property names must be compliant with the snake_case naming convention."
     message: "OAR066: RequestBody and Responses schema property names must be compliant with the snake_case naming convention."
@@ -834,10 +832,12 @@ rules:
     description: "API should include a 429 response to indicate rate limiting, except for health check paths like /status, /health, /health-check, /ping, /liveness, /readiness."
     message: "OAR073: API should include a 429 response to indicate rate limiting."
     severity: error
-    given: "$.paths[?(@property !== '/status' && @property !== '/health' && @property !== '/health-check' && @property !== '/ping' && @property !== '/liveness' && @property !== '/readiness')][*].responses"
+    given: "$.paths[*][get,post,put,patch,delete]"
     then:
-      field: "429"
-      function: truthy
+      function: apq-rate-limit-response
+      functionOptions:
+        paths: "/status, /health, /health-check, /ping, /liveness, /readiness"
+        pathValidationStrategy: "/exclude"
   apiq:OAR074:
     description: "Numeric parameters should define minimum and maximum, or a format restriction."
     message: "OAR074: Numeric parameter should define both 'minimum' and 'maximum', or a 'format' restriction."
@@ -898,7 +898,8 @@ rules:
     then:
       function: apq-require-response-on-path-params
       functionOptions:
-        response: "404"
+        paths: "/status"
+        pathValidationStrategy: "/exclude"
   apiq:OAR080:
     description: "The security scheme must be among those allowed by the organization and must be complete."
     message: "OAR080: The security scheme '{{property}}' must be among those allowed by the organization and must be complete."
@@ -936,15 +937,16 @@ rules:
       functionOptions:
         notMatch: "^(email|password)$"
   apiq:OAR084:
-    description: "The format password should not pass through the querystring."
-    message: "OAR084: The format password should not be used in querystring parameters."
+    description: "Some formats should not pass through this querystring."
+    message: "{{error}}"
     severity: error
     given: "$.paths[*][get,post,put,patch,delete].parameters[?(@.in == 'query')]"
     then:
-      field: "schema.format"
-      function: pattern
+      function: apq-forbidden-query-format
       functionOptions:
-        notMatch: "^password$"
+        forbidden-query-formats: "password"
+        paths: "/examples"
+        pathValidationStrategy: "/include"
   apiq:OAR085:
     description: "The OpenAPI version must be one of: 2.0, 3.0.0, 3.0.1, 3.0.2, 3.0.3, 3.0.4, 3.1.0, 3.1.1, 3.1.2, 3.2.0."
     message: "{{error}}"

package/functions/apq-allowed-http-verbs.js

@@ -0,0 +1,31 @@
+const HTTP_VERBS = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];
+
+/**
+ * @param {object} given
+ * @param {object} options
+ * @param {import('@stoplight/spectral-core').RulesetFunctionContext} context
+ */
+module.exports = (given, options, context) => {
+  if (!given || typeof given !== 'object') {
+    return [];
+  }
+
+  const allowedVerbs = ((options && options['allowed-verbs']) || '')
+    .split(',')
+    .map((verb) => verb.trim().toLowerCase())
+    .filter(Boolean);
+
+  const basePath = context.path || [];
+  const errors = [];
+
+  HTTP_VERBS.forEach((verb) => {
+    if (Object.prototype.hasOwnProperty.call(given, verb) && !allowedVerbs.includes(verb)) {
+      errors.push({
+        message: `HTTP verb '${verb}' is not encouraged. Only the following verbs are allowed: ${allowedVerbs.join(', ')}.`,
+        path: [...basePath, verb]
+      });
+    }
+  });
+
+  return errors;
+};

package/functions/apq-alternate-paths.js

@@ -1,18 +1,22 @@
-
 const isVariable = (part) => {
   return (part.startsWith('{') && part.endsWith('}'));
 }
 
-module.exports = (given, { except }, context) => {
+module.exports = (given, options, context) => {
   const result = [];
   const paths = given || [];
   if (paths.length === 0) return result;
 
+  const excludePatterns = ((options && options['exclude_patterns']) || '')
+    .split(',')
+    .map((pattern) => pattern.trim())
+    .filter(Boolean);
+
   const parts = paths.substr(1).split('/').filter(p => p.length > 0);
   if (parts.length === 0) return result;
   const firstPart = parts.shift();
   let previousIsVar;
-  if (except && except.includes(firstPart)) {
+  if (excludePatterns.includes(firstPart)) {
     previousIsVar = true;
   } else if (isVariable(firstPart)) {
     return [{ message: context.rule.message }];
@@ -21,7 +25,7 @@ module.exports = (given, { except }, context) => {
   }
 
   for (const part of parts) {
-    if (except && except.includes(part)) {
+    if (excludePatterns.includes(part)) {
       previousIsVar = true;
       continue;
     }

package/functions/apq-check-ambiguous-path.js

@@ -1,52 +1,38 @@
+const PARAM_REGEX = /\{[^}{]*}/g;
+
+const DEFAULT_AMBIGUOUS_NAMES =
+  'elementos,instancias,recursos,valores,terminos,objetos,articulos,elements,instances,resources,values,terms,objects,items';
+
 /**
- * Validates that URL path segments use clear, unambiguous names
  * @param {string} given - The path key (e.g. "/users/{id}/items")
- * @param {object} options - Function options
- * @param {string} options.ambiguous-words - Comma-separated list of ambiguous words
+ * @param {object} options
+ * @param {string} options['ambiguous-names']
  * @param {import('@stoplight/spectral-core').RulesetFunctionContext} context
  */
 module.exports = (given, options, context) => {
-  const results = [];
-
   if (typeof given !== 'string') {
-    return results;
+    return [];
   }
 
-  // Default ambiguous words (from the original regex)
-  const defaultAmbiguousWords = [
-    'elements', 'instances', 'resources', 'values', 'terms', 'objects', 'items'
-  ];
-
-  // Parse custom ambiguous words from options if provided
-  let ambiguousWords = defaultAmbiguousWords;
-  if (options && options['ambiguous-words']) {
-    ambiguousWords = options['ambiguous-words']
+  const forbiddenValues = new Set(
+    ((options && options['ambiguous-names']) || DEFAULT_AMBIGUOUS_NAMES)
       .split(',')
-      .map(w => w.trim().toLowerCase())
-      .filter(Boolean);
-  }
+      .map((value) => value.trim())
+      .filter(Boolean)
+  );
 
-  // Split path into segments and filter out parameters
-  const segments = given
-    .split('/')
-    .filter(segment => {
-      // Keep only static segments (not empty, not {param})
-      return segment.length > 0 && !segment.startsWith('{');
-    });
+  const pathWithoutParams = given.replace(PARAM_REGEX, '');
+  const pathParts = pathWithoutParams.split('/').filter(Boolean);
+  const forbidden = pathParts.filter((part) => forbiddenValues.has(part));
 
-  // Check each segment for ambiguous words
-  for (const segment of segments) {
-    const lowerSegment = segment.toLowerCase();
-    for (const word of ambiguousWords) {
-      if (lowerSegment.includes(word)) {
-        results.push({
-          message: `${context.rule.message || 'OAR032'}: Path segment '${segment}' is ambiguous. Avoid using words like '${word}' in resource names.`,
-          path: context.path
-        });
-        break; // Report only once per segment
-      }
-    }
+  if (forbidden.length === 0) {
+    return [];
   }
 
-  return results;
+  return [
+    {
+      message: `Ambiguous name(s) found in path: ${forbidden.join(', ')}.`,
+      path: context.path
+    }
+  ];
 };

package/functions/apq-forbidden-query-format.js

@@ -0,0 +1,29 @@
+module.exports = (parameter, options, context) => {
+  if (!parameter || typeof parameter !== 'object') return [];
+
+  const forbiddenFormats = ((options && options['forbidden-query-formats']) || '')
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean);
+  if (forbiddenFormats.length === 0) return [];
+
+  const paths = ((options && options.paths) || '')
+    .split(',')
+    .map((path) => path.trim())
+    .filter(Boolean);
+  const strategy = (options && options.pathValidationStrategy) || '/include';
+
+  const currentPath = context.path[1];
+  const isListed = paths.includes(currentPath);
+  const shouldExclude = strategy === '/exclude' ? isListed : !isListed;
+  if (shouldExclude) return [];
+
+  const root = context.document.parserResult.data;
+  const format = root.swagger ? parameter.format : parameter.schema && parameter.schema.format;
+
+  if (typeof format === 'string' && forbiddenFormats.includes(format)) {
+    return [{ message: context.rule.message }];
+  }
+
+  return [];
+};

package/functions/apq-mandatory-response-codes.js

@@ -0,0 +1,36 @@
+module.exports = (operation, options, context) => {
+  if (!operation || typeof operation !== 'object') return [];
+
+  const mandatoryCodes = ((options && options['mandatory-response-codes']) || '')
+    .split(',')
+    .map((code) => code.trim())
+    .filter(Boolean);
+  if (mandatoryCodes.length === 0) return [];
+
+  const paths = ((options && options.paths) || '')
+    .split(',')
+    .map((path) => path.trim())
+    .filter(Boolean);
+  const strategy = (options && options.pathValidationStrategy) || '/exclude';
+
+  const currentPath = context.path[context.path.length - 2];
+  const isListed = paths.includes(currentPath);
+  const shouldExclude = strategy === '/exclude' ? isListed : !isListed;
+  if (shouldExclude) return [];
+
+  const message = `Mandatory response code(s) required: ${mandatoryCodes.join(', ')}.`;
+
+  const responses = operation.responses;
+  if (!responses || typeof responses !== 'object') {
+    return [{ message }];
+  }
+
+  const responseCodes = Object.keys(responses).map((code) => code.trim());
+  const hasMandatoryCode = mandatoryCodes.some((code) => responseCodes.includes(code));
+
+  if (!hasMandatoryCode) {
+    return [{ message }];
+  }
+
+  return [];
+};

package/functions/apq-rate-limit-response.js

@@ -0,0 +1,21 @@
+module.exports = (operation, options, context) => {
+  if (!operation || typeof operation !== 'object' || Array.isArray(operation)) return [];
+
+  const paths = ((options && options.paths) || '')
+    .split(',')
+    .map((path) => path.trim())
+    .filter(Boolean);
+  const strategy = (options && options.pathValidationStrategy) || '/exclude';
+
+  const currentPath = context.path[context.path.length - 2];
+  const isListed = paths.includes(currentPath);
+  const shouldExclude = strategy === '/exclude' ? isListed : !isListed;
+  if (shouldExclude) return [];
+
+  const responses = operation.responses;
+  if (!responses || typeof responses !== 'object' || !('429' in responses)) {
+    return [{ message: context.rule.message }];
+  }
+
+  return [];
+};

package/functions/apq-require-response-on-path-params.js

@@ -1,9 +1,8 @@
 /**
- * Requires one or more HTTP response codes when path parameters are present.
- *
  * @param {object} given
  * @param {object} options
- * @param {string} options.response Comma-separated HTTP status codes (e.g. "400,404,200")
+ * @param {string} options.paths Comma-separated list of paths to include/exclude (exact match)
+ * @param {string} options.pathValidationStrategy "/include" or "/exclude" (default "/exclude")
  * @param {import('@stoplight/spectral-core').RulesetFunctionContext} context
  */
 module.exports = (given, options, context) => {
@@ -11,21 +10,15 @@ module.exports = (given, options, context) => {
     return [];
   }
 
-  const ruleCode = context.rule?.name?.split(':').pop();
-  const responseOpt = options?.response;
-
-  if (typeof responseOpt !== 'string') {
-    throw new TypeError(`${ruleCode}: "response" option must be a comma-separated string of HTTP status codes`);
-  }
-
-  const requiredResponses = responseOpt
+  const excludedPaths = ((options && options.paths) || '')
     .split(',')
-    .map(r => r.trim())
-    .filter(r => /^\d{3}$/.test(r));
-
-  if (requiredResponses.length === 0) {
-    throw new Error(`${ruleCode}: No valid HTTP status codes found in "response" option`);
-  }
+    .map((path) => path.trim())
+    .filter(Boolean);
+  const strategy = (options && options.pathValidationStrategy) || '/exclude';
+  const currentPath = context.path[context.path.length - 2];
+  const isListed = excludedPaths.includes(currentPath);
+  const shouldExclude = strategy === '/exclude' ? isListed : !isListed;
+  if (shouldExclude) return [];
 
   const pathItemKeyIndex = context.path?.length - 2;
   const pathItem = typeof pathItemKeyIndex === 'number'
@@ -46,11 +39,7 @@ module.exports = (given, options, context) => {
 
   const responses = given?.responses || {};
 
-  const hasRequiredResponse = requiredResponses.some(
-    code => responses[code]
-  );
-
-  if (!hasRequiredResponse) {
+  if (!responses['404']) {
     return [
       {
         message: context.rule.message,
@@ -59,4 +48,4 @@ module.exports = (given, options, context) => {
   }
 
   return [];
-};
+};

package/functions/apq-response-media-type.js

@@ -1,21 +1,43 @@
 /**
  * @param {object} given
  * @param {object} options
+ * @param {string} options['default-media-type']
+ * @param {string} options['media-type-exceptions']
  * @param {import('@stoplight/spectral-core').RulesetFunctionContext} context
  */
 
 const NO_BODY_CODES = new Set(['204']);
 
+function parseExceptions(value) {
+  return new Set(
+    String(value ?? '-')
+      .split(',')
+      .map((mediaType) => mediaType.trim().toLowerCase())
+      .filter(Boolean)
+  );
+}
+
+function isSupported(mediaType, defaultMediaType, exceptions) {
+  return mediaType === defaultMediaType || exceptions.has(mediaType);
+}
+
 module.exports = (given, options, context) => {
   const errors = [];
   if (!given) return errors;
 
+  const defaultMediaType = ((options && options['default-media-type']) || 'application/json').toLowerCase();
+  const exceptions = parseExceptions(options && options['media-type-exceptions']);
+
   const root = context.document.parserResult.data;
 
   if (root.swagger) {
     const produces = given.produces ?? root.produces;
 
-    if (!produces || !Array.isArray(produces) || !produces.includes('application/json')) {
+    if (
+      !produces ||
+      !Array.isArray(produces) ||
+      !produces.some((mediaType) => isSupported(String(mediaType).toLowerCase(), defaultMediaType, exceptions))
+    ) {
       errors.push({
         message: context.rule.message,
         path: [...context.path]
@@ -31,7 +53,10 @@ module.exports = (given, options, context) => {
   for (const [statusCode, response] of Object.entries(responses)) {
     if (NO_BODY_CODES.has(statusCode)) continue;
 
-    if (!response?.content?.['application/json']) {
+    const contentTypes = response?.content ? Object.keys(response.content) : [];
+    const supported = contentTypes.some((mediaType) => isSupported(mediaType.toLowerCase(), defaultMediaType, exceptions));
+
+    if (!supported) {
       errors.push({
         message: context.rule.message,
         path: [...context.path, 'responses', statusCode]
@@ -40,4 +65,4 @@ module.exports = (given, options, context) => {
   }
 
   return errors;
-};
+};

package/functions/apq-url-naming-convention.js

@@ -0,0 +1,59 @@
+const NAMING_REGEX = {
+  snake_case: /^[a-z0-9_$]*$/,
+  'kebab-case': /^[a-z0-9-.]*$/,
+  camelCase: /^[a-z]+(?:[A-Z][a-z]+)*([A-Z])?$/,
+  UpperCamelCase: /^[A-Z]+(?:[a-z]+)*([A-Z])?$/
+};
+
+const PARAM_REGEX = /\{[^}{]*}/g;
+const URL_PREFIX_REGEX = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^/]*/;
+
+function stripParams(name) {
+  return name.indexOf('/') >= 0 ? name.replace(PARAM_REGEX, '') : name;
+}
+
+function extractUrlPath(value) {
+  const match = URL_PREFIX_REGEX.exec(value);
+  return match ? value.slice(match[0].length) : value;
+}
+
+function isValid(name, convention) {
+  const regex = NAMING_REGEX[convention];
+  if (convention === 'camelCase' || convention === 'UpperCamelCase') {
+    const joined = name.replace(/\//g, '');
+    if (joined.includes('_') || joined.includes('-')) return false;
+    return regex.test(joined);
+  }
+  const separator = convention === 'kebab-case' ? '-' : '_';
+  return regex.test(name.replace(/\//g, separator));
+}
+
+/**
+ * @param {string} given
+ * @param {object} options
+ * @param {string} options['naming-convention']
+ * @param {import('@stoplight/spectral-core').RulesetFunctionContext} context
+ */
+module.exports = (given, options, context) => {
+  if (typeof given !== 'string') {
+    return [];
+  }
+
+  const convention = (options && options['naming-convention']) || 'kebab-case';
+  if (!NAMING_REGEX[convention]) {
+    return [];
+  }
+
+  const name = stripParams(extractUrlPath(given));
+
+  if (!isValid(name, convention)) {
+    return [
+      {
+        message: `Value '${given}' does not follow the '${convention}' naming convention.`,
+        path: context.path
+      }
+    ];
+  }
+
+  return [];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-quality-spectral-ruleset",
-  "version": "1.5.0-beta.3",
+  "version": "1.5.0",
   "description": "Spectral ruleset by API Quality",
   "main": "apq-spectral.yaml",
   "files": [