@strapi/typescript-utils 0.0.0-next.f45143c5e2a8a9d85691d0abf79a3f42024a0c71 → 0.0.0-next.f4ec69568d980c6fee91ce2ee0f41c138347aa81

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,70 +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(
-    undefined,
-    [factory.createModifier(ts.SyntaxKind.DeclareKeyword)],
-    factory.createIdentifier('global'),
-    factory.createModuleBlock([
-      factory.createModuleDeclaration(
-        undefined,
-        undefined,
-        factory.createIdentifier('Strapi'),
-        factory.createModuleBlock([
-          factory.createInterfaceDeclaration(
-            undefined,
-            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,33 +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,
-      undefined,
-      factory.createImportClause(false, undefined, factory.createNamedImports(formattedImports)),
-      factory.createStringLiteral('@strapi/strapi'),
-      undefined
-    );
-  },
-};

package/lib/generators/schemas/index.js

@@ -1,185 +0,0 @@
-'use strict';
-
-const path = require('path');
-
-const ts = require('typescript');
-const { factory } = require('typescript');
-
-const fp = require('lodash/fp');
-const fse = require('fs-extra');
-const prettier = require('prettier');
-const chalk = require('chalk');
-const CLITable = require('cli-table3');
-
-const { generateImportDefinition } = require('./imports');
-const { generateSchemaDefinition } = require('./schema');
-const { generateGlobalDefinition } = require('./global');
-const {
-  getAllStrapiSchemas,
-  getSchemaInterfaceName,
-  getSchemaModelType,
-  getDefinitionAttributesCount,
-} = require('./utils');
-
-const DEFAULT_OUT_FILENAME = 'schemas.d.ts';
-
-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({ newLine: true, omitTrailingSemicolon: true });
-
-  return printer.printList(ts.ListFormat.MultiLine, nodeArray, sourceFile);
-};
-
-const saveDefinitionToFileSystem = async (dir, file, content) => {
-  const filepath = path.join(dir, file);
-
-  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) => {
-  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);
-};
-
-const logDebugInformation = (definitions, options = {}) => {
-  const { filepath, verbose, silent } = options;
-
-  if (verbose) {
-    const table = new CLITable({
-      head: [
-        chalk.bold(chalk.green('Model Type')),
-        chalk.bold(chalk.blue('UID')),
-        chalk.bold(chalk.blue('Type')),
-        chalk.bold(chalk.gray('Attributes Count')),
-      ],
-      colAligns: ['center', 'left', 'left', 'center'],
-    });
-
-    const sortedDefinitions = definitions.map((def) => ({
-      ...def,
-      attributesCount: getDefinitionAttributesCount(def.definition),
-    }));
-
-    for (const { schema, attributesCount } of sortedDefinitions) {
-      const modelType = fp.upperFirst(getSchemaModelType(schema));
-      const interfaceType = getSchemaInterfaceName(schema.uid);
-
-      table.push([
-        chalk.greenBright(modelType),
-        chalk.blue(schema.uid),
-        chalk.blue(interfaceType),
-        chalk.grey(fp.isNil(attributesCount) ? 'N/A' : attributesCount),
-      ]);
-    }
-
-    // Table
-    console.log(table.toString());
-  }
-
-  if (!silent) {
-    // Metrics
-    console.log(
-      chalk.greenBright(
-        `Generated ${definitions.length} type definition for your Strapi application's schemas.`
-      )
-    );
-
-    // Filepath
-    const relativePath = path.relative(process.cwd(), filepath);
-
-    console.log(
-      chalk.grey(`The definitions file has been generated here: ${chalk.bold(relativePath)}`)
-    );
-  }
-};
-
-/**
- * Generate type definitions for Strapi schemas
- *
- * @param {object} options
- * @param {Strapi} options.strapi
- * @param {{ distDir: string; appDir: string; }} options.dirs
- * @param {string} [options.outDir]
- * @param {string} [options.file]
- * @param {boolean} [options.verbose]
- */
-const generateSchemasDefinitions = async (options = {}) => {
-  const {
-    strapi,
-    outDir = process.cwd(),
-    file = DEFAULT_OUT_FILENAME,
-    verbose = false,
-    silent = false,
-  } = options;
-
-  const schemas = getAllStrapiSchemas(strapi);
-
-  const schemasDefinitions = Object.values(schemas).map((schema) => ({
-    schema,
-    definition: generateSchemaDefinition(schema),
-  }));
-
-  const formattedSchemasDefinitions = schemasDefinitions.reduce((acc, def) => {
-    acc.push(
-      // Definition
-      def.definition,
-
-      // Add a newline between each interface declaration
-      factory.createIdentifier('\n')
-    );
-
-    return acc;
-  }, []);
-
-  const allDefinitions = [
-    // Imports
-    generateImportDefinition(),
-
-    // Add a newline after the import statement
-    factory.createIdentifier('\n'),
-
-    // Schemas
-    ...formattedSchemasDefinitions,
-
-    // Global
-    generateGlobalDefinition(schemasDefinitions),
-  ];
-
-  const output = emitDefinitions(allDefinitions);
-  const formattedOutput = await format(output);
-
-  const definitionFilepath = await saveDefinitionToFileSystem(outDir, file, formattedOutput);
-
-  logDebugInformation(schemasDefinitions, { filepath: definitionFilepath, verbose, silent });
-};
-
-module.exports = generateSchemasDefinitions;

package/lib/generators/schemas/mappers.js

@@ -1,131 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-const _ = require('lodash/fp');
-
-const { toTypeLiteral } = require('./utils');
-
-const { factory } = ts;
-
-module.exports = {
-  string() {
-    return ['StringAttribute'];
-  },
-  text() {
-    return ['TextAttribute'];
-  },
-  richtext() {
-    return ['RichTextAttribute'];
-  },
-  password() {
-    return ['PasswordAttribute'];
-  },
-  email() {
-    return ['EmailAttribute'];
-  },
-  date() {
-    return ['DateAttribute'];
-  },
-  time() {
-    return ['TimeAttribute'];
-  },
-  datetime() {
-    return ['DateTimeAttribute'];
-  },
-  timestamp() {
-    return ['TimestampAttribute'];
-  },
-  integer() {
-    return ['IntegerAttribute'];
-  },
-  biginteger() {
-    return ['BigIntegerAttribute'];
-  },
-  float() {
-    return ['FloatAttribute'];
-  },
-  decimal() {
-    return ['DecimalAttribute'];
-  },
-  uid({ attribute, uid }) {
-    const { targetField, options } = attribute;
-
-    // If there are no params to compute, then return the attribute type alone
-    if (targetField === undefined && options === undefined) {
-      return ['UIDAttribute'];
-    }
-
-    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)];
-
-    params.push(...targetFieldParams);
-
-    // If the options property is defined, transform it to
-    // a type literral node and add it to the params list
-    if (_.isObject(options)) {
-      params.push(toTypeLiteral(options));
-    }
-
-    return ['UIDAttribute', params];
-  },
-  enumeration({ attribute }) {
-    const { enum: enumValues } = attribute;
-
-    return ['EnumerationAttribute', [toTypeLiteral(enumValues)]];
-  },
-  boolean() {
-    return ['BooleanAttribute'];
-  },
-  json() {
-    return ['JSONAttribute'];
-  },
-  media() {
-    return ['MediaAttribute'];
-  },
-  relation({ uid, attribute }) {
-    const { relation, target } = attribute;
-
-    const isMorphRelation = relation.toLowerCase().includes('morph');
-
-    if (isMorphRelation) {
-      return [
-        'RelationAttribute',
-        [factory.createStringLiteral(uid, true), factory.createStringLiteral(relation, true)],
-      ];
-    }
-
-    return [
-      'RelationAttribute',
-      [
-        factory.createStringLiteral(uid, true),
-        factory.createStringLiteral(relation, true),
-        factory.createStringLiteral(target, true),
-      ],
-    ];
-  },
-  component({ attribute }) {
-    const target = attribute.component;
-    const params = [factory.createStringLiteral(target, true)];
-
-    if (attribute.repeatable) {
-      params.push(factory.createTrue());
-    }
-
-    return ['ComponentAttribute', params];
-  },
-  dynamiczone({ attribute }) {
-    const componentsParam = factory.createTupleTypeNode(
-      attribute.components.map((component) => factory.createStringLiteral(component))
-    );
-
-    return ['DynamicZoneAttribute', [componentsParam]];
-  },
-};