@strapi/typescript-utils 0.0.0-next.ff946d2c25a3e577b47132a357cac2932eb8e635 → 0.0.0-next.ffc36acb308febe288f1a31b62cbbb75b286585c

package/lib/generators/utils.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const path = require('path');
+const assert = require('assert');
+const ts = require('typescript');
+const fse = require('fs-extra');
+const chalk = require('chalk');
+
+const { factory } = ts;
+
+const MODULE_DECLARATION = '@strapi/strapi';
+const PUBLIC_NAMESPACE = 'Public';
+
+/**
+ * Aggregate the given TypeScript nodes into a single string
+ *
+ * @param {ts.Node[]} definitions
+ * @return {string}
+ */
+const emitDefinitions = (definitions) => {
+  const nodeArray = factory.createNodeArray(definitions);
+
+  const sourceFile = ts.createSourceFile(
+    'placeholder.ts',
+    '',
+    ts.ScriptTarget.ESNext,
+    true,
+    ts.ScriptKind.TS
+  );
+
+  const printer = ts.createPrinter({ omitTrailingSemicolon: true });
+
+  return printer.printList(ts.ListFormat.MultiLine, nodeArray, sourceFile);
+};
+
+/**
+ * Save the given string representation of TS nodes in a file
+ * If the given directory doesn't exist, it'll be created automatically
+ *
+ * @param {string} dir
+ * @param {string} file
+ * @param {string} content
+ *
+ * @return {Promise<string>} The path of the created file
+ */
+const saveDefinitionToFileSystem = async (dir, file, content) => {
+  const filepath = path.join(dir, file);
+
+  fse.ensureDirSync(dir);
+  await fse.writeFile(filepath, content);
+
+  return filepath;
+};
+
+/**
+ * Format the given definitions.
+ * Uses the existing config if one is defined in the project.
+ *
+ * @param {string} 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)
+    : // Default config
+      {
+        singleQuote: true,
+        useTabs: false,
+        tabWidth: 2,
+      };
+
+  Object.assign(config, { parser: 'typescript' });
+
+  return prettier.format(content, config);
+};
+
+/**
+ * Generate the extension block for a shared component from strapi/strapi
+ *
+ * @param {string} registry The registry to extend
+ * @param {Array<{ uid: string; definition: ts.TypeNode }>} definitions
+ * @returns {ts.ModuleDeclaration}
+ */
+const generateSharedExtensionDefinition = (registry, definitions) => {
+  const properties = definitions.map(({ uid, definition }) =>
+    factory.createPropertySignature(
+      undefined,
+      factory.createStringLiteral(uid, true),
+      undefined,
+      factory.createTypeReferenceNode(factory.createIdentifier(definition.name.escapedText))
+    )
+  );
+
+  return factory.createModuleDeclaration(
+    [factory.createModifier(ts.SyntaxKind.DeclareKeyword)],
+    factory.createStringLiteral(MODULE_DECLARATION, true),
+    factory.createModuleBlock([
+      factory.createModuleDeclaration(
+        [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        factory.createIdentifier(PUBLIC_NAMESPACE),
+        factory.createModuleBlock(
+          properties.length > 0
+            ? [
+                factory.createInterfaceDeclaration(
+                  [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+                  factory.createIdentifier(registry),
+                  undefined,
+                  undefined,
+                  properties
+                ),
+              ]
+            : []
+        )
+      ),
+    ]),
+    ts.NodeFlags.ExportContext
+  );
+};
+
+const createLogger = (options = {}) => {
+  const { silent = false, debug = false } = options;
+
+  const state = { errors: 0, warning: 0 };
+
+  return {
+    get warnings() {
+      return state.warning;
+    },
+
+    get errors() {
+      return state.errors;
+    },
+
+    debug(...args) {
+      if (silent || !debug) {
+        return;
+      }
+
+      console.log(chalk.cyan(`[DEBUG]\t[${new Date().toISOString()}] (Typegen)`), ...args);
+    },
+
+    info(...args) {
+      if (silent) {
+        return;
+      }
+
+      console.info(chalk.blue(`[INFO]\t[${new Date().toISOString()}] (Typegen)`), ...args);
+    },
+
+    warn(...args) {
+      state.warning += 1;
+
+      if (silent) {
+        return;
+      }
+
+      console.warn(chalk.yellow(`[WARN]\t[${new Date().toISOString()}] (Typegen)`), ...args);
+    },
+
+    error(...args) {
+      state.errors += 1;
+
+      if (silent) {
+        return;
+      }
+
+      console.error(chalk.red(`[ERROR]\t[${new Date().toISOString()}] (Typegen)`), ...args);
+    },
+  };
+};
+
+const timer = () => {
+  const state = {
+    start: null,
+    end: null,
+  };
+
+  return {
+    start() {
+      assert(state.start === null, 'The timer has already been started');
+      assert(state.end === null, 'The timer has already been ended');
+
+      state.start = Date.now();
+
+      return this;
+    },
+
+    end() {
+      assert(state.start !== null, 'The timer needs to be started before ending it');
+      assert(state.end === null, 'The timer has already been ended');
+
+      state.end = Date.now();
+
+      return this;
+    },
+
+    get duration() {
+      assert(state.start !== null, 'The timer has not been started');
+
+      return ((state.end ?? Date.now) - state.start) / 1000;
+    },
+  };
+};
+
+module.exports = {
+  emitDefinitions,
+  saveDefinitionToFileSystem,
+  format,
+  generateSharedExtensionDefinition,
+  createLogger,
+  timer,
+};

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,
 };

package/lib/utils/resolve-outdir-sync.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const path = require('path');
+const resolveConfigOptions = require('./resolve-config-options');
+const isUsingTypescriptSync = require('./is-using-typescript-sync');
+
+const DEFAULT_TS_CONFIG_FILENAME = 'tsconfig.json';
+/**
+ * Gets the outDir value from config file (tsconfig)
+ * @param {string} dir
+ * @param {string | undefined} configFilename
+ * @returns {string | undefined}
+ */
+module.exports = (dir, configFilename = DEFAULT_TS_CONFIG_FILENAME) => {
+  return isUsingTypescriptSync(dir)
+    ? resolveConfigOptions(path.join(dir, configFilename)).options.outDir
+    : undefined;
+};

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@strapi/typescript-utils",
-  "version": "0.0.0-next.ff946d2c25a3e577b47132a357cac2932eb8e635",
+  "version": "0.0.0-next.ffc36acb308febe288f1a31b62cbbb75b286585c",
   "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",
@@ -31,15 +36,17 @@
   },
   "dependencies": {
     "chalk": "4.1.2",
-    "cli-table3": "0.6.2",
-    "fs-extra": "10.0.1",
+    "cli-table3": "0.6.5",
+    "fs-extra": "11.2.0",
     "lodash": "4.17.21",
-    "prettier": "2.8.4",
-    "typescript": "5.0.4"
+    "prettier": "3.3.3",
+    "typescript": "5.4.4"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "11.0.4"
   },
   "engines": {
-    "node": ">=14.19.1 <=18.x.x",
+    "node": ">=18.0.0 <=22.x.x",
     "npm": ">=6.0.0"
-  },
-  "gitHead": "ff946d2c25a3e577b47132a357cac2932eb8e635"
+  }
 }

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,21 @@
 {
-    "$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,
+
+    "tsBuildInfoFile": "./.tsbuildinfo",
+    "incremental": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "noEmitOnError": true,
+    "noImplicitThis": true
+  }
+}

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

