@strapi/typescript-utils 0.0.0-next.f7babb775ed9a7e18d8351cb7f74c63e016323c4 → 0.0.0-next.f86041c89a8c1545c6437a881dc613e98bc52bd7

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

@@ -120,9 +120,9 @@ describe('Utils', () => {
 
   describe('Get Schema Extends Type Name', () => {
     test.each([
-      [{ modelType: 'component', kind: null }, 'Schema.Component'],
-      [{ modelType: 'contentType', kind: 'singleType' }, 'Schema.SingleType'],
-      [{ modelType: 'contentType', kind: 'collectionType' }, 'Schema.CollectionType'],
+      [{ modelType: 'component', kind: null }, 'Struct.ComponentSchema'],
+      [{ modelType: 'contentType', kind: 'singleType' }, 'Struct.SingleTypeSchema'],
+      [{ modelType: 'contentType', kind: 'collectionType' }, 'Struct.CollectionTypeSchema'],
       [{ modelType: 'invalidType', kind: 'foo' }, null],
     ])("Expect %p to generate %p as the base type for a schema's interface", (schema, expected) => {
       expect(getSchemaExtendsTypeName(schema)).toBe(expected);
@@ -168,10 +168,16 @@ describe('Utils', () => {
     });
 
     test('Number', () => {
-      const node = toTypeLiteral(42);
+      const nodePositive = toTypeLiteral(42);
+      const nodeNegative = toTypeLiteral(-42);
 
-      expect(node.kind).toBe(ts.SyntaxKind.FirstLiteralToken);
-      expect(node.text).toBe('42');
+      expect(nodePositive.kind).toBe(ts.SyntaxKind.FirstLiteralToken);
+      expect(nodePositive.text).toBe('42');
+
+      expect(nodeNegative.kind).toBe(ts.SyntaxKind.PrefixUnaryExpression);
+      expect(nodeNegative.operator).toBe(ts.SyntaxKind.MinusToken);
+      expect(nodeNegative.operand.kind).toBe(ts.SyntaxKind.FirstLiteralToken);
+      expect(nodeNegative.operand.text).toBe('42');
     });
 
     test('Boolean', () => {
@@ -247,13 +253,13 @@ describe('Utils', () => {
       expect(objectNode.members).toHaveLength(2);
 
       expect(objectNode.members[0].kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(objectNode.members[0].name.escapedText).toBe('foo');
-      expect(objectNode.members[0].type.kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(objectNode.members[0].type.text).toBe('bar');
+      expect(objectNode.members[0].name.escapedText).toBe('bar');
+      expect(objectNode.members[0].type.kind).toBe(ts.SyntaxKind.TrueKeyword);
 
       expect(objectNode.members[1].kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(objectNode.members[1].name.escapedText).toBe('bar');
-      expect(objectNode.members[1].type.kind).toBe(ts.SyntaxKind.TrueKeyword);
+      expect(objectNode.members[1].name.escapedText).toBe('foo');
+      expect(objectNode.members[1].type.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(objectNode.members[1].type.text).toBe('bar');
     });
 
     test('Object', () => {
@@ -262,20 +268,20 @@ describe('Utils', () => {
       expect(node.kind).toBe(ts.SyntaxKind.TypeLiteral);
       expect(node.members).toHaveLength(2);
 
-      const [firstMember, secondMember] = node.members;
+      const [barMember, fooMember] = node.members;
 
-      expect(firstMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(firstMember.name.escapedText).toBe('foo');
-      expect(firstMember.type.kind).toBe(ts.SyntaxKind.TupleType);
-      expect(firstMember.type.elements).toHaveLength(3);
-      expect(firstMember.type.elements[0].kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(firstMember.type.elements[1].kind).toBe(ts.SyntaxKind.TrueKeyword);
-      expect(firstMember.type.elements[2].kind).toBe(ts.SyntaxKind.FirstLiteralToken);
+      expect(barMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(barMember.name.escapedText).toBe('bar');
+      expect(barMember.type.kind).toBe(ts.SyntaxKind.LiteralType);
+      expect(barMember.type.literal).toBe(ts.SyntaxKind.NullKeyword);
 
-      expect(secondMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(secondMember.name.escapedText).toBe('bar');
-      expect(secondMember.type.kind).toBe(ts.SyntaxKind.LiteralType);
-      expect(secondMember.type.literal).toBe(ts.SyntaxKind.NullKeyword);
+      expect(fooMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(fooMember.name.escapedText).toBe('foo');
+      expect(fooMember.type.kind).toBe(ts.SyntaxKind.TupleType);
+      expect(fooMember.type.elements).toHaveLength(3);
+      expect(fooMember.type.elements[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(fooMember.type.elements[1].kind).toBe(ts.SyntaxKind.TrueKeyword);
+      expect(fooMember.type.elements[2].kind).toBe(ts.SyntaxKind.FirstLiteralToken);
     });
 
     test('Object with complex keys', () => {
@@ -284,19 +290,19 @@ describe('Utils', () => {
       expect(node.kind).toBe(ts.SyntaxKind.TypeLiteral);
       expect(node.members).toHaveLength(2);
 
-      const [firstMember, secondMember] = node.members;
+      const [fooBar, fooDashBar] = node.members;
 
-      expect(firstMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(firstMember.name.kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(firstMember.name.text).toBe('foo-bar');
-      expect(firstMember.type.kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(firstMember.type.text).toBe('foobar');
+      expect(fooBar.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(fooBar.name.kind).toBe(ts.SyntaxKind.Identifier);
+      expect(fooBar.name.escapedText).toBe('foo');
+      expect(fooBar.type.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(fooBar.type.text).toBe('bar');
 
-      expect(secondMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(secondMember.name.kind).toBe(ts.SyntaxKind.Identifier);
-      expect(secondMember.name.escapedText).toBe('foo');
-      expect(secondMember.type.kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(secondMember.type.text).toBe('bar');
+      expect(fooDashBar.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(fooDashBar.name.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(fooDashBar.name.text).toBe('foo-bar');
+      expect(fooDashBar.type.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(fooDashBar.type.text).toBe('foobar');
     });
 
     test('Invalid data type supplied (function)', () => {

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/imports.js

@@ -18,9 +18,9 @@ module.exports = {
   },
 
   generateImportDefinition() {
-    const formattedImports = imports.map((key) =>
-      factory.createImportSpecifier(false, undefined, factory.createIdentifier(key))
-    );
+    const formattedImports = imports
+      .sort()
+      .map((key) => factory.createImportSpecifier(false, undefined, factory.createIdentifier(key)));
 
     return [
       factory.createImportDeclaration(

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
  *
@@ -26,8 +28,8 @@ const getAttributeType = (attributeName, attribute, uid) => {
 
   const [attributeType, typeParams] = mappers[attribute.type]({ uid, attribute, attributeName });
 
-  // Make sure the attribute namespace is imported
-  addImport(NAMESPACES.attribute);
+  // Make sure the schema namespace is imported
+  addImport(NAMESPACES.Schema);
 
   return getTypeNode(attributeType, typeParams);
 };
@@ -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)]
       )
     );
   }
@@ -124,8 +151,8 @@ const getAttributeModifiers = (attribute) => {
     );
   }
 
-  // Default
-  if (!_.isNil(attribute.default)) {
+  // Default (ignore if default is a function)
+  if (!_.isNil(attribute.default) && !_.isFunction(attribute.default)) {
     const defaultLiteral = toTypeLiteral(attribute.default);
 
     modifiers.push(
@@ -168,6 +195,4 @@ const attributeToPropertySignature = (schema, attributeName, attribute) => {
 
 module.exports = attributeToPropertySignature;
 
-module.exports.mappers = mappers;
-module.exports.getAttributeType = getAttributeType;
-module.exports.getAttributeModifiers = getAttributeModifiers;
+Object.assign(module.exports, { mappers, getAttributeModifiers, getAttributeType });

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

@@ -47,7 +47,7 @@ module.exports = {
   decimal() {
     return [withAttributeNamespace('Decimal')];
   },
-  uid({ attribute, uid }) {
+  uid({ attribute }) {
     const { targetField, options } = attribute;
 
     // If there are no params to compute, then return the attribute type alone
@@ -58,18 +58,15 @@ module.exports = {
     const params = [];
 
     // If the targetField property is defined, then reference it,
-    // otherwise, put `undefined` keyword type nodes as placeholders
-    const targetFieldParams = _.isUndefined(targetField)
-      ? [
-          factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
-          factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
-        ]
-      : [factory.createStringLiteral(uid), factory.createStringLiteral(targetField)];
+    // otherwise, put `undefined` keyword type node as placeholder
+    const targetFieldParam = _.isUndefined(targetField)
+      ? factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+      : factory.createStringLiteral(targetField);
 
-    params.push(...targetFieldParams);
+    params.push(targetFieldParam);
 
     // If the options property is defined, transform it to
-    // a type literral node and add it to the params list
+    // a type literal node and add it to the params list
     if (_.isObject(options)) {
       params.push(toTypeLiteral(options));
     }
@@ -87,28 +84,42 @@ module.exports = {
   json() {
     return [withAttributeNamespace('JSON')];
   },
-  media() {
-    return [withAttributeNamespace('Media')];
+  blocks() {
+    return [withAttributeNamespace('Blocks')];
   },
-  relation({ uid, attribute }) {
+  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({ attribute }) {
     const { relation, target } = attribute;
 
     const isMorphRelation = relation.toLowerCase().includes('morph');
 
     if (isMorphRelation) {
-      return [
-        withAttributeNamespace('Relation'),
-        [factory.createStringLiteral(uid, true), factory.createStringLiteral(relation, true)],
-      ];
+      return [withAttributeNamespace('Relation'), [factory.createStringLiteral(relation, true)]];
     }
 
     return [
       withAttributeNamespace('Relation'),
-      [
-        factory.createStringLiteral(uid, true),
-        factory.createStringLiteral(relation, true),
-        factory.createStringLiteral(target, true),
-      ],
+      [factory.createStringLiteral(relation, true), factory.createStringLiteral(target, true)],
     ];
   },
   component({ attribute }) {
@@ -117,6 +128,8 @@ module.exports = {
 
     if (attribute.repeatable) {
       params.push(factory.createTrue());
+    } else {
+      params.push(factory.createFalse());
     }
 
     return [withAttributeNamespace('Component'), params];

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

@@ -22,9 +22,11 @@ const { addImport } = require('../imports');
 const generateAttributePropertySignature = (schema) => {
   const { attributes } = schema;
 
-  const properties = Object.entries(attributes).map(([attributeName, attribute]) => {
-    return attributeToPropertySignature(schema, attributeName, attribute);
-  });
+  const properties = Object.entries(attributes)
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([attributeName, attribute]) => {
+      return attributeToPropertySignature(schema, attributeName, attribute);
+    });
 
   return factory.createPropertySignature(
     undefined,
@@ -56,8 +58,8 @@ const generateSchemaDefinition = (schema) => {
   const interfaceName = getSchemaInterfaceName(uid);
   const parentType = getSchemaExtendsTypeName(schema);
 
-  // Make sure the Schema namespace is imported
-  addImport(NAMESPACES.schema);
+  // Make sure the Struct namespace is imported
+  addImport(NAMESPACES.Struct);
 
   // Properties whose values can be mapped to a literal type expression
   const literalPropertiesDefinitions = ['collectionName', 'info', 'options', 'pluginOptions']

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

@@ -18,8 +18,8 @@ const {
 } = require('lodash/fp');
 
 const NAMESPACES = {
-  schema: 'Schema',
-  attribute: 'Attribute',
+  Struct: 'Struct',
+  Schema: 'Schema',
 };
 
 /**
@@ -50,7 +50,7 @@ const getSchemaModelType = (schema) => {
  * Get the parent type name to extend based on the schema's nature
  *
  * @param {object} schema
- * @returns {string}
+ * @returns {string|null}
  */
 const getSchemaExtendsTypeName = (schema) => {
   const base = getSchemaModelType(schema);
@@ -59,7 +59,7 @@ const getSchemaExtendsTypeName = (schema) => {
     return null;
   }
 
-  return `${NAMESPACES.schema}.${upperFirst(base)}`;
+  return `${NAMESPACES.Struct}.${upperFirst(base)}Schema`;
 };
 
 /**
@@ -92,7 +92,12 @@ const toTypeLiteral = (data) => {
   }
 
   if (isNumber(data)) {
-    return factory.createNumericLiteral(data);
+    return data < 0
+      ? factory.createPrefixUnaryExpression(
+          ts.SyntaxKind.MinusToken,
+          factory.createNumericLiteral(-data)
+        )
+      : factory.createNumericLiteral(data);
   }
 
   if (isBoolean(data)) {
@@ -111,7 +116,7 @@ const toTypeLiteral = (data) => {
     throw new Error(`Cannot convert to object literal. Unknown type "${typeof data}"`);
   }
 
-  const entries = Object.entries(data);
+  const entries = Object.entries(data).sort((a, b) => a[0].localeCompare(b[0]));
 
   const props = entries.reduce((acc, [key, value]) => {
     // Handle keys such as content-type-builder & co.
@@ -145,12 +150,12 @@ const getDefinitionAttributesCount = (definition) => {
 };
 
 /**
- * Add the attribute namespace before the typename
+ * Add the Schema.Attribute namespace before the typename
  *
  * @param {string} typeName
  * @returns {string}
  */
-const withAttributeNamespace = (typeName) => `${NAMESPACES.attribute}.${typeName}`;
+const withAttributeNamespace = (typeName) => `${NAMESPACES.Schema}.Attribute.${typeName}`;
 
 /**
  * Add the schema namespace before the typename

package/lib/generators/components/index.js

@@ -1,10 +1,16 @@
 'use strict';
 
 const { factory } = require('typescript');
+const { pipe, values, sortBy, map } = require('lodash/fp');
 
 const { models } = require('../common');
 const { emitDefinitions, format, generateSharedExtensionDefinition } = require('../utils');
 
+const NO_COMPONENT_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any components yet.
+ */
+`;
+
 /**
  * Generate type definitions for Strapi Components
  *
@@ -18,10 +24,20 @@ const generateComponentsDefinitions = async (options = {}) => {
 
   const { components } = strapi;
 
-  const componentsDefinitions = Object.values(components).map((contentType) => ({
-    uid: contentType.uid,
-    definition: models.schema.generateSchemaDefinition(contentType),
-  }));
+  const componentsDefinitions = pipe(
+    values,
+    sortBy('uid'),
+    map((component) => ({
+      uid: component.uid,
+      definition: models.schema.generateSchemaDefinition(component),
+    }))
+  )(components);
+
+  options.logger.debug(`Found ${componentsDefinitions.length} components.`);
+
+  if (componentsDefinitions.length === 0) {
+    return { output: NO_COMPONENT_PLACEHOLDER_COMMENT, stats: {} };
+  }
 
   const formattedSchemasDefinitions = componentsDefinitions.reduce((acc, def) => {
     acc.push(
@@ -46,7 +62,7 @@ const generateComponentsDefinitions = async (options = {}) => {
     ...formattedSchemasDefinitions,
 
     // Global
-    generateSharedExtensionDefinition('Components', componentsDefinitions),
+    generateSharedExtensionDefinition('ComponentSchemas', componentsDefinitions),
   ];
 
   const output = emitDefinitions(allDefinitions);

package/lib/generators/content-types/index.js

@@ -1,10 +1,16 @@
 'use strict';
 
 const { factory } = require('typescript');
+const { values, pipe, map, sortBy } = require('lodash/fp');
 
 const { models } = require('../common');
 const { emitDefinitions, format, generateSharedExtensionDefinition } = require('../utils');
 
+const NO_CONTENT_TYPE_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any content-types yet.
+ */
+`;
+
 /**
  * Generate type definitions for Strapi Content-Types
  *
@@ -18,10 +24,20 @@ const generateContentTypesDefinitions = async (options = {}) => {
 
   const { contentTypes } = strapi;
 
-  const contentTypesDefinitions = Object.values(contentTypes).map((contentType) => ({
-    uid: contentType.uid,
-    definition: models.schema.generateSchemaDefinition(contentType),
-  }));
+  const contentTypesDefinitions = pipe(
+    values,
+    sortBy('uid'),
+    map((contentType) => ({
+      uid: contentType.uid,
+      definition: models.schema.generateSchemaDefinition(contentType),
+    }))
+  )(contentTypes);
+
+  options.logger.debug(`Found ${contentTypesDefinitions.length} content-types.`);
+
+  if (contentTypesDefinitions.length === 0) {
+    return { output: NO_CONTENT_TYPE_PLACEHOLDER_COMMENT, stats: {} };
+  }
 
   const formattedSchemasDefinitions = contentTypesDefinitions.reduce((acc, def) => {
     acc.push(
@@ -46,7 +62,7 @@ const generateContentTypesDefinitions = async (options = {}) => {
     ...formattedSchemasDefinitions,
 
     // Global
-    generateSharedExtensionDefinition('ContentTypes', contentTypesDefinitions),
+    generateSharedExtensionDefinition('ContentTypeSchemas', contentTypesDefinitions),
   ];
 
   const output = emitDefinitions(allDefinitions);

package/lib/generators/index.js

@@ -100,7 +100,7 @@ const generate = async (config = {}) => {
 
     try {
       const outPath = await saveDefinitionToFileSystem(registryPwd, filename, report.output);
-      const relativeOutPath = path.relative(__dirname, outPath);
+      const relativeOutPath = path.relative(process.cwd(), outPath);
 
       artifactFsTimer.end();
 

package/lib/generators/utils.js

@@ -1,14 +1,16 @@
 'use strict';
 
+const path = require('path');
+const assert = require('assert');
 const ts = require('typescript');
-const prettier = require('prettier');
 const fse = require('fs-extra');
-const path = require('path');
 const chalk = require('chalk');
-const assert = require('assert');
 
 const { factory } = ts;
 
+const MODULE_DECLARATION = '@strapi/strapi';
+const PUBLIC_NAMESPACE = 'Public';
+
 /**
  * Aggregate the given TypeScript nodes into a single string
  *
@@ -58,6 +60,9 @@ const saveDefinitionToFileSystem = async (dir, file, content) => {
  * @returns {Promise<string>}
  */
 const format = async (content) => {
+  // eslint-disable-next-line node/no-unsupported-features/es-syntax
+  const prettier = await import('prettier'); // ESM-only
+
   const configFile = await prettier.resolveConfigFile();
   const config = configFile
     ? await prettier.resolveConfig(configFile)
@@ -92,11 +97,11 @@ const generateSharedExtensionDefinition = (registry, definitions) => {
 
   return factory.createModuleDeclaration(
     [factory.createModifier(ts.SyntaxKind.DeclareKeyword)],
-    factory.createStringLiteral('@strapi/strapi', true),
+    factory.createStringLiteral(MODULE_DECLARATION, true),
     factory.createModuleBlock([
       factory.createModuleDeclaration(
         [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-        factory.createIdentifier('Shared'),
+        factory.createIdentifier(PUBLIC_NAMESPACE),
         factory.createModuleBlock(
           properties.length > 0
             ? [

package/lib/index.js

@@ -2,15 +2,12 @@
 
 const compile = require('./compile');
 const compilers = require('./compilers');
-const admin = require('./admin');
 const utils = require('./utils');
 const generators = require('./generators');
 
 module.exports = {
   compile,
   compilers,
-  admin,
   generators,
-
   ...utils,
 };

package/lib/utils/index.js

@@ -7,6 +7,7 @@ const reportDiagnostics = require('./report-diagnostics');
 const resolveConfigOptions = require('./resolve-config-options');
 const formatHost = require('./format-host');
 const resolveOutDir = require('./resolve-outdir');
+const resolveOutDirSync = require('./resolve-outdir-sync');
 
 module.exports = {
   isUsingTypeScript,
@@ -16,4 +17,5 @@ module.exports = {
   resolveConfigOptions,
   formatHost,
   resolveOutDir,
+  resolveOutDirSync,
 };