@strapi/typescript-utils 0.0.0-experimental.6340da17068c3bed7fb006e7bcc554c71129e282 → 0.0.0-experimental.63624e21eb5b0713345a0cf2f68f1c40eab427bc

package/dist/generators/content-types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/content-types/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AASjD;;GAEG;AACH,eAAO,MAAM,+BAA+B,GAC1C,UAAS,gBAAyC;;;EAyDnD,CAAC"}

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

@@ -0,0 +1,84 @@
+'use strict';
+
+var ts = require('typescript');
+var _ = require('lodash');
+var schema = require('../common/models/schema.js');
+var imports = require('../common/imports.js');
+var interfaceNames = require('../common/interface-names.js');
+var utils = require('../utils.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+
+const { factory } = ts__namespace;
+const NO_CONTENT_TYPE_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any content-types yet.
+ */
+`;
+/**
+ * Generate type definitions for Strapi Content-Types
+ */ const generateContentTypesDefinitions = async (options = {})=>{
+    const { strapi, strict = false } = options;
+    const { contentTypes } = strapi;
+    const schemas = _.sortBy(Object.values(contentTypes ?? {}), 'uid');
+    const interfaceNames$1 = interfaceNames.resolveInterfaceNames(schemas.map(({ uid })=>uid), options.logger, {
+        strict
+    });
+    const contentTypesDefinitions = schemas.map((contentType)=>({
+            uid: contentType.uid,
+            definition: schema.generateSchemaDefinition(contentType, interfaceNames$1.get(contentType.uid), {
+                strict
+            })
+        }));
+    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(// Definition
+        def.definition, // Add a newline between each interface declaration
+        factory.createIdentifier('\n'));
+        return acc;
+    }, []);
+    const allDefinitions = [
+        // Imports
+        ...imports.generateImportDefinition(),
+        // Add a newline after the import statement
+        factory.createIdentifier('\n'),
+        // Schemas
+        ...formattedSchemasDefinitions,
+        // Global
+        utils.generateSharedExtensionDefinition('ContentTypeSchemas', contentTypesDefinitions, {
+            strict
+        })
+    ];
+    const output = utils.emitDefinitions(allDefinitions);
+    const formattedOutput = await utils.format(output);
+    return {
+        output: formattedOutput,
+        stats: {}
+    };
+};
+
+exports.generateContentTypesDefinitions = generateContentTypesDefinitions;
+//# sourceMappingURL=index.js.map

package/dist/generators/content-types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/generators/content-types/index.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { sortBy } from 'lodash';\n\nimport { models } from '../common';\nimport { resolveInterfaceNames } from '../common/interface-names';\nimport { emitDefinitions, format, generateSharedExtensionDefinition } from '../utils';\nimport type { GeneratorOptions } from '../utils';\n\nconst { factory } = ts;\n\nconst NO_CONTENT_TYPE_PLACEHOLDER_COMMENT = `/*\n * The app doesn't have any content-types yet.\n */\n`;\n\n/**\n * Generate type definitions for Strapi Content-Types\n */\nexport const generateContentTypesDefinitions = async (\n  options: GeneratorOptions = {} as GeneratorOptions\n) => {\n  const { strapi, strict = false } = options;\n\n  const { contentTypes } = strapi;\n\n  const schemas = sortBy(Object.values<models.utils.Schema>(contentTypes ?? {}), 'uid');\n  const interfaceNames = resolveInterfaceNames(\n    schemas.map(({ uid }) => uid),\n    options.logger,\n    { strict }\n  );\n  const contentTypesDefinitions = schemas.map((contentType) => ({\n    uid: contentType.uid,\n    definition: models.schema.generateSchemaDefinition(\n      contentType,\n      interfaceNames.get(contentType.uid),\n      { strict }\n    ),\n  }));\n\n  options.logger.debug(`Found ${contentTypesDefinitions.length} content-types.`);\n\n  if (contentTypesDefinitions.length === 0) {\n    return { output: NO_CONTENT_TYPE_PLACEHOLDER_COMMENT, stats: {} };\n  }\n\n  const formattedSchemasDefinitions = contentTypesDefinitions.reduce<any[]>((acc, def) => {\n    acc.push(\n      // Definition\n      def.definition,\n\n      // Add a newline between each interface declaration\n      factory.createIdentifier('\\n')\n    );\n\n    return acc;\n  }, []);\n\n  const allDefinitions = [\n    // Imports\n    ...models.imports.generateImportDefinition(),\n\n    // Add a newline after the import statement\n    factory.createIdentifier('\\n'),\n\n    // Schemas\n    ...formattedSchemasDefinitions,\n\n    // Global\n    generateSharedExtensionDefinition('ContentTypeSchemas', contentTypesDefinitions, { strict }),\n  ];\n\n  const output = emitDefinitions(allDefinitions);\n  const formattedOutput = await format(output);\n\n  return { output: formattedOutput, stats: {} };\n};\n"],"names":["factory","ts","NO_CONTENT_TYPE_PLACEHOLDER_COMMENT","generateContentTypesDefinitions","options","strapi","strict","contentTypes","schemas","sortBy","Object","values","interfaceNames","resolveInterfaceNames","map","uid","logger","contentTypesDefinitions","contentType","definition","models","get","debug","length","output","stats","formattedSchemasDefinitions","reduce","acc","def","push","createIdentifier","allDefinitions","generateSharedExtensionDefinition","emitDefinitions","formattedOutput","format"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,MAAM,EAAEA,OAAO,EAAE,GAAGC,aAAAA;AAEpB,MAAMC,sCAAsC,CAAC;;;AAG7C,CAAC;AAED;;AAEC,IACM,MAAMC,+BAAAA,GAAkC,OAC7CC,OAAAA,GAA4B,EAAsB,GAAA;AAElD,IAAA,MAAM,EAAEC,MAAM,EAAEC,MAAAA,GAAS,KAAK,EAAE,GAAGF,OAAAA;IAEnC,MAAM,EAAEG,YAAY,EAAE,GAAGF,MAAAA;AAEzB,IAAA,MAAMG,UAAUC,QAAAA,CAAOC,MAAAA,CAAOC,MAAM,CAAsBJ,YAAAA,IAAgB,EAAC,CAAA,EAAI,KAAA,CAAA;AAC/E,IAAA,MAAMK,gBAAAA,GAAiBC,oCAAAA,CACrBL,OAAAA,CAAQM,GAAG,CAAC,CAAC,EAAEC,GAAG,EAAE,GAAKA,GAAAA,CAAAA,EACzBX,OAAAA,CAAQY,MAAM,EACd;AAAEV,QAAAA;AAAO,KAAA,CAAA;AAEX,IAAA,MAAMW,0BAA0BT,OAAAA,CAAQM,GAAG,CAAC,CAACI,eAAiB;AAC5DH,YAAAA,GAAAA,EAAKG,YAAYH,GAAG;YACpBI,UAAAA,EAAYC,+BAAsC,CAChDF,WAAAA,EACAN,gBAAAA,CAAeS,GAAG,CAACH,WAAAA,CAAYH,GAAG,CAAA,EAClC;AAAET,gBAAAA;AAAO,aAAA;SAEb,CAAA,CAAA;IAEAF,OAAAA,CAAQY,MAAM,CAACM,KAAK,CAAC,CAAC,MAAM,EAAEL,uBAAAA,CAAwBM,MAAM,CAAC,eAAe,CAAC,CAAA;IAE7E,IAAIN,uBAAAA,CAAwBM,MAAM,KAAK,CAAA,EAAG;QACxC,OAAO;YAAEC,MAAAA,EAAQtB,mCAAAA;AAAqCuB,YAAAA,KAAAA,EAAO;AAAG,SAAA;AAClE,IAAA;AAEA,IAAA,MAAMC,2BAAAA,GAA8BT,uBAAAA,CAAwBU,MAAM,CAAQ,CAACC,GAAAA,EAAKC,GAAAA,GAAAA;QAC9ED,GAAAA,CAAIE,IAAI;QAEND,GAAAA,CAAIV,UAAU;AAGdnB,QAAAA,OAAAA,CAAQ+B,gBAAgB,CAAC,IAAA,CAAA,CAAA;QAG3B,OAAOH,GAAAA;AACT,IAAA,CAAA,EAAG,EAAE,CAAA;AAEL,IAAA,MAAMI,cAAAA,GAAiB;;WAElBZ,gCAAuC,EAAA;;AAG1CpB,QAAAA,OAAAA,CAAQ+B,gBAAgB,CAAC,IAAA,CAAA;;AAGtBL,QAAAA,GAAAA,2BAAAA;;AAGHO,QAAAA,uCAAAA,CAAkC,sBAAsBhB,uBAAAA,EAAyB;AAAEX,YAAAA;AAAO,SAAA;AAC3F,KAAA;AAED,IAAA,MAAMkB,SAASU,qBAAAA,CAAgBF,cAAAA,CAAAA;IAC/B,MAAMG,eAAAA,GAAkB,MAAMC,YAAAA,CAAOZ,MAAAA,CAAAA;IAErC,OAAO;QAAEA,MAAAA,EAAQW,eAAAA;AAAiBV,QAAAA,KAAAA,EAAO;AAAG,KAAA;AAC9C;;;;"}

package/dist/generators/content-types/index.mjs

@@ -0,0 +1,62 @@
+import * as ts from 'typescript';
+import { sortBy } from 'lodash';
+import { generateSchemaDefinition } from '../common/models/schema.mjs';
+import { generateImportDefinition } from '../common/imports.mjs';
+import { resolveInterfaceNames } from '../common/interface-names.mjs';
+import { generateSharedExtensionDefinition, emitDefinitions, format } from '../utils.mjs';
+
+const { factory } = ts;
+const NO_CONTENT_TYPE_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any content-types yet.
+ */
+`;
+/**
+ * Generate type definitions for Strapi Content-Types
+ */ const generateContentTypesDefinitions = async (options = {})=>{
+    const { strapi, strict = false } = options;
+    const { contentTypes } = strapi;
+    const schemas = sortBy(Object.values(contentTypes ?? {}), 'uid');
+    const interfaceNames = resolveInterfaceNames(schemas.map(({ uid })=>uid), options.logger, {
+        strict
+    });
+    const contentTypesDefinitions = schemas.map((contentType)=>({
+            uid: contentType.uid,
+            definition: generateSchemaDefinition(contentType, interfaceNames.get(contentType.uid), {
+                strict
+            })
+        }));
+    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(// 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
+        generateSharedExtensionDefinition('ContentTypeSchemas', contentTypesDefinitions, {
+            strict
+        })
+    ];
+    const output = emitDefinitions(allDefinitions);
+    const formattedOutput = await format(output);
+    return {
+        output: formattedOutput,
+        stats: {}
+    };
+};
+
+export { generateContentTypesDefinitions };
+//# sourceMappingURL=index.mjs.map

package/dist/generators/content-types/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../src/generators/content-types/index.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { sortBy } from 'lodash';\n\nimport { models } from '../common';\nimport { resolveInterfaceNames } from '../common/interface-names';\nimport { emitDefinitions, format, generateSharedExtensionDefinition } from '../utils';\nimport type { GeneratorOptions } from '../utils';\n\nconst { factory } = ts;\n\nconst NO_CONTENT_TYPE_PLACEHOLDER_COMMENT = `/*\n * The app doesn't have any content-types yet.\n */\n`;\n\n/**\n * Generate type definitions for Strapi Content-Types\n */\nexport const generateContentTypesDefinitions = async (\n  options: GeneratorOptions = {} as GeneratorOptions\n) => {\n  const { strapi, strict = false } = options;\n\n  const { contentTypes } = strapi;\n\n  const schemas = sortBy(Object.values<models.utils.Schema>(contentTypes ?? {}), 'uid');\n  const interfaceNames = resolveInterfaceNames(\n    schemas.map(({ uid }) => uid),\n    options.logger,\n    { strict }\n  );\n  const contentTypesDefinitions = schemas.map((contentType) => ({\n    uid: contentType.uid,\n    definition: models.schema.generateSchemaDefinition(\n      contentType,\n      interfaceNames.get(contentType.uid),\n      { strict }\n    ),\n  }));\n\n  options.logger.debug(`Found ${contentTypesDefinitions.length} content-types.`);\n\n  if (contentTypesDefinitions.length === 0) {\n    return { output: NO_CONTENT_TYPE_PLACEHOLDER_COMMENT, stats: {} };\n  }\n\n  const formattedSchemasDefinitions = contentTypesDefinitions.reduce<any[]>((acc, def) => {\n    acc.push(\n      // Definition\n      def.definition,\n\n      // Add a newline between each interface declaration\n      factory.createIdentifier('\\n')\n    );\n\n    return acc;\n  }, []);\n\n  const allDefinitions = [\n    // Imports\n    ...models.imports.generateImportDefinition(),\n\n    // Add a newline after the import statement\n    factory.createIdentifier('\\n'),\n\n    // Schemas\n    ...formattedSchemasDefinitions,\n\n    // Global\n    generateSharedExtensionDefinition('ContentTypeSchemas', contentTypesDefinitions, { strict }),\n  ];\n\n  const output = emitDefinitions(allDefinitions);\n  const formattedOutput = await format(output);\n\n  return { output: formattedOutput, stats: {} };\n};\n"],"names":["factory","ts","NO_CONTENT_TYPE_PLACEHOLDER_COMMENT","generateContentTypesDefinitions","options","strapi","strict","contentTypes","schemas","sortBy","Object","values","interfaceNames","resolveInterfaceNames","map","uid","logger","contentTypesDefinitions","contentType","definition","models","get","debug","length","output","stats","formattedSchemasDefinitions","reduce","acc","def","push","createIdentifier","allDefinitions","generateSharedExtensionDefinition","emitDefinitions","formattedOutput","format"],"mappings":";;;;;;;AAQA,MAAM,EAAEA,OAAO,EAAE,GAAGC,EAAAA;AAEpB,MAAMC,sCAAsC,CAAC;;;AAG7C,CAAC;AAED;;AAEC,IACM,MAAMC,+BAAAA,GAAkC,OAC7CC,OAAAA,GAA4B,EAAsB,GAAA;AAElD,IAAA,MAAM,EAAEC,MAAM,EAAEC,MAAAA,GAAS,KAAK,EAAE,GAAGF,OAAAA;IAEnC,MAAM,EAAEG,YAAY,EAAE,GAAGF,MAAAA;AAEzB,IAAA,MAAMG,UAAUC,MAAAA,CAAOC,MAAAA,CAAOC,MAAM,CAAsBJ,YAAAA,IAAgB,EAAC,CAAA,EAAI,KAAA,CAAA;AAC/E,IAAA,MAAMK,cAAAA,GAAiBC,qBAAAA,CACrBL,OAAAA,CAAQM,GAAG,CAAC,CAAC,EAAEC,GAAG,EAAE,GAAKA,GAAAA,CAAAA,EACzBX,OAAAA,CAAQY,MAAM,EACd;AAAEV,QAAAA;AAAO,KAAA,CAAA;AAEX,IAAA,MAAMW,0BAA0BT,OAAAA,CAAQM,GAAG,CAAC,CAACI,eAAiB;AAC5DH,YAAAA,GAAAA,EAAKG,YAAYH,GAAG;YACpBI,UAAAA,EAAYC,wBAAsC,CAChDF,WAAAA,EACAN,cAAAA,CAAeS,GAAG,CAACH,WAAAA,CAAYH,GAAG,CAAA,EAClC;AAAET,gBAAAA;AAAO,aAAA;SAEb,CAAA,CAAA;IAEAF,OAAAA,CAAQY,MAAM,CAACM,KAAK,CAAC,CAAC,MAAM,EAAEL,uBAAAA,CAAwBM,MAAM,CAAC,eAAe,CAAC,CAAA;IAE7E,IAAIN,uBAAAA,CAAwBM,MAAM,KAAK,CAAA,EAAG;QACxC,OAAO;YAAEC,MAAAA,EAAQtB,mCAAAA;AAAqCuB,YAAAA,KAAAA,EAAO;AAAG,SAAA;AAClE,IAAA;AAEA,IAAA,MAAMC,2BAAAA,GAA8BT,uBAAAA,CAAwBU,MAAM,CAAQ,CAACC,GAAAA,EAAKC,GAAAA,GAAAA;QAC9ED,GAAAA,CAAIE,IAAI;QAEND,GAAAA,CAAIV,UAAU;AAGdnB,QAAAA,OAAAA,CAAQ+B,gBAAgB,CAAC,IAAA,CAAA,CAAA;QAG3B,OAAOH,GAAAA;AACT,IAAA,CAAA,EAAG,EAAE,CAAA;AAEL,IAAA,MAAMI,cAAAA,GAAiB;;WAElBZ,wBAAuC,EAAA;;AAG1CpB,QAAAA,OAAAA,CAAQ+B,gBAAgB,CAAC,IAAA,CAAA;;AAGtBL,QAAAA,GAAAA,2BAAAA;;AAGHO,QAAAA,iCAAAA,CAAkC,sBAAsBhB,uBAAAA,EAAyB;AAAEX,YAAAA;AAAO,SAAA;AAC3F,KAAA;AAED,IAAA,MAAMkB,SAASU,eAAAA,CAAgBF,cAAAA,CAAAA;IAC/B,MAAMG,eAAAA,GAAkB,MAAMC,MAAAA,CAAOZ,MAAAA,CAAAA;IAErC,OAAO;QAAEA,MAAAA,EAAQW,eAAAA;AAAiBV,QAAAA,KAAAA,EAAO;AAAG,KAAA;AAC9C;;;;"}

package/dist/generators/controllers/index.d.ts

@@ -0,0 +1,35 @@
+import type { GeneratorOptions } from '../utils';
+/**
+ * Generate type definitions for the application's controllers (api::*)
+ *
+ * Controllers are typed from their source file, so only the ones with a source in src/api are emitted.
+ * Plugin and admin controllers are left to the packages themselves (Strapi.Registries.PackageControllers).
+ *
+ * declare global {
+ *   namespace Strapi {
+ *     namespace Registries {
+ *       interface AppControllers {
+ *         'api::<api>.<controller>': ControllerInstance<typeof import('<relative path to the source>')>;
+ *         'api::<api>.<controller>': ControllerContractOf<import('<relative path to the source>').ControllerContract>;
+ *       }
+ *       interface InferredControllers {
+ *         'api::<api>.<controller>': true;
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * A controller whose module exports a `ControllerContract` type registers that contract; any other
+ * controller registers the type its default export provides. A JS source registers as `unknown`:
+ * without `allowJs` its import is an error type. So do a controller module, a default export and a
+ * contract typed `any`.
+ *
+ * `InferredControllers` lists the TypeScript controllers registered without a contract, whose type
+ * is read from the factory itself: `Core.ControllerFactory` rejects their uid. It is not emitted when
+ * there are none.
+ */
+export declare const generateControllersDefinitions: (options?: GeneratorOptions) => Promise<{
+    output: string;
+    stats: {};
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/controllers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/controllers/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAgBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,8BAA8B,GACzC,UAAS,gBAAyC;;;EAkEnD,CAAC"}

package/dist/generators/controllers/index.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var sources = require('../common/sources.js');
+
+const REGISTRY = 'AppControllers';
+// Same helper as the services generator's ServiceInstance
+const INSTANCE_HELPER = 'ControllerInstance';
+const CONTRACT_EXPORT = 'ControllerContract';
+const CONTRACT_HELPER = 'ControllerContractOf';
+const INFERRED_REGISTRY = 'InferredControllers';
+const NO_CONTROLLER_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any controllers yet.
+ */
+
+export {};
+`;
+/**
+ * Generate type definitions for the application's controllers (api::*)
+ *
+ * Controllers are typed from their source file, so only the ones with a source in src/api are emitted.
+ * Plugin and admin controllers are left to the packages themselves (Strapi.Registries.PackageControllers).
+ *
+ * declare global {
+ *   namespace Strapi {
+ *     namespace Registries {
+ *       interface AppControllers {
+ *         'api::<api>.<controller>': ControllerInstance<typeof import('<relative path to the source>')>;
+ *         'api::<api>.<controller>': ControllerContractOf<import('<relative path to the source>').ControllerContract>;
+ *       }
+ *       interface InferredControllers {
+ *         'api::<api>.<controller>': true;
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * A controller whose module exports a `ControllerContract` type registers that contract; any other
+ * controller registers the type its default export provides. A JS source registers as `unknown`:
+ * without `allowJs` its import is an error type. So do a controller module, a default export and a
+ * contract typed `any`.
+ *
+ * `InferredControllers` lists the TypeScript controllers registered without a contract, whose type
+ * is read from the factory itself: `Core.ControllerFactory` rejects their uid. It is not emitted when
+ * there are none.
+ */ const generateControllersDefinitions = async (options = {})=>{
+    const { strapi, logger, pwd: outDir } = options;
+    if (!outDir) {
+        throw new Error('The controllers generator needs the output directory to resolve source imports');
+    }
+    const sources$1 = await sources.collectAppSources('controllers', {
+        api: strapi.dirs.app.api
+    }, outDir, logger);
+    const controllersDefinitions = sources.filterRegisteredSources(sources$1, strapi.controllers, logger);
+    logger.debug(`Found ${controllersDefinitions.length} controllers.`);
+    const contract = {
+        exportName: CONTRACT_EXPORT,
+        helper: CONTRACT_HELPER,
+        uids: await sources.findTypeExports(controllersDefinitions, CONTRACT_EXPORT, logger)
+    };
+    if (controllersDefinitions.length === 0) {
+        return {
+            output: NO_CONTROLLER_PLACEHOLDER_COMMENT,
+            stats: {}
+        };
+    }
+    const inferredUIDs = controllersDefinitions.filter(sources.isInferredSource(contract)).map(({ uid })=>uid);
+    // Each helper is only emitted when an entry reads it: `noUnusedLocals` reports an unused one
+    const output = await sources.emitRegistryDefinitions(REGISTRY, [
+        ...inferredUIDs.length > 0 ? [
+            sources.generateInstanceHelperDefinition(INSTANCE_HELPER, '*\n * Type of the controller exposed by a controller module: the return type of its default export\n * when it is a factory, the default export itself otherwise.\n ')
+        ] : [],
+        ...contract.uids.size > 0 ? [
+            sources.generateContractHelperDefinition(CONTRACT_HELPER, '*\n * Contract a controller module exports as `ControllerContract`, `unknown` when it is typed `any`.\n ')
+        ] : []
+    ], controllersDefinitions, sources.instanceTypeOf(INSTANCE_HELPER, logger, contract), [
+        {
+            registry: INFERRED_REGISTRY,
+            uids: inferredUIDs
+        }
+    ]);
+    return {
+        output,
+        stats: {}
+    };
+};
+
+exports.generateControllersDefinitions = generateControllersDefinitions;
+//# sourceMappingURL=index.js.map

package/dist/generators/controllers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/generators/controllers/index.ts"],"sourcesContent":["import {\n  collectAppSources,\n  emitRegistryDefinitions,\n  filterRegisteredSources,\n  findTypeExports,\n  generateContractHelperDefinition,\n  generateInstanceHelperDefinition,\n  instanceTypeOf,\n  isInferredSource,\n} from '../common/sources';\nimport type { GeneratorOptions } from '../utils';\n\nconst REGISTRY = 'AppControllers';\n// Same helper as the services generator's ServiceInstance\nconst INSTANCE_HELPER = 'ControllerInstance';\nconst CONTRACT_EXPORT = 'ControllerContract';\nconst CONTRACT_HELPER = 'ControllerContractOf';\nconst INFERRED_REGISTRY = 'InferredControllers';\n\nconst NO_CONTROLLER_PLACEHOLDER_COMMENT = `/*\n * The app doesn't have any controllers yet.\n */\n\nexport {};\n`;\n\n/**\n * Generate type definitions for the application's controllers (api::*)\n *\n * Controllers are typed from their source file, so only the ones with a source in src/api are emitted.\n * Plugin and admin controllers are left to the packages themselves (Strapi.Registries.PackageControllers).\n *\n * declare global {\n *   namespace Strapi {\n *     namespace Registries {\n *       interface AppControllers {\n *         'api::<api>.<controller>': ControllerInstance<typeof import('<relative path to the source>')>;\n *         'api::<api>.<controller>': ControllerContractOf<import('<relative path to the source>').ControllerContract>;\n *       }\n *       interface InferredControllers {\n *         'api::<api>.<controller>': true;\n *       }\n *     }\n *   }\n * }\n *\n * A controller whose module exports a `ControllerContract` type registers that contract; any other\n * controller registers the type its default export provides. A JS source registers as `unknown`:\n * without `allowJs` its import is an error type. So do a controller module, a default export and a\n * contract typed `any`.\n *\n * `InferredControllers` lists the TypeScript controllers registered without a contract, whose type\n * is read from the factory itself: `Core.ControllerFactory` rejects their uid. It is not emitted when\n * there are none.\n */\nexport const generateControllersDefinitions = async (\n  options: GeneratorOptions = {} as GeneratorOptions\n) => {\n  const { strapi, logger, pwd: outDir } = options;\n\n  if (!outDir) {\n    throw new Error(\n      'The controllers generator needs the output directory to resolve source imports'\n    );\n  }\n\n  const sources = await collectAppSources(\n    'controllers',\n    { api: strapi.dirs.app.api },\n    outDir,\n    logger\n  );\n  const controllersDefinitions = filterRegisteredSources(sources, strapi.controllers, logger);\n\n  logger.debug(`Found ${controllersDefinitions.length} controllers.`);\n\n  const contract = {\n    exportName: CONTRACT_EXPORT,\n    helper: CONTRACT_HELPER,\n    uids: await findTypeExports(controllersDefinitions, CONTRACT_EXPORT, logger),\n  };\n\n  if (controllersDefinitions.length === 0) {\n    return { output: NO_CONTROLLER_PLACEHOLDER_COMMENT, stats: {} };\n  }\n\n  const inferredUIDs = controllersDefinitions\n    .filter(isInferredSource(contract))\n    .map(({ uid }) => uid);\n\n  // Each helper is only emitted when an entry reads it: `noUnusedLocals` reports an unused one\n  const output = await emitRegistryDefinitions(\n    REGISTRY,\n    [\n      ...(inferredUIDs.length > 0\n        ? [\n            generateInstanceHelperDefinition(\n              INSTANCE_HELPER,\n              '*\\n * Type of the controller exposed by a controller module: the return type of its default export\\n * when it is a factory, the default export itself otherwise.\\n '\n            ),\n          ]\n        : []),\n      ...(contract.uids.size > 0\n        ? [\n            generateContractHelperDefinition(\n              CONTRACT_HELPER,\n              '*\\n * Contract a controller module exports as `ControllerContract`, `unknown` when it is typed `any`.\\n '\n            ),\n          ]\n        : []),\n    ],\n    controllersDefinitions,\n    instanceTypeOf(INSTANCE_HELPER, logger, contract),\n    [\n      {\n        registry: INFERRED_REGISTRY,\n        uids: inferredUIDs,\n      },\n    ]\n  );\n\n  return { output, stats: {} };\n};\n"],"names":["REGISTRY","INSTANCE_HELPER","CONTRACT_EXPORT","CONTRACT_HELPER","INFERRED_REGISTRY","NO_CONTROLLER_PLACEHOLDER_COMMENT","generateControllersDefinitions","options","strapi","logger","pwd","outDir","Error","sources","collectAppSources","api","dirs","app","controllersDefinitions","filterRegisteredSources","controllers","debug","length","contract","exportName","helper","uids","findTypeExports","output","stats","inferredUIDs","filter","isInferredSource","map","uid","emitRegistryDefinitions","generateInstanceHelperDefinition","size","generateContractHelperDefinition","instanceTypeOf","registry"],"mappings":";;;;AAYA,MAAMA,QAAAA,GAAW,gBAAA;AACjB;AACA,MAAMC,eAAAA,GAAkB,oBAAA;AACxB,MAAMC,eAAAA,GAAkB,oBAAA;AACxB,MAAMC,eAAAA,GAAkB,sBAAA;AACxB,MAAMC,iBAAAA,GAAoB,qBAAA;AAE1B,MAAMC,oCAAoC,CAAC;;;;;AAK3C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BC,IACM,MAAMC,8BAAAA,GAAiC,OAC5CC,OAAAA,GAA4B,EAAsB,GAAA;IAElD,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAEC,GAAAA,EAAKC,MAAM,EAAE,GAAGJ,OAAAA;AAExC,IAAA,IAAI,CAACI,MAAAA,EAAQ;AACX,QAAA,MAAM,IAAIC,KAAAA,CACR,gFAAA,CAAA;AAEJ,IAAA;IAEA,MAAMC,SAAAA,GAAU,MAAMC,yBAAAA,CACpB,aAAA,EACA;AAAEC,QAAAA,GAAAA,EAAKP,MAAAA,CAAOQ,IAAI,CAACC,GAAG,CAACF;AAAI,KAAA,EAC3BJ,MAAAA,EACAF,MAAAA,CAAAA;AAEF,IAAA,MAAMS,sBAAAA,GAAyBC,+BAAAA,CAAwBN,SAAAA,EAASL,MAAAA,CAAOY,WAAW,EAAEX,MAAAA,CAAAA;IAEpFA,MAAAA,CAAOY,KAAK,CAAC,CAAC,MAAM,EAAEH,sBAAAA,CAAuBI,MAAM,CAAC,aAAa,CAAC,CAAA;AAElE,IAAA,MAAMC,QAAAA,GAAW;QACfC,UAAAA,EAAYtB,eAAAA;QACZuB,MAAAA,EAAQtB,eAAAA;QACRuB,IAAAA,EAAM,MAAMC,uBAAAA,CAAgBT,sBAAAA,EAAwBhB,eAAAA,EAAiBO,MAAAA;AACvE,KAAA;IAEA,IAAIS,sBAAAA,CAAuBI,MAAM,KAAK,CAAA,EAAG;QACvC,OAAO;YAAEM,MAAAA,EAAQvB,iCAAAA;AAAmCwB,YAAAA,KAAAA,EAAO;AAAG,SAAA;AAChE,IAAA;AAEA,IAAA,MAAMC,YAAAA,GAAeZ,sBAAAA,CAClBa,MAAM,CAACC,wBAAAA,CAAiBT,QAAAA,CAAAA,CAAAA,CACxBU,GAAG,CAAC,CAAC,EAAEC,GAAG,EAAE,GAAKA,GAAAA,CAAAA;;IAGpB,MAAMN,MAAAA,GAAS,MAAMO,+BAAAA,CACnBnC,QAAAA,EACA;WACM8B,YAAAA,CAAaR,MAAM,GAAG,CAAA,GACtB;AACEc,YAAAA,wCAAAA,CACEnC,eAAAA,EACA,sKAAA;AAEH,SAAA,GACD,EAAE;AACFsB,QAAAA,GAAAA,QAAAA,CAASG,IAAI,CAACW,IAAI,GAAG,CAAA,GACrB;AACEC,YAAAA,wCAAAA,CACEnC,eAAAA,EACA,0GAAA;AAEH,SAAA,GACD;AACL,KAAA,EACDe,sBAAAA,EACAqB,sBAAAA,CAAetC,eAAAA,EAAiBQ,MAAAA,EAAQc,QAAAA,CAAAA,EACxC;AACE,QAAA;YACEiB,QAAAA,EAAUpC,iBAAAA;YACVsB,IAAAA,EAAMI;AACR;AACD,KAAA,CAAA;IAGH,OAAO;AAAEF,QAAAA,MAAAA;AAAQC,QAAAA,KAAAA,EAAO;AAAG,KAAA;AAC7B;;;;"}

package/dist/generators/controllers/index.mjs

@@ -0,0 +1,86 @@
+import { collectAppSources, filterRegisteredSources, findTypeExports, isInferredSource, emitRegistryDefinitions, generateInstanceHelperDefinition, generateContractHelperDefinition, instanceTypeOf } from '../common/sources.mjs';
+
+const REGISTRY = 'AppControllers';
+// Same helper as the services generator's ServiceInstance
+const INSTANCE_HELPER = 'ControllerInstance';
+const CONTRACT_EXPORT = 'ControllerContract';
+const CONTRACT_HELPER = 'ControllerContractOf';
+const INFERRED_REGISTRY = 'InferredControllers';
+const NO_CONTROLLER_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any controllers yet.
+ */
+
+export {};
+`;
+/**
+ * Generate type definitions for the application's controllers (api::*)
+ *
+ * Controllers are typed from their source file, so only the ones with a source in src/api are emitted.
+ * Plugin and admin controllers are left to the packages themselves (Strapi.Registries.PackageControllers).
+ *
+ * declare global {
+ *   namespace Strapi {
+ *     namespace Registries {
+ *       interface AppControllers {
+ *         'api::<api>.<controller>': ControllerInstance<typeof import('<relative path to the source>')>;
+ *         'api::<api>.<controller>': ControllerContractOf<import('<relative path to the source>').ControllerContract>;
+ *       }
+ *       interface InferredControllers {
+ *         'api::<api>.<controller>': true;
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * A controller whose module exports a `ControllerContract` type registers that contract; any other
+ * controller registers the type its default export provides. A JS source registers as `unknown`:
+ * without `allowJs` its import is an error type. So do a controller module, a default export and a
+ * contract typed `any`.
+ *
+ * `InferredControllers` lists the TypeScript controllers registered without a contract, whose type
+ * is read from the factory itself: `Core.ControllerFactory` rejects their uid. It is not emitted when
+ * there are none.
+ */ const generateControllersDefinitions = async (options = {})=>{
+    const { strapi, logger, pwd: outDir } = options;
+    if (!outDir) {
+        throw new Error('The controllers generator needs the output directory to resolve source imports');
+    }
+    const sources = await collectAppSources('controllers', {
+        api: strapi.dirs.app.api
+    }, outDir, logger);
+    const controllersDefinitions = filterRegisteredSources(sources, strapi.controllers, logger);
+    logger.debug(`Found ${controllersDefinitions.length} controllers.`);
+    const contract = {
+        exportName: CONTRACT_EXPORT,
+        helper: CONTRACT_HELPER,
+        uids: await findTypeExports(controllersDefinitions, CONTRACT_EXPORT, logger)
+    };
+    if (controllersDefinitions.length === 0) {
+        return {
+            output: NO_CONTROLLER_PLACEHOLDER_COMMENT,
+            stats: {}
+        };
+    }
+    const inferredUIDs = controllersDefinitions.filter(isInferredSource(contract)).map(({ uid })=>uid);
+    // Each helper is only emitted when an entry reads it: `noUnusedLocals` reports an unused one
+    const output = await emitRegistryDefinitions(REGISTRY, [
+        ...inferredUIDs.length > 0 ? [
+            generateInstanceHelperDefinition(INSTANCE_HELPER, '*\n * Type of the controller exposed by a controller module: the return type of its default export\n * when it is a factory, the default export itself otherwise.\n ')
+        ] : [],
+        ...contract.uids.size > 0 ? [
+            generateContractHelperDefinition(CONTRACT_HELPER, '*\n * Contract a controller module exports as `ControllerContract`, `unknown` when it is typed `any`.\n ')
+        ] : []
+    ], controllersDefinitions, instanceTypeOf(INSTANCE_HELPER, logger, contract), [
+        {
+            registry: INFERRED_REGISTRY,
+            uids: inferredUIDs
+        }
+    ]);
+    return {
+        output,
+        stats: {}
+    };
+};
+
+export { generateControllersDefinitions };
+//# sourceMappingURL=index.mjs.map

package/dist/generators/controllers/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../src/generators/controllers/index.ts"],"sourcesContent":["import {\n  collectAppSources,\n  emitRegistryDefinitions,\n  filterRegisteredSources,\n  findTypeExports,\n  generateContractHelperDefinition,\n  generateInstanceHelperDefinition,\n  instanceTypeOf,\n  isInferredSource,\n} from '../common/sources';\nimport type { GeneratorOptions } from '../utils';\n\nconst REGISTRY = 'AppControllers';\n// Same helper as the services generator's ServiceInstance\nconst INSTANCE_HELPER = 'ControllerInstance';\nconst CONTRACT_EXPORT = 'ControllerContract';\nconst CONTRACT_HELPER = 'ControllerContractOf';\nconst INFERRED_REGISTRY = 'InferredControllers';\n\nconst NO_CONTROLLER_PLACEHOLDER_COMMENT = `/*\n * The app doesn't have any controllers yet.\n */\n\nexport {};\n`;\n\n/**\n * Generate type definitions for the application's controllers (api::*)\n *\n * Controllers are typed from their source file, so only the ones with a source in src/api are emitted.\n * Plugin and admin controllers are left to the packages themselves (Strapi.Registries.PackageControllers).\n *\n * declare global {\n *   namespace Strapi {\n *     namespace Registries {\n *       interface AppControllers {\n *         'api::<api>.<controller>': ControllerInstance<typeof import('<relative path to the source>')>;\n *         'api::<api>.<controller>': ControllerContractOf<import('<relative path to the source>').ControllerContract>;\n *       }\n *       interface InferredControllers {\n *         'api::<api>.<controller>': true;\n *       }\n *     }\n *   }\n * }\n *\n * A controller whose module exports a `ControllerContract` type registers that contract; any other\n * controller registers the type its default export provides. A JS source registers as `unknown`:\n * without `allowJs` its import is an error type. So do a controller module, a default export and a\n * contract typed `any`.\n *\n * `InferredControllers` lists the TypeScript controllers registered without a contract, whose type\n * is read from the factory itself: `Core.ControllerFactory` rejects their uid. It is not emitted when\n * there are none.\n */\nexport const generateControllersDefinitions = async (\n  options: GeneratorOptions = {} as GeneratorOptions\n) => {\n  const { strapi, logger, pwd: outDir } = options;\n\n  if (!outDir) {\n    throw new Error(\n      'The controllers generator needs the output directory to resolve source imports'\n    );\n  }\n\n  const sources = await collectAppSources(\n    'controllers',\n    { api: strapi.dirs.app.api },\n    outDir,\n    logger\n  );\n  const controllersDefinitions = filterRegisteredSources(sources, strapi.controllers, logger);\n\n  logger.debug(`Found ${controllersDefinitions.length} controllers.`);\n\n  const contract = {\n    exportName: CONTRACT_EXPORT,\n    helper: CONTRACT_HELPER,\n    uids: await findTypeExports(controllersDefinitions, CONTRACT_EXPORT, logger),\n  };\n\n  if (controllersDefinitions.length === 0) {\n    return { output: NO_CONTROLLER_PLACEHOLDER_COMMENT, stats: {} };\n  }\n\n  const inferredUIDs = controllersDefinitions\n    .filter(isInferredSource(contract))\n    .map(({ uid }) => uid);\n\n  // Each helper is only emitted when an entry reads it: `noUnusedLocals` reports an unused one\n  const output = await emitRegistryDefinitions(\n    REGISTRY,\n    [\n      ...(inferredUIDs.length > 0\n        ? [\n            generateInstanceHelperDefinition(\n              INSTANCE_HELPER,\n              '*\\n * Type of the controller exposed by a controller module: the return type of its default export\\n * when it is a factory, the default export itself otherwise.\\n '\n            ),\n          ]\n        : []),\n      ...(contract.uids.size > 0\n        ? [\n            generateContractHelperDefinition(\n              CONTRACT_HELPER,\n              '*\\n * Contract a controller module exports as `ControllerContract`, `unknown` when it is typed `any`.\\n '\n            ),\n          ]\n        : []),\n    ],\n    controllersDefinitions,\n    instanceTypeOf(INSTANCE_HELPER, logger, contract),\n    [\n      {\n        registry: INFERRED_REGISTRY,\n        uids: inferredUIDs,\n      },\n    ]\n  );\n\n  return { output, stats: {} };\n};\n"],"names":["REGISTRY","INSTANCE_HELPER","CONTRACT_EXPORT","CONTRACT_HELPER","INFERRED_REGISTRY","NO_CONTROLLER_PLACEHOLDER_COMMENT","generateControllersDefinitions","options","strapi","logger","pwd","outDir","Error","sources","collectAppSources","api","dirs","app","controllersDefinitions","filterRegisteredSources","controllers","debug","length","contract","exportName","helper","uids","findTypeExports","output","stats","inferredUIDs","filter","isInferredSource","map","uid","emitRegistryDefinitions","generateInstanceHelperDefinition","size","generateContractHelperDefinition","instanceTypeOf","registry"],"mappings":";;AAYA,MAAMA,QAAAA,GAAW,gBAAA;AACjB;AACA,MAAMC,eAAAA,GAAkB,oBAAA;AACxB,MAAMC,eAAAA,GAAkB,oBAAA;AACxB,MAAMC,eAAAA,GAAkB,sBAAA;AACxB,MAAMC,iBAAAA,GAAoB,qBAAA;AAE1B,MAAMC,oCAAoC,CAAC;;;;;AAK3C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BC,IACM,MAAMC,8BAAAA,GAAiC,OAC5CC,OAAAA,GAA4B,EAAsB,GAAA;IAElD,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAEC,GAAAA,EAAKC,MAAM,EAAE,GAAGJ,OAAAA;AAExC,IAAA,IAAI,CAACI,MAAAA,EAAQ;AACX,QAAA,MAAM,IAAIC,KAAAA,CACR,gFAAA,CAAA;AAEJ,IAAA;IAEA,MAAMC,OAAAA,GAAU,MAAMC,iBAAAA,CACpB,aAAA,EACA;AAAEC,QAAAA,GAAAA,EAAKP,MAAAA,CAAOQ,IAAI,CAACC,GAAG,CAACF;AAAI,KAAA,EAC3BJ,MAAAA,EACAF,MAAAA,CAAAA;AAEF,IAAA,MAAMS,sBAAAA,GAAyBC,uBAAAA,CAAwBN,OAAAA,EAASL,MAAAA,CAAOY,WAAW,EAAEX,MAAAA,CAAAA;IAEpFA,MAAAA,CAAOY,KAAK,CAAC,CAAC,MAAM,EAAEH,sBAAAA,CAAuBI,MAAM,CAAC,aAAa,CAAC,CAAA;AAElE,IAAA,MAAMC,QAAAA,GAAW;QACfC,UAAAA,EAAYtB,eAAAA;QACZuB,MAAAA,EAAQtB,eAAAA;QACRuB,IAAAA,EAAM,MAAMC,eAAAA,CAAgBT,sBAAAA,EAAwBhB,eAAAA,EAAiBO,MAAAA;AACvE,KAAA;IAEA,IAAIS,sBAAAA,CAAuBI,MAAM,KAAK,CAAA,EAAG;QACvC,OAAO;YAAEM,MAAAA,EAAQvB,iCAAAA;AAAmCwB,YAAAA,KAAAA,EAAO;AAAG,SAAA;AAChE,IAAA;AAEA,IAAA,MAAMC,YAAAA,GAAeZ,sBAAAA,CAClBa,MAAM,CAACC,gBAAAA,CAAiBT,QAAAA,CAAAA,CAAAA,CACxBU,GAAG,CAAC,CAAC,EAAEC,GAAG,EAAE,GAAKA,GAAAA,CAAAA;;IAGpB,MAAMN,MAAAA,GAAS,MAAMO,uBAAAA,CACnBnC,QAAAA,EACA;WACM8B,YAAAA,CAAaR,MAAM,GAAG,CAAA,GACtB;AACEc,YAAAA,gCAAAA,CACEnC,eAAAA,EACA,sKAAA;AAEH,SAAA,GACD,EAAE;AACFsB,QAAAA,GAAAA,QAAAA,CAASG,IAAI,CAACW,IAAI,GAAG,CAAA,GACrB;AACEC,YAAAA,gCAAAA,CACEnC,eAAAA,EACA,0GAAA;AAEH,SAAA,GACD;AACL,KAAA,EACDe,sBAAAA,EACAqB,cAAAA,CAAetC,eAAAA,EAAiBQ,MAAAA,EAAQc,QAAAA,CAAAA,EACxC;AACE,QAAA;YACEiB,QAAAA,EAAUpC,iBAAAA;YACVsB,IAAAA,EAAMI;AACR;AACD,KAAA,CAAA;IAGH,OAAO;AAAEF,QAAAA,MAAAA;AAAQC,QAAAA,KAAAA,EAAO;AAAG,KAAA;AAC7B;;;;"}

package/dist/generators/index.d.ts

@@ -0,0 +1,31 @@
+export interface GenerateConfig {
+    strapi: any;
+    pwd: string;
+    rootDir?: string;
+    /**
+     * Artifacts to generate. `true` generates the artifact, `false` removes the file a previous
+     * run may have generated for it, unset leaves it untouched.
+     * `services`, `controllers`, `policies`, `middlewares` and `strict` are the strict types artifacts
+     * (`typescript.strictTypes`).
+     */
+    artifacts?: {
+        contentTypes?: boolean;
+        components?: boolean;
+        plugins?: boolean;
+        services?: boolean;
+        strict?: boolean;
+        controllers?: boolean;
+        policies?: boolean;
+        middlewares?: boolean;
+    };
+    logger?: {
+        silent?: boolean;
+        debug?: boolean;
+        verbose?: boolean;
+    };
+}
+/**
+ * Generate types definitions based on the given configuration
+ */
+export declare const generate: (config?: GenerateConfig) => Promise<Record<string, any>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generators/index.ts"],"names":[],"mappings":"AAkDA,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,GAAG,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,SAAS,CAAC,EAAE;QACV,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;IACF,MAAM,CAAC,EAAE;QACP,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;CACH;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAU,SAAQ,cAAqC,iCAkI3E,CAAC"}

package/dist/generators/index.js

@@ -0,0 +1,150 @@
+'use strict';
+
+var path = require('node:path');
+var fs = require('node:fs/promises');
+var chalk = require('chalk');
+var constants = require('./constants.js');
+var utils = require('./utils.js');
+var index$7 = require('./content-types/index.js');
+var index$6 = require('./components/index.js');
+var index$5 = require('./plugins/index.js');
+var index$4 = require('./services/index.js');
+var index$3 = require('./controllers/index.js');
+var index$2 = require('./policies/index.js');
+var index$1 = require('./middlewares/index.js');
+var index = require('./strict/index.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+
+const GENERATORS = {
+    contentTypes: index$7.generateContentTypesDefinitions,
+    components: index$6.generateComponentsDefinitions,
+    plugins: index$5.generatePluginDefinitions,
+    services: index$4.generateServicesDefinitions,
+    controllers: index$3.generateControllersDefinitions,
+    policies: index$2.generatePoliciesDefinitions,
+    middlewares: index$1.generateMiddlewaresDefinitions,
+    strict: index.generateStrictDefinitions
+};
+/**
+ * Artifacts written as `.ts` rather than `.d.ts`: they import the application's sources, and a
+ * reference that no longer resolves (a moved source, a renamed contract) is reported by `tsc` even
+ * with `skipLibCheck`, rather than silently typing the lookup as `any`. The other artifacts only
+ * hold declarations generated from the schemas, and stay `.d.ts`.
+ */ const SOURCE_ARTIFACTS = new Set([
+    'services',
+    'controllers',
+    'policies',
+    'middlewares'
+]);
+/**
+ * The application's linters would check the `.ts` artifacts, whose helpers use `any`.
+ */ const LINT_DISABLE_HEADER = '/* eslint-disable */\n/* oxlint-disable */\n';
+const isSourceArtifact = (artifact)=>SOURCE_ARTIFACTS.has(artifact);
+const filenameOf = (artifact)=>isSourceArtifact(artifact) === true ? `${artifact}.ts` : `${artifact}.d.ts`;
+/**
+ * File name an earlier generation wrote the artifact to, removed with the artifact's own file
+ */ const previousFilenameOf = (artifact)=>isSourceArtifact(artifact) === true ? `${artifact}.d.ts` : undefined;
+/**
+ * Generate types definitions based on the given configuration
+ */ const generate = async (config = {})=>{
+    const { pwd, rootDir = constants.TYPES_ROOT_DIR, strapi, artifacts = {}, logger: loggerConfig } = config;
+    const reports = {};
+    const logger = utils.createLogger(loggerConfig);
+    const psTimer = utils.timer().start();
+    const registryPwd = path__default.default.join(pwd, rootDir, constants.GENERATED_OUT_DIR);
+    // Strict mode reads only the global schema registries, so schemas use that form with the opt-in.
+    const strict = artifacts.strict === true;
+    const generatorConfig = {
+        strapi,
+        pwd: registryPwd,
+        appDir: pwd,
+        logger,
+        strict
+    };
+    const returnWithMessage = ()=>{
+        const nbWarnings = chalk__default.default.yellow(`${logger.warnings} warning(s)`);
+        const nbErrors = chalk__default.default.red(`${logger.errors} error(s)`);
+        const status = logger.errors > 0 ? chalk__default.default.red('errored') : chalk__default.default.green('completed successfully');
+        psTimer.end();
+        logger.info(`The task ${status} with ${nbWarnings} and ${nbErrors} in ${psTimer.duration}s.`);
+        return reports;
+    };
+    const enabledArtifacts = Object.keys(artifacts).filter((p)=>artifacts[p] === true);
+    const disabledArtifacts = Object.keys(artifacts).filter((p)=>artifacts[p] === false && p in GENERATORS);
+    logger.info('Starting the type generation process');
+    logger.debug(`Enabled artifacts: ${enabledArtifacts.join(', ')}`);
+    for (const artifact of enabledArtifacts){
+        const boldArtifact = chalk__default.default.bold(artifact); // used for log messages
+        logger.info(`Generating types for ${boldArtifact}`);
+        if (artifact in GENERATORS) {
+            const generator = GENERATORS[artifact];
+            try {
+                const artifactGenTimer = utils.timer().start();
+                reports[artifact] = await generator(generatorConfig);
+                artifactGenTimer.end();
+                logger.debug(`Generated ${boldArtifact} in ${artifactGenTimer.duration}s`);
+            } catch (e) {
+                logger.error(`Failed to generate types for ${boldArtifact}: ${e.message ?? e.toString()}. Exiting`);
+                return returnWithMessage();
+            }
+        } else {
+            logger.warn(`The types generator for ${boldArtifact} is not implemented, skipping`);
+        }
+    }
+    for (const artifact of Object.keys(reports)){
+        const boldArtifact = chalk__default.default.bold(artifact); // used for log messages
+        const artifactFsTimer = utils.timer().start();
+        const report = reports[artifact];
+        const filename = filenameOf(artifact);
+        const previousFilename = previousFilenameOf(artifact);
+        const content = isSourceArtifact(artifact) === true ? `${LINT_DISABLE_HEADER}${report.output}` : report.output;
+        try {
+            const outPath = await utils.saveDefinitionToFileSystem(registryPwd, filename, content);
+            // A stale `.d.ts` would declare the registry entries a second time
+            if (previousFilename !== undefined) {
+                await fs__default.default.rm(path__default.default.join(registryPwd, previousFilename), {
+                    force: true
+                });
+            }
+            const relativeOutPath = path__default.default.relative(process.cwd(), outPath);
+            artifactFsTimer.end();
+            logger.info(`Saved ${boldArtifact} types in ${chalk__default.default.bold(relativeOutPath)}`);
+            logger.debug(`Saved ${boldArtifact} in ${artifactFsTimer.duration}s`);
+        } catch (e) {
+            logger.error(`An error occurred while saving ${boldArtifact} types to the filesystem: ${e.message ?? e.toString()}. Exiting`);
+            return returnWithMessage();
+        }
+    }
+    // Disabled artifacts are removed so that a stale generated file does not keep applying
+    for (const artifact of disabledArtifacts){
+        const boldArtifact = chalk__default.default.bold(artifact); // used for log messages
+        const previousFilename = previousFilenameOf(artifact);
+        const outPaths = [
+            filenameOf(artifact),
+            ...previousFilename === undefined ? [] : [
+                previousFilename
+            ]
+        ].map((filename)=>path__default.default.join(registryPwd, filename));
+        try {
+            for (const outPath of outPaths){
+                if (await utils.pathExists(outPath) === false) {
+                    continue;
+                }
+                await fs__default.default.rm(outPath);
+                logger.info(`Removed ${boldArtifact} types from ${chalk__default.default.bold(path__default.default.relative(process.cwd(), outPath))} (artifact disabled)`);
+            }
+        } catch (e) {
+            logger.error(`An error occurred while removing ${boldArtifact} types from the filesystem: ${e.message ?? e.toString()}. Exiting`);
+            return returnWithMessage();
+        }
+    }
+    return returnWithMessage();
+};
+
+exports.generate = generate;
+//# sourceMappingURL=index.js.map