@@ -1,108 +0,0 @@
-'use strict';
-
-jest.mock('../../../generators/schemas/utils', () => ({
-  getSchemaInterfaceName: jest.fn(),
-}));
-
-const ts = require('typescript');
-const { get } = require('lodash/fp');
-
-const { generateGlobalDefinition } = require('../../../generators/schemas/global');
-const { getSchemaInterfaceName } = require('../../../generators/schemas/utils');
-
-const getSchemasInterfaceNode = get('body.statements[0].body.statements[0]');
-
-describe('Global', () => {
-  afterAll(() => {
-    jest.resetAllMocks();
-  });
-
-  const assertGlobalNodeStructure = (node) => {
-    // "declare global"
-    expect(node.kind).toBe(ts.SyntaxKind.ModuleDeclaration);
-    expect(node.modifiers).toHaveLength(1);
-    expect(node.modifiers[0].kind).toBe(ts.SyntaxKind.DeclareKeyword);
-    expect(node.name.originalKeywordKind).toBe(ts.SyntaxKind.GlobalKeyword);
-    expect(node.name.escapedText).toBe('global');
-
-    // "namespace Strapi"
-    const [strapiNamespace] = node.body.statements;
-
-    expect(strapiNamespace.kind).toBe(ts.SyntaxKind.ModuleDeclaration);
-    expect(strapiNamespace.name.kind).toBe(ts.SyntaxKind.Identifier);
-    expect(strapiNamespace.name.escapedText).toBe('Strapi');
-
-    // "interface Schemas"
-    const [schemasInterface] = strapiNamespace.body.statements;
-
-    expect(schemasInterface.kind).toBe(ts.SyntaxKind.InterfaceDeclaration);
-    expect(schemasInterface.name.escapedText).toBe('Schemas');
-  };
-
-  describe('Generate Global Definition', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
-    test('With empty definition', () => {
-      const definitions = [];
-
-      const globalNode = generateGlobalDefinition(definitions);
-
-      assertGlobalNodeStructure(globalNode);
-
-      expect(getSchemaInterfaceName).not.toHaveBeenCalled();
-
-      const schemasNode = getSchemasInterfaceNode(globalNode);
-
-      expect(schemasNode.members).toHaveLength(0);
-    });
-
-    test('With no definition', () => {
-      const globalNode = generateGlobalDefinition();
-
-      assertGlobalNodeStructure(globalNode);
-
-      expect(getSchemaInterfaceName).not.toHaveBeenCalled();
-
-      const schemasNode = getSchemasInterfaceNode(globalNode);
-
-      expect(schemasNode.members).toHaveLength(0);
-    });
-
-    test('With multiple definitions', () => {
-      const definitions = [
-        { schema: { uid: 'api::foo.foo' } },
-        { schema: { uid: 'api::bar.bar' } },
-        { schema: { uid: 'api::foobar.foobar' } },
-        { schema: { uid: 'default.barfoo' } },
-      ];
-
-      getSchemaInterfaceName.mockReturnValue('Placeholder');
-
-      const globalNode = generateGlobalDefinition(definitions);
-
-      assertGlobalNodeStructure(globalNode);
-
-      const schemasNode = getSchemasInterfaceNode(globalNode);
-
-      expect(schemasNode.members).toHaveLength(definitions.length);
-
-      definitions.forEach(({ schema }, index) => {
-        const { uid } = schema;
-        const node = schemasNode.members[index];
-
-        expect(node.kind).toBe(ts.SyntaxKind.PropertySignature);
-
-        expect(getSchemaInterfaceName).toHaveBeenCalledWith(uid);
-
-        expect(node.name.kind).toBe(ts.SyntaxKind.StringLiteral);
-        expect(node.name.text).toBe(uid);
-        expect(node.name.singleQuote).toBeTruthy();
-
-        expect(node.type.kind).toBe(ts.SyntaxKind.TypeReference);
-        expect(node.type.typeName.escapedText).toBe('Placeholder');
-      });
-    });
-  });
-});

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

