now works for components

Author: Alexnortung

bin/index.js

@@ -7,6 +7,7 @@
   },
   "scripts": {
     "build": "tsc -p .",
+    "testtypes": "node ./bin/index.js --out src/testtypes",
     "t4s": "node ./bin/index.js"
   },
   "repository": {

package.json

@@ -15,15 +15,15 @@ export default class Attributes {
             case "component":
             case "dynamiczone":
             case "relation":
-                return false;
+                return true;
             default:
                 break;
         }
 
-        return attr.required !== true;
+        return !attr.required;
     }
 
-    getDependencies() {
+    getDependencies(strapiName: string) {
         const dependencies = [];
         for (const attrName in this.Attrs) {
             const attr = this.Attrs[attrName];
@@ -38,18 +38,24 @@ export default class Attributes {
                 default:
                     continue;
             }
+            // // If the current dependency is the interface itself, do not report it as a dependency
+            // if (dependencyName === strapiName) {
+            //     continue;
+            // }
             dependencies.push(dependencyName);
         }
         return dependencies;
     }
 
     attributeToString(attrName: string, attr: any) {
         let optionalString = this.isAttributeOptional(attr) ? '?' : '';
-        let str = `${attrName}${optionalString}: `
+        let str = `    ${attrName}${optionalString}: `
         let isArray : boolean = false;
         switch (attr.type) {
             case "relation":
                 const apiName = attr.target;
+                // console.log(attrName)
+                // console.log(this.RelationNames, apiName)
                 const dependencyName = this.RelationNames[apiName][0];
                 isArray = attr.relation.endsWith("ToMany");
                 str += dependencyName;
@@ -82,6 +88,7 @@ export default class Attributes {
                 break;
             case "boolean":
                 str += attr.type;
+                break;
             case "json":
             default:
                 str += "any";
@@ -102,7 +109,7 @@ export default class Attributes {
             }
             strings.push(attrString)
         }
-        strings.push("}")
+        strings.push("  }")
         return strings.join("\n");
     }
 }

src/interface/Attributes.ts

@@ -1,5 +1,16 @@
+import { prefixDotSlash } from "../utils";
 import Interface from "./Interface";
 
 export default class ComponentInterface extends Interface {
+    protected Category: string;
 
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, category: string, prefix: string = "") {
+        super(baseName, attributes, relativeDirectoryPath, prefix);
+        this.Category = category;
+        this.updateStrapiName();
+    }
+
+    updateStrapiName() {
+        this.StrapiName = `${this.Category}.${this.getBaseName()}`
+    }
 }

src/interface/ComponentInterface.ts

