@mintlify/validation 0.1.448 → 0.1.450

package/dist/openapi/SchemaConverter.js

@@ -347,6 +347,10 @@ export class SchemaConverter extends BaseConverter {
             copyKeyIfDefined('readOnly', schema, sharedProps);
             copyKeyIfDefined('writeOnly', schema, sharedProps);
             copyKeyIfDefined('deprecated', schema, sharedProps);
+            copyKeyIfDefined('x-enum-for-clients', schema, sharedProps);
+            copyKeyIfDefined('x-enum-for-feature-flags', schema, sharedProps);
+            copyKeyIfDefined('x-for-feature-flags', schema, sharedProps);
+            copyKeyIfDefined('x-for-clients', schema, sharedProps);
             if (schema.type === undefined) {
                 const inferredType = inferType(schema);
                 if (inferredType === undefined) {
@@ -433,7 +437,9 @@ export class SchemaConverter extends BaseConverter {
                         additionalProperties =
                             // validator allows additionalProperties to be null
                             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                            typeof schema.additionalProperties === 'object' && schema.additionalProperties != null
+                            typeof schema.additionalProperties === 'object' &&
+                                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                                schema.additionalProperties != null
                                 ? this.convertSchemaRecursive(addlPropsPath, schema.additionalProperties)
                                 : schema.additionalProperties;
                     }

package/dist/openapi/generateExampleFromSchema.d.ts

@@ -1,2 +1,3 @@
-import { DataSchema } from '../index.js';
+import { DataSchema, DataSchemaArray } from '../index.js';
+export declare const isDataSchemaArray: (schemaArray: unknown) => schemaArray is DataSchemaArray;
 export declare const generateExampleFromSchema: (schema: DataSchema, depth?: number) => unknown;

package/dist/openapi/generateExampleFromSchema.js

@@ -1,4 +1,43 @@
 const MAX_DEPTH = 100;
+export const isDataSchemaArray = (schemaArray) => {
+    return Array.isArray(schemaArray) && schemaArray.length > 0;
+};
+const filterXAuth = (schema) => {
+    var _a, _b, _c, _d;
+    if (schema.type === 'object') {
+        const propertiesWithXAuthFiltered = Object.entries(schema.properties).filter(([_, [schema]]) => !('x-for-clients' in schema || 'x-for-feature-flags' in schema));
+        return Object.assign(Object.assign({}, schema), { properties: Object.fromEntries(propertiesWithXAuthFiltered) });
+    }
+    if (schema.type === 'array') {
+        const itemsWithXAuthFiltered = schema.items.filter((schema) => !('x-for-clients' in schema || 'x-for-feature-flags' in schema));
+        if (isDataSchemaArray(itemsWithXAuthFiltered)) {
+            return Object.assign(Object.assign({}, schema), { items: itemsWithXAuthFiltered });
+        }
+    }
+    if (schema.type === 'enum<string>') {
+        const enumValues = schema.enum;
+        const xFilteredEnumValues = [];
+        Object.entries((_a = schema['x-enum-for-clients']) !== null && _a !== void 0 ? _a : {}).forEach(([enumKey]) => {
+            xFilteredEnumValues.push(enumKey.toString());
+        });
+        Object.entries((_b = schema['x-enum-for-feature-flags']) !== null && _b !== void 0 ? _b : {}).forEach(([enumKey]) => {
+            xFilteredEnumValues.push(enumKey.toString());
+        });
+        return Object.assign(Object.assign({}, schema), { enum: enumValues.filter((enumValue) => !xFilteredEnumValues.includes(enumValue)) });
+    }
+    if (schema.type === 'enum<number>' || schema.type === 'enum<integer>') {
+        const enumValues = schema.enum;
+        const xFilteredEnumValues = [];
+        Object.entries((_c = schema['x-enum-for-clients']) !== null && _c !== void 0 ? _c : {}).forEach(([enumKey]) => {
+            xFilteredEnumValues.push(Number(enumKey));
+        });
+        Object.entries((_d = schema['x-enum-for-feature-flags']) !== null && _d !== void 0 ? _d : {}).forEach(([enumKey]) => {
+            xFilteredEnumValues.push(Number(enumKey));
+        });
+        return Object.assign(Object.assign({}, schema), { enum: enumValues.filter((enumValue) => !xFilteredEnumValues.includes(enumValue)) });
+    }
+    return schema;
+};
 export const generateExampleFromSchema = (schema, depth = 0) => {
     if (schema.example !== undefined) {
         return schema.example;
@@ -6,24 +45,25 @@ export const generateExampleFromSchema = (schema, depth = 0) => {
     if (schema.default !== undefined) {
         return schema.default;
     }
-    switch (schema.type) {
+    const schemaForExampleGeneration = filterXAuth(schema);
+    switch (schemaForExampleGeneration.type) {
         case 'string':
-            return generateStringExample(schema);
+            return generateStringExample(schemaForExampleGeneration);
         case 'boolean':
             return true;
         case 'number':
         case 'integer':
-            return generateNumericExample(schema);
+            return generateNumericExample(schemaForExampleGeneration);
         case 'enum<string>':
         case 'enum<number>':
         case 'enum<integer>':
-            return schema.enum[0];
+            return schemaForExampleGeneration.enum[0];
         case 'null':
             return null;
         case 'any':
             return '<any>';
         case 'object':
-            const entries = Object.entries(schema.properties)
+            const entries = Object.entries(schemaForExampleGeneration.properties)
                 // generate examples for all properties until depth reached - then only required properties
                 .filter(([_, [{ required }]]) => depth < MAX_DEPTH || required)
                 .map(([propName, subschema]) => [
@@ -34,9 +74,9 @@ export const generateExampleFromSchema = (schema, depth = 0) => {
         case 'array':
             return depth < MAX_DEPTH
                 ? [
-                    generateExampleFromSchema(schema.items[0], 
+                    generateExampleFromSchema(schemaForExampleGeneration.items[0], 
                     // prevent the weird [{}] example value by counting array<object> as one level
-                    schema.items[0].type === 'object' ? depth : depth + 1),
+                    schemaForExampleGeneration.items[0].type === 'object' ? depth : depth + 1),
                 ]
                 : [];
     }

package/dist/openapi/types/endpoint.d.ts

@@ -127,6 +127,8 @@ export type BaseSchema<T> = {
     isAllOf?: string;
     'x-enum-for-clients'?: string[];
     'x-enum-for-feature-flags'?: string[];
+    'x-for-feature-flags'?: string[];
+    'x-for-clients'?: string[];
 };
 export type BooleanSchema = {
     type: 'boolean';
@@ -246,4 +248,10 @@ export declare const XMintType: import("arktype/internal/methods/object.ts").Obj
         description?: string | undefined;
     } | undefined;
 }, {}>;
+export type SchemaWithXFlags = OpenAPIV3_1.SchemaObject & {
+    'x-enum-for-clients'?: string[];
+    'x-enum-for-feature-flags'?: string[];
+    'x-for-feature-flags'?: string[];
+    'x-for-clients'?: string[];
+};
 export {};

package/dist/openapi/types/schema.d.ts

@@ -13,6 +13,8 @@ export type SimpleSchema = Omit<OpenAPIV3_1.SchemaObject, Compositions> & {
     isAllOf?: string;
     'x-enum-for-clients'?: string[];
     'x-enum-for-feature-flags'?: string[];
+    'x-for-feature-flags'?: string[];
+    'x-for-clients'?: string[];
 };
 export type SumOfProducts = SimpleSchema[][];
 export type SimpleSchemaWithSubschemas = SimpleSchema & {
@@ -30,4 +32,6 @@ export type SchemaOrRefComposition = SchemaOrRef & {
     isOneOf?: string;
     isAnyOf?: string;
     isAllOf?: string;
+    'x-for-feature-flags'?: string[];
+    'x-for-clients'?: string[];
 };

package/dist/openapi/utils.js

@@ -166,6 +166,8 @@ export function copyAndCombineKeys(acc, curr) {
     copyKeyIfDefined('const', curr, acc);
     copyKeyIfDefined('x-enum-for-clients', curr, acc);
     copyKeyIfDefined('x-enum-for-feature-flags', curr, acc);
+    copyKeyIfDefined('x-for-feature-flags', curr, acc);
+    copyKeyIfDefined('x-for-clients', curr, acc);
     combineKeyIfDefined('multipleOf', curr, acc, lcm);
     combineKeyIfDefined('maxLength', curr, acc, Math.min);
     combineKeyIfDefined('minLength', curr, acc, Math.max);