Works for basic collection types

Author: Alexnortung

.gitignore

@@ -0,0 +1,3 @@
+lib/
+node_modules/
+types/

bin/index.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("../lib/index.js")

package-lock.json

@@ -0,0 +1,35 @@
+{
+  "name": "@oak-digital/types-4-strapi-2",
+  "version": "0.1.0",
+  "description": "Typescript interface generator for Strapi 4 models",
+  "bin": {
+    "t4s": "./bin/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p .",
+    "t4s": "node ./bin/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Oak-Digital/types-4-strapi-2.git"
+  },
+  "keywords": [
+    "strapi",
+    "typescript",
+    "types",
+    "generator"
+  ],
+  "author": "Oak digital",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Oak-Digital/types-4-strapi-2/issues"
+  },
+  "homepage": "https://github.com/Oak-Digital/types-4-strapi-2",
+  "devDependencies": {
+    "@types/node": "^18.7.2",
+    "typescript": "^4.7.4"
+  },
+  "dependencies": {
+    "commander": "^9.4.0"
+  }
+}

package.json

@@ -0,0 +1,22 @@
+import { program } from 'commander'
+import * as fs from 'node:fs/promises'
+import InterfaceManager from './interface/InterfaceManager'
+
+program
+    .name("t4s")
+
+program
+    .option('-i, --in <dir>', 'The src directory for strapi', './src')
+    .option('-o, --out <dir>', 'The output directory to output the types to', './types')
+
+program.parse()
+const options = program.opts()
+const {
+    in: input,
+    out,
+} = options
+
+const manager = new InterfaceManager(out, input)
+manager.run().catch((err) => {
+    console.error(err)
+});

src/index.ts

@@ -0,0 +1,108 @@
+import Interface from "./Interface";
+
+export default class Attributes {
+    Attrs: Record<string, Record<string, any>>;
+    private RelationNames: Record<string, [string, Interface]> = {};
+
+    constructor(attr: Record<string, Record<string, any>>, relationNames: Record<string, [string, Interface]>) {
+        this.Attrs = attr;
+        this.RelationNames = relationNames;
+    }
+
+    isAttributeOptional(attr: any) {
+        // If it is a component / relation / dynamiczone it is always optional due to population
+        switch (attr.type) {
+            case "component":
+            case "dynamiczone":
+            case "relation":
+                return false;
+            default:
+                break;
+        }
+
+        return attr.required !== true;
+    }
+
+    getDependencies() {
+        const dependencies = [];
+        for (const attrName in this.Attrs) {
+            const attr = this.Attrs[attrName];
+            let dependencyName : string;
+            switch (attr.type) {
+                case "relation":
+                    dependencyName = attr.target;
+                    break;
+                case "component":
+                    dependencyName = attr.component;
+                    break;
+                default:
+                    continue;
+            }
+            dependencies.push(dependencyName);
+        }
+        return dependencies;
+    }
+
+    attributeToString(attrName: string, attr: any) {
+        let optionalString = this.isAttributeOptional(attr) ? '?' : '';
+        let str = `${attrName}${optionalString}: `
+        let isArray : boolean = false;
+        switch (attr.type) {
+            case "relation":
+                const apiName = attr.target;
+                const dependencyName = this.RelationNames[apiName][0];
+                isArray = attr.relation.endsWith("ToMany");
+                str += dependencyName;
+                break;
+            case "component":
+                const componentName = attr.component;
+                const dependencyComponentName = this.RelationNames[componentName][0];
+                isArray = attr.repeatable ?? false;
+                str += dependencyComponentName;
+                break;
+            case "password":
+                return null;
+            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;
+            case "json":
+            default:
+                str += "any";
+                break;
+        }
+        const isArrayString = isArray ? '[]' : ''
+        str += `${isArrayString};`;
+        return str;
+    }
+
+    toString() : string {
+        const strings = [ "{" ];
+        for (const attrName in this.Attrs) {
+            const attr = this.Attrs[attrName];
+            const attrString = this.attributeToString(attrName, attr);
+            if (attrString === null) {
+                continue;
+            }
+            strings.push(attrString)
+        }
+        strings.push("}")
+        return strings.join("\n");
+    }
+}

