@strapi/typescript-utils 0.0.0-next.c5f067b5650921187770124e9b6c8186e805e242 → 0.0.0-next.c80d4d9b205f7844215758ba333894819685e6c1

package/lib/__tests__/generators/schemas/attributes.test.js

@@ -148,6 +148,72 @@ describe('Attributes', () => {
         expect(addImport).toHaveBeenCalledWith('Attribute');
       };
 
+      describe('Media', () => {
+        test('Media with multiple and with no allowedTypes', () => {
+          const attribute = { type: 'media', multiple: true };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'Attribute.Media');
+
+          expect(typeNode.typeArguments).toHaveLength(2);
+
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.UndefinedKeyword);
+
+          expect(typeNode.typeArguments[1].kind).toBe(ts.SyntaxKind.TrueKeyword);
+        });
+
+        test('Media without multiple with allowedTypes', () => {
+          const attribute = { type: 'media', allowedTypes: ['images', 'videos'] };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'Attribute.Media');
+
+          expect(typeNode.typeArguments).toHaveLength(1);
+
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.UnionType);
+
+          const unionTypes = typeNode.typeArguments[0].types;
+
+          attribute.allowedTypes.forEach((value, index) => {
+            const element = unionTypes[index];
+
+            expect(element.kind).toBe(ts.SyntaxKind.StringLiteral);
+            expect(element.text).toBe(value);
+          });
+        });
+
+        test('Media with multiple and with allowedTypes', () => {
+          const attribute = { type: 'media', multiple: true, allowedTypes: ['images', 'videos'] };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'Attribute.Media');
+
+          expect(typeNode.typeArguments).toHaveLength(2);
+
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.UnionType);
+
+          const unionTypes = typeNode.typeArguments[0].types;
+
+          attribute.allowedTypes.forEach((value, index) => {
+            const element = unionTypes[index];
+
+            expect(element.kind).toBe(ts.SyntaxKind.StringLiteral);
+            expect(element.text).toBe(value);
+          });
+
+          expect(typeNode.typeArguments[1].kind).toBe(ts.SyntaxKind.TrueKeyword);
+        });
+
+        test('Media without multiple and with no allowedTypes', () => {
+          const attribute = { type: 'media' };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'Attribute.Media');
+
+          expect(typeNode.typeArguments).toBeUndefined();
+        });
+      });
+
       describe('Enumeration', () => {
         test('Enumeration with an enum property', () => {
           const attribute = { type: 'enumeration', enum: ['a', 'b', 'c'] };
@@ -671,6 +737,38 @@ describe('Attributes', () => {
           // Check for string keyword on the second typeArgument
           expect(typeofMinMax.kind).toBe(ts.SyntaxKind.StringKeyword);
         });
+
+        test('Min: 0', () => {
+          const attribute = { min: 0 };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMax');
+
+          const [setMinMax] = modifiers;
+          const { typeArguments } = setMinMax;
+
+          expect(typeArguments).toBeDefined();
+          expect(typeArguments).toHaveLength(2);
+
+          const [definition, typeofMinMax] = typeArguments;
+
+          // Min/Max
+          expect(definition.kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(definition.members).toHaveLength(1);
+
+          const [min] = definition.members;
+
+          expect(min.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+          expect(min.name.escapedText).toBe('min');
+          expect(min.type.kind).toBe(ts.SyntaxKind.NumericLiteral);
+          expect(min.type.text).toBe('0');
+
+          // Check for string keyword on the second typeArgument
+          expect(typeofMinMax.kind).toBe(ts.SyntaxKind.NumberKeyword);
+        });
       });
 
       describe('MinLength / MaxLength', () => {

package/lib/generators/common/models/attributes.js

@@ -114,21 +114,21 @@ const getAttributeModifiers = (attribute) => {
       throw new Error('typeof min/max values mismatch');
     }
 
-    const typeofMinMax = (max && typeofMax) ?? (min && typeofMin);
     let typeKeyword;
 
-    // Determines type keyword (string/number) based on min/max options, throws error for invalid types
-    switch (typeofMinMax) {
-      case 'string':
-        typeKeyword = ts.SyntaxKind.StringKeyword;
-        break;
-      case 'number':
-        typeKeyword = ts.SyntaxKind.NumberKeyword;
-        break;
-      default:
-        throw new Error(
-          `Invalid data type for min/max options. Must be string or number, but found ${typeofMinMax}`
-        );
+    // use 'string'
+    if (typeofMin === 'string' || typeofMax === 'string') {
+      typeKeyword = ts.SyntaxKind.StringKeyword;
+    }
+    // use 'number'
+    else if (typeofMin === 'number' || typeofMax === 'number') {
+      typeKeyword = ts.SyntaxKind.NumberKeyword;
+    }
+    // invalid type
+    else {
+      throw new Error(
+        `Invalid data type for min/max options. Must be string, number or undefined, but found { min: ${min} (${typeofMin}), max: ${max} (${typeofMax}) }`
+      );
     }
 
     modifiers.push(

package/lib/generators/common/models/mappers.js

@@ -90,8 +90,26 @@ module.exports = {
   blocks() {
     return [withAttributeNamespace('Blocks')];
   },
-  media() {
-    return [withAttributeNamespace('Media')];
+  media({ attribute }) {
+    const { allowedTypes, multiple } = attribute;
+
+    const params = [];
+
+    const typesParam = allowedTypes
+      ? factory.createUnionTypeNode(
+          allowedTypes.map((allowedType) => factory.createStringLiteral(allowedType))
+        )
+      : factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword);
+
+    if (allowedTypes || multiple) {
+      params.push(typesParam);
+    }
+
+    if (multiple) {
+      params.push(factory.createTrue());
+    }
+
+    return [withAttributeNamespace('Media'), params];
   },
   relation({ uid, attribute }) {
     const { relation, target } = attribute;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/typescript-utils",
-  "version": "0.0.0-next.c5f067b5650921187770124e9b6c8186e805e242",
+  "version": "0.0.0-next.c80d4d9b205f7844215758ba333894819685e6c1",
   "description": "Typescript support for Strapi",
   "keywords": [
     "strapi",
@@ -46,5 +46,5 @@
     "node": ">=18.0.0 <=20.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "c5f067b5650921187770124e9b6c8186e805e242"
+  "gitHead": "c80d4d9b205f7844215758ba333894819685e6c1"
 }