@@ -1,37 +0,0 @@
-'use strict';
-
-const path = require('path');
-const fs = require('fs-extra');
-
-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,
-    },
-    include: ['../../../src/admin/*', '../../../src/**/**/admin/src/*'],
-    exclude: ['node_modules', '**/*.test.js', '*.js'],
-  };
-
-  const filePath = path.join(dest, 'admin', 'src', 'tsconfig.json');
-
-  try {
-    await fs.ensureFile(filePath);
-
-    await fs.writeJSON(filePath, tsConfig, { spaces: 2 });
-  } catch (err) {
-    console.log(err);
-  }
-};

package/lib/admin/index.js

@@ -1,5 +0,0 @@
-'use strict';
-
-const createTSConfigFile = require('./create-tsconfig-file');
-
-module.exports = { createTSConfigFile };

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);
-  },
-};

package/lib/generators/schemas/global.js

@@ -1,67 +0,0 @@
-'use strict';
-
-/* eslint-disable no-bitwise */
-
-const ts = require('typescript');
-const { factory } = require('typescript');
-
-const { getSchemaInterfaceName } = require('./utils');
-
-/**
- *
- * @param {object} schemaDefinition
- * @param {ts.InterfaceDeclaration} schemaDefinition.definition
- * @param {object} schemaDefinition.schema
- */
-const schemaDefinitionToPropertySignature = ({ schema }) => {
-  const { uid } = schema;
-
-  const interfaceTypeName = getSchemaInterfaceName(uid);
-
-  return factory.createPropertySignature(
-    undefined,
-    factory.createStringLiteral(uid, true),
-    undefined,
-    factory.createTypeReferenceNode(factory.createIdentifier(interfaceTypeName))
-  );
-};
-
-/**
- * Generate the global module augmentation block
- *
- * @param {Array<{ schema: object; definition: ts.TypeNode }>} schemasDefinitions
- * @returns {ts.ModuleDeclaration}
- */
-const generateGlobalDefinition = (schemasDefinitions = []) => {
-  const properties = schemasDefinitions.map(schemaDefinitionToPropertySignature);
-
-  return factory.createModuleDeclaration(
-    [factory.createModifier(ts.SyntaxKind.DeclareKeyword)],
-    factory.createIdentifier('global'),
-    factory.createModuleBlock([
-      factory.createModuleDeclaration(
-        undefined,
-        factory.createIdentifier('Strapi'),
-        factory.createModuleBlock([
-          factory.createInterfaceDeclaration(
-            undefined,
-            factory.createIdentifier('Schemas'),
-            undefined,
-            undefined,
-            properties
-          ),
-        ]),
-        ts.NodeFlags.Namespace |
-          ts.NodeFlags.ExportContext |
-          ts.NodeFlags.Ambient |
-          ts.NodeFlags.ContextFlags
-      ),
-    ]),
-    ts.NodeFlags.ExportContext |
-      ts.NodeFlags.GlobalAugmentation |
-      ts.NodeFlags.Ambient |
-      ts.NodeFlags.ContextFlags
-  );
-};
-
-module.exports = { generateGlobalDefinition };

package/lib/generators/schemas/imports.js

@@ -1,32 +0,0 @@
-'use strict';
-
-const { factory } = require('typescript');
-
-const imports = [];
-
-module.exports = {
-  getImports() {
-    return imports;
-  },
-
-  addImport(type) {
-    const hasType = imports.includes(type);
-
-    if (!hasType) {
-      imports.push(type);
-    }
-  },
-
-  generateImportDefinition() {
-    const formattedImports = imports.map((key) =>
-      factory.createImportSpecifier(false, undefined, factory.createIdentifier(key))
-    );
-
-    return factory.createImportDeclaration(
-      undefined,
-      factory.createImportClause(false, undefined, factory.createNamedImports(formattedImports)),
-      factory.createStringLiteral('@strapi/strapi'),
-      undefined
-    );
-  },
-};