@oak-digital/types-4-strapi-2 0.5.3 → 0.5.4

package/lib/content-types/reader.d.ts

@@ -5,10 +5,10 @@ export declare function getComponentSchemas(strapiSrcRoot: string): Promise<{
     category: string;
     schemas: {
         name: string;
-        attributes: any;
+        schema: any;
     }[];
 }[]>;
 export declare function getApiSchemas(strapiSrcRoot: string): Promise<{
     name: string;
-    attributes: any;
+    schema: any;
 }[]>;

package/lib/content-types/reader.js

@@ -51,7 +51,7 @@ function readSchema(schemaPath) {
                     return [4 /*yield*/, (0, promises_1.readFile)(schemaPath)];
                 case 1:
                     schemaData = _a.sent();
-                    return [2 /*return*/, JSON.parse(schemaData.toString()).attributes];
+                    return [2 /*return*/, JSON.parse(schemaData.toString())];
                 case 2:
                     e_1 = _a.sent();
                     return [2 /*return*/, null];
@@ -117,16 +117,16 @@ function getComponentSchemas(strapiSrcRoot) {
                                 case 1:
                                     schemaFiles = _a.sent();
                                     schemaNamesWithAttributesPromises = schemaFiles.map(function (file) { return __awaiter(_this, void 0, void 0, function () {
-                                        var schemaPath, attributes, name;
+                                        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:
-                                                    attributes = _a.sent();
+                                                    schema = _a.sent();
                                                     name = file.split('.')[0];
-                                                    return [2 /*return*/, { name: name, attributes: attributes }];
+                                                    return [2 /*return*/, { name: name, schema: schema }];
                                             }
                                         });
                                     }); });
@@ -156,15 +156,15 @@ function getApiSchemas(strapiSrcRoot) {
                 case 1:
                     apiFolders = _a.sent();
                     schemasWithAttributesPromises = apiFolders.map(function (folder) { return __awaiter(_this, void 0, void 0, function () {
-                        var schemaPath, attributes;
+                        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:
-                                    attributes = _a.sent();
-                                    return [2 /*return*/, { name: folder, attributes: attributes }];
+                                    schema = _a.sent();
+                                    return [2 /*return*/, { name: folder, schema: schema }];
                             }
                         });
                     }); });

package/lib/events/index.d.ts

