@strapi/utils 5.19.0 → 5.21.0

package/dist/validation/route-validators/base.mjs

@@ -0,0 +1,90 @@
+import { queryParameterSchemas } from './query-params.mjs';
+
+/**
+ * AbstractRouteValidator provides the foundation for validating routes.
+ *
+ * This abstract class provides common query parameter validators that can be reused
+ * across different route validators in Strapi. It serves as a building block for
+ * both generic validation (plugins, external packages) and schema-aware validation
+ * (core content types).
+ */ class AbstractRouteValidator {
+    /**
+   * Creates a fields query parameter validator
+   * Validates field selection for API responses
+   */ get queryFields() {
+        return queryParameterSchemas.fields;
+    }
+    /**
+   * Creates a populate query parameter validator
+   * Validates which relations to populate in the response
+   */ get queryPopulate() {
+        return queryParameterSchemas.populate;
+    }
+    /**
+   * Creates a sort query parameter validator
+   * Validates sorting options for list endpoints
+   */ get querySort() {
+        return queryParameterSchemas.sort;
+    }
+    /**
+   * Creates a pagination query parameter validator
+   * Supports both page-based and offset-based pagination
+   */ get pagination() {
+        return queryParameterSchemas.pagination;
+    }
+    /**
+   * Creates a filters query parameter validator
+   * Validates filtering options for list endpoints
+   */ get filters() {
+        return queryParameterSchemas.filters;
+    }
+    /**
+   * Creates a locale query parameter validator
+   * Used for internationalization
+   */ get locale() {
+        return queryParameterSchemas.locale;
+    }
+    /**
+   * Creates a status query parameter validator
+   * Used for draft & publish functionality
+   */ get status() {
+        return queryParameterSchemas.status;
+    }
+    /**
+   * Creates a search query parameter validator
+   * Used for text search functionality
+   */ get query() {
+        return queryParameterSchemas._q;
+    }
+    /**
+   * Provides access to all base query parameter validators
+   */ get baseQueryValidators() {
+        return {
+            fields: ()=>this.queryFields.optional(),
+            populate: ()=>this.queryPopulate.optional(),
+            sort: ()=>this.querySort.optional(),
+            filters: ()=>this.filters.optional(),
+            pagination: ()=>this.pagination.optional(),
+            locale: ()=>this.locale.optional(),
+            status: ()=>this.status.optional(),
+            _q: ()=>this.query.optional()
+        };
+    }
+    /**
+   * Helper method to create a query parameters object with specified validators
+   *
+   * @param params - Array of query parameter names to include
+   * @returns Object containing Zod schemas for the requested query parameters
+   */ queryParams(params) {
+        const validators = this.baseQueryValidators;
+        return params.reduce((acc, param)=>{
+            if (param in validators) {
+                acc[param] = validators[param]();
+            }
+            return acc;
+        }, {});
+    }
+}
+
+export { AbstractRouteValidator };
+//# sourceMappingURL=base.mjs.map

