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

package/src/index.ts

@@ -1,22 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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 false;
-    }
-
-    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 "enumeration":
-                const hasDefault = "default" in attr;
-                const enums = attr.enum.map((en: string) => `"${en}"`)
-                enums.push("null")
-                const 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;
-        }
-        const isArrayString = isArray ? '[]' : ''
-        str += `${isArrayString};`;
-        return str;
-    }
-
-    toFieldsString() : 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)
-        }
-        return strings.map(s => `${s}\n`).join("");
-    }
-
-    toString() : string {
-        const strings = [ "{" ];
-        strings.push(this.toFieldsString());
-        strings.push("}")
-        return strings.join("\n");
-    }
-}

package/src/interface/ComponentInterface.ts

@@ -1,27 +0,0 @@
-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.Attributes.id = {
-        //     type: "number", // Components have a id field with a number
-        //     required: true,
-        // };
-        this.updateStrapiName();
-    }
-
-    updateStrapiName() {
-        this.StrapiName = `${this.Category}.${this.getBaseName()}`
-    }
-
-    getInterfaceFieldsString() {
-        const attrs = this.getAttributes();
-        let str = '';
-        str += `  id: number;\n`;
-        str += `  __component: "${this.getStrapiName()}";\n`
-        return str + attrs.toFieldsString();
-    }
-}

package/src/interface/Interface.ts

@@ -1,123 +0,0 @@
-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 = "";
-    protected 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");
-    }
-
-    getAttributes() : Attributes {
-        return new Attributes(this.Attributes, this.RelationNames);
-    }
-
-    attributesToString() {
-        const attrs = this.getAttributes();
-        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

@@ -1,116 +0,0 @@
-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/interfaceWriter.ts

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

package/src/interface/schemaReader.ts

@@ -1,51 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,15 +0,0 @@
-{
-  "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/**/*" ]
-}