@oak-digital/types-4-strapi-2 0.3.6 → 0.5.0

package/lib/file/File.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = void 0;
+var utils_1 = require("../utils");
+var posix_1 = require("path/posix");
+var casing_1 = require("../utils/casing");
+var File = /** @class */ (function () {
+    function File(baseName, relativeDirectoryPath, fileCaseType) {
+        if (fileCaseType === void 0) { fileCaseType = 'pascal'; }
+        this.Relations = []; // Components and relations
+        this.RelationNames = {};
+        this.RelationNamesCounter = {};
+        this.BaseName = baseName;
+        this.StrapiName = '';
+        this.FileCase = fileCaseType;
+        this.RelativeDirectoryPath = relativeDirectoryPath;
+    }
+    File.prototype.setRelations = function (relations) {
+        var _this = this;
+        this.Relations = relations;
+        this.RelationNames = {};
+        this.RelationNamesCounter = {};
+        this.Relations.forEach(function (file) {
+            var name = file.getFullName();
+            // FIXME: clean up this mess...
+            if (file.getStrapiName() !== _this.getStrapiName()) {
+                // Avoid duplicate names
+                if (name in _this.RelationNamesCounter) {
+                    name += ++_this.RelationNamesCounter[name];
+                }
+                else {
+                    _this.RelationNamesCounter[name] = 0;
+                }
+            }
+            _this.RelationNames[file.getStrapiName()] = { name: name, file: file };
+        });
+    };
+    // For typescript import from index file
+    File.prototype.getRelativeRootPath = function () {
+        var path = (0, posix_1.join)(this.RelativeDirectoryPath, this.getFileBaseName());
+        return (0, utils_1.prefixDotSlash)(path);
+    };
+    File.prototype.getBaseName = function () {
+        return this.BaseName;
+    };
+    File.prototype.getRelativeRootPathFile = function () {
+        return "".concat(this.getRelativeRootPath(), ".ts");
+    };
+    File.prototype.getRelativeRootDir = function () {
+        var path = (0, posix_1.dirname)(this.getRelativeRootPathFile());
+        return path;
+    };
+    File.prototype.getFileBaseName = function () {
+        return (0, casing_1.changeCase)(this.getBaseName(), this.FileCase);
+    };
+    File.prototype.getTsImports = function () {
+        var _this = this;
+        return Object.keys(this.RelationNames).map(function (strapiName) {
+            if (strapiName === _this.getStrapiName()) {
+                return '';
+            }
+            var relationName = _this.RelationNames[strapiName].name;
+            var inter = _this.RelationNames[strapiName].file;
+            var importPath = (0, utils_1.prefixDotSlash)((0, posix_1.relative)(_this.getRelativeRootDir(), inter.getRelativeRootPath()));
+            var fullName = inter.getFullName();
+            var importNameString = fullName === relationName ? fullName : "".concat(fullName, " as ").concat(relationName);
+            return "import { ".concat(importNameString, " } from '").concat(importPath, "';");
+        }).filter(function (s) { return s; }).join('\n');
+    };
+    return File;
+}());
+exports.File = File;

package/lib/index.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var commander_1 = require("commander");
-var InterfaceManager_1 = __importDefault(require("./interface/InterfaceManager"));
+var InterfaceManager_1 = __importDefault(require("./program/InterfaceManager"));
 commander_1.program
     .name('t4s');
 commander_1.program

package/lib/interface/BuiltinComponentInterface.d.ts

@@ -1,4 +1,4 @@
-import { caseType } from '../case';
+import { caseType } from '../utils/casing';
 import ComponentInterface from './ComponentInterface';
 export default class BuiltinComponentInterface extends ComponentInterface {
     constructor(baseName: string, attributes: any, relativeDirectoryPath: string, fileCase: caseType, prefix?: string);

package/lib/interface/BuiltinInterface.d.ts

@@ -1,4 +1,4 @@
-import { caseType } from '../case';
+import { caseType } from '../utils/casing';
 import Interface from './Interface';
 export default class BuiltinInterface extends Interface {
     constructor(baseName: string, attributes: any, relativeDirectoryPath: string, fileCase: caseType, prefix?: string);

package/lib/interface/ComponentInterface.d.ts

@@ -1,9 +1,10 @@
-import { caseType } from '../case';
+import { caseType } from '../utils/casing';
 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, fileCase: caseType, prefix?: string, options?: Record<string, any>);
     updateStrapiName(): void;
+    getInerfaceString(): string;
     getInterfaceFieldsString(): string;
 }