package/dist/validation/route-validators/base.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.mjs","sources":["../../../src/validation/route-validators/base.ts"],"sourcesContent":["import * as z from 'zod/v4';\nimport { queryParameterSchemas, type QueryParam } from './query-params';\n\n/**\n * AbstractRouteValidator provides the foundation for validating routes.\n *\n * This abstract class provides common query parameter validators that can be reused\n * across different route validators in Strapi. It serves as a building block for\n * both generic validation (plugins, external packages) and schema-aware validation\n * (core content types).\n */\nexport abstract class AbstractRouteValidator {\n  /**\n   * Creates a fields query parameter validator\n   * Validates field selection for API responses\n   */\n  get queryFields() {\n    return queryParameterSchemas.fields;\n  }\n\n  /**\n   * Creates a populate query parameter validator\n   * Validates which relations to populate in the response\n   */\n  get queryPopulate() {\n    return queryParameterSchemas.populate;\n  }\n\n  /**\n   * Creates a sort query parameter validator\n   * Validates sorting options for list endpoints\n   */\n  get querySort() {\n    return queryParameterSchemas.sort;\n  }\n\n  /**\n   * Creates a pagination query parameter validator\n   * Supports both page-based and offset-based pagination\n   */\n  get pagination() {\n    return queryParameterSchemas.pagination;\n  }\n\n  /**\n   * Creates a filters query parameter validator\n   * Validates filtering options for list endpoints\n   */\n  get filters() {\n    return queryParameterSchemas.filters;\n  }\n\n  /**\n   * Creates a locale query parameter validator\n   * Used for internationalization\n   */\n  get locale() {\n    return queryParameterSchemas.locale;\n  }\n\n  /**\n   * Creates a status query parameter validator\n   * Used for draft & publish functionality\n   */\n  get status() {\n    return queryParameterSchemas.status;\n  }\n\n  /**\n   * Creates a search query parameter validator\n   * Used for text search functionality\n   */\n  get query() {\n    return queryParameterSchemas._q;\n  }\n\n  /**\n   * Provides access to all base query parameter validators\n   */\n  protected get baseQueryValidators() {\n    return {\n      fields: () => this.queryFields.optional(),\n      populate: () => this.queryPopulate.optional(),\n      sort: () => this.querySort.optional(),\n      filters: () => this.filters.optional(),\n      pagination: () => this.pagination.optional(),\n      locale: () => this.locale.optional(),\n      status: () => this.status.optional(),\n      _q: () => this.query.optional(),\n    };\n  }\n\n  /**\n   * Helper method to create a query parameters object with specified validators\n   *\n   * @param params - Array of query parameter names to include\n   * @returns Object containing Zod schemas for the requested query parameters\n   */\n  queryParams(params: QueryParam[]): Record<string, z.ZodSchema> {\n    const validators = this.baseQueryValidators;\n\n    return params.reduce(\n      (acc, param) => {\n        if (param in validators) {\n          acc[param] = validators[param]();\n        }\n        return acc;\n      },\n      {} as Record<string, z.ZodSchema>\n    );\n  }\n}\n"],"names":["AbstractRouteValidator","queryFields","queryParameterSchemas","fields","queryPopulate","populate","querySort","sort","pagination","filters","locale","status","query","_q","baseQueryValidators","optional","queryParams","params","validators","reduce","acc","param"],"mappings":";;AAGA;;;;;;;AAOC,IACM,MAAeA,sBAAAA,CAAAA;AACpB;;;AAGC,MACD,IAAIC,WAAc,GAAA;AAChB,QAAA,OAAOC,sBAAsBC,MAAM;AACrC;AAEA;;;AAGC,MACD,IAAIC,aAAgB,GAAA;AAClB,QAAA,OAAOF,sBAAsBG,QAAQ;AACvC;AAEA;;;AAGC,MACD,IAAIC,SAAY,GAAA;AACd,QAAA,OAAOJ,sBAAsBK,IAAI;AACnC;AAEA;;;AAGC,MACD,IAAIC,UAAa,GAAA;AACf,QAAA,OAAON,sBAAsBM,UAAU;AACzC;AAEA;;;AAGC,MACD,IAAIC,OAAU,GAAA;AACZ,QAAA,OAAOP,sBAAsBO,OAAO;AACtC;AAEA;;;AAGC,MACD,IAAIC,MAAS,GAAA;AACX,QAAA,OAAOR,sBAAsBQ,MAAM;AACrC;AAEA;;;AAGC,MACD,IAAIC,MAAS,GAAA;AACX,QAAA,OAAOT,sBAAsBS,MAAM;AACrC;AAEA;;;AAGC,MACD,IAAIC,KAAQ,GAAA;AACV,QAAA,OAAOV,sBAAsBW,EAAE;AACjC;AAEA;;AAEC,MACD,IAAcC,mBAAsB,GAAA;QAClC,OAAO;AACLX,YAAAA,MAAAA,EAAQ,IAAM,IAAI,CAACF,WAAW,CAACc,QAAQ,EAAA;AACvCV,YAAAA,QAAAA,EAAU,IAAM,IAAI,CAACD,aAAa,CAACW,QAAQ,EAAA;AAC3CR,YAAAA,IAAAA,EAAM,IAAM,IAAI,CAACD,SAAS,CAACS,QAAQ,EAAA;AACnCN,YAAAA,OAAAA,EAAS,IAAM,IAAI,CAACA,OAAO,CAACM,QAAQ,EAAA;AACpCP,YAAAA,UAAAA,EAAY,IAAM,IAAI,CAACA,UAAU,CAACO,QAAQ,EAAA;AAC1CL,YAAAA,MAAAA,EAAQ,IAAM,IAAI,CAACA,MAAM,CAACK,QAAQ,EAAA;AAClCJ,YAAAA,MAAAA,EAAQ,IAAM,IAAI,CAACA,MAAM,CAACI,QAAQ,EAAA;AAClCF,YAAAA,EAAAA,EAAI,IAAM,IAAI,CAACD,KAAK,CAACG,QAAQ;AAC/B,SAAA;AACF;AAEA;;;;;MAMAC,WAAAA,CAAYC,MAAoB,EAA+B;QAC7D,MAAMC,UAAAA,GAAa,IAAI,CAACJ,mBAAmB;AAE3C,QAAA,OAAOG,MAAOE,CAAAA,MAAM,CAClB,CAACC,GAAKC,EAAAA,KAAAA,GAAAA;AACJ,YAAA,IAAIA,SAASH,UAAY,EAAA;AACvBE,gBAAAA,GAAG,CAACC,KAAAA,CAAM,GAAGH,UAAU,CAACG,KAAM,CAAA,EAAA;AAChC;YACA,OAAOD,GAAAA;AACT,SAAA,EACA,EAAC,CAAA;AAEL;AACF;;;;"}

