@oak-digital/types-4-strapi-2 0.2.0 → 0.2.3

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;
+}

package/lib/src/interface/Interface.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = require("path");
+var utils_1 = require("../utils");
+var Attributes_1 = __importDefault(require("./Attributes"));
+var Interface = /** @class */ (function () {
+    function Interface(baseName, attributes, relativeDirectoryPath, prefix) {
+        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;
+    }
+    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();
+    };
+    Interface.prototype.getFullInterfaceName = function () {
+        var pascalName = (0, utils_1.pascalCase)(this.BaseName);
+        return "".concat(this.NamePrefix).concat(pascalName);
+    };
+    // For typescript import from index file
+    Interface.prototype.getRelativeRootPath = function () {
+        var path = (0, path_1.join)(this.RelativeDirectoryPath, this.getBaseName());
+        return (0, utils_1.prefixDotSlash)(path);
+    };
+    Interface.prototype.getRelativeRootDir = function () {
+        var path = (0, path_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, path_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.getAttributes = function () {
+        return new Attributes_1.default(this.Attributes, this.RelationNames);
+    };
+    Interface.prototype.attributesToString = function () {
+        var attrs = this.getAttributes();
+        return attrs.toString();
+    };
+    Interface.prototype.getInerfaceString = function () {
+        var str = "export interface ".concat(this.getFullInterfaceName(), " {\n");
+        str += this.getInterfaceFieldsString();
+        str += '}';
+        return str;
+    };
+    Interface.prototype.getInterfaceFieldsString = function () {
+        var str = '';
+        str += 'id: number;\n';
+        str += "attributes: ".concat(this.attributesToString(), "\n");
+        return str;
+    };
+    Interface.prototype.toString = function () {
+        var strings = [
+            this.getTsImports(),
+            this.getInerfaceString()
+        ];
+        return strings.join('\n');
+    };
+    return Interface;
+}());
+exports.default = Interface;

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

@@ -0,0 +1,25 @@
+export default class InterfaceManager {
+    private Interfaces;
+    private OutRoot;
+    private StrapiSrcRoot;
+    private Options;
+    private PrettierOptions;
+    static BaseOptions: {
+        prefix: string;
+        useCategoryPrefix: boolean;
+        componentPrefix: string;
+        componentPrefixOverridesPrefix: boolean;
+        builtinsPrefix: string;
+        builtinsPrefixOverridesPrefix: boolean;
+        prettierFile: any;
+    };
+    constructor(outRoot: string, strapiSrcRoot: string, options?: any);
+    loadPrettierConfig(): Promise<void>;
+    createInterfaces(): Promise<void>;
+    createBuiltinInterfaces(): void;
+    injectDependencies(): void;
+    makeFolders(): Promise<void>;
+    writeInterfaces(): Promise<void>;
+    writeIndexFile(): Promise<void>;
+    run(): Promise<void>;
+}