@@ -1,6 +1,11 @@
 export declare enum Events {
     BeforeReadSchema = "BeforeReadSchema",
-    AfterReadSchema = "AfterReadSchema"
+    AfterReadSchema = "AfterReadSchema",
+    BeforeReadSchemas = "BeforeReadSchemas",
+    AfterReadSchemas = "AfterReadSchemas",
+    ModifySchemas = "ModifySchemas",
+    BeforeInjectDependencies = "BeforeInjectDependencies",
+    AfterInjectDependencies = "AfterInjectDependencies"
 }
 export declare type SchemasType = {
     apiSchemas: Record<string, any>[];

package/lib/events/index.js

@@ -5,4 +5,9 @@ var Events;
 (function (Events) {
     Events["BeforeReadSchema"] = "BeforeReadSchema";
     Events["AfterReadSchema"] = "AfterReadSchema";
+    Events["BeforeReadSchemas"] = "BeforeReadSchemas";
+    Events["AfterReadSchemas"] = "AfterReadSchemas";
+    Events["ModifySchemas"] = "ModifySchemas";
+    Events["BeforeInjectDependencies"] = "BeforeInjectDependencies";
+    Events["AfterInjectDependencies"] = "AfterInjectDependencies";
 })(Events = exports.Events || (exports.Events = {}));

package/lib/interface/Interface.js

@@ -32,9 +32,13 @@ var Interface = /** @class */ (function (_super) {
         _this.updateStrapiName();
         _this.NamePrefix = prefix;
         _this.Attributes = attributes;
+        if (!attributes) {
+            console.warn("Warning: attributes for ".concat(_this.getStrapiName(), " is empty!"));
+        }
         return _this;
     }
     Interface.prototype.updateStrapiName = function () {
+        // TODO: add support for api name
         this.StrapiName = "api::".concat(this.BaseName, ".").concat(this.BaseName);
     };
     Interface.prototype.getStrapiName = function () {
@@ -44,6 +48,7 @@ var Interface = /** @class */ (function (_super) {
         return this.getAttributes().getDependencies();
     };
     Interface.prototype.getFullName = function () {
+        // TODO: use correct casing from options
         var pascalName = (0, change_case_1.pascalCase)(this.BaseName);
         return "".concat(this.NamePrefix).concat(pascalName);
     };

package/lib/plugins/PluginManager.d.ts

@@ -1,9 +1,13 @@
+import { Events } from '../events';
 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;
+    [Events.BeforeReadSchema]: (state: InterfaceManager, schema: any) => void;
+    [Events.AfterReadSchema]: (state: InterfaceManager, schema: any) => void;
+    [Events.BeforeReadSchemas]: (state: InterfaceManager) => void;
+    [Events.AfterReadSchemas]: (state: InterfaceManager) => void;
+    [Events.ModifySchemas]: (state: InterfaceManager) => void;
+    [Events.BeforeInjectDependencies]: (state: InterfaceManager) => void;
+    [Events.AfterInjectDependencies]: (state: InterfaceManager) => void;
 };
 export declare type HooksType = {
     [HookType in keyof HookTypes]: {

package/lib/plugins/PluginManager.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginManager = void 0;
+var events_1 = require("../events");
 var PluginManager = /** @class */ (function () {
     function PluginManager() {
-        this.hooks = {
-            BeforeReadSchema: [],
-            BeforeReadSchemas: [],
-            AfterReadSchema: [],
-            AfterReadSchemas: [],
-        };
+        var _a;
+        this.hooks = (_a = {},
+            _a[events_1.Events.BeforeReadSchema] = [],
+            _a[events_1.Events.BeforeReadSchemas] = [],
+            _a[events_1.Events.AfterReadSchema] = [],
+            _a[events_1.Events.AfterReadSchemas] = [],
+            _a[events_1.Events.ModifySchemas] = [],
+            _a[events_1.Events.BeforeInjectDependencies] = [],
+            _a[events_1.Events.AfterInjectDependencies] = [],
+            _a);
     }
     PluginManager.prototype.registerPlugin = function (hooks) {
         var _a;

package/lib/plugins/draft-and-publish/index.d.ts

@@ -0,0 +1,3 @@
+import { PluginRegister } from "../types";
+declare const register: PluginRegister;
+export default register;

package/lib/plugins/draft-and-publish/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var constants_1 = require("../../constants");
+var events_1 = require("../../events");
+var addFieldsToContentTypes = function (state, schema) {
+    var apiSchemas = schema.apiSchemas;
+    apiSchemas.forEach(function (_a) {
+        var name = _a.name, schema = _a.schema;
+        var attributes = schema.attributes, _b = schema.options, options = _b === void 0 ? {} : _b;
+        if ((options === null || options === void 0 ? void 0 : options.draftAndPublish) !== true) {
+            return;
+        }
+        var fieldNames = ['publishedAt', 'createdAt', 'updatedAt'];
+        fieldNames.forEach(function (fieldName) {
+            var _a;
+            attributes[fieldName] = (_a = {
+                    type: 'string',
+                    required: true
+                },
+                _a[constants_1.CERTAINLY_REQUIRED_KEY] = true,
+                _a);
+        });
+    });
+};
+var register = function () {
+    var _a;
+    return _a = {},
+        _a[events_1.Events.AfterReadSchema] = [
+            {
+                fn: addFieldsToContentTypes,
+                priority: 10,
+            },
+        ],
+        _a;
+};
+exports.default = register;

package/lib/plugins/i18n/index.d.ts

@@ -0,0 +1,3 @@
+import { PluginRegister } from "../types";
+declare const register: PluginRegister;
+export default register;

package/lib/plugins/i18n/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var constants_1 = require("../../constants");
+var events_1 = require("../../events");
+var addLocaleToLocalizedContentTypes = function (state, _a) {
+    var apiSchemas = _a.apiSchemas;
+    apiSchemas.forEach(function (_a) {
+        var _b;
+        var _c, _d;
+        var name = _a.name, schema = _a.schema;
+        var attributes = schema.attributes;
+        if (((_d = (_c = schema === null || schema === void 0 ? void 0 : schema.pluginOptions) === null || _c === void 0 ? void 0 : _c.i18n) === null || _d === void 0 ? void 0 : _d.localized) !== true) {
+            return;
+        }
+        // Add locale to all localized content types
+        attributes.locale = (_b = {
+                type: 'string',
+                required: true
+            },
+            _b[constants_1.CERTAINLY_REQUIRED_KEY] = true,
+            _b);
+        // Add populatable field for localizations
+        attributes.localizations = {
+            type: 'relation',
+            relation: 'oneToMany',
+            target: "api::".concat(name, ".").concat(name), // TODO: make this more complete
+        };
+    });
+};
+var register = function () {
+    var _a;
+    return _a = {},
+        _a[events_1.Events.AfterReadSchema] = [
+            {
+                fn: addLocaleToLocalizedContentTypes,
+                priority: 10,
+            },
+        ],
+        _a;
+};
+exports.default = register;

package/lib/plugins/index.js

@@ -5,9 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerBuiltinPlugins = void 0;
 var url_alias_1 = __importDefault(require("./url-alias"));
+var draft_and_publish_1 = __importDefault(require("./draft-and-publish"));
+var i18n_1 = __importDefault(require("./i18n"));
 var registerBuiltinPlugins = function (pluginManager, pluginNames) {
+    // Draft and publish is always registered since it is built into Strapi
+    pluginManager.registerPlugin((0, draft_and_publish_1.default)());
     if (pluginNames.has('url-alias')) {
         pluginManager.registerPlugin((0, url_alias_1.default)());
     }
+    if (pluginNames.has('i18n')) {
+        pluginManager.registerPlugin((0, i18n_1.default)());
+    }
 };
 exports.registerBuiltinPlugins = registerBuiltinPlugins;

package/lib/plugins/types.d.ts

@@ -1,2 +1,4 @@
-export declare const supportedPluginNames: readonly ["url-alias"];
+import { HooksType } from "./PluginManager";
+export declare const supportedPluginNames: readonly ["url-alias", "i18n"];
 export declare type SupportedPluginNamesType = typeof supportedPluginNames[number];
+export declare type PluginRegister = () => Partial<HooksType>;

package/lib/plugins/types.js

@@ -3,4 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.supportedPluginNames = void 0;
 exports.supportedPluginNames = [
     'url-alias',
+    'i18n',
 ];

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

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

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

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var events_1 = require("../../events");
+var type_1 = require("./type");
 var addUrlAliasToAllContentTypes = function (state, _a) {
     var apiSchemas = _a.apiSchemas;
-    apiSchemas.forEach(function (schema) {
+    apiSchemas.forEach(function (_a) {
+        var name = _a.name, schema = _a.schema;
         var attributes = schema.attributes;
+        // TODO: write comment here if it is intentional that it it can be null
         attributes.url_path = {
             type: 'string',
             required: true,
@@ -16,6 +19,10 @@ var addUrlAliasToAllContentTypes = function (state, _a) {
         // };
     });
 };
+var addUrlAliasGetType = function (state) {
+    var urlAliasGet = new type_1.UrlAliasGet();
+    state.addType(urlAliasGet.getStrapiName(), urlAliasGet);
+};
 var register = function () {
     var _a;
     return _a = {},
@@ -25,6 +32,12 @@ var register = function () {
                 priority: 10,
             },
         ],
+        _a[events_1.Events.AfterReadSchemas] = [
+            {
+                fn: addUrlAliasGetType,
+                priority: 10,
+            },
+        ],
         _a;
 };
 exports.default = register;

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

@@ -0,0 +1,8 @@
+import { File } from '../../file/File';
+export declare class UrlAliasGet extends File {
+    constructor();
+    getStrapiName(): string;
+    getFullName(): string;
+    getDependencies(): any[];
+    toString(): string;
+}

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

@@ -0,0 +1,41 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlAliasGet = void 0;
+var File_1 = require("../../file/File");
+/* import Interface from "../../interface/Interface"; */
+var UrlAliasGet = /** @class */ (function (_super) {
+    __extends(UrlAliasGet, _super);
+    function UrlAliasGet() {
+        var baseName = 'url-alias';
+        return _super.call(this, baseName, 'plugins/url-alias', 'pascal') || this;
+    }
+    UrlAliasGet.prototype.getStrapiName = function () {
+        return 'plugins::url-alias.get';
+    };
+    UrlAliasGet.prototype.getFullName = function () {
+        return 'UrlAliasGet';
+    };
+    UrlAliasGet.prototype.getDependencies = function () {
+        return [];
+    };
+    UrlAliasGet.prototype.toString = function () {
+        return "\n            export type ".concat(this.getFullName(), "<ContentType extends { attributes: {} }> = ContentType & {\n                attributes: {\n                    contentType: string;\n                },\n            }\n        ");
+    };
+    return UrlAliasGet;
+}(File_1.File));
+exports.UrlAliasGet = UrlAliasGet;

package/lib/program/InterfaceManager.d.ts

@@ -1,11 +1,12 @@
+import { File } from '../file/File';
 export default class InterfaceManager {
-    private Interfaces;
     private Files;
     private OutRoot;
     private StrapiSrcRoot;
     private Options;
     private PrettierOptions;
     private PluginManager;
+    private dependenciesInjected;
     static BaseOptions: {
         prefix: string;
         useCategoryPrefix: boolean;
@@ -17,7 +18,7 @@ export default class InterfaceManager {
         prettierFile: any;
         fileCaseType: "camel" | "capital" | "dot" | "snake" | "pascal" | "constant" | "kebab";
         folderCaseType: "camel" | "capital" | "dot" | "snake" | "pascal" | "constant" | "kebab";
-        enabledPlugins: "url-alias"[];
+        enabledPlugins: ("url-alias" | "i18n")[];
     };
     constructor(outRoot: string, strapiSrcRoot: string, options?: Partial<typeof InterfaceManager['BaseOptions']>);
     registerBuiltinPlugins(): void;
@@ -28,6 +29,7 @@ export default class InterfaceManager {
         apiSchemas: any[];
         componentSchemas: any[];
     }>;
+    addType(name: string, file: File, force?: boolean): boolean;
     createInterfaces(): Promise<void>;
     createBuiltinInterfaces(): void;
     injectDependencies(): void;

package/lib/program/InterfaceManager.js

@@ -78,9 +78,8 @@ var InterfaceManager = /** @class */ (function () {
     function InterfaceManager(outRoot, strapiSrcRoot, options) {
         if (options === void 0) { options = {}; }
         var _this = this;
-        // TODO: remove Interfaces
-        this.Interfaces = {}; // string = strapi name
         this.Files = {}; // string = strapi name
+        this.dependenciesInjected = false;
         this.OutRoot = outRoot;
         this.StrapiSrcRoot = strapiSrcRoot;
         this.Options = __assign(__assign({}, InterfaceManager.BaseOptions), options);
@@ -170,6 +169,17 @@ var InterfaceManager = /** @class */ (function () {
             });
         });
     };
+    InterfaceManager.prototype.addType = function (name, file, force) {
+        if (force === void 0) { force = false; }
+        if (this.dependenciesInjected) {
+            console.warn('You should not add types after dependencies have been injected');
+        }
+        if (this.Files[name] && !force) {
+            return false;
+        }
+        this.Files[name] = file;
+        return true;
+    };
     InterfaceManager.prototype.createInterfaces = function () {
         return __awaiter(this, void 0, void 0, function () {
             var _a, apiSchemas, componentSchemas;
@@ -179,18 +189,19 @@ var InterfaceManager = /** @class */ (function () {
                     case 0: return [4 /*yield*/, this.readSchemas()];
                     case 1:
                         _a = _b.sent(), apiSchemas = _a.apiSchemas, componentSchemas = _a.componentSchemas;
+                        this.PluginManager.invoke(events_1.Events.BeforeReadSchemas, this);
                         apiSchemas.forEach(function (schema) {
-                            var name = schema.name, attributes = schema.attributes;
+                            var name = schema.name, attributes = schema.schema.attributes;
                             var strapiName = "api::".concat(name, ".").concat(name);
                             var inter = new Interface_1.default(name, attributes, './', _this.Options.fileCaseType, _this.Options.prefix);
-                            _this.Interfaces[strapiName] = inter;
-                            _this.Files[strapiName] = inter;
+                            _this.addType(strapiName, inter);
                         });
                         componentSchemas.forEach(function (category) {
                             var categoryName = category.category;
-                            category.schemas.forEach(function (schema) {
-                                var componentName = schema.name;
-                                var strapiName = "".concat(categoryName, ".").concat(schema.name);
+                            category.schemas.forEach(function (_a) {
+                                var name = _a.name, schema = _a.schema;
+                                var componentName = name;
+                                var strapiName = "".concat(categoryName, ".").concat(name);
                                 var componentPrefix = "".concat(_this.Options.componentPrefix).concat(_this.Options.useCategoryPrefix
                                     ? (0, pascal_case_1.pascalCase)(categoryName)
                                     : '');
@@ -200,10 +211,10 @@ var InterfaceManager = /** @class */ (function () {
                                 var categoryFolderName = (0, casing_1.changeCase)(categoryName, _this.Options.folderCaseType);
                                 // make component interface
                                 var inter = new ComponentInterface_1.default(componentName, schema.attributes, "./".concat(categoryFolderName), categoryName, _this.Options.fileCaseType, prefix);
-                                _this.Interfaces[strapiName] = inter;
-                                _this.Files[strapiName] = inter;
+                                _this.addType(strapiName, inter);
                             });
                         });
+                        this.PluginManager.invoke(events_1.Events.AfterReadSchemas, this);
                         return [2 /*return*/];
                 }
             });
@@ -218,20 +229,19 @@ var InterfaceManager = /** @class */ (function () {
         builtinInterfaces.push((0, builtinInterfaces_1.createMediaInterface)(outDir, this.Options.fileCaseType, this.Options.prefix));
         builtinInterfaces.push((0, builtinInterfaces_1.createMediaFormatInterface)(outDir, this.Options.fileCaseType, this.Options.prefix));
         builtinInterfaces.forEach(function (inter) {
-            _this.Interfaces[inter.getStrapiName()] = inter;
-            _this.Files[inter.getStrapiName()] = inter;
+            _this.addType(inter.getStrapiName(), inter);
         });
         // Types
         var types = [];
         types.push.apply(types, (0, createExtraTypes_1.createExtraTypes)());
         types.forEach(function (t) {
-            _this.Files[t.getStrapiName()] = t;
+            _this.addType(t.getStrapiName(), t);
         });
     };
     // Inject dependencies into all interfaces
     InterfaceManager.prototype.injectDependencies = function () {
         var _this = this;
-        // console.log("Injecting dependencies")
+        this.PluginManager.invoke(events_1.Events.BeforeInjectDependencies, this);
         Object.keys(this.Files).forEach(function (strapiName) {
             var file = _this.Files[strapiName];
             var dependencies = file.getDependencies();
@@ -243,6 +253,8 @@ var InterfaceManager = /** @class */ (function () {
                 .filter(function (inter) { return inter; });
             file.setRelations(interfacesToInject);
         });
+        this.dependenciesInjected = true;
+        this.PluginManager.invoke(events_1.Events.AfterInjectDependencies, this);
     };
     InterfaceManager.prototype.deleteOldFolders = function () {
         return __awaiter(this, void 0, void 0, function () {
@@ -330,8 +342,13 @@ var InterfaceManager = /** @class */ (function () {
                                         fileData = file.toString();
                                         formattedFileData = prettier_1.default.format(fileData, this.PrettierOptions);
                                         filePath = (0, posix_1.join)(this.OutRoot, file.getRelativeRootPathFile());
-                                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, formattedFileData)];
+                                        return [4 /*yield*/, (0, promises_1.mkdir)((0, posix_1.dirname)(filePath), {
+                                                recursive: true,
+                                            })];
                                     case 1:
+                                        _a.sent();
+                                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, formattedFileData)];
+                                    case 2:
                                         _a.sent();
                                         return [2 /*return*/];
                                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oak-digital/types-4-strapi-2",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Typescript interface generator for Strapi 4 models",
   "bin": {
     "t4s": "./bin/index.js"