package/dist/validation/route-validators/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Route validation utilities for Strapi
+ *
+ * This module provides route validation that can be used across different
+ * packages & plugins.
+ *
+ * The utilities are designed to work both standalone (for generic validation) and
+ * as building blocks for more sophisticated schema-aware validation via @strapi/core.
+ *
+ * @example
+ * ```typescript
+ * import { AbstractRouteValidator, type QueryParam } from '@strapi/utils';
+ * import * as z from 'zod/v4';
+ *
+ * export class MyPluginRouteValidator extends AbstractRouteValidator {
+ *   constructor(strapi: Core.Strapi) {
+ *     super();
+ *   }
+ *
+ *   // Add custom validators for your plugin
+ *   get myEntity() {
+ *     return z.object({
+ *       id: z.number(),
+ *       name: z.string(),
+ *       // ... other fields
+ *     });
+ *   }
+ *
+ *   // Use inherited query parameter validators
+ *   // In your routes:
+ *   // request: {
+ *   //   query: validator.queryParams(['fields', 'populate', 'sort', 'pagination'])
+ *   // }
+ * }
+ * ```
+ */
+export { AbstractRouteValidator } from './base';
+export * from './query-params';
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/route-validators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/validation/route-validators/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAC;AAChD,cAAc,gBAAgB,CAAC"}

package/dist/validation/route-validators/query-params.d.ts

@@ -0,0 +1,100 @@
+import * as z from 'zod/v4';
+/**
+ * Standard query parameter validators that can be reused across different route validators
+ *
+ * These schemas provide the basic structure validation for common Strapi API query parameters.
+ * They can be used as building blocks for both generic validation and schema-aware validation.
+ */
+/**
+ * Fields parameter validation
+ * Supports: 'title', ['title', 'name'], or '*'
+ */
+export declare const queryFieldsSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+/**
+ * Populate parameter validation
+ * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects
+ */
+export declare const queryPopulateSchema: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+/**
+ * Sort parameter validation
+ * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]
+ */
+export declare const querySortSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>>>]>;
+/**
+ * Pagination parameter validation
+ * Supports both page-based and offset-based pagination
+ */
+export declare const paginationSchema: z.ZodIntersection<z.ZodObject<{
+    withCount: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+    page: z.ZodNumber;
+    pageSize: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    start: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strip>]>>;
+/**
+ * Filters parameter validation
+ * Supports any object structure for filtering
+ */
+export declare const filtersSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+/**
+ * Locale parameter validation
+ * Used for internationalization
+ */
+export declare const localeSchema: z.ZodString;
+/**
+ * Status parameter validation
+ * Used for draft & publish functionality
+ */
+export declare const statusSchema: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+}>;
+/**
+ * Search query parameter validation
+ * Used for text search functionality
+ */
+export declare const searchQuerySchema: z.ZodString;
+/**
+ * Complete collection of all standard query parameter schemas
+ * This object provides easy access to all available query parameter validators
+ */
+export declare const queryParameterSchemas: {
+    readonly fields: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    readonly populate: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+    readonly sort: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>>]>;
+    readonly pagination: z.ZodIntersection<z.ZodObject<{
+        withCount: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        page: z.ZodNumber;
+        pageSize: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        start: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>]>>;
+    readonly filters: z.ZodRecord<z.ZodString, z.ZodAny>;
+    readonly locale: z.ZodString;
+    readonly status: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+    }>;
+    readonly _q: z.ZodString;
+};
+/**
+ * Query parameter names supported by Strapi's API
+ */
+export type QueryParam = keyof typeof queryParameterSchemas;
+//# sourceMappingURL=query-params.d.ts.map

package/dist/validation/route-validators/query-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-params.d.ts","sourceRoot":"","sources":["../../../src/validation/route-validators/query-params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB,6DAEiC,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,oHAEkC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;MAOuB,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;oBAoBO,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,aAAa,oCAAuE,CAAC;AAElG;;;GAGG;AACH,eAAO,MAAM,YAAY,aAAkE,CAAC;AAE5F;;;GAGG;AACH,eAAO,MAAM,YAAY;;;EAA0E,CAAC;AAEpG;;;GAGG;AACH,eAAO,MAAM,iBAAiB,aAA6C,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;CASxB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,qBAAqB,CAAC"}

package/dist/validation/route-validators/query-params.js