src/interface/Attributes.ts

@@ -0,0 +1,5 @@
+import Interface from "./Interface";
+
+export default class ComponentInterface extends Interface {
+
+}

src/interface/ComponentInterface.ts

@@ -0,0 +1,105 @@
+import { join, parse, relative } from "path";
+import Attributes from "./Attributes";
+
+export default class Interface {
+    private BaseName: string;
+    private Relations: Interface[] = []; // Components and relations
+    private RelationNames: Record<string, [string, Interface]> = {};
+    private RelationNamesCounter: Record<string, number> = {};
+    private NamePrefix: string = "";
+    private Attributes: any;
+    private RelativeDirectoryPath: string;
+    private StrapiName: string;
+
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, prefix: string = "") {
+        this.BaseName = baseName;
+        this.StrapiName = `api::${baseName}.${baseName}`;
+        this.NamePrefix = prefix;
+        this.Attributes = attributes;
+        this.RelativeDirectoryPath = relativeDirectoryPath;
+    }
+
+    getBaseName() {
+        return this.BaseName;
+    }
+
+    getStrapiName() {
+        return this.StrapiName;
+    }
+
+    getDependencies() {
+        const attrs = new Attributes(this.Attributes, this.RelationNames);
+        return attrs.getDependencies();
+    }
+
+    getFullInterfaceName() {
+        return `${this.NamePrefix}${this.BaseName}`;
+    }
+
+    // For typescript import from index file
+    getRelativeRootPath() {
+        const path = join(this.RelativeDirectoryPath, this.getBaseName());
+        const relativePath = (/^\.?\.\//).test(path) ? path : "./" + path;
+        return relativePath;
+    }
+
+    getRelativeRootPathFile() {
+        return `${this.getRelativeRootPath()}.ts`
+    }
+
+    setRelations(relations: Interface[]) {
+        this.Relations = relations;
+        this.RelationNames = {};
+        this.Relations.forEach((inter: Interface) => {
+            let name = inter.getBaseName();
+            // Avoid duplicate names
+            if (name in this.RelationNamesCounter) {
+                name += ++this.RelationNamesCounter[name];
+            } else {
+                this.RelationNamesCounter[name] = 0;
+            }
+            this.RelationNames[inter.getStrapiName()] = [name, inter];
+        })
+    }
+
+    private getTsImports() {
+        return Object.keys(this.RelationNames).map((strapiName: string) => {
+            const relationName = this.RelationNames[strapiName][0];
+            const inter = this.RelationNames[strapiName][1];
+            const importPath = relative(this.getRelativeRootPath(), inter.getRelativeRootPath());
+            const fullName = inter.getFullInterfaceName();
+            const importNameString = fullName === relationName ? fullName : `${fullName} as ${relationName}`;
+            return `import { ${importNameString} } from '${importPath}';`;
+        }).join("\n");
+    }
+
+    attributesToString() {
+        let str = '';
+        for (const attributeName in this.Attributes) {
+            const attr = this.Attributes[attributeName];
+            switch (attr.type) {
+                default:
+                    
+                    break;
+            }
+        }
+    }
+
+    getInerfaceString() {
+        let str = 'export interface ${this.getFullInterfaceName()} {\n';
+        str += this.getInterfaceFieldsString();
+        str += `}`
+        return str;
+    }
+
+    getInterfaceFieldsString() {
+        let str: string;
+        str += `  id: number;\n`;
+        str += `  attributes: ${this.attributesToString()}\n`;
+        return str;
+    }
+
+    toString() {
+        return this.getTsImports() + this.getInerfaceString();
+    }
+}