@@ -1,24 +1,29 @@
-import { join, parse, relative } from "path";
+import { dirname, join, parse, relative } from "path";
+import { pascalCase, prefixDotSlash } from "../utils";
 import Attributes from "./Attributes";
 
 export default class Interface {
-    private BaseName: string;
+    protected 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;
+    protected StrapiName: string;
 
     constructor(baseName: string, attributes: any, relativeDirectoryPath: string, prefix: string = "") {
         this.BaseName = baseName;
-        this.StrapiName = `api::${baseName}.${baseName}`;
+        this.updateStrapiName()
         this.NamePrefix = prefix;
         this.Attributes = attributes;
         this.RelativeDirectoryPath = relativeDirectoryPath;
     }
 
+    protected updateStrapiName() {
+        this.StrapiName = `api::${this.BaseName}.${this.BaseName}`;
+    }
+
     getBaseName() {
         return this.BaseName;
     }
@@ -29,18 +34,23 @@ export default class Interface {
 
     getDependencies() {
         const attrs = new Attributes(this.Attributes, this.RelationNames);
-        return attrs.getDependencies();
+        return attrs.getDependencies(this.getStrapiName());
     }
 
     getFullInterfaceName() {
-        return `${this.NamePrefix}${this.BaseName}`;
+        const pascalName = pascalCase(this.BaseName);
+        return `${this.NamePrefix}${pascalName}`;
     }
 
     // For typescript import from index file
     getRelativeRootPath() {
         const path = join(this.RelativeDirectoryPath, this.getBaseName());
-        const relativePath = (/^\.?\.\//).test(path) ? path : "./" + path;
-        return relativePath;
+        return prefixDotSlash(path);
+    }
+
+    getRelativeRootDir() {
+        const path = dirname(this.getRelativeRootPathFile());
+        return path;
     }
 
     getRelativeRootPathFile() {
@@ -51,55 +61,59 @@ export default class 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];
+            let name = inter.getFullInterfaceName();
+            // FIXME: clean up this mess...
+            if (inter.getStrapiName() === this.getStrapiName()) {
             } else {
-                this.RelationNamesCounter[name] = 0;
+                // 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) => {
+            if (strapiName === this.getStrapiName()) {
+                return "";
+            }
             const relationName = this.RelationNames[strapiName][0];
             const inter = this.RelationNames[strapiName][1];
-            const importPath = relative(this.getRelativeRootPath(), inter.getRelativeRootPath());
+            const importPath = prefixDotSlash(relative(this.getRelativeRootDir(), inter.getRelativeRootPath()));
             const fullName = inter.getFullInterfaceName();
             const importNameString = fullName === relationName ? fullName : `${fullName} as ${relationName}`;
             return `import { ${importNameString} } from '${importPath}';`;
-        }).join("\n");
+        }).filter(s => s).join("\n");
     }
 
     attributesToString() {
-        let str = '';
-        for (const attributeName in this.Attributes) {
-            const attr = this.Attributes[attributeName];
-            switch (attr.type) {
-                default:
-                    
-                    break;
-            }
-        }
+        const attrs = new Attributes(this.Attributes, this.RelationNames);
+        return attrs.toString();
     }
 
     getInerfaceString() {
-        let str = 'export interface ${this.getFullInterfaceName()} {\n';
+        let str = `export interface ${this.getFullInterfaceName()} {\n`;
         str += this.getInterfaceFieldsString();
         str += `}`
         return str;
     }
 
     getInterfaceFieldsString() {
-        let str: string;
+        let str = '';
         str += `  id: number;\n`;
         str += `  attributes: ${this.attributesToString()}\n`;
         return str;
     }
 
     toString() {
-        return this.getTsImports() + this.getInerfaceString();
+        const strings = [
+            this.getTsImports(),
+            this.getInerfaceString()
+        ];
+        return strings.join("\n")
     }
 }

src/interface/Interface.ts

@@ -1,5 +1,8 @@
+import { existsSync } from "fs";
 import { mkdir, rm, writeFile } from "fs/promises";
 import { join } from "path";
+import { pascalCase } from "../utils";
+import ComponentInterface from "./ComponentInterface";
 import Interface from "./Interface";
 import { getApiSchemas, getComponentCategoryFolders, getComponentSchemas } from "./schemaReader";
 