@@ -0,0 +1,117 @@
+'use strict';
+
+var z = require('zod/v4');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
+
+/**
+ * Standard query parameter validators that can be reused across different route validators
+ *
+ * These schemas provide the basic structure validation for common Strapi API query parameters.
+ * They can be used as building blocks for both generic validation and schema-aware validation.
+ */ /**
+ * Fields parameter validation
+ * Supports: 'title', ['title', 'name'], or '*'
+ */ const queryFieldsSchema = z__namespace.union([
+    z__namespace.string(),
+    z__namespace.array(z__namespace.string())
+]).describe('Select specific fields to return in the response');
+/**
+ * Populate parameter validation
+ * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects
+ */ const queryPopulateSchema = z__namespace.union([
+    z__namespace.literal('*'),
+    z__namespace.string(),
+    z__namespace.array(z__namespace.string()),
+    z__namespace.record(z__namespace.string(), z__namespace.any())
+]).describe('Specify which relations to populate in the response');
+/**
+ * Sort parameter validation
+ * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]
+ */ const querySortSchema = z__namespace.union([
+    z__namespace.string(),
+    z__namespace.array(z__namespace.string()),
+    z__namespace.record(z__namespace.string(), z__namespace.enum([
+        'asc',
+        'desc'
+    ])),
+    z__namespace.array(z__namespace.record(z__namespace.string(), z__namespace.enum([
+        'asc',
+        'desc'
+    ])))
+]).describe('Sort the results by specified fields');
+/**
+ * Pagination parameter validation
+ * Supports both page-based and offset-based pagination
+ */ const paginationSchema = z__namespace.intersection(z__namespace.object({
+    withCount: z__namespace.boolean().optional().describe('Include total count in response')
+}), z__namespace.union([
+    z__namespace.object({
+        page: z__namespace.number().int().positive().describe('Page number (1-based)'),
+        pageSize: z__namespace.number().int().positive().describe('Number of entries per page')
+    }).describe('Page-based pagination'),
+    z__namespace.object({
+        start: z__namespace.number().int().min(0).describe('Number of entries to skip'),
+        limit: z__namespace.number().int().positive().describe('Maximum number of entries to return')
+    }).describe('Offset-based pagination')
+])).describe('Pagination parameters');
+/**
+ * Filters parameter validation
+ * Supports any object structure for filtering
+ */ const filtersSchema = z__namespace.record(z__namespace.string(), z__namespace.any()).describe('Apply filters to the query');
+/**
+ * Locale parameter validation
+ * Used for internationalization
+ */ const localeSchema = z__namespace.string().describe('Specify the locale for localized content');
+/**
+ * Status parameter validation
+ * Used for draft & publish functionality
+ */ const statusSchema = z__namespace.enum([
+    'draft',
+    'published'
+]).describe('Filter by publication status');
+/**
+ * Search query parameter validation
+ * Used for text search functionality
+ */ const searchQuerySchema = z__namespace.string().describe('Search query string');
+/**
+ * Complete collection of all standard query parameter schemas
+ * This object provides easy access to all available query parameter validators
+ */ const queryParameterSchemas = {
+    fields: queryFieldsSchema,
+    populate: queryPopulateSchema,
+    sort: querySortSchema,
+    pagination: paginationSchema,
+    filters: filtersSchema,
+    locale: localeSchema,
+    status: statusSchema,
+    _q: searchQuerySchema
+};
+
+exports.filtersSchema = filtersSchema;
+exports.localeSchema = localeSchema;
+exports.paginationSchema = paginationSchema;
+exports.queryFieldsSchema = queryFieldsSchema;
+exports.queryParameterSchemas = queryParameterSchemas;
+exports.queryPopulateSchema = queryPopulateSchema;
+exports.querySortSchema = querySortSchema;
+exports.searchQuerySchema = searchQuerySchema;
+exports.statusSchema = statusSchema;
+//# sourceMappingURL=query-params.js.map

package/dist/validation/route-validators/query-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-params.js","sources":["../../../src/validation/route-validators/query-params.ts"],"sourcesContent":["import * as z from 'zod/v4';\n\n/**\n * Standard query parameter validators that can be reused across different route validators\n *\n * These schemas provide the basic structure validation for common Strapi API query parameters.\n * They can be used as building blocks for both generic validation and schema-aware validation.\n */\n\n/**\n * Fields parameter validation\n * Supports: 'title', ['title', 'name'], or '*'\n */\nexport const queryFieldsSchema = z\n  .union([z.string(), z.array(z.string())])\n  .describe('Select specific fields to return in the response');\n\n/**\n * Populate parameter validation\n * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects\n */\nexport const queryPopulateSchema = z\n  .union([z.literal('*'), z.string(), z.array(z.string()), z.record(z.string(), z.any())])\n  .describe('Specify which relations to populate in the response');\n\n/**\n * Sort parameter validation\n * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]\n */\nexport const querySortSchema = z\n  .union([\n    z.string(),\n    z.array(z.string()),\n    z.record(z.string(), z.enum(['asc', 'desc'])),\n    z.array(z.record(z.string(), z.enum(['asc', 'desc']))),\n  ])\n  .describe('Sort the results by specified fields');\n\n/**\n * Pagination parameter validation\n * Supports both page-based and offset-based pagination\n */\nexport const paginationSchema = z\n  .intersection(\n    z.object({\n      withCount: z.boolean().optional().describe('Include total count in response'),\n    }),\n    z.union([\n      z\n        .object({\n          page: z.number().int().positive().describe('Page number (1-based)'),\n          pageSize: z.number().int().positive().describe('Number of entries per page'),\n        })\n        .describe('Page-based pagination'),\n      z\n        .object({\n          start: z.number().int().min(0).describe('Number of entries to skip'),\n          limit: z.number().int().positive().describe('Maximum number of entries to return'),\n        })\n        .describe('Offset-based pagination'),\n    ])\n  )\n  .describe('Pagination parameters');\n\n/**\n * Filters parameter validation\n * Supports any object structure for filtering\n */\nexport const filtersSchema = z.record(z.string(), z.any()).describe('Apply filters to the query');\n\n/**\n * Locale parameter validation\n * Used for internationalization\n */\nexport const localeSchema = z.string().describe('Specify the locale for localized content');\n\n/**\n * Status parameter validation\n * Used for draft & publish functionality\n */\nexport const statusSchema = z.enum(['draft', 'published']).describe('Filter by publication status');\n\n/**\n * Search query parameter validation\n * Used for text search functionality\n */\nexport const searchQuerySchema = z.string().describe('Search query string');\n\n/**\n * Complete collection of all standard query parameter schemas\n * This object provides easy access to all available query parameter validators\n */\nexport const queryParameterSchemas = {\n  fields: queryFieldsSchema,\n  populate: queryPopulateSchema,\n  sort: querySortSchema,\n  pagination: paginationSchema,\n  filters: filtersSchema,\n  locale: localeSchema,\n  status: statusSchema,\n  _q: searchQuerySchema,\n} as const;\n\n/**\n * Query parameter names supported by Strapi's API\n */\nexport type QueryParam = keyof typeof queryParameterSchemas;\n"],"names":["queryFieldsSchema","z","union","string","array","describe","queryPopulateSchema","literal","record","any","querySortSchema","enum","paginationSchema","intersection","object","withCount","boolean","optional","page","number","int","positive","pageSize","start","min","limit","filtersSchema","localeSchema","statusSchema","searchQuerySchema","queryParameterSchemas","fields","populate","sort","pagination","filters","locale","status","_q"],"mappings":"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"}

