@oak-digital/types-4-strapi-2 0.1.1 → 0.2.1

package/README.md

@@ -0,0 +1,67 @@
+# types-4-strapi-2
+
+types-4-strapi-2 is a typescript program that will generate typescript types for your strapi projects.
+This can be useful if you have a frontend written with typescript to make sure you are using the correct types and can help report errors at compile time.
+
+types-4-strapi-2 is a rewrite of (francescolorenzetti/types-4-strapi)[https://github.com/francescolorenzetti/types-4-strapi] written in typescript, with the goal of being much easier to extend and maintain.
+
+## Getting started
+
+Install the script for your project:
+
+```bash
+npm install --save-dev @oak-digital/types-4-strapi-2
+```
+
+Then set up a script in your `package.json`
+
+```jsonc
+// package.json
+{
+    "scripts": {
+        "types": "t4s"
+    }
+}
+```
+
+In some cases it is desirable to change the output directory which is `./types` by default.
+This can be done with the `--out` flag like in the following example.
+
+```jsonc
+// package.json
+{
+    "scripts": {
+        "types": "t4s --out ../frontend/src/lib/types"
+    }
+}
+```
+
+## Features
+
+* Generate typescript interfaces for all your api content-types and components
+* Generate typescript interfaces for builtin types such as `Media` and `MediaFormat`
+* Select input and output directory
+
+### Planned features
+
+* Support if you are using other plugins, such as `url-alias`, which should add extra fields for some interfaces.
+* Nicer formatted interfaces
+
+## Help
+
+use `t4s --help` to display which options are available for you
+
+## Building
+
+To build this project, use the following command
+
+```bash
+npm run build
+```
+
+## Publihsing
+
+```bash
+npm run build
+npm publish
+```

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,22 @@
+"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', "");
+commander_1.program.parse();
+var options = commander_1.program.opts();
+var input = options.in, out = options.out, componentPrefix = options.componentPrefix;
+var manager = new InterfaceManager_1.default(out, input, {
+    componentPrefix: componentPrefix,
+});
+manager.run().catch(function (err) {
+    console.error(err);
+});

package/lib/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/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/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/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/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/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/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/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/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/interface/Interface.js

@@ -0,0 +1,114 @@
+"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()) {
+            }
+            else {
+                // 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/interface/InterfaceManager.d.ts

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