@strapi/typescript-utils 0.0.0-next.f426350b859ddae6592e9bfa99e6be94ae22e117 → 0.0.0-next.f4ff842a3cb7b83db540bee67554b704e042b042

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'] };
@@ -548,19 +614,27 @@ describe('Attributes', () => {
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
           expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMax');
 
-          expect(modifiers[0].typeArguments).toHaveLength(1);
-          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
-          expect(modifiers[0].typeArguments[0].members).toHaveLength(1);
+          const [setMinMax] = modifiers;
+          const { typeArguments } = setMinMax;
+
+          expect(typeArguments).toBeDefined();
+          expect(typeArguments).toHaveLength(2);
+
+          const [definition, typeofMinMax] = typeArguments;
 
           // Min
-          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
-            ts.SyntaxKind.PropertyDeclaration
-          );
-          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('min');
-          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
-            ts.SyntaxKind.NumericLiteral
-          );
-          expect(modifiers[0].typeArguments[0].members[0].type.text).toBe('2');
+          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('2');
+
+          // Check for number keyword on the second typeArgument
+          expect(typeofMinMax.kind).toBe(ts.SyntaxKind.NumberKeyword);
         });
 
         test('No Min, Max: 3', () => {
@@ -572,19 +646,27 @@ describe('Attributes', () => {
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
           expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMax');
 
-          expect(modifiers[0].typeArguments).toHaveLength(1);
-          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
-          expect(modifiers[0].typeArguments[0].members).toHaveLength(1);
+          const [setMinMax] = modifiers;
+          const { typeArguments } = setMinMax;
 
-          // Min
-          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
-            ts.SyntaxKind.PropertyDeclaration
-          );
-          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('max');
-          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
-            ts.SyntaxKind.NumericLiteral
-          );
-          expect(modifiers[0].typeArguments[0].members[0].type.text).toBe('3');
+          expect(typeArguments).toBeDefined();
+          expect(typeArguments).toHaveLength(2);
+
+          const [definition, typeofMinMax] = typeArguments;
+
+          // Max
+          expect(definition.kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(definition.members).toHaveLength(1);
+
+          const [max] = definition.members;
+
+          expect(max.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+          expect(max.name.escapedText).toBe('max');
+          expect(max.type.kind).toBe(ts.SyntaxKind.NumericLiteral);
+          expect(max.type.text).toBe('3');
+
+          // Check for number keyword on the second typeArgument
+          expect(typeofMinMax.kind).toBe(ts.SyntaxKind.NumberKeyword);
         });
 
         test('Min: 4, Max: 12', () => {
@@ -596,28 +678,96 @@ describe('Attributes', () => {
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
           expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMax');
 
-          expect(modifiers[0].typeArguments).toHaveLength(1);
-          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
-          expect(modifiers[0].typeArguments[0].members).toHaveLength(2);
+          const [setMinMax] = modifiers;
+          const { typeArguments } = setMinMax;
 
-          // Min
-          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
-            ts.SyntaxKind.PropertyDeclaration
-          );
-          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('min');
-          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
-            ts.SyntaxKind.NumericLiteral
-          );
-          expect(modifiers[0].typeArguments[0].members[0].type.text).toBe('4');
+          expect(typeArguments).toBeDefined();
+          expect(typeArguments).toHaveLength(2);
 
-          expect(modifiers[0].typeArguments[0].members[1].kind).toBe(
-            ts.SyntaxKind.PropertyDeclaration
-          );
-          expect(modifiers[0].typeArguments[0].members[1].name.escapedText).toBe('max');
-          expect(modifiers[0].typeArguments[0].members[1].type.kind).toBe(
-            ts.SyntaxKind.NumericLiteral
-          );
-          expect(modifiers[0].typeArguments[0].members[1].type.text).toBe('12');
+          const [definition, typeofMinMax] = typeArguments;
+
+          // Min/Max
+          expect(definition.kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(definition.members).toHaveLength(2);
+
+          const [min, max] = 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('4');
+
+          expect(max.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+          expect(max.name.escapedText).toBe('max');
+          expect(max.type.kind).toBe(ts.SyntaxKind.NumericLiteral);
+          expect(max.type.text).toBe('12');
+
+          // Check for number keyword on the second typeArgument
+          expect(typeofMinMax.kind).toBe(ts.SyntaxKind.NumberKeyword);
+        });
+
+        test('Min: "1"', () => {
+          const attribute = { min: '1' };
+          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.StringLiteral);
+          expect(min.type.text).toBe('1');
+
+          // 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);
         });
       });
 

package/lib/admin/create-tsconfig-file.js

@@ -2,25 +2,11 @@
 
 const path = require('path');
 const fs = require('fs-extra');
+const adminTsConfig = require('../../tsconfigs/admin.json');
 
 module.exports = async (dest) => {
   const tsConfig = {
-    compilerOptions: {
-      lib: ['es2019', 'es2020.promise', 'es2020.bigint', 'es2020.string', 'DOM'],
-      noImplicitAny: false,
-      module: 'es2020',
-      target: 'es5',
-      jsx: 'react',
-      allowJs: true,
-      strict: true,
-      moduleResolution: 'node',
-      skipLibCheck: true,
-      esModuleInterop: true,
-      allowSyntheticDefaultImports: true,
-      resolveJsonModule: true,
-      noEmit: false,
-      incremental: true,
-    },
+    ...adminTsConfig,
     include: ['../../../src/admin/*', '../../../src/**/**/admin/src/*'],
     exclude: ['node_modules', '**/*.test.js', '*.js'],
   };

package/lib/compile.js

@@ -3,12 +3,8 @@
 const compilers = require('./compilers');
 const getConfigPath = require('./utils/get-config-path');
 
-module.exports = async (srcDir, { watch = false, configOptions = {} } = {}) => {
-  // TODO: Use the Strapi debug logger instead or don't log at all
-  console.log(`Starting the compilation for TypeScript files in ${srcDir}`);
-
-  const compiler = watch ? compilers.watch : compilers.basic;
+module.exports = async (srcDir, { configOptions = {} } = {}) => {
   const configPath = getConfigPath(srcDir);
 
-  compiler.run(configPath, configOptions);
+  compilers.basic.run(configPath, configOptions);
 };

package/lib/compilers/basic.js

@@ -13,15 +13,23 @@ module.exports = {
    * @param {Object} configOptions
    * @param {Array.<string>} configOptions.fileNames
    * @param {Object} configOptions.options
+   * @param {boolean} configOptions.ignoreDiagnostics
    */
   run(tsConfigPath, configOptions = {}) {
+    const { ignoreDiagnostics = false } = configOptions;
     // Parse the tsconfig.json file & resolve the configuration options
     const { fileNames, options, projectReferences } = resolveConfigOptions(tsConfigPath);
 
+    const compilerOptions = merge(options, configOptions.options);
+
+    if (ignoreDiagnostics) {
+      Object.assign(compilerOptions, { noEmit: false, noEmitOnError: false });
+    }
+
     const program = ts.createProgram({
       rootNames: configOptions.fileNames ? configOptions.fileNames : fileNames,
       projectReferences,
-      options: merge(options, configOptions.options),
+      options: compilerOptions,
     });
 
     const emitResults = program.emit();
@@ -30,12 +38,12 @@ module.exports = {
       ts.getPreEmitDiagnostics(program).concat(emitResults.diagnostics)
     );
 
-    if (diagnostics.length > 0) {
+    if (!ignoreDiagnostics && diagnostics.length > 0) {
       reportDiagnostics(diagnostics);
     }
 
-    // If the compilation failed, exit early
-    if (emitResults.emitSkipped) {
+    // If the compilation failed and diagnostics are not ignored, exit early
+    if (!ignoreDiagnostics && emitResults.emitSkipped) {
       process.exit(1);
     }
   },

package/lib/compilers/index.js

@@ -1,9 +1,7 @@
 'use strict';
 
 const basic = require('./basic');
-const watch = require('./watch');
 
 module.exports = {
   basic,
-  watch,
 };

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

@@ -1,12 +1,14 @@
 'use strict';
 
-const { factory } = require('typescript');
+const ts = require('typescript');
 const _ = require('lodash/fp');
 
 const { addImport } = require('../imports');
 const { getTypeNode, toTypeLiteral, withAttributeNamespace, NAMESPACES } = require('./utils');
 const mappers = require('./mappers');
 
+const { factory } = ts;
+
 /**
  * Create the base type node for a given attribute
  *
@@ -100,14 +102,39 @@ const getAttributeModifiers = (attribute) => {
   }
 
   // Min / Max
-  // TODO: Always provide a second type argument for min/max (ie: resolve the attribute scalar type with a `GetAttributeType<${mappers[attribute][0]}>` (useful for biginter (string values)))
   if (!_.isNil(attribute.min) || !_.isNil(attribute.max)) {
     const minMaxProperties = _.pick(['min', 'max'], attribute);
+    const { min, max } = minMaxProperties;
+
+    const typeofMin = typeof min;
+    const typeofMax = typeof max;
+
+    // Throws error if min/max exist but have different types to prevent unexpected behavior
+    if (min !== undefined && max !== undefined && typeofMin !== typeofMax) {
+      throw new Error('typeof min/max values mismatch');
+    }
+
+    let typeKeyword;
+
+    // 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(
       factory.createTypeReferenceNode(
         factory.createIdentifier(withAttributeNamespace('SetMinMax')),
-        [toTypeLiteral(minMaxProperties)]
+        [toTypeLiteral(minMaxProperties), factory.createKeywordTypeNode(typeKeyword)]
       )
     );
   }

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

@@ -87,8 +87,29 @@ module.exports = {
   json() {
     return [withAttributeNamespace('JSON')];
   },
-  media() {
-    return [withAttributeNamespace('Media')];
+  blocks() {
+    return [withAttributeNamespace('Blocks')];
+  },
+  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/lib/generators/utils.js

@@ -92,7 +92,7 @@ const generateSharedExtensionDefinition = (registry, definitions) => {
 
   return factory.createModuleDeclaration(
     [factory.createModifier(ts.SyntaxKind.DeclareKeyword)],
-    factory.createStringLiteral('@strapi/strapi', true),
+    factory.createStringLiteral('@strapi/types', true),
     factory.createModuleBlock([
       factory.createModuleDeclaration(
         [factory.createModifier(ts.SyntaxKind.ExportKeyword)],

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@strapi/typescript-utils",
-  "version": "0.0.0-next.f426350b859ddae6592e9bfa99e6be94ae22e117",
+  "version": "0.0.0-next.f4ff842a3cb7b83db540bee67554b704e042b042",
   "description": "Typescript support for Strapi",
   "keywords": [
     "strapi",
     "generators"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/strapi/strapi.git",
+    "directory": "packages/utils/typescript"
+  },
   "license": "SEE LICENSE IN LICENSE",
   "author": {
     "name": "Strapi Solutions SAS",
@@ -35,11 +40,11 @@
     "fs-extra": "10.0.0",
     "lodash": "4.17.21",
     "prettier": "2.8.4",
-    "typescript": "5.1.3"
+    "typescript": "5.2.2"
   },
   "engines": {
-    "node": ">=16.0.0 <=20.x.x",
+    "node": ">=18.0.0 <=20.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "f426350b859ddae6592e9bfa99e6be94ae22e117"
+  "gitHead": "f4ff842a3cb7b83db540bee67554b704e042b042"
 }

package/tsconfigs/admin.json

@@ -1,20 +1,19 @@
 {
-    "$schema": "https://json.schemastore.org/tsconfig",
-    
-    "compilerOptions": {
-        "module": "ES2020",
-        "moduleResolution": "node",
-        "lib": ["ES2020", "DOM"],
-        "target": "ES5",
-
-        "jsx": "react",
-        "sourceMap": true,
-        "incremental": true,
-
-        "allowJs": true,
-        "allowSyntheticDefaultImports": true,
-        "resolveJsonModule": true,
-        "noEmit": true,
-        "skipLibCheck": true
-    }
-}
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "useDefineForClassFields": true,
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "jsx": "react-jsx"
+  }
+}

package/tsconfigs/server.json

@@ -1,19 +1,20 @@
 {
-    "$schema": "https://json.schemastore.org/tsconfig",
-    
-    "compilerOptions": {
-        "module": "CommonJS",
-        "moduleResolution": "Node",
-        "lib": ["ES2020"],
-        "target": "ES2019",
+  "$schema": "https://json.schemastore.org/tsconfig",
 
-        "strict": false,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "lib": ["ES2020"],
+    "target": "ES2019",
 
-        "incremental": true,
-        "esModuleInterop": true,
-        "resolveJsonModule": true,
-        "noEmitOnError": true
-    }
-}
+    "strict": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+
+    "incremental": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "noEmitOnError": true,
+    "noImplicitThis": true
+  }
+}

package/lib/compilers/watch.js

@@ -1,37 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-
-const reportDiagnostics = require('../utils/report-diagnostics');
-const formatHost = require('../utils/format-host');
-const resolveConfigOptions = require('../utils/resolve-config-options');
-
-/**
- * Prints a diagnostic every time the watch status changes.
- * This is mainly for messages like "Starting compilation" or "Compilation completed".
- */
-const reportWatchStatusChanged = (diagnostic) => {
-  console.info(ts.formatDiagnostic(diagnostic, formatHost));
-};
-
-module.exports = {
-  run(configPath) {
-    const createProgram = ts.createSemanticDiagnosticsBuilderProgram;
-
-    const { fileNames, options, projectReferences, watchOptions } =
-      resolveConfigOptions(configPath);
-
-    const host = ts.createWatchCompilerHost(
-      fileNames,
-      options,
-      ts.sys,
-      createProgram,
-      reportDiagnostics,
-      reportWatchStatusChanged,
-      projectReferences,
-      watchOptions
-    );
-
-    ts.createWatchProgram(host);
-  },
-};