package/dist/validation/route-validators/query-params.mjs

@@ -0,0 +1,88 @@
+import * as z from 'zod/v4';
+
+/**
+ * Standard query parameter validators that can be reused across different route validators
+ *
+ * These schemas provide the basic structure validation for common Strapi API query parameters.
+ * They can be used as building blocks for both generic validation and schema-aware validation.
+ */ /**
+ * Fields parameter validation
+ * Supports: 'title', ['title', 'name'], or '*'
+ */ const queryFieldsSchema = z.union([
+    z.string(),
+    z.array(z.string())
+]).describe('Select specific fields to return in the response');
+/**
+ * Populate parameter validation
+ * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects
+ */ const queryPopulateSchema = z.union([
+    z.literal('*'),
+    z.string(),
+    z.array(z.string()),
+    z.record(z.string(), z.any())
+]).describe('Specify which relations to populate in the response');
+/**
+ * Sort parameter validation
+ * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]
+ */ const querySortSchema = z.union([
+    z.string(),
+    z.array(z.string()),
+    z.record(z.string(), z.enum([
+        'asc',
+        'desc'
+    ])),
+    z.array(z.record(z.string(), z.enum([
+        'asc',
+        'desc'
+    ])))
+]).describe('Sort the results by specified fields');
+/**
+ * Pagination parameter validation
+ * Supports both page-based and offset-based pagination
+ */ const paginationSchema = z.intersection(z.object({
+    withCount: z.boolean().optional().describe('Include total count in response')
+}), z.union([
+    z.object({
+        page: z.number().int().positive().describe('Page number (1-based)'),
+        pageSize: z.number().int().positive().describe('Number of entries per page')
+    }).describe('Page-based pagination'),
+    z.object({
+        start: z.number().int().min(0).describe('Number of entries to skip'),
+        limit: z.number().int().positive().describe('Maximum number of entries to return')
+    }).describe('Offset-based pagination')
+])).describe('Pagination parameters');
+/**
+ * Filters parameter validation
+ * Supports any object structure for filtering
+ */ const filtersSchema = z.record(z.string(), z.any()).describe('Apply filters to the query');
+/**
+ * Locale parameter validation
+ * Used for internationalization
+ */ const localeSchema = z.string().describe('Specify the locale for localized content');
+/**
+ * Status parameter validation
+ * Used for draft & publish functionality
+ */ const statusSchema = z.enum([
+    'draft',
+    'published'
+]).describe('Filter by publication status');
+/**
+ * Search query parameter validation
+ * Used for text search functionality
+ */ const searchQuerySchema = z.string().describe('Search query string');
+/**
+ * Complete collection of all standard query parameter schemas
+ * This object provides easy access to all available query parameter validators
+ */ const queryParameterSchemas = {
+    fields: queryFieldsSchema,
+    populate: queryPopulateSchema,
+    sort: querySortSchema,
+    pagination: paginationSchema,
+    filters: filtersSchema,
+    locale: localeSchema,
+    status: statusSchema,
+    _q: searchQuerySchema
+};
+
+export { filtersSchema, localeSchema, paginationSchema, queryFieldsSchema, queryParameterSchemas, queryPopulateSchema, querySortSchema, searchQuerySchema, statusSchema };
+//# sourceMappingURL=query-params.mjs.map

