@oak-digital/types-4-strapi-2 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2022 Oak Digital
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/bin/index.js

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

package/package.json

@@ -0,0 +1,36 @@
+{
+  "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 .",
+    "testtypes": "node ./bin/index.js --out src/testtypes",
+    "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/src/index.ts

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

package/src/interface/Attributes.ts

@@ -0,0 +1,115 @@
+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 true;
+            default:
+                break;
+        }
+
+        return !attr.required;
+    }
+
+    getDependencies(strapiName: string) {
+        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;
+            }
+            // // 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 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;
+                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;
+                break;
+            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");
+    }
+}

package/src/interface/ComponentInterface.ts

@@ -0,0 +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()}`
+    }
+}

package/src/interface/Interface.ts

@@ -0,0 +1,119 @@
+import { dirname, join, parse, relative } from "path";
+import { pascalCase, prefixDotSlash } from "../utils";
+import Attributes from "./Attributes";
+
+export default class Interface {
+    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;
+    protected StrapiName: string;
+
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, prefix: string = "") {
+        this.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;
+    }
+
+    getStrapiName() {
+        return this.StrapiName;
+    }
+
+    getDependencies() {
+        const attrs = new Attributes(this.Attributes, this.RelationNames);
+        return attrs.getDependencies(this.getStrapiName());
+    }
+
+    getFullInterfaceName() {
+        const pascalName = pascalCase(this.BaseName);
+        return `${this.NamePrefix}${pascalName}`;
+    }
+
+    // For typescript import from index file
+    getRelativeRootPath() {
+        const path = join(this.RelativeDirectoryPath, this.getBaseName());
+        return prefixDotSlash(path);
+    }
+
+    getRelativeRootDir() {
+        const path = dirname(this.getRelativeRootPathFile());
+        return path;
+    }
+
+    getRelativeRootPathFile() {
+        return `${this.getRelativeRootPath()}.ts`
+    }
+
+    setRelations(relations: Interface[]) {
+        this.Relations = relations;
+        this.RelationNames = {};
+        this.Relations.forEach((inter: Interface) => {
+            let 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, 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 = prefixDotSlash(relative(this.getRelativeRootDir(), inter.getRelativeRootPath()));
+            const fullName = inter.getFullInterfaceName();
+            const importNameString = fullName === relationName ? fullName : `${fullName} as ${relationName}`;
+            return `import { ${importNameString} } from '${importPath}';`;
+        }).filter(s => s).join("\n");
+    }
+
+    attributesToString() {
+        const attrs = new Attributes(this.Attributes, this.RelationNames);
+        return attrs.toString();
+    }
+
+    getInerfaceString() {
+        let str = `export interface ${this.getFullInterfaceName()} {\n`;
+        str += this.getInterfaceFieldsString();
+        str += `}`
+        return str;
+    }
+
+    getInterfaceFieldsString() {
+        let str = '';
+        str += `  id: number;\n`;
+        str += `  attributes: ${this.attributesToString()}\n`;
+        return str;
+    }
+
+    toString() {
+        const strings = [
+            this.getTsImports(),
+            this.getInerfaceString()
+        ];
+        return strings.join("\n")
+    }
+}

package/src/interface/InterfaceManager.ts

@@ -0,0 +1,116 @@
+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";
+
+export default class InterfaceManager {
+    private Interfaces: Record<string, Interface> = {}; // string = strapi name
+    private OutRoot: string;
+    private StrapiSrcRoot: string;
+    private Options: any;
+
+    static BaseOptions = {
+        prefix: "I",
+        useCategoryPrefix: true,
+        componentPrefix: "",
+        componentPrefixOverridesPrefix: false,
+    };
+
+    constructor(outRoot: string, strapiSrcRoot: string, options: any = {}) {
+        this.OutRoot = outRoot;
+        this.StrapiSrcRoot = strapiSrcRoot;
+        this.Options = Object.assign({}, InterfaceManager.BaseOptions, options);
+    }
+
+    async createInterfaces() {
+        const apiSchemasPromise = getApiSchemas(this.StrapiSrcRoot);
+        const componentSchemasPromise = getComponentSchemas(this.StrapiSrcRoot);
+        const apiSchemas = await apiSchemasPromise;
+        apiSchemas.forEach((schema) => {
+            const { name, attributes } = schema;
+            const strapiName = `api::${name}.${name}`;
+            const inter = new Interface(name, attributes, "./", this.Options.prefix);
+            this.Interfaces[strapiName] = inter;
+        })
+
+        const componentSchemas = await componentSchemasPromise;
+        componentSchemas.forEach((category) => {
+            const categoryName : string = category.category;
+            category.schemas.forEach((schema) => {
+                const componentName = schema.name;
+                const strapiName = `${categoryName}.${schema.name}`
+                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 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);
+            inter.setRelations(interfacesToInject);
+        })
+    }
+
+    async makeFolders() {
+        const componentCategories = await getComponentCategoryFolders(this.StrapiSrcRoot);
+        if (!existsSync(this.OutRoot)) {
+            await mkdir(this.OutRoot, {
+                recursive: true,
+            });
+        }
+        await Promise.all(componentCategories.map(async (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.getRelativeRootPathFile());
+            await writeFile(filePath, fileData)
+        });
+        await Promise.all(writePromises);
+    }
+
+    async writeIndexFile() {
+        const strings = Object.keys(this.Interfaces).map((strapiName: string) => {
+            const inter = this.Interfaces[strapiName];
+            return `export * from '${inter.getRelativeRootPath()}'`;
+        });
+        const fileData = strings.join("\n");
+        const filePath = join(this.OutRoot, "index.ts");
+        await writeFile(filePath, fileData);
+    }
+
+    async run() {
+        try {
+            const createInterfacesPromise = this.createInterfaces();
+            const makeFoldersPromise = this.makeFolders();
+            await createInterfacesPromise;
+            this.injectDependencies();
+            await makeFoldersPromise;
+            await Promise.all([this.writeInterfaces(), this.writeIndexFile()])
+        } catch (err) {
+            console.error(err);
+        }
+    }
+}

package/src/interface/interfaceCreator.ts

@@ -0,0 +1,7 @@
+// import Interface from "./Interface";
+//
+// export default async function createInterface(schemaPath: string, baseName: string, prefix: string = "") {
+//     const schema = await readSchema(schemaPath);
+//     const inter = new Interface(baseName, schema, prefix);
+//     return inter;
+// }

package/src/interface/interfaceWriter.ts

@@ -0,0 +1,5 @@
+import type Interface from "./Interface"
+
+export default async function writeInterface(inter: Interface) {
+    
+}

package/src/interface/schemaReader.ts

@@ -0,0 +1,51 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readDirFiltered } from '../utils';
+
+export async function readSchema(schemaPath: string) {
+    try {
+        const schemaData = await readFile(schemaPath);
+        return JSON.parse(schemaData.toString()).attributes;
+    } catch (e) {
+        return null;
+    }
+}
+
+export async function getApiFolders(strapiSrcRoot: string) {
+    const path = join(strapiSrcRoot, 'api');
+    return await readDirFiltered(path)
+}
+
+export async function getComponentCategoryFolders(strapiSrcRoot: string) {
+    const path = join(strapiSrcRoot, "components")
+    return await readDirFiltered(path)
+}
+
+export async function getComponentSchemas(strapiSrcRoot: string) {
+    const categories = await getComponentCategoryFolders(strapiSrcRoot);
+    const nestedSchemasPromises = categories.map(async (category: string) => {
+        const schemaFilesPath = join(strapiSrcRoot, "components", category);
+        const schemaFiles = await readDirFiltered(schemaFilesPath);
+        const schemaNamesWithAttributesPromises = schemaFiles.map(async (file: string) => {
+            const schemaPath = join(schemaFilesPath, file);
+            const attributes = await readSchema(schemaPath);
+            const name = file.split(".")[0];
+            return { name, attributes }
+        })
+        const schemaNamesWithAttributes = await Promise.all(schemaNamesWithAttributesPromises);
+        return { category, schemas: schemaNamesWithAttributes };
+    });
+    const nestedSchemasArr = await Promise.all(nestedSchemasPromises);
+    return nestedSchemasArr;
+}
+
+export async function getApiSchemas(strapiSrcRoot: string) {
+    const apiFolders = await getApiFolders(strapiSrcRoot);
+    const schemasWithAttributesPromises = apiFolders.map(async (folder: string) => {
+        const schemaPath = join(strapiSrcRoot, "api", folder, "content-types", folder, "schema.json")
+        const attributes = await readSchema(schemaPath);
+        return { name: folder, attributes };
+    })
+    const schemasWithAttributes = Promise.all(schemasWithAttributesPromises);
+    return schemasWithAttributes;
+}

package/src/utils/index.ts

@@ -0,0 +1,19 @@
+import { readdir } from "fs/promises";
+
+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;
+}

package/tsconfig.jsonc

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "incremental": true,            /* Enable incremental compilation */
+    "target": "es5",                /* Specify ECMAScript target version: */
+    "module": "commonjs",           /* 'none', 'commonjs', 'amd', 'system', etc */
+    "declaration": true,            /* Concatenate & emit output to single file.*/
+    "outDir": "lib",                /* Redirect output to the directory. */
+    "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/**/*" ]
+}