@strapi/core 0.0.0-experimental.3218535c8b12e654be4191f9c36c07b43861b437 → 0.0.0-experimental.32a96e212ac6550182455c62b032966a13f0a362

package/dist/core-api/routes/validation/attributes.js

@@ -0,0 +1,588 @@
+'use strict';
+
+var strapiUtils = require('@strapi/utils');
+var zod = require('zod');
+var constants = require('./constants.js');
+var component = require('./component.js');
+var contentType = require('./content-type.js');
+
+/**
+ * Maps a Strapi attribute definition to a corresponding Zod validation schema.
+ * This function handles various Strapi attribute types and converts them into
+ * appropriate Zod validation schemas with their respective constraints.
+ *
+ * @param attribute - The Strapi attribute configuration object. Contains type information
+ *                   and validation rules for the attribute.
+ *
+ * @returns A Zod schema that corresponds to the input attribute's type and validation rules
+ *
+ * @example
+ * ```typescript
+ * // String attribute with constraints
+ * const stringAttribute = {
+ *   type: 'string',
+ *   minLength: 3,
+ *   maxLength: 50,
+ *   required: true
+ * };
+ * const stringSchema = mapAttributeToSchema(stringAttribute);
+ *
+ * // Enumeration attribute
+ * const enumAttribute = {
+ *   type: 'enumeration',
+ *   enum: ['draft', 'published', 'archived']
+ * };
+ * const enumSchema = mapAttributeToSchema(enumAttribute);
+ *
+ * // Media attribute with multiple files
+ * const mediaAttribute = {
+ *   type: 'media',
+ *   multiple: true
+ * };
+ * const mediaSchema = mapAttributeToSchema(mediaAttribute);
+ * ```
+ *
+ * @throws {Error} Throws an error if an unsupported attribute type is provided
+ *
+ * @todo: Move to @strapi/utils if needed for other validation
+ */ const mapAttributeToSchema = (attribute)=>{
+    switch(attribute.type){
+        case 'biginteger':
+            {
+                const { writable, required, min, max, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    (schema)=>min !== undefined ? schema.min(min) : schema,
+                    (schema)=>max !== undefined ? schema.max(max) : schema,
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A biginteger field');
+            }
+        case 'blocks':
+            {
+                // TODO: better support blocks data structure
+                return zod.z.array(zod.z.any()).describe('A blocks field');
+            }
+        case 'boolean':
+            {
+                const { writable, required, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.boolean(), [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A boolean field');
+            }
+        case 'component':
+            {
+                const { _idmap } = zod.z.globalRegistry;
+                const set = (id, schema)=>{
+                    if (_idmap.has(id)) {
+                        _idmap.delete(id);
+                    }
+                    zod.z.globalRegistry.add(schema, {
+                        id
+                    });
+                };
+                const { writable, required, min, max, component: component$1, repeatable } = attribute;
+                const existsInGlobalRegistry = _idmap.has(component$1);
+                let componentSchema;
+                if (existsInGlobalRegistry) {
+                    componentSchema = _idmap.get(component$1);
+                } else {
+                    set(component$1, zod.z.any());
+                    const validator = new component.CoreComponentRouteValidator(strapi, component$1);
+                    const schema = validator.entry;
+                    set(component$1, schema);
+                    componentSchema = schema;
+                }
+                const baseSchema = repeatable ? zod.z.array(componentSchema) : componentSchema;
+                const schema = augmentSchema(baseSchema, [
+                    (schema)=>min !== undefined && schema instanceof zod.z.ZodArray ? schema.min(min) : schema,
+                    (schema)=>max !== undefined && schema instanceof zod.z.ZodArray ? schema.max(max) : schema,
+                    maybeRequired(required),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A component field');
+            }
+        case 'date':
+            {
+                const { writable, required, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A date field');
+            }
+        case 'datetime':
+            {
+                const { writable, required, default: defaultValue } = attribute;
+                const baseSchema = zod.z.string();
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A datetime field');
+            }
+        case 'decimal':
+            {
+                const { writable, required, min, max, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.number(), [
+                    maybeWithMinMax(min, max),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A decimal field');
+            }
+        // TODO(zodV4): use the components' reference type instead of z.any
+        // TODO(zodV4): use discriminated unions to handle the different types of components
+        case 'dynamiczone':
+            {
+                const { writable, required, min, max } = attribute;
+                const baseSchema = zod.z.array(zod.z.any());
+                const schema = augmentSchema(baseSchema, [
+                    maybeWithMinMax(min, max),
+                    maybeRequired(required),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A dynamic zone field');
+            }
+        case 'email':
+            {
+                const { writable, required, default: defaultValue, minLength, maxLength } = attribute;
+                const baseSchema = zod.z.string().email();
+                const schema = augmentSchema(baseSchema, [
+                    maybeWithMinMax(minLength, maxLength),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('An email field');
+            }
+        case 'enumeration':
+            {
+                const { writable, required, default: defaultValue, enum: enumValues } = attribute;
+                const baseSchema = zod.z.enum(enumValues);
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('An enum field');
+            }
+        case 'float':
+            {
+                const { writable, required, min, max, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.number(), [
+                    maybeWithMinMax(min, max),
+                    maybeRequired(required),
+                    maybeReadonly(writable),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A float field');
+            }
+        case 'integer':
+            {
+                const { writable, required, min, max, default: defaultValue } = attribute;
+                const baseSchema = zod.z.number().int();
+                const schema = augmentSchema(baseSchema, [
+                    maybeWithMinMax(min, max),
+                    maybeRequired(required),
+                    maybeReadonly(writable),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A float field');
+            }
+        // TODO(zodV4): use reference to create fake cyclical JSON values
+        //              see https://zod.dev/?id=json-type for more info
+        case 'json':
+            {
+                const { writable, required, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.any(), [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A JSON field');
+            }
+        case 'media':
+            {
+                const { writable, required, multiple } = attribute;
+                const uploadPlugin = strapi.plugin('upload');
+                // @ts-expect-error there is a mismatch between a raw module and a loader module
+                const fileSchema = uploadPlugin.contentTypes.file;
+                const mediaSchema = safeSchemaCreation(fileSchema.uid, ()=>new contentType.CoreContentTypeRouteValidator(strapi, fileSchema.uid).document);
+                const baseSchema = multiple ? zod.z.array(mediaSchema) : mediaSchema;
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A media field');
+            }
+        // TODO(zodV4): handle polymorphic relations using discriminated unions
+        case 'relation':
+            {
+                // Extract writable and required flags from the attribute
+                if (!('target' in attribute)) {
+                    return zod.z.any();
+                }
+                const { writable, required, target } = attribute;
+                const targetSchema = safeSchemaCreation(target, ()=>new contentType.CoreContentTypeRouteValidator(strapi, target).document);
+                const baseSchema = strapiUtils.relations.isAnyToMany(attribute) ? zod.z.array(targetSchema) : targetSchema;
+                // Add required and readonly constraints based on attribute flags
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A relational field');
+            }
+        case 'password':
+        case 'text':
+        case 'richtext':
+        case 'string':
+            {
+                const { writable, required, default: defaultValue, minLength, maxLength } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    maybeWithMinMax(minLength, maxLength),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe(`A ${attribute.type} field`);
+            }
+        case 'time':
+            {
+                const { writable, required, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A time field');
+            }
+        case 'timestamp':
+            {
+                const { writable, required, default: defaultValue } = attribute;
+                const baseSchema = zod.z.union([
+                    zod.z.string(),
+                    zod.z.number()
+                ]);
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A timestamp field');
+            }
+        case 'uid':
+            {
+                const { writable, required, default: defaultValue, minLength, maxLength } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    maybeWithMinMax(minLength, maxLength),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue),
+                    maybeReadonly(writable)
+                ]);
+                return schema.describe('A UID field');
+            }
+        default:
+            throw new Error(`Unsupported attribute type: ${attribute.type}`);
+    }
+};
+/**
+ * Maps a Strapi attribute definition to a corresponding Zod validation schema.
+ * This function handles various Strapi attribute types and converts them into
+ * appropriate Zod validation schemas with their respective constraints.
+ *
+ * @param attribute - The Strapi attribute configuration object. Contains type information
+ *                   and validation rules for the attribute.
+ *
+ * @returns A Zod schema that corresponds to the input attribute's type and validation rules
+ *
+ * @example
+ * ```typescript
+ * // String attribute with constraints
+ * const stringAttribute = {
+ *   type: 'string',
+ *   minLength: 3,
+ *   maxLength: 50,
+ *   required: true
+ * };
+ * const stringSchema = mapAttributeToInputSchema(stringAttribute);
+ *
+ * // Enumeration attribute
+ * const enumAttribute = {
+ *   type: 'enumeration',
+ *   enum: ['draft', 'published', 'archived']
+ * };
+ * const enumSchema = mapAttributeToInputSchema(enumAttribute);
+ *
+ * // Media attribute with multiple files
+ * const mediaAttribute = {
+ *   type: 'media',
+ *   multiple: true
+ * };
+ * const mediaSchema = mapAttributeToInputSchema(mediaAttribute);
+ * ```
+ *
+ * @throws {Error} Throws an error if an unsupported attribute type is provided
+ *
+ * @remarks
+ * - Complex types (component, relation, dynamic zone) use placeholder schemas
+ *
+ * @todo: Move to @strapi/utils if needed for other validation
+ */ const mapAttributeToInputSchema = (attribute)=>{
+    switch(attribute.type){
+        case 'biginteger':
+            {
+                const { required, min, max, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    (schema)=>min !== undefined ? schema.min(min) : schema,
+                    (schema)=>max !== undefined ? schema.max(max) : schema,
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A biginteger field');
+            }
+        case 'blocks':
+            {
+                // TODO: better support blocks data structure
+                return zod.z.array(zod.z.any()).describe('A blocks field');
+            }
+        case 'boolean':
+            {
+                const { required, default: defaultValue } = attribute;
+                const baseSchema = zod.z.enum(constants.BOOLEAN_LITERAL_VALUES);
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A boolean field');
+            }
+        // TODO(zodV4): use the component reference type instead of z.any
+        case 'component':
+            {
+                const { required, repeatable, min, max } = attribute;
+                const baseSchema = repeatable ? zod.z.array(zod.z.any()) : zod.z.any();
+                const schema = augmentSchema(baseSchema, [
+                    (schema)=>min !== undefined && schema instanceof zod.z.ZodArray ? schema.min(min) : schema,
+                    (schema)=>max !== undefined && schema instanceof zod.z.ZodArray ? schema.max(max) : schema,
+                    maybeRequired(required)
+                ]);
+                return schema.describe('A component field');
+            }
+        case 'date':
+            {
+                const { required, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A date field');
+            }
+        case 'datetime':
+            {
+                const { required, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A datetime field');
+            }
+        case 'decimal':
+            {
+                const { required, min, max, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.number(), [
+                    maybeWithMinMax(min, max),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A decimal field');
+            }
+        // TODO(zodV4): use the components' reference type instead of z.any
+        // TODO(zodV4): use discriminated unions to handle the different types of components
+        case 'dynamiczone':
+            {
+                const { required, min, max } = attribute;
+                const baseSchema = zod.z.array(zod.z.any());
+                const schema = augmentSchema(baseSchema, [
+                    maybeWithMinMax(min, max),
+                    maybeRequired(required)
+                ]);
+                return schema.describe('A dynamic zone field');
+            }
+        case 'email':
+            {
+                const { required, default: defaultValue, minLength, maxLength } = attribute;
+                const baseSchema = zod.z.string().email();
+                const schema = augmentSchema(baseSchema, [
+                    maybeWithMinMax(minLength, maxLength),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('An email field');
+            }
+        case 'enumeration':
+            {
+                const { required, default: defaultValue, enum: enumValues } = attribute;
+                const baseSchema = zod.z.enum(enumValues);
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('An enum field');
+            }
+        case 'float':
+            {
+                const { required, min, max, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.number(), [
+                    maybeWithMinMax(min, max),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A float field');
+            }
+        case 'integer':
+            {
+                const { required, min, max, default: defaultValue } = attribute;
+                const baseSchema = zod.z.number().int();
+                const schema = augmentSchema(baseSchema, [
+                    maybeWithMinMax(min, max),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A float field');
+            }
+        // TODO(zodV4): use reference to create fake cyclical JSON values
+        //              see https://zod.dev/?id=json-type for more info
+        case 'json':
+            {
+                const { required, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.any(), [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A JSON field');
+            }
+        case 'media':
+            {
+                const { required, multiple } = attribute;
+                const baseSchema = multiple ? zod.z.array(zod.z.any()) : zod.z.any();
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required)
+                ]);
+                return schema.describe('A media field');
+            }
+        // TODO(zodV4): use reference for relations types
+        // TODO(zodV4): handle polymorphic relations using discriminated unions
+        // TODO(zodv4): add the relation ordering API https://docs.strapi.io/cms/api/rest/relations
+        case 'relation':
+            {
+                const { required } = attribute;
+                const isToMany = strapiUtils.relations.isAnyToMany(attribute);
+                const uuid = zod.z.string().uuid();
+                const baseSchema = isToMany ? zod.z.array(uuid) : uuid;
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required)
+                ]);
+                return schema.describe('A relational field');
+            }
+        case 'password':
+        case 'text':
+        case 'richtext':
+        case 'string':
+            {
+                const { required, default: defaultValue, minLength, maxLength } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    maybeWithMinMax(minLength, maxLength),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe(`A ${attribute.type} field`);
+            }
+        case 'time':
+            {
+                const { required, default: defaultValue } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A time field');
+            }
+        case 'timestamp':
+            {
+                const { required, default: defaultValue } = attribute;
+                const baseSchema = zod.z.union([
+                    zod.z.string(),
+                    zod.z.number()
+                ]);
+                const schema = augmentSchema(baseSchema, [
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A timestamp field');
+            }
+        case 'uid':
+            {
+                const { required, default: defaultValue, minLength, maxLength } = attribute;
+                const schema = augmentSchema(zod.z.string(), [
+                    maybeWithMinMax(minLength, maxLength),
+                    maybeRequired(required),
+                    maybeWithDefault(defaultValue)
+                ]);
+                return schema.describe('A UID field');
+            }
+        default:
+            throw new Error(`Unsupported attribute type: ${attribute.type}`);
+    }
+};
+const maybeRequired = (required)=>{
+    return (schema)=>required !== true ? schema.optional() : schema;
+};
+const maybeReadonly = (writable)=>{
+    return (schema)=>writable !== false ? schema : schema.readonly();
+};
+const maybeWithDefault = (defaultValue)=>{
+    return (schema)=>{
+        return defaultValue !== undefined ? schema.default(typeof defaultValue === 'function' ? defaultValue() : defaultValue) : schema;
+    };
+};
+const maybeWithMinMax = (min, max)=>{
+    return (schema)=>{
+        return min !== undefined && max !== undefined ? schema.min(min).max(max) : schema;
+    };
+};
+const augmentSchema = (schema, modifiers)=>{
+    return modifiers.reduce((acc, modifier)=>modifier(acc), schema);
+};
+const safeGlobalRegistrySet = (id, schema)=>{
+    const { _idmap } = zod.z.globalRegistry;
+    // Allow safe overrides in the ID map
+    if (_idmap.has(id)) {
+        _idmap.delete(id);
+    }
+    zod.z.globalRegistry.add(schema, {
+        id
+    });
+};
+const safeSchemaCreation = (id, callback)=>{
+    const { _idmap } = zod.z.globalRegistry;
+    const existsInGlobalRegistry = _idmap.has(id);
+    if (existsInGlobalRegistry) {
+        return _idmap.get(id);
+    }
+    // Temporary any placeholder before replacing with the actual schema type
+    // Used to prevent infinite loops in cyclical data structures
+    safeGlobalRegistrySet(id, zod.z.any());
+    const schema = callback();
+    safeGlobalRegistrySet(id, schema);
+    return schema;
+};
+
+exports.mapAttributeToInputSchema = mapAttributeToInputSchema;
+exports.mapAttributeToSchema = mapAttributeToSchema;
+//# sourceMappingURL=attributes.js.map