package/dist/validation/route-validators/query-params.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-params.mjs","sources":["../../../src/validation/route-validators/query-params.ts"],"sourcesContent":["import * as z from 'zod/v4';\n\n/**\n * Standard query parameter validators that can be reused across different route validators\n *\n * These schemas provide the basic structure validation for common Strapi API query parameters.\n * They can be used as building blocks for both generic validation and schema-aware validation.\n */\n\n/**\n * Fields parameter validation\n * Supports: 'title', ['title', 'name'], or '*'\n */\nexport const queryFieldsSchema = z\n  .union([z.string(), z.array(z.string())])\n  .describe('Select specific fields to return in the response');\n\n/**\n * Populate parameter validation\n * Supports: '*', 'relation', ['relation1', 'relation2'], or complex objects\n */\nexport const queryPopulateSchema = z\n  .union([z.literal('*'), z.string(), z.array(z.string()), z.record(z.string(), z.any())])\n  .describe('Specify which relations to populate in the response');\n\n/**\n * Sort parameter validation\n * Supports: 'name', ['name', 'title'], { name: 'asc' }, or [{ name: 'desc' }]\n */\nexport const querySortSchema = z\n  .union([\n    z.string(),\n    z.array(z.string()),\n    z.record(z.string(), z.enum(['asc', 'desc'])),\n    z.array(z.record(z.string(), z.enum(['asc', 'desc']))),\n  ])\n  .describe('Sort the results by specified fields');\n\n/**\n * Pagination parameter validation\n * Supports both page-based and offset-based pagination\n */\nexport const paginationSchema = z\n  .intersection(\n    z.object({\n      withCount: z.boolean().optional().describe('Include total count in response'),\n    }),\n    z.union([\n      z\n        .object({\n          page: z.number().int().positive().describe('Page number (1-based)'),\n          pageSize: z.number().int().positive().describe('Number of entries per page'),\n        })\n        .describe('Page-based pagination'),\n      z\n        .object({\n          start: z.number().int().min(0).describe('Number of entries to skip'),\n          limit: z.number().int().positive().describe('Maximum number of entries to return'),\n        })\n        .describe('Offset-based pagination'),\n    ])\n  )\n  .describe('Pagination parameters');\n\n/**\n * Filters parameter validation\n * Supports any object structure for filtering\n */\nexport const filtersSchema = z.record(z.string(), z.any()).describe('Apply filters to the query');\n\n/**\n * Locale parameter validation\n * Used for internationalization\n */\nexport const localeSchema = z.string().describe('Specify the locale for localized content');\n\n/**\n * Status parameter validation\n * Used for draft & publish functionality\n */\nexport const statusSchema = z.enum(['draft', 'published']).describe('Filter by publication status');\n\n/**\n * Search query parameter validation\n * Used for text search functionality\n */\nexport const searchQuerySchema = z.string().describe('Search query string');\n\n/**\n * Complete collection of all standard query parameter schemas\n * This object provides easy access to all available query parameter validators\n */\nexport const queryParameterSchemas = {\n  fields: queryFieldsSchema,\n  populate: queryPopulateSchema,\n  sort: querySortSchema,\n  pagination: paginationSchema,\n  filters: filtersSchema,\n  locale: localeSchema,\n  status: statusSchema,\n  _q: searchQuerySchema,\n} as const;\n\n/**\n * Query parameter names supported by Strapi's API\n */\nexport type QueryParam = keyof typeof queryParameterSchemas;\n"],"names":["queryFieldsSchema","z","union","string","array","describe","queryPopulateSchema","literal","record","any","querySortSchema","enum","paginationSchema","intersection","object","withCount","boolean","optional","page","number","int","positive","pageSize","start","min","limit","filtersSchema","localeSchema","statusSchema","searchQuerySchema","queryParameterSchemas","fields","populate","sort","pagination","filters","locale","status","_q"],"mappings":";;AAEA;;;;;;;;AAUC,IACM,MAAMA,iBAAoBC,GAAAA,CAAAA,CAC9BC,KAAK,CAAC;AAACD,IAAAA,CAAAA,CAAEE,MAAM,EAAA;IAAIF,CAAEG,CAAAA,KAAK,CAACH,CAAAA,CAAEE,MAAM,EAAA;CAAI,CACvCE,CAAAA,QAAQ,CAAC,kDAAoD;AAEhE;;;AAGC,IACM,MAAMC,mBAAsBL,GAAAA,CAAAA,CAChCC,KAAK,CAAC;AAACD,IAAAA,CAAAA,CAAEM,OAAO,CAAC,GAAA,CAAA;AAAMN,IAAAA,CAAAA,CAAEE,MAAM,EAAA;IAAIF,CAAEG,CAAAA,KAAK,CAACH,CAAAA,CAAEE,MAAM,EAAA,CAAA;AAAKF,IAAAA,CAAAA,CAAEO,MAAM,CAACP,CAAAA,CAAEE,MAAM,EAAA,EAAIF,EAAEQ,GAAG,EAAA;CAAI,CACtFJ,CAAAA,QAAQ,CAAC,qDAAuD;AAEnE;;;AAGC,IACM,MAAMK,eAAkBT,GAAAA,CAAAA,CAC5BC,KAAK,CAAC;AACLD,IAAAA,CAAAA,CAAEE,MAAM,EAAA;IACRF,CAAEG,CAAAA,KAAK,CAACH,CAAAA,CAAEE,MAAM,EAAA,CAAA;AAChBF,IAAAA,CAAAA,CAAEO,MAAM,CAACP,CAAAA,CAAEE,MAAM,EAAIF,EAAAA,CAAAA,CAAEU,IAAI,CAAC;AAAC,QAAA,KAAA;AAAO,QAAA;AAAO,KAAA,CAAA,CAAA;IAC3CV,CAAEG,CAAAA,KAAK,CAACH,CAAAA,CAAEO,MAAM,CAACP,EAAEE,MAAM,EAAA,EAAIF,CAAEU,CAAAA,IAAI,CAAC;AAAC,QAAA,KAAA;AAAO,QAAA;AAAO,KAAA,CAAA,CAAA;CACpD,CACAN,CAAAA,QAAQ,CAAC,sCAAwC;AAEpD;;;UAIaO,gBAAmBX,GAAAA,CAAAA,CAC7BY,YAAY,CACXZ,CAAAA,CAAEa,MAAM,CAAC;AACPC,IAAAA,SAAAA,EAAWd,EAAEe,OAAO,EAAA,CAAGC,QAAQ,EAAA,CAAGZ,QAAQ,CAAC,iCAAA;AAC7C,CACAJ,CAAAA,EAAAA,CAAAA,CAAEC,KAAK,CAAC;AACND,IAAAA,CAAAA,CACGa,MAAM,CAAC;QACNI,IAAMjB,EAAAA,CAAAA,CAAEkB,MAAM,EAAGC,CAAAA,GAAG,GAAGC,QAAQ,EAAA,CAAGhB,QAAQ,CAAC,uBAAA,CAAA;QAC3CiB,QAAUrB,EAAAA,CAAAA,CAAEkB,MAAM,EAAGC,CAAAA,GAAG,GAAGC,QAAQ,EAAA,CAAGhB,QAAQ,CAAC,4BAAA;AACjD,KAAA,CAAA,CACCA,QAAQ,CAAC,uBAAA,CAAA;AACZJ,IAAAA,CAAAA,CACGa,MAAM,CAAC;QACNS,KAAOtB,EAAAA,CAAAA,CAAEkB,MAAM,EAAGC,CAAAA,GAAG,GAAGI,GAAG,CAAC,CAAGnB,CAAAA,CAAAA,QAAQ,CAAC,2BAAA,CAAA;QACxCoB,KAAOxB,EAAAA,CAAAA,CAAEkB,MAAM,EAAGC,CAAAA,GAAG,GAAGC,QAAQ,EAAA,CAAGhB,QAAQ,CAAC,qCAAA;AAC9C,KAAA,CAAA,CACCA,QAAQ,CAAC,yBAAA;CACb,CAEFA,CAAAA,CAAAA,QAAQ,CAAC,uBAAyB;AAErC;;;AAGC,IACM,MAAMqB,aAAgBzB,GAAAA,CAAAA,CAAEO,MAAM,CAACP,CAAAA,CAAEE,MAAM,EAAA,EAAIF,CAAEQ,CAAAA,GAAG,EAAIJ,CAAAA,CAAAA,QAAQ,CAAC,4BAA8B;AAElG;;;UAIasB,YAAe1B,GAAAA,CAAAA,CAAEE,MAAM,EAAGE,CAAAA,QAAQ,CAAC,0CAA4C;AAE5F;;;AAGC,IACM,MAAMuB,YAAe3B,GAAAA,CAAAA,CAAEU,IAAI,CAAC;AAAC,IAAA,OAAA;AAAS,IAAA;CAAY,CAAEN,CAAAA,QAAQ,CAAC,8BAAgC;AAEpG;;;UAIawB,iBAAoB5B,GAAAA,CAAAA,CAAEE,MAAM,EAAGE,CAAAA,QAAQ,CAAC,qBAAuB;AAE5E;;;UAIayB,qBAAwB,GAAA;IACnCC,MAAQ/B,EAAAA,iBAAAA;IACRgC,QAAU1B,EAAAA,mBAAAA;IACV2B,IAAMvB,EAAAA,eAAAA;IACNwB,UAAYtB,EAAAA,gBAAAA;IACZuB,OAAST,EAAAA,aAAAA;IACTU,MAAQT,EAAAA,YAAAA;IACRU,MAAQT,EAAAA,YAAAA;IACRU,EAAIT,EAAAA;AACN;;;;"}

package/dist/validation/utilities.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @file This file contains utility functions for working with Zod schemas.
+ * It provides functions to modify schemas (e.g., make them optional, readonly, or add default values),
+ * and to safely register and create schemas within Zod's global registry.
+ */
+import * as z from 'zod/v4';
+/**
+ * Transforms a Strapi UID into an OpenAPI-compliant component name.
+ *
+ * @param uid - The Strapi UID to transform (e.g., "basic.seo", "api::category.category", "plugin::upload.file")
+ * @returns The OpenAPI-compliant component name (e.g., "BasicSeoEntry", "ApiCategoryCategoryDocument", "PluginUploadFileDocument")
+ */
+export declare const transformUidToValidOpenApiName: (uid: string) => string;
+/**
+ * Conditionally makes a Zod schema optional based on the `required` parameter.
+ *
+ * @param required - If `false` or `undefined`, the schema will be made optional. If `true`, the schema becomes non-optional.
+ * @returns A function that takes a Zod schema and returns a modified schema (optional or required).
+ * @example
+ * ```typescript
+ * const optionalString = maybeRequired(false)(z.string()); // z.ZodOptional<z.ZodString>
+ *
+ * const requiredString = maybeRequired(true)(z.string());  // z.ZodString
+ * ```
+ */
+export declare const maybeRequired: (required?: boolean) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(schema: T) => z.ZodOptional<T> | z.ZodNonOptional<T>;
+/**
+ * Conditionally makes a Zod schema readonly based on the `writable` parameter.
+ *
+ * @param writable - If `false`, the schema will be made readonly. If `true` or `undefined`, the schema remains unchanged.
+ * @returns A function that takes a Zod schema and returns a modified schema (readonly or original).
+ * @example
+ * ```typescript
+ * const readonlyNumber = maybeReadonly(false)(z.number()); // z.ZodReadonly<z.ZodNumber>
+ * const writableNumber = maybeReadonly(true)(z.number());  // z.ZodNumber
+ * ```
+ */
+export declare const maybeReadonly: (writable?: boolean) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(schema: T) => T | z.ZodReadonly<T>;
+/**
+ * Conditionally adds a default value to a Zod schema based on the `defaultValue` parameter.
+ *
+ * @param defaultValue - The default value to apply to the schema. If `undefined`, no default value is added.
+ *                       If `defaultValue` is a function, its return value will be used as the default.
+ * @returns A function that takes a Zod schema and returns a modified schema (with default or original).
+ * @example
+ * ```typescript
+ * const stringWithDefault = maybeWithDefault("default")(z.string()); // z.ZodDefault<z.ZodString>
+ * const numberWithFunctionDefault = maybeWithDefault(() => Math.random())(z.number());
+ * ```
+ */
+export declare const maybeWithDefault: (defaultValue?: unknown) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(schema: T) => T | z.ZodDefault<T>;
+/**
+ * Conditionally applies `min` and `max` constraints to a Zod string, number, or array schema.
+ *
+ * @param min - The minimum value/length. If `undefined`, no minimum constraint is applied.
+ * @param max - The maximum value/length. If `undefined`, no maximum constraint is applied.
+ * @returns A function that takes a Zod string, number, or array schema and returns a modified schema (with min/max constraints or original).
+ * @example
+ * ```typescript
+ * const stringWithMinMax = maybeWithMinMax(5, 10)(z.string()); // z.ZodString with min(5) and max(10)
+ * const numberWithMinMax = maybeWithMinMax(0, 100)(z.number()); // z.ZodNumber with min(0) and max(100)
+ * ```
+ */
+export declare const maybeWithMinMax: (min?: number, max?: number) => <R extends z.ZodString | z.ZodNumber | z.ZodEmail | z.ZodArray<z.ZodAny>>(schema: R) => z.ZodString | z.ZodNumber | z.ZodEmail | z.ZodArray<z.ZodAny>;
+/**
+ * Applies a series of modifier functions to a Zod schema sequentially.
+ *
+ * @template T - The type of the Zod schema.
+ * @param schema - The initial Zod schema to which modifiers will be applied.
+ * @param modifiers - An array of functions, each taking a Zod schema and returning a modified schema.
+ * @returns The final Zod schema after all modifiers have been applied.
+ * @example
+ * ```typescript
+ * const modifiedSchema = augmentSchema(z.string(), [
+ *   maybeRequired(false),
+ *   maybeWithDefault("test")
+ * ]);
+ * ```
+ */
+export declare const augmentSchema: <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(schema: T, modifiers: ((schema: T) => z.Schema)[]) => T;
+//# sourceMappingURL=utilities.d.ts.map

package/dist/validation/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/validation/utilities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,QAAS,MAAM,KAAG,MAyB5D,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,cAAe,OAAO,iGACV,CAAC,2CAGtC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,cAAe,OAAO,iGACV,CAAC,yBACtC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,kBAAmB,OAAO,iGACjB,CAAC,wBAQtC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,SAAU,MAAM,QAAQ,MAAM,uFACiC,CAAC,kEAG3F,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,8FAChB,CAAC,aACE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,MAGvC,CAAC"}