package/lib/interface/ComponentInterface.js

@@ -18,6 +18,7 @@ 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 Interface_1 = __importDefault(require("./Interface"));
 var ComponentInterface = /** @class */ (function (_super) {
     __extends(ComponentInterface, _super);
@@ -41,6 +42,38 @@ var ComponentInterface = /** @class */ (function (_super) {
     ComponentInterface.prototype.updateStrapiName = function () {
         this.StrapiName = "".concat(this.Category, ".").concat(this.getBaseName());
     };
+    // TODO: make this more dynamic in parent
+    ComponentInterface.prototype.getInerfaceString = function () {
+        var isPopulatable = this.hasPopulatableAttributes();
+        /* const populateString = isPopulatable ? `<${POPULATE_GENERIC_NAME} extends string | never = never>` : ''; */
+        var strArr = [];
+        if (isPopulatable) {
+            strArr.push("export type ".concat(this.getFullName()));
+        }
+        else {
+            strArr.push("export interface ".concat(this.getFullName()));
+        }
+        if (isPopulatable) {
+            strArr.push("<".concat(constants_1.POPULATE_GENERIC_NAME, " extends string | never = never>"));
+            strArr.push(" = ".concat(this.RelationNames['builtins::RequiredBy'].name, "<"));
+        }
+        strArr.push(' {\n');
+        strArr.push(this.getInterfaceFieldsString());
+        strArr.push('}');
+        if (isPopulatable) {
+            strArr.push(', ');
+            strArr.push(this.RelationNames['builtins::ExtractFlat'].name);
+            // extract flat start
+            strArr.push('<');
+            strArr.push(constants_1.POPULATE_GENERIC_NAME);
+            // extract flat end
+            strArr.push('>');
+            // required by end
+            strArr.push('>');
+        }
+        var str = strArr.join('');
+        return str;
+    };
     ComponentInterface.prototype.getInterfaceFieldsString = function () {
         var attrs = this.getAttributes();
         var str = '';

package/lib/interface/Interface.d.ts

@@ -1,31 +1,15 @@
-import { caseType } from '../case';
-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;
+import { caseType } from '../utils/casing';
+import Attributes from '../attributes/Attributes';
+import { File } from '../file/File';
+export default class Interface extends File {
     private NamePrefix;
     protected Attributes: any;
-    private RelativeDirectoryPath;
-    protected StrapiName: string;
-    protected FileCase: caseType;
     constructor(baseName: string, attributes: any, relativeDirectoryPath: string, fileCaseType?: caseType, prefix?: string);
     protected updateStrapiName(): void;
-    getBaseName(): string;
     getStrapiName(): string;
-    getDependencies(): any[];
-    getFullInterfaceName(): string;
-    getFileBaseName(): string;
-    getRelativeRootPath(): any;
-    getRelativeRootDir(): string;
-    getRelativeRootPathFile(): string;
-    setRelations(relations: Interface[]): void;
-    private getTsImports;
+    getDependencies(): string[];
+    getFullName(): string;
+    hasPopulatableAttributes(): boolean;
     getAttributes(): Attributes;
     attributesToString(): string;
     getInerfaceString(): string;

package/lib/interface/Interface.js

@@ -1,92 +1,54 @@
 "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 posix_1 = require("path/posix");
-var case_1 = require("../case");
-var utils_1 = require("../utils");
-var Attributes_1 = __importDefault(require("./Attributes"));
+var Attributes_1 = __importDefault(require("../attributes/Attributes"));
 var change_case_1 = require("change-case");
-var Interface = /** @class */ (function () {
+var constants_1 = require("../constants");
+var File_1 = require("../file/File");
+var Interface = /** @class */ (function (_super) {
+    __extends(Interface, _super);
     function Interface(baseName, attributes, relativeDirectoryPath, fileCaseType, prefix) {
         if (fileCaseType === void 0) { fileCaseType = 'pascal'; }
         if (prefix === void 0) { prefix = ''; }
-        this.Relations = []; // Components and relations
-        this.RelationNames = {};
-        this.RelationNamesCounter = {};
-        this.NamePrefix = '';
-        this.BaseName = baseName;
-        this.updateStrapiName();
-        this.NamePrefix = prefix;
-        this.Attributes = attributes;
-        this.RelativeDirectoryPath = relativeDirectoryPath;
-        this.FileCase = fileCaseType;
+        var _this = _super.call(this, baseName, relativeDirectoryPath, fileCaseType) || this;
+        _this.NamePrefix = '';
+        _this.updateStrapiName();
+        _this.NamePrefix = prefix;
+        _this.Attributes = attributes;
+        return _this;
     }
     Interface.prototype.updateStrapiName = function () {
         this.StrapiName = "api::".concat(this.BaseName, ".").concat(this.BaseName);
     };
-    Interface.prototype.getBaseName = function () {
-        return this.BaseName;
-    };
     Interface.prototype.getStrapiName = function () {
         return this.StrapiName;
     };
     Interface.prototype.getDependencies = function () {
-        var attrs = new Attributes_1.default(this.Attributes, this.RelationNames);
-        return attrs.getDependencies();
+        return this.getAttributes().getDependencies();
     };
-    Interface.prototype.getFullInterfaceName = function () {
+    Interface.prototype.getFullName = function () {
         var pascalName = (0, change_case_1.pascalCase)(this.BaseName);
         return "".concat(this.NamePrefix).concat(pascalName);
     };
-    Interface.prototype.getFileBaseName = function () {
-        return (0, case_1.changeCase)(this.getBaseName(), this.FileCase);
-    };
-    // For typescript import from index file
-    Interface.prototype.getRelativeRootPath = function () {
-        var path = (0, posix_1.join)(this.RelativeDirectoryPath, this.getFileBaseName());
-        return (0, utils_1.prefixDotSlash)(path);
-    };
-    Interface.prototype.getRelativeRootDir = function () {
-        var path = (0, posix_1.dirname)(this.getRelativeRootPathFile());
-        return path;
-    };
-    Interface.prototype.getRelativeRootPathFile = function () {
-        return "".concat(this.getRelativeRootPath(), ".ts");
-    };
-    Interface.prototype.setRelations = function (relations) {
-        var _this = this;
-        this.Relations = relations;
-        this.RelationNames = {};
-        this.Relations.forEach(function (inter) {
-            var name = inter.getFullInterfaceName();
-            // FIXME: clean up this mess...
-            if (inter.getStrapiName() !== _this.getStrapiName()) {
-                // Avoid duplicate names
-                if (name in _this.RelationNamesCounter) {
-                    name += ++_this.RelationNamesCounter[name];
-                }
-                else {
-                    _this.RelationNamesCounter[name] = 0;
-                }
-            }
-            _this.RelationNames[inter.getStrapiName()] = { name: name, inter: inter };
-        });
-    };
-    Interface.prototype.getTsImports = function () {
-        var _this = this;
-        return Object.keys(this.RelationNames).map(function (strapiName) {
-            if (strapiName === _this.getStrapiName()) {
-                return '';
-            }
-            var relationName = _this.RelationNames[strapiName].name;
-            var inter = _this.RelationNames[strapiName].inter;
-            var importPath = (0, utils_1.prefixDotSlash)((0, posix_1.relative)(_this.getRelativeRootDir(), inter.getRelativeRootPath()));
-            var fullName = inter.getFullInterfaceName();
-            var importNameString = fullName === relationName ? fullName : "".concat(fullName, " as ").concat(relationName);
-            return "import { ".concat(importNameString, " } from '").concat(importPath, "';");
-        }).filter(function (s) { return s; }).join('\n');
+    Interface.prototype.hasPopulatableAttributes = function () {
+        return this.getAttributes().hasPopulatableAttributes();
     };
     Interface.prototype.getAttributes = function () {
         return new Attributes_1.default(this.Attributes, this.RelationNames);
@@ -96,24 +58,42 @@ var Interface = /** @class */ (function () {
         return attrs.toString();
     };
     Interface.prototype.getInerfaceString = function () {
-        var str = "export interface ".concat(this.getFullInterfaceName(), " {\n");
-        str += this.getInterfaceFieldsString();
-        str += '}';
+        var isPopulatable = this.hasPopulatableAttributes();
+        /* const populateString = isPopulatable ? `<${POPULATE_GENERIC_NAME} extends string | never = never>` : ''; */
+        var strArr = ["export interface ".concat(this.getFullName())];
+        if (isPopulatable) {
+            strArr.push("<".concat(constants_1.POPULATE_GENERIC_NAME, " extends string | never = never>"));
+        }
+        strArr.push(' {\n');
+        strArr.push(this.getInterfaceFieldsString());
+        strArr.push('}');
+        var str = strArr.join('');
         return str;
     };
     Interface.prototype.getInterfaceFieldsString = function () {
-        var str = '';
-        str += 'id: number;\n';
-        str += "attributes: ".concat(this.attributesToString(), "\n");
-        return str;
+        var populatable = this.hasPopulatableAttributes();
+        var strArr = [];
+        strArr.push('id: number;\n');
+        strArr.push("attributes: ");
+        if (populatable) {
+            strArr.push("RequiredBy<");
+        }
+        strArr.push("".concat(this.attributesToString()));
+        if (populatable) {
+            // The comma for required by
+            strArr.push(', ');
+            // second generic for required by
+            strArr.push("".concat(this.RelationNames['builtins::ExtractFlat'].name, "<").concat(constants_1.POPULATE_GENERIC_NAME, ">"));
+            // close the required by
+            strArr.push('>');
+        }
+        strArr.push("\n");
+        return strArr.join('');
     };
     Interface.prototype.toString = function () {
-        var strings = [
-            this.getTsImports(),
-            this.getInerfaceString()
-        ];
+        var strings = [this.getTsImports(), this.getInerfaceString()];
         return strings.join('\n');
     };
     return Interface;
-}());
+}(File_1.File));
 exports.default = Interface;

package/lib/interface/builtinInterfaces.d.ts

@@ -1,4 +1,4 @@
-import { caseType } from '../case';
+import { caseType } from '../utils/casing';
 import BuiltinComponentInterface from './BuiltinComponentInterface';
 import BuiltinInterface from './BuiltinInterface';
 export declare function createMediaInterface(directory: string, caseTypeName: caseType, prefix: string): BuiltinInterface;

package/lib/plugins/PluginManager.d.ts

@@ -0,0 +1,20 @@
+import InterfaceManager from '../program/InterfaceManager';
+export declare type HookTypes = {
+    BeforeReadSchema: (state: InterfaceManager, schema: any) => void;
+    AfterReadSchema: (state: InterfaceManager, schema: any) => void;
+    BeforeReadSchemas: (state: InterfaceManager) => void;
+    AfterReadSchemas: (state: InterfaceManager) => void;
+};
+export declare type HooksType = {
+    [HookType in keyof HookTypes]: {
+        fn: HookTypes[HookType];
+        priority: number;
+    }[];
+};
+export declare class PluginManager {
+    hooks: HooksType;
+    registerPlugin(hooks: Partial<HooksType>): void;
+    registerHook<Hook extends keyof HookTypes>(hook: Hook, fn: HookTypes[Hook], priority: number): void;
+    sortHooks(): void;
+    invoke<Hook extends keyof HookTypes>(hook: Hook, ...args: Parameters<HookTypes[Hook]>): void;
+}

package/lib/plugins/PluginManager.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+var PluginManager = /** @class */ (function () {
+    function PluginManager() {
+        this.hooks = {
+            BeforeReadSchema: [],
+            BeforeReadSchemas: [],
+            AfterReadSchema: [],
+            AfterReadSchemas: [],
+        };
+    }
+    PluginManager.prototype.registerPlugin = function (hooks) {
+        var _a;
+        for (var hook in hooks) {
+            if (hooks[hook]) {
+                (_a = this.hooks[hook]).push.apply(_a, hooks[hook]);
+            }
+        }
+    };
+    PluginManager.prototype.registerHook = function (hook, fn, priority) {
+        this.hooks[hook].push({ fn: fn, priority: priority });
+    };
+    PluginManager.prototype.sortHooks = function () {
+        for (var hook in this.hooks) {
+            this.hooks[hook].sort(function (a, b) { return a.priority - b.priority; });
+        }
+    };
+    PluginManager.prototype.invoke = function (hook) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        this.hooks[hook].forEach(function (hook) {
+            // @ts-ignore we know that it is the correct type, sunce HooksType is built from HookTypes
+            hook.fn.apply(hook, args);
+        });
+    };
+    return PluginManager;
+}());
+exports.PluginManager = PluginManager;

package/lib/plugins/index.d.ts

@@ -1,3 +1,3 @@
-import EventEmitter from "events";
-import { SupportedPluginNamesType } from "./types";
-export declare const registerPlugins: (pluginNames: Set<SupportedPluginNamesType>, eventEmitter: EventEmitter) => void;
+import { SupportedPluginNamesType } from './types';
+import { PluginManager } from './PluginManager';
+export declare const registerBuiltinPlugins: (pluginManager: PluginManager, pluginNames: Set<SupportedPluginNamesType>) => void;

package/lib/plugins/index.js

@@ -3,11 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerPlugins = void 0;
+exports.registerBuiltinPlugins = void 0;
 var url_alias_1 = __importDefault(require("./url-alias"));
-var registerPlugins = function (pluginNames, eventEmitter) {
+var registerBuiltinPlugins = function (pluginManager, pluginNames) {
     if (pluginNames.has('url-alias')) {
-        (0, url_alias_1.default)(eventEmitter);
+        pluginManager.registerPlugin((0, url_alias_1.default)());
     }
 };
-exports.registerPlugins = registerPlugins;
+exports.registerBuiltinPlugins = registerBuiltinPlugins;

package/lib/plugins/url-alias/index.d.ts

@@ -1,3 +1,3 @@
-import EventEmitter from "events";
-declare const register: (eventEmitter: EventEmitter) => void;
+import { HooksType } from '../PluginManager';
+declare const register: () => Partial<HooksType>;
 export default register;

package/lib/plugins/url-alias/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var events_1 = require("../../events");
-var addUrlAliasToAllContentTypes = function (_a) {
+var addUrlAliasToAllContentTypes = function (state, _a) {
     var apiSchemas = _a.apiSchemas;
     apiSchemas.forEach(function (schema) {
         var attributes = schema.attributes;
@@ -16,7 +16,15 @@ var addUrlAliasToAllContentTypes = function (_a) {
         // };
     });
 };
-var register = function (eventEmitter) {
-    eventEmitter.on(events_1.Events.AfterReadSchema, addUrlAliasToAllContentTypes);
+var register = function () {
+    var _a;
+    return _a = {},
+        _a[events_1.Events.AfterReadSchema] = [
+            {
+                fn: addUrlAliasToAllContentTypes,
+                priority: 10,
+            },
+        ],
+        _a;
 };
 exports.default = register;

package/lib/program/InterfaceManager.d.ts

@@ -0,0 +1,39 @@
+export default class InterfaceManager {
+    private Interfaces;
+    private Files;
+    private OutRoot;
+    private StrapiSrcRoot;
+    private Options;
+    private PrettierOptions;
+    private PluginManager;
+    static BaseOptions: {
+        prefix: string;
+        useCategoryPrefix: boolean;
+        componentPrefix: string;
+        componentPrefixOverridesPrefix: boolean;
+        builtinsPrefix: string;
+        builtinsPrefixOverridesPrefix: boolean;
+        deleteOld: boolean;
+        prettierFile: any;
+        fileCaseType: "camel" | "capital" | "dot" | "snake" | "pascal" | "constant" | "kebab";
+        folderCaseType: "camel" | "capital" | "dot" | "snake" | "pascal" | "constant" | "kebab";
+        enabledPlugins: "url-alias"[];
+    };
+    constructor(outRoot: string, strapiSrcRoot: string, options?: Partial<typeof InterfaceManager['BaseOptions']>);
+    registerBuiltinPlugins(): void;
+    registerPlugin(): void;
+    validateOptions(): void;
+    loadPrettierConfig(): Promise<void>;
+    readSchemas(): Promise<{
+        apiSchemas: any[];
+        componentSchemas: any[];
+    }>;
+    createInterfaces(): Promise<void>;
+    createBuiltinInterfaces(): void;
+    injectDependencies(): void;
+    deleteOldFolders(): Promise<void>;
+    makeFolders(): Promise<void>;
+    writeInterfaces(): Promise<void>;
+    writeIndexFile(): Promise<void>;
+    run(): Promise<void>;
+}