@@ -39,20 +42,22 @@ export default class InterfaceManager {
             category.schemas.forEach((schema) => {
                 const componentName = schema.name;
                 const strapiName = `${categoryName}.${schema.name}`
-                const componentPrefix = `${this.Options.componentPrefix}${this.Options.useCategoryPrefix ? categoryName : ""}`;
+                const componentPrefix = `${this.Options.componentPrefix}${this.Options.useCategoryPrefix ? pascalCase(categoryName) : ""}`;
                 const prefix = this.Options.componentPrefixOverridesPrefix ? componentPrefix : this.Options.prefix + componentPrefix;
                 // TODO: make component interface
-                // const inter = new Interface(componentName, schema.attributes, `./${categoryName}`, prefix);
-                // this.Interfaces[strapiName] = inter;
+                const inter = new ComponentInterface(componentName, schema.attributes, `./${categoryName}`, categoryName, prefix);
+                this.Interfaces[strapiName] = inter;
             })
         })
     }
 
     // Inject dependencies into all interfaces
     injectDependencies() {
+        // console.log("Injecting dependencies")
         Object.keys(this.Interfaces).forEach((strapiName: string) => {
             const inter = this.Interfaces[strapiName];
             const dependencies = inter.getDependencies();
+            // console.log(`Interfaces for ${inter.getStrapiName()} are`)
             const interfacesToInject = dependencies.map((dependencyStrapiName: string) => {
                 return this.Interfaces[dependencyStrapiName];
             }).filter((inter) => inter);
@@ -62,22 +67,25 @@ export default class InterfaceManager {
 
     async makeFolders() {
         const componentCategories = await getComponentCategoryFolders(this.StrapiSrcRoot);
-        await rm(this.OutRoot, {
-            recursive: true,
-        });
-        await mkdir(this.OutRoot, {
-            recursive: true,
-        });
+        if (!existsSync(this.OutRoot)) {
+            await mkdir(this.OutRoot, {
+                recursive: true,
+            });
+        }
         await Promise.all(componentCategories.map(async (category) => {
-            await mkdir(join(this.OutRoot, category));
+            const path = join(this.OutRoot, category);
+            if (existsSync(path)) {
+                return;
+            }
+            await mkdir(path);
         }));
     }
 
     async writeInterfaces() {
         const writePromises = Object.keys(this.Interfaces).map(async (strapiName) => {
             const inter = this.Interfaces[strapiName];
             const fileData = inter.toString();
-            const filePath = join(this.OutRoot, inter.getRelativeRootPath());
+            const filePath = join(this.OutRoot, inter.getRelativeRootPathFile());
             await writeFile(filePath, fileData)
         });
         await Promise.all(writePromises);

src/interface/InterfaceManager.ts

@@ -27,7 +27,8 @@ export async function getComponentSchemas(strapiSrcRoot: string) {
         const schemaFilesPath = join(strapiSrcRoot, "components", category);
         const schemaFiles = await readDirFiltered(schemaFilesPath);
         const schemaNamesWithAttributesPromises = schemaFiles.map(async (file: string) => {
-            const attributes = await readSchema(file);
+            const schemaPath = join(schemaFilesPath, file);
+            const attributes = await readSchema(schemaPath);
             const name = file.split(".")[0];
             return { name, attributes }
         })

src/interface/schemaReader.ts

@@ -1,10 +1,19 @@
 import { readdir } from "fs/promises";
 
-export function strapiToPascalCase(strapiName: string) {
-
+export function pascalCase(name: string) {
+    const words = name.match(/[a-z]+/gi);
+    const pascalName = words.map((word: string) => {
+        return word.charAt(0).toUpperCase() + word.substring(1).toLowerCase();
+    }).join("");
+    // console.log(pascalName)
+    return pascalName;
 }
 
 export async function readDirFiltered(dir: string) {
     const folders = await readdir(dir);
     return folders.filter((folder: string) => !folder.startsWith("."));
 }
+
+export function prefixDotSlash(path) {
+    return (/^\.?\.\//).test(path) ? path : "./" + path;
+}

src/utils/index.ts

@@ -0,0 +1 @@
+tsconfig.jsonc

tsconfig.json

@@ -5,10 +5,11 @@
     "module": "commonjs",           /* 'none', 'commonjs', 'amd', 'system', etc */
     "declaration": true,            /* Concatenate & emit output to single file.*/
     "outDir": "lib",                /* Redirect output to the directory. */
-    "rootDir": "src",
     "types": [ "node" ],
     "resolveJsonModule": true,
     "esModuleInterop": true,        /* Enables intero between CommonJS and ES */
     "skipLibCheck": true            /* Skip type checking of declaration files. */
-  }
+  },
+  "include": [ "src/**/*" ],
+  "exclude": [ "types/**/*", "src/testtypes/**/*" ]
 }