@oak-digital/types-4-strapi-2 0.1.2 → 0.2.2

package/lib/interface/InterfaceManager.js

@@ -43,9 +43,11 @@ var fs_1 = require("fs");
 var promises_1 = require("fs/promises");
 var path_1 = require("path");
 var utils_1 = require("../utils");
+var builtinInterfaces_1 = require("./builtinInterfaces");
 var ComponentInterface_1 = __importDefault(require("./ComponentInterface"));
 var Interface_1 = __importDefault(require("./Interface"));
 var schemaReader_1 = require("./schemaReader");
+var prettier_1 = __importDefault(require("prettier"));
 var InterfaceManager = /** @class */ (function () {
     function InterfaceManager(outRoot, strapiSrcRoot, options) {
         if (options === void 0) { options = {}; }
@@ -54,6 +56,28 @@ var InterfaceManager = /** @class */ (function () {
         this.StrapiSrcRoot = strapiSrcRoot;
         this.Options = Object.assign({}, InterfaceManager.BaseOptions, options);
     }
+    InterfaceManager.prototype.loadPrettierConfig = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var defaultOptions, resolved;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        defaultOptions = {
+                            parser: 'typescript',
+                        };
+                        if (!this.Options.prettierFile) {
+                            this.PrettierOptions = defaultOptions;
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, prettier_1.default.resolveConfig(this.Options.prettierFile)];
+                    case 1:
+                        resolved = _a.sent();
+                        this.PrettierOptions = Object.assign({}, defaultOptions, resolved);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     InterfaceManager.prototype.createInterfaces = function () {
         return __awaiter(this, void 0, void 0, function () {
             var apiSchemasPromise, componentSchemasPromise, apiSchemas, componentSchemas;
@@ -69,7 +93,7 @@ var InterfaceManager = /** @class */ (function () {
                         apiSchemas.forEach(function (schema) {
                             var name = schema.name, attributes = schema.attributes;
                             var strapiName = "api::".concat(name, ".").concat(name);
-                            var inter = new Interface_1.default(name, attributes, "./", _this.Options.prefix);
+                            var inter = new Interface_1.default(name, attributes, './', _this.Options.prefix);
                             _this.Interfaces[strapiName] = inter;
                         });
                         return [4 /*yield*/, componentSchemasPromise];
@@ -80,7 +104,7 @@ var InterfaceManager = /** @class */ (function () {
                             category.schemas.forEach(function (schema) {
                                 var componentName = schema.name;
                                 var strapiName = "".concat(categoryName, ".").concat(schema.name);
-                                var componentPrefix = "".concat(_this.Options.componentPrefix).concat(_this.Options.useCategoryPrefix ? (0, utils_1.pascalCase)(categoryName) : "");
+                                var componentPrefix = "".concat(_this.Options.componentPrefix).concat(_this.Options.useCategoryPrefix ? (0, utils_1.pascalCase)(categoryName) : '');
                                 var prefix = _this.Options.componentPrefixOverridesPrefix ? componentPrefix : _this.Options.prefix + componentPrefix;
                                 // TODO: make component interface
                                 var inter = new ComponentInterface_1.default(componentName, schema.attributes, "./".concat(categoryName), categoryName, prefix);
@@ -92,6 +116,16 @@ var InterfaceManager = /** @class */ (function () {
             });
         });
     };
+    InterfaceManager.prototype.createBuiltinInterfaces = function () {
+        var _this = this;
+        var outDir = './builtins';
+        var builtinInterfaces = [];
+        builtinInterfaces.push((0, builtinInterfaces_1.createMediaInterface)(outDir, this.Options.prefix));
+        builtinInterfaces.push((0, builtinInterfaces_1.createMediaFormatInterface)(outDir, this.Options.prefix));
+        builtinInterfaces.forEach(function (inter) {
+            _this.Interfaces[inter.getStrapiName()] = inter;
+        });
+    };
     // Inject dependencies into all interfaces
     InterfaceManager.prototype.injectDependencies = function () {
         var _this = this;
@@ -108,7 +142,7 @@ var InterfaceManager = /** @class */ (function () {
     };
     InterfaceManager.prototype.makeFolders = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var componentCategories;
+            var componentCategories, promises, componentCategoriesPromises, builtinsPath;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -122,7 +156,9 @@ var InterfaceManager = /** @class */ (function () {
                     case 2:
                         _a.sent();
                         _a.label = 3;
-                    case 3: return [4 /*yield*/, Promise.all(componentCategories.map(function (category) { return __awaiter(_this, void 0, void 0, function () {
+                    case 3:
+                        promises = [];
+                        componentCategoriesPromises = componentCategories.map(function (category) { return __awaiter(_this, void 0, void 0, function () {
                             var path;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
@@ -137,7 +173,13 @@ var InterfaceManager = /** @class */ (function () {
                                         return [2 /*return*/];
                                 }
                             });
-                        }); }))];
+                        }); });
+                        promises.push.apply(promises, componentCategoriesPromises);
+                        builtinsPath = (0, path_1.join)(this.OutRoot, 'builtins');
+                        if (!(0, fs_1.existsSync)(builtinsPath)) {
+                            promises.push((0, promises_1.mkdir)((0, path_1.join)(this.OutRoot, 'builtins')));
+                        }
+                        return [4 /*yield*/, Promise.all(promises)];
                     case 4:
                         _a.sent();
                         return [2 /*return*/];
@@ -153,14 +195,15 @@ var InterfaceManager = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         writePromises = Object.keys(this.Interfaces).map(function (strapiName) { return __awaiter(_this, void 0, void 0, function () {
-                            var inter, fileData, filePath;
+                            var inter, fileData, formattedFileData, filePath;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
                                         inter = this.Interfaces[strapiName];
                                         fileData = inter.toString();
+                                        formattedFileData = prettier_1.default.format(fileData, this.PrettierOptions);
                                         filePath = (0, path_1.join)(this.OutRoot, inter.getRelativeRootPathFile());
-                                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, fileData)];
+                                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, formattedFileData)];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -177,7 +220,7 @@ var InterfaceManager = /** @class */ (function () {
     };
     InterfaceManager.prototype.writeIndexFile = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var strings, fileData, filePath;
+            var strings, fileData, formattedFileData, filePath;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -186,9 +229,10 @@ var InterfaceManager = /** @class */ (function () {
                             var inter = _this.Interfaces[strapiName];
                             return "export * from '".concat(inter.getRelativeRootPath(), "'");
                         });
-                        fileData = strings.join("\n");
-                        filePath = (0, path_1.join)(this.OutRoot, "index.ts");
-                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, fileData)];
+                        fileData = strings.join('\n');
+                        formattedFileData = prettier_1.default.format(fileData, this.PrettierOptions);
+                        filePath = (0, path_1.join)(this.OutRoot, 'index.ts');
+                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, formattedFileData)];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];
@@ -198,18 +242,21 @@ var InterfaceManager = /** @class */ (function () {
     };
     InterfaceManager.prototype.run = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var createInterfacesPromise, makeFoldersPromise, err_1;
+            var createInterfacesPromise, makeFoldersPromise, loadPrettierPromise, err_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 4, , 5]);
                         createInterfacesPromise = this.createInterfaces();
                         makeFoldersPromise = this.makeFolders();
+                        loadPrettierPromise = this.loadPrettierConfig();
+                        this.createBuiltinInterfaces();
                         return [4 /*yield*/, createInterfacesPromise];
                     case 1:
                         _a.sent();
+                        // Create all interfaces before injecting
                         this.injectDependencies();
-                        return [4 /*yield*/, makeFoldersPromise];
+                        return [4 /*yield*/, Promise.all([makeFoldersPromise, loadPrettierPromise])];
                     case 2:
                         _a.sent();
                         return [4 /*yield*/, Promise.all([this.writeInterfaces(), this.writeIndexFile()])];
@@ -226,10 +273,13 @@ var InterfaceManager = /** @class */ (function () {
         });
     };
     InterfaceManager.BaseOptions = {
-        prefix: "I",
+        prefix: 'I',
         useCategoryPrefix: true,
-        componentPrefix: "",
+        componentPrefix: '',
         componentPrefixOverridesPrefix: false,
+        builtinsPrefix: '',
+        builtinsPrefixOverridesPrefix: false,
+        prettierFile: null,
     };
     return InterfaceManager;
 }());

package/lib/interface/builtinInterfaces.d.ts

@@ -0,0 +1,4 @@
+import BuiltinComponentInterface from "./BuiltinComponentInterface";
+import BuiltinInterface from "./BuiltinInterface";
+export declare function createMediaInterface(directory: string, prefix: string): BuiltinInterface;
+export declare function createMediaFormatInterface(directory: string, prefix: string): BuiltinComponentInterface;

package/lib/interface/builtinInterfaces.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMediaFormatInterface = exports.createMediaInterface = void 0;
+var BuiltinComponentInterface_1 = __importDefault(require("./BuiltinComponentInterface"));
+var BuiltinInterface_1 = __importDefault(require("./BuiltinInterface"));
+function createMediaInterface(directory, prefix) {
+    var stringFields = [
+        "name",
+        "alternativeText",
+        "caption",
+        "hash",
+        "ext",
+        "mime",
+        "url",
+        "previewUrl",
+        "provider",
+    ];
+    var numberFields = [
+        "width",
+        "height",
+        "size",
+    ];
+    var mediaFormat = {
+        type: "component",
+        repeatable: false,
+        component: "builtins::MediaFormat",
+    };
+    var mediaAttrs = {
+        formats: {
+            // types-4-strapi-2 specific
+            type: "nested",
+            fields: {
+                thumbnail: mediaFormat,
+                medium: mediaFormat,
+                small: mediaFormat,
+            },
+        },
+    };
+    stringFields.forEach(function (s) { return mediaAttrs[s] = { type: "string" }; });
+    numberFields.forEach(function (s) { return mediaAttrs[s] = { type: "integer" }; });
+    // const dataAttrs = {
+    //     data: {
+    //         type: "nested",
+    //         fields: mediaAttrs,
+    //         nullable: true,
+    //     },
+    // };
+    return new BuiltinInterface_1.default("Media", mediaAttrs, directory, prefix);
+}
+exports.createMediaInterface = createMediaInterface;
+function createMediaFormatInterface(directory, prefix) {
+    var stringFields = [
+        "name",
+        "hash",
+        "ext",
+        "mime",
+        "path",
+        "url",
+    ];
+    var numberFields = [
+        "width",
+        "height",
+        "size",
+    ];
+    var mediaAttrs = {};
+    stringFields.forEach(function (s) { return mediaAttrs[s] = { type: "string" }; });
+    numberFields.forEach(function (s) { return mediaAttrs[s] = { type: "integer" }; });
+    return new BuiltinComponentInterface_1.default("MediaFormat", mediaAttrs, directory, prefix);
+}
+exports.createMediaFormatInterface = createMediaFormatInterface;

package/lib/src/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/src/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var commander_1 = require("commander");
+var InterfaceManager_1 = __importDefault(require("./interface/InterfaceManager"));
+commander_1.program
+    .name('t4s');
+commander_1.program
+    .option('-i, --in <dir>', 'The src directory for strapi', './src')
+    .option('-o, --out <dir>', 'The output directory to output the types to', './types')
+    .option('--component-prefix <prefix>', 'A prefix for components', '')
+    .option('--prettier <file>', 'The prettier config file to use for formatting typescript interfaces');
+commander_1.program.parse();
+var options = commander_1.program.opts();
+console.log(options);
+var input = options.in, out = options.out, componentPrefix = options.componentPrefix, prettierFile = options.prettier;
+var manager = new InterfaceManager_1.default(out, input, {
+    componentPrefix: componentPrefix,
+    prettierFile: prettierFile,
+});
+manager.run().catch(function (err) {
+    console.error(err);
+});

package/lib/src/interface/Attributes.d.ts

@@ -0,0 +1,11 @@
+import { RelationNames } from './Interface';
+export default class Attributes {
+    Attrs: Record<string, Record<string, any>>;
+    private RelationNames;
+    constructor(attr: Record<string, Record<string, any>>, relationNames: RelationNames);
+    isAttributeOptional(attr: any): boolean;
+    getDependencies(): any[];
+    attributeToString(attrName: string, attr: any): string;
+    toFieldsString(): string;
+    toString(): string;
+}

package/lib/src/interface/Attributes.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Attributes = /** @class */ (function () {
+    function Attributes(attr, relationNames) {
+        this.RelationNames = {};
+        this.Attrs = attr;
+        this.RelationNames = relationNames;
+    }
+    Attributes.prototype.isAttributeOptional = function (attr) {
+        // If it is a component / relation / dynamiczone it is always optional due to population
+        switch (attr.type) {
+            case 'nested':
+                return attr.nullable === true;
+            case 'component':
+            case 'dynamiczone':
+            case 'relation':
+                return true;
+            default:
+                break;
+        }
+        return false;
+    };
+    Attributes.prototype.getDependencies = function () {
+        var dependencies = [];
+        for (var attrName in this.Attrs) {
+            var attr = this.Attrs[attrName];
+            var dependencyNames = [];
+            switch (attr.type) {
+                case 'nested':
+                    var attrs = new Attributes(attr.fields, this.RelationNames);
+                    dependencyNames.push.apply(dependencyNames, attrs.getDependencies());
+                    break;
+                case 'relation':
+                    dependencyNames.push(attr.target);
+                    break;
+                case 'component':
+                    dependencyNames.push(attr.component);
+                    break;
+                case 'media':
+                    dependencyNames.push('builtins::Media');
+                    break;
+                default:
+                    continue;
+            }
+            // // If the current dependency is the interface itself, do not report it as a dependency
+            // if (dependencyName === strapiName) {
+            //     continue;
+            // }
+            dependencyNames.forEach(function (dependencyName) {
+                if (!dependencies.includes(dependencyName)) {
+                    dependencies.push(dependencyName);
+                }
+            });
+        }
+        return dependencies;
+    };
+    Attributes.prototype.attributeToString = function (attrName, attr) {
+        var _a, _b;
+        var optionalString = this.isAttributeOptional(attr) ? '?' : '';
+        var str = "    ".concat(attrName).concat(optionalString, ": ");
+        var isArray = false;
+        switch (attr.type) {
+            // types-4-strapi-2 specific, used for builtin types
+            case 'nested':
+                // Be careful with recursion
+                // console.log(attr);
+                var newAttrs = new Attributes(attr.fields, this.RelationNames);
+                str += newAttrs.toString();
+                break;
+            case 'relation':
+                var apiName = attr.target;
+                // console.log(this.RelationNames, apiName)
+                var dependencyName = this.RelationNames[apiName].name;
+                isArray = attr.relation.endsWith('ToMany');
+                str += dependencyName;
+                break;
+            case 'component':
+                var componentName = attr.component;
+                var relationNameObj = this.RelationNames[componentName];
+                var dependencyComponentName = relationNameObj.name;
+                isArray = (_a = attr.repeatable) !== null && _a !== void 0 ? _a : false;
+                str += dependencyComponentName;
+                break;
+            case 'media':
+                var mediaOptional = attr.required !== true ? '?' : '';
+                str += "{ data".concat(mediaOptional, ": ").concat(this.RelationNames['builtins::Media'].name, "; }");
+                isArray = (_b = attr.multiple) !== null && _b !== void 0 ? _b : false;
+                break;
+            case 'password':
+                return null;
+            case 'enumeration':
+                var hasDefault = 'default' in attr;
+                var enums = attr.enum.map(function (en) { return "\"".concat(en, "\""); });
+                enums.push('null');
+                var typeString = enums.join(' | ');
+                str += typeString;
+                break;
+            case 'string':
+            case 'text':
+            case 'richtext':
+            case 'email':
+            case 'uid':
+                str += 'string';
+                break;
+            case 'integer':
+            case 'biginteger':
+            case 'decimal':
+            case 'float':
+                str += 'number';
+                break;
+            case 'date':
+            case 'datetime':
+            case 'time':
+                str += 'Date';
+                break;
+            case 'boolean':
+                str += attr.type;
+                break;
+            case 'json':
+            default:
+                str += 'any';
+                break;
+        }
+        var isArrayString = isArray ? '[]' : '';
+        str += "".concat(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);
+            if (attrString === null) {
+                continue;
+            }
+            strings.push(attrString);
+        }
+        return strings.map(function (s) { return "".concat(s, "\n"); }).join('');
+    };
+    Attributes.prototype.toString = function () {
+        var strings = ['{'];
+        strings.push(this.toFieldsString());
+        strings.push('}');
+        return strings.join('\n');
+    };
+    return Attributes;
+}());
+exports.default = Attributes;

package/lib/src/interface/BuiltinComponentInterface.d.ts

@@ -0,0 +1,5 @@
+import ComponentInterface from './ComponentInterface';
+export default class BuiltinComponentInterface extends ComponentInterface {
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, prefix?: string);
+    updateStrapiName(): void;
+}

package/lib/src/interface/BuiltinComponentInterface.js

@@ -0,0 +1,36 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ComponentInterface_1 = __importDefault(require("./ComponentInterface"));
+var BuiltinComponentInterface = /** @class */ (function (_super) {
+    __extends(BuiltinComponentInterface, _super);
+    function BuiltinComponentInterface(baseName, attributes, relativeDirectoryPath, prefix) {
+        if (prefix === void 0) { prefix = ''; }
+        return _super.call(this, baseName, attributes, relativeDirectoryPath, 'builtins', prefix, {
+            hasId: false,
+            hasComponent: false,
+        }) || this;
+    }
+    BuiltinComponentInterface.prototype.updateStrapiName = function () {
+        this.StrapiName = "builtins::".concat(this.BaseName);
+    };
+    return BuiltinComponentInterface;
+}(ComponentInterface_1.default));
+exports.default = BuiltinComponentInterface;

package/lib/src/interface/BuiltinInterface.d.ts

@@ -0,0 +1,5 @@
+import Interface from './Interface';
+export default class BuiltinInterface extends Interface {
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, prefix?: string);
+    updateStrapiName(): void;
+}

package/lib/src/interface/BuiltinInterface.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Interface_1 = __importDefault(require("./Interface"));
+var BuiltinInterface = /** @class */ (function (_super) {
+    __extends(BuiltinInterface, _super);
+    function BuiltinInterface(baseName, attributes, relativeDirectoryPath, prefix) {
+        if (prefix === void 0) { prefix = ''; }
+        return _super.call(this, baseName, attributes, relativeDirectoryPath, prefix) || this;
+    }
+    BuiltinInterface.prototype.updateStrapiName = function () {
+        this.StrapiName = "builtins::".concat(this.BaseName);
+    };
+    return BuiltinInterface;
+}(Interface_1.default));
+exports.default = BuiltinInterface;

package/lib/src/interface/ComponentInterface.d.ts

@@ -0,0 +1,8 @@
+import Interface from './Interface';
+export default class ComponentInterface extends Interface {
+    protected Category: string;
+    protected Options: Record<string, any>;
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, category: string, prefix?: string, options?: Record<string, any>);
+    updateStrapiName(): void;
+    getInterfaceFieldsString(): string;
+}

package/lib/src/interface/ComponentInterface.js

@@ -0,0 +1,58 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Interface_1 = __importDefault(require("./Interface"));
+var ComponentInterface = /** @class */ (function (_super) {
+    __extends(ComponentInterface, _super);
+    function ComponentInterface(baseName, attributes, relativeDirectoryPath, category, prefix, options) {
+        if (prefix === void 0) { prefix = ''; }
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this, baseName, attributes, relativeDirectoryPath, prefix) || this;
+        _this.Options = {
+            hasId: true,
+            hasComponent: true,
+        };
+        _this.Category = category;
+        // this.Attributes.id = {
+        //     type: "number", // Components have a id field with a number
+        //     required: true,
+        // };
+        _this.updateStrapiName();
+        Object.assign(_this.Options, options);
+        return _this;
+    }
+    ComponentInterface.prototype.updateStrapiName = function () {
+        this.StrapiName = "".concat(this.Category, ".").concat(this.getBaseName());
+    };
+    ComponentInterface.prototype.getInterfaceFieldsString = function () {
+        var attrs = this.getAttributes();
+        var str = '';
+        var _a = this.Options, hasId = _a.hasId, hasComponent = _a.hasComponent;
+        if (hasId) {
+            str += '  id: number;\n';
+        }
+        if (hasComponent) {
+            str += "  __component: \"".concat(this.getStrapiName(), "\";\n");
+        }
+        return str + attrs.toFieldsString();
+    };
+    return ComponentInterface;
+}(Interface_1.default));
+exports.default = ComponentInterface;

package/lib/src/interface/Interface.d.ts

@@ -0,0 +1,31 @@
+import Attributes from './Attributes';
+export declare type RelationNames = Record<string, {
+    name: string;
+    inter: Interface;
+}>;
+export default class Interface {
+    protected BaseName: string;
+    private Relations;
+    private RelationNames;
+    private RelationNamesCounter;
+    private NamePrefix;
+    protected Attributes: any;
+    private RelativeDirectoryPath;
+    protected StrapiName: string;
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, prefix?: string);
+    protected updateStrapiName(): void;
+    getBaseName(): string;
+    getStrapiName(): string;
+    getDependencies(): any[];
+    getFullInterfaceName(): string;
+    getRelativeRootPath(): any;
+    getRelativeRootDir(): string;
+    getRelativeRootPathFile(): string;
+    setRelations(relations: Interface[]): void;
+    private getTsImports;
+    getAttributes(): Attributes;
+    attributesToString(): string;
+    getInerfaceString(): string;
+    getInterfaceFieldsString(): string;
+    toString(): string;
+}