@oak-digital/types-4-strapi-2 0.5.5 → 1.0.0-beta.2

package/.eslintrc.json

@@ -38,7 +38,8 @@
         ],
         "quotes": [
             "error",
-            "single"
+            "single",
+            { "allowTemplateLiterals": true }
         ],
         "semi": [
             "error",

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+## v1
+
+* Generated files and folders will be seperated by admin, plugin, api and builtin.
+* Added readers and cli reader option.
+* Added `load-strapi` reader, which can find all content types.
+* Better type safety (removed some uses of any).
+* targets es6 instead of es5.

package/README.md

@@ -47,27 +47,35 @@ This can be done with the `--out` flag like in the following example.
 
 * Generate TypeScript interfaces for all your api content-types and components
 * Generate TypeScript interfaces for builtin types such as `Media` and `MediaFormat`
+* Generate TypeScript interfaces for plugins' content types
 * Select input and output directory
 * Prettier formatting and ability to use your own `.prettierrc`.
 * Generate types for plugins such as [url-alias](https://github.com/strapi-community/strapi-plugin-url-alias)
 * Population by generics
 
-### Planned features
-
-* Support for localization
-
 ## Flags
 
 | **Flag**                    | **Description**                                                                      | **Default** |
 |-----------------------------|--------------------------------------------------------------------------------------|-------------|
-| -i, --in <dir>              | The src directory for strapi                                                         | `./src`     |
+| -i, --in <dir>              | The root directory for strapi                                                        | `./`     |
 | -o, --out <dir>             | The output directory to output the types to                                          | `./types`   |
+| -r, --reader <reader>       | The reader to use, see reader section                                                | `by-file`   |
 | --prefix <prefix>           | A prefix for all generated interfaces                                                | `I`         |
 | --component-prefix <prefix> | A prefix for components                                                              | none        |
 | -D, --delete-old            | CAUTION: This option is equivalent to running `rm -rf` on the output directory first | `false`     |
 | --prettier <file>           | The prettier config file to use for formatting TypeScript interfaces                 | none        |
 | --plugins <plugins...>      | The plugins to use                                                                   | none        |
 
+## Readers
+
+To fetch the content types from strapi, we need to read it in some way.
+In version 0.x.x it was done by simply reading the generated files.
+In version 1.x.x the default will be to read the generated files with the `by-file` reader.
+
+You can select which reader you want to use in the cli with the `--reader` flag.
+The `by-file` reader is very fast, but it will not work in some cases and may not provide all the desired types.
+The `load-strapi` reader is slow, but gets all types, it works by creating a strapi instance that would then have loaded all the content types, which can then be etracted.
+
 ## Using plugins
 
 It is possible to generate types for plugins, for example url-alias gives a new field on your content types, so that plugin will automatically add that field to your types.
@@ -149,6 +157,10 @@ export default (plugin: any) => {
 }
 ```
 
+## API
+
+The api is not finished, so it may change over time.
+
 ## Building
 
 To build this project, use the following command

package/lib/attributes/Attributes.d.ts

@@ -1,13 +1,14 @@
 import { RelationNames } from '../file/File';
+import { AttributeWithNested } from '../interface/builtinInterfaces';
 export default class Attributes {
-    Attrs: Record<string, Record<string, any>>;
+    Attrs: Record<string, AttributeWithNested>;
     private RelationNames;
     constructor(attr: Record<string, Record<string, any>>, relationNames: RelationNames);
-    isAttributePopulatable(attr: any): boolean;
+    isAttributePopulatable(attr: AttributeWithNested): boolean;
     hasPopulatableAttributes(): boolean;
     getPopulatableAttributes(): Set<string>;
     getDependencies(): string[];
-    attributeToString(attrName: string, attr: any): string;
+    attributeToString(attrName: string, attr: AttributeWithNested): string;
     toFieldsString(): string;
     toString(): string;
 }

package/lib/attributes/Attributes.js

@@ -1,13 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("../constants");
-var Attributes = /** @class */ (function () {
-    function Attributes(attr, relationNames) {
+const constants_1 = require("../constants");
+const Interface_1 = __importDefault(require("../interface/Interface"));
+class Attributes {
+    constructor(attr, relationNames) {
         this.RelationNames = {};
         this.Attrs = attr;
         this.RelationNames = relationNames;
     }
-    Attributes.prototype.isAttributePopulatable = function (attr) {
+    isAttributePopulatable(attr) {
         // If it is a component / relation / dynamiczone it is always optional due to population
         switch (attr.type) {
             case 'nested':
@@ -22,38 +26,41 @@ var Attributes = /** @class */ (function () {
                 break;
         }
         return false;
-    };
-    Attributes.prototype.hasPopulatableAttributes = function () {
-        for (var attrName in this.Attrs) {
-            var attr = this.Attrs[attrName];
+    }
+    hasPopulatableAttributes() {
+        for (const attrName in this.Attrs) {
+            const attr = this.Attrs[attrName];
             if (this.isAttributePopulatable(attr)) {
                 return true;
             }
         }
         return false;
-    };
-    Attributes.prototype.getPopulatableAttributes = function () {
-        var populatableAttributes = new Set();
-        for (var attrName in this.Attrs) {
-            var attr = this.Attrs[attrName];
+    }
+    getPopulatableAttributes() {
+        const populatableAttributes = new Set();
+        for (const attrName in this.Attrs) {
+            const attr = this.Attrs[attrName];
             if (this.isAttributePopulatable(attr)) {
                 populatableAttributes.add(attrName);
             }
         }
         return populatableAttributes;
-    };
-    Attributes.prototype.getDependencies = function () {
+    }
+    getDependencies() {
         var _a;
-        var dependencies = new Set();
-        for (var attrName in this.Attrs) {
-            var attr = this.Attrs[attrName];
+        const dependencies = new Set();
+        for (const attrName in this.Attrs) {
+            const attr = this.Attrs[attrName];
             switch (attr.type) {
                 case 'nested':
-                    var attrs = new Attributes(attr.fields, this.RelationNames);
-                    var deps = attrs.getDependencies();
-                    deps.forEach(function (dep) { return dependencies.add(dep); });
+                    const attrs = new Attributes(attr.fields, this.RelationNames);
+                    const deps = attrs.getDependencies();
+                    deps.forEach((dep) => dependencies.add(dep));
                     break;
                 case 'relation':
+                    if (attr.relation === 'morphToMany') {
+                        break;
+                    }
                     dependencies.add(attr.target);
                     break;
                 case 'component':
@@ -63,8 +70,8 @@ var Attributes = /** @class */ (function () {
                     dependencies.add('builtins::Media');
                     break;
                 case 'dynamiczone':
-                    var componentDeps = (_a = attr.components) !== null && _a !== void 0 ? _a : [];
-                    componentDeps.forEach(function (dep) { return dependencies.add(dep); });
+                    const componentDeps = (_a = attr.components) !== null && _a !== void 0 ? _a : [];
+                    componentDeps.forEach((dep) => dependencies.add(dep));
                     break;
                 default:
                     continue;
@@ -80,60 +87,72 @@ var Attributes = /** @class */ (function () {
             dependencies.add('builtins::RequiredBy');
         }
         return Array.from(dependencies);
-    };
-    Attributes.prototype.attributeToString = function (attrName, attr) {
-        var _this = this;
+    }
+    attributeToString(attrName, attr) {
         var _a, _b, _c;
-        var isPopulatable = this.isAttributePopulatable(attr);
-        var isOptional = isPopulatable;
-        var optionalString = isOptional ? '?' : '';
-        var orNull = ' | null';
+        const isPopulatable = this.isAttributePopulatable(attr);
+        const isOptional = isPopulatable;
+        const optionalString = isOptional ? '?' : '';
+        const orNull = ' | null';
         // TODO: only add this in non paranoid mode
         /* const requiredString = attr.required !== true ? orNull : ''; */
-        var requiredString = (attr === null || attr === void 0 ? void 0 : attr[constants_1.CERTAINLY_REQUIRED_KEY]) === true ? '' : orNull;
-        var str = "    ".concat(attrName).concat(optionalString, ": ");
-        var isArray = false;
+        const requiredString = (attr === null || attr === void 0 ? void 0 : attr[constants_1.CERTAINLY_REQUIRED_KEY]) === true ? '' : orNull;
+        let str = `    ${attrName}${optionalString}: `;
+        let isArray = false;
         switch (attr.type) {
             // types-4-strapi-2 specific, used for builtin types
             case 'nested':
                 // Be careful with recursion
                 // console.log(attr);
-                var nullableString = ((_a = attr === null || attr === void 0 ? void 0 : attr.nullable) !== null && _a !== void 0 ? _a : false) ? ' | null' : '';
-                var newAttrs = new Attributes(attr.fields, this.RelationNames);
+                const nullableString = ((_a = attr === null || attr === void 0 ? void 0 : attr.nullable) !== null && _a !== void 0 ? _a : false) ? ' | null' : '';
+                const newAttrs = new Attributes(attr.fields, this.RelationNames);
                 str += newAttrs.toString() + nullableString;
                 break;
             case 'relation':
-                var apiName = attr.target;
+                if (attr.relation === 'morphToMany') {
+                    str += 'any';
+                    break;
+                }
+                const apiName = attr.target;
                 // console.log(this.RelationNames, apiName)
-                var dependencyName = (_c = (_b = this.RelationNames[apiName]) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : 'any';
-                var relationMultipleString = attr.relation.endsWith('ToMany')
+                const dependencyName = (_c = (_b = this.RelationNames[apiName]) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : 'any';
+                const relationMultipleString = attr.relation.endsWith('ToMany')
                     ? '[]'
                     : orNull;
-                str += "{ data: ";
+                str += `{ data: `;
                 str += dependencyName;
-                // TODO: assert correctly
-                var relationInterface = this.RelationNames[apiName].file;
+                const relationInterfaceWrapped = this.RelationNames[apiName];
+                if (!relationInterfaceWrapped) {
+                    throw new Error(`Could not find relation ${apiName}, consider using another reader.`);
+                }
+                const relationInterface = relationInterfaceWrapped.file;
+                if (!(relationInterface instanceof Interface_1.default)) {
+                    throw new Error(`t4s internal error: Expected relation ${apiName} to be an interface, but it was not. Please open an issue on the GitHub repository.`);
+                }
                 if (relationInterface.hasPopulatableAttributes()) {
                     str += '<';
-                    str += "".concat(this.RelationNames['builtins::ExtractNested'].name, "<").concat(constants_1.POPULATE_GENERIC_NAME, ", '").concat(attrName, "'>");
+                    str += `${this.RelationNames['builtins::ExtractNested'].name}<${constants_1.POPULATE_GENERIC_NAME}, '${attrName}'>`;
                     str += '>';
                 }
                 str += relationMultipleString;
-                str += "; }";
+                str += `; }`;
                 break;
             case 'component':
-                var componentName = attr.component;
-                var relationNameObj = this.RelationNames[componentName];
+                const componentName = attr.component;
+                const relationNameObj = this.RelationNames[componentName];
                 // TODO: assert correctly
-                var componentInterface = relationNameObj.file;
+                const componentInterface = relationNameObj.file;
+                if (!(componentInterface instanceof Interface_1.default)) {
+                    throw new Error(`t4s internal error: Expected component ${componentName} to be an interface, but it was not. Please open an issue on the GitHub repository.`);
+                }
                 /* console.log(this.RelationNames); */
-                var dependencyComponentName = relationNameObj.name;
+                const dependencyComponentName = relationNameObj.name;
                 /* isArray = attr.repeatable ?? false; */
                 isArray = false; // we already handle this here.
                 str += dependencyComponentName;
                 if (componentInterface.hasPopulatableAttributes()) {
                     str += '<';
-                    str += "".concat(this.RelationNames['builtins::ExtractNested'].name, "<").concat(constants_1.POPULATE_GENERIC_NAME, ", '").concat(attrName, "'>");
+                    str += `${this.RelationNames['builtins::ExtractNested'].name}<${constants_1.POPULATE_GENERIC_NAME}, '${attrName}'>`;
                     str += '>';
                 }
                 if (attr.repeatable) {
@@ -144,40 +163,46 @@ var Attributes = /** @class */ (function () {
                 }
                 break;
             case 'media':
-                var mediaMultipleString = attr.multiple
+                const mediaMultipleString = attr.multiple
                     ? '[]'
                     : requiredString;
-                str += "{ data: ";
+                str += `{ data: `;
                 str += this.RelationNames['builtins::Media'].name;
                 str += mediaMultipleString;
-                str += "; }";
+                str += `; }`;
                 break;
             case 'password':
                 return null;
             case 'enumeration':
-                var hasDefault = 'default' in attr;
-                var enums = attr.enum.map(function (en) { return "\"".concat(en, "\""); });
+                const hasDefault = 'default' in attr;
+                const enums = attr.enum.map((en) => `"${en}"`);
                 enums.push('null');
-                var typeString = enums.join(' | ');
+                const typeString = enums.join(' | ');
                 str += typeString;
                 break;
             case 'dynamiczone':
                 // console.log(attr.components);
-                var relations = attr.components.map(function (componentName) {
-                    var component = _this.RelationNames[componentName];
+                const relations = attr.components.map((componentName) => {
+                    const component = this.RelationNames[componentName];
+                    if (!component) {
+                        throw new Error(`Could not find component ${componentName}, consider using another reader.`);
+                    }
                     // in this context file should always be an interface
-                    var file = component.file;
-                    var populatable = file.hasPopulatableAttributes();
+                    const file = component.file;
+                    if (!(file instanceof Interface_1.default)) {
+                        throw new Error(`t4s internal error: Expected component ${componentName} to be an interface, but it was not. Please open an issue on the GitHub repository.`);
+                    }
+                    const populatable = file.hasPopulatableAttributes();
                     /* false; */
-                    var populatableString = populatable
-                        ? "".concat(_this.RelationNames[componentName].name, "<").concat(_this.RelationNames['builtins::ExtractNested'].name, "<").concat(constants_1.POPULATE_GENERIC_NAME, ", '").concat(attrName, "'>>")
-                        : _this.RelationNames[componentName].name;
+                    const populatableString = populatable
+                        ? `${this.RelationNames[componentName].name}<${this.RelationNames['builtins::ExtractNested'].name}<${constants_1.POPULATE_GENERIC_NAME}, '${attrName}'>>`
+                        : this.RelationNames[componentName].name;
                     return populatableString;
                 });
                 // console.log(relations);
-                var relationsString = relations.join(' | ');
+                const relationsString = relations.join(' | ');
                 // console.log(relationsString);
-                str += "Array<".concat(relationsString, ">");
+                str += `Array<${relationsString}>`;
                 break;
             case 'string':
             case 'text':
@@ -209,28 +234,27 @@ var Attributes = /** @class */ (function () {
                 str += 'any';
                 break;
         }
-        var isArrayString = isArray ? '[]' : '';
-        str += "".concat(isArrayString, ";");
+        const isArrayString = isArray ? '[]' : '';
+        str += `${isArrayString};`;
         return str;
-    };
-    Attributes.prototype.toFieldsString = function () {
-        var strings = [];
-        for (var attrName in this.Attrs) {
-            var attr = this.Attrs[attrName];
-            var attrString = this.attributeToString(attrName, attr);
+    }
+    toFieldsString() {
+        const strings = [];
+        for (const attrName in this.Attrs) {
+            const attr = this.Attrs[attrName];
+            const attrString = this.attributeToString(attrName, attr);
             if (attrString === null) {
                 continue;
             }
             strings.push(attrString);
         }
-        return strings.map(function (s) { return "".concat(s, "\n"); }).join('');
-    };
-    Attributes.prototype.toString = function () {
-        var strings = ['{'];
+        return strings.map((s) => `${s}\n`).join('');
+    }
+    toString() {
+        const strings = ['{'];
         strings.push(this.toFieldsString());
         strings.push('}');
         return strings.join('\n');
-    };
-    return Attributes;
-}());
+    }
+}
 exports.default = Attributes;

package/lib/content-types/reader.js

@@ -8,170 +8,74 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getApiSchemas = exports.getComponentSchemas = exports.getComponentCategoryFolders = exports.getApiFolders = exports.readSchema = void 0;
-var node_fs_1 = require("node:fs");
-var promises_1 = require("node:fs/promises");
-var posix_1 = require("node:path/posix");
-var utils_1 = require("../utils");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const posix_1 = require("node:path/posix");
+const utils_1 = require("../utils");
 function readSchema(schemaPath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var schemaData, e_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, (0, promises_1.readFile)(schemaPath)];
-                case 1:
-                    schemaData = _a.sent();
-                    return [2 /*return*/, JSON.parse(schemaData.toString())];
-                case 2:
-                    e_1 = _a.sent();
-                    return [2 /*return*/, null];
-                case 3: return [2 /*return*/];
-            }
-        });
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const schemaData = yield (0, promises_1.readFile)(schemaPath);
+            return JSON.parse(schemaData.toString());
+        }
+        catch (e) {
+            return null;
+        }
     });
 }
 exports.readSchema = readSchema;
 function getApiFolders(strapiSrcRoot) {
-    return __awaiter(this, void 0, void 0, function () {
-        var path, folders;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    path = (0, posix_1.join)(strapiSrcRoot, 'api');
-                    return [4 /*yield*/, (0, utils_1.readDirFiltered)(path)];
-                case 1:
-                    folders = _a.sent();
-                    return [2 /*return*/, folders];
-            }
-        });
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = (0, posix_1.join)(strapiSrcRoot, 'api');
+        const folders = yield (0, utils_1.readDirFiltered)(path);
+        return folders;
     });
 }
 exports.getApiFolders = getApiFolders;
 function getComponentCategoryFolders(strapiSrcRoot) {
-    return __awaiter(this, void 0, void 0, function () {
-        var path, folders;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    path = (0, posix_1.join)(strapiSrcRoot, 'components');
-                    // If there exists no components, just fallback to an empty array.
-                    if (!(0, node_fs_1.existsSync)(path)) {
-                        return [2 /*return*/, []];
-                    }
-                    return [4 /*yield*/, (0, utils_1.readDirFiltered)(path)];
-                case 1:
-                    folders = _a.sent();
-                    return [2 /*return*/, folders];
-            }
-        });
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = (0, posix_1.join)(strapiSrcRoot, 'components');
+        // If there exists no components, just fallback to an empty array.
+        if (!(0, node_fs_1.existsSync)(path)) {
+            return [];
+        }
+        const folders = yield (0, utils_1.readDirFiltered)(path);
+        return folders;
     });
 }
 exports.getComponentCategoryFolders = getComponentCategoryFolders;
 function getComponentSchemas(strapiSrcRoot) {
-    return __awaiter(this, void 0, void 0, function () {
-        var categories, nestedSchemasPromises, nestedSchemasArr;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getComponentCategoryFolders(strapiSrcRoot)];
-                case 1:
-                    categories = _a.sent();
-                    nestedSchemasPromises = categories.map(function (category) { return __awaiter(_this, void 0, void 0, function () {
-                        var schemaFilesPath, schemaFiles, schemaNamesWithAttributesPromises, schemaNamesWithAttributes;
-                        var _this = this;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    schemaFilesPath = (0, posix_1.join)(strapiSrcRoot, 'components', category);
-                                    return [4 /*yield*/, (0, utils_1.readDirFiltered)(schemaFilesPath)];
-                                case 1:
-                                    schemaFiles = _a.sent();
-                                    schemaNamesWithAttributesPromises = schemaFiles.map(function (file) { return __awaiter(_this, void 0, void 0, function () {
-                                        var schemaPath, schema, name;
-                                        return __generator(this, function (_a) {
-                                            switch (_a.label) {
-                                                case 0:
-                                                    schemaPath = (0, posix_1.join)(schemaFilesPath, file);
-                                                    return [4 /*yield*/, readSchema(schemaPath)];
-                                                case 1:
-                                                    schema = _a.sent();
-                                                    name = file.split('.')[0];
-                                                    return [2 /*return*/, { name: name, schema: schema }];
-                                            }
-                                        });
-                                    }); });
-                                    return [4 /*yield*/, Promise.all(schemaNamesWithAttributesPromises)];
-                                case 2:
-                                    schemaNamesWithAttributes = _a.sent();
-                                    return [2 /*return*/, { category: category, schemas: schemaNamesWithAttributes }];
-                            }
-                        });
-                    }); });
-                    return [4 /*yield*/, Promise.all(nestedSchemasPromises)];
-                case 2:
-                    nestedSchemasArr = _a.sent();
-                    return [2 /*return*/, nestedSchemasArr];
-            }
-        });
+    return __awaiter(this, void 0, void 0, function* () {
+        const categories = yield getComponentCategoryFolders(strapiSrcRoot);
+        const nestedSchemasPromises = categories.map((category) => __awaiter(this, void 0, void 0, function* () {
+            const schemaFilesPath = (0, posix_1.join)(strapiSrcRoot, 'components', category);
+            const schemaFiles = yield (0, utils_1.readDirFiltered)(schemaFilesPath);
+            const schemaNamesWithAttributesPromises = schemaFiles.map((file) => __awaiter(this, void 0, void 0, function* () {
+                const schemaPath = (0, posix_1.join)(schemaFilesPath, file);
+                const schema = yield readSchema(schemaPath);
+                const name = file.split('.')[0];
+                return { name, schema };
+            }));
+            const schemaNamesWithAttributes = yield Promise.all(schemaNamesWithAttributesPromises);
+            return { category, schemas: schemaNamesWithAttributes };
+        }));
+        const nestedSchemasArr = yield Promise.all(nestedSchemasPromises);
+        return nestedSchemasArr;
     });
 }
 exports.getComponentSchemas = getComponentSchemas;
 function getApiSchemas(strapiSrcRoot) {
-    return __awaiter(this, void 0, void 0, function () {
-        var apiFolders, schemasWithAttributesPromises, schemasWithAttributes;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getApiFolders(strapiSrcRoot)];
-                case 1:
-                    apiFolders = _a.sent();
-                    schemasWithAttributesPromises = apiFolders.map(function (folder) { return __awaiter(_this, void 0, void 0, function () {
-                        var schemaPath, schema;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    schemaPath = (0, posix_1.join)(strapiSrcRoot, 'api', folder, 'content-types', folder, 'schema.json');
-                                    return [4 /*yield*/, readSchema(schemaPath)];
-                                case 1:
-                                    schema = _a.sent();
-                                    return [2 /*return*/, { name: folder, schema: schema }];
-                            }
-                        });
-                    }); });
-                    schemasWithAttributes = Promise.all(schemasWithAttributesPromises);
-                    return [2 /*return*/, schemasWithAttributes];
-            }
-        });
+    return __awaiter(this, void 0, void 0, function* () {
+        const apiFolders = yield getApiFolders(strapiSrcRoot);
+        const schemasWithAttributesPromises = apiFolders.map((folder) => __awaiter(this, void 0, void 0, function* () {
+            const schemaPath = (0, posix_1.join)(strapiSrcRoot, 'api', folder, 'content-types', folder, 'schema.json');
+            const schema = yield readSchema(schemaPath);
+            return { name: folder, schema };
+        }));
+        const schemasWithAttributes = Promise.all(schemasWithAttributesPromises);
+        return schemasWithAttributes;
     });
 }
 exports.getApiSchemas = getApiSchemas;

package/lib/extra-types/ExtraType.d.ts

@@ -1,5 +1,5 @@
-import { File } from "../file/File";
-import { caseType } from "../utils/casing";
+import { File } from '../file/File';
+import { caseType } from '../utils/casing';
 export declare class ExtraType extends File {
     protected typeString: string;
     constructor(typeString: string, baseName: string, relativeDirectoryPath: string, fileCaseType?: caseType);