@oak-digital/types-4-strapi-2 0.5.4 → 1.0.0-beta.1

package/lib/readers/by-file.d.ts

@@ -0,0 +1,321 @@
+import { ContentTypeReader } from './types/content-type-reader';
+export declare class ByFileContentTypeReader implements ContentTypeReader {
+    private readonly strapiSrcRoot;
+    constructor(strapiRoot: string);
+    readComponents(): Promise<Record<`${string}.${string}`, {
+        collectionName?: string;
+        attributes?: Record<string, {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "text" | "string";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "email";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "uid";
+            targetField?: string;
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "richtext";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "json";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "password";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "integer";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "float";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "biginteger";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "decimal";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "enumeration";
+            enum?: string[];
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "date";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "datetime";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "time";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "media";
+            multiple?: boolean;
+            allowedTypes?: ("images" | "videos" | "audios" | "files")[];
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "boolean";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "relation";
+            target?: string;
+            relation?: "oneToOne";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "relation";
+            target?: string;
+            relation?: "oneToOne";
+            inversedBy?: string;
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "relation";
+            target?: string;
+            mappedBy?: string;
+            relation?: "oneToMany";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "relation";
+            target?: string;
+            relation?: "manyToOne";
+            inversedBy?: string;
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "relation";
+            target?: string;
+            relation?: "manyToMany";
+            inversedBy?: string;
+            mappedBy?: string;
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "relation";
+            target?: string;
+            relation?: "oneToMany";
+        } | {
+            type?: "relation";
+            relation?: "morphToMany";
+        } | {
+            __t4s_required?: boolean;
+            pluginOptions?: any;
+            required?: boolean;
+            type?: "component";
+            repeatable?: boolean;
+            component?: string;
+        }>;
+        options?: {};
+        uid?: string;
+    }>>;
+    readContentTypes(): Promise<Record<`api::${string}` | `plugin::${string}` | `admin::${string}` | `builtins::${string}`, {
+        name: string;
+        contentType: {
+            attributes?: Record<string, {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "text" | "string";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "email";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "uid";
+                targetField?: string;
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "richtext";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "json";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "password";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "integer";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "float";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "biginteger";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "decimal";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "enumeration";
+                enum?: string[];
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "date";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "datetime";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "time";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "media";
+                multiple?: boolean;
+                allowedTypes?: ("images" | "videos" | "audios" | "files")[];
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "boolean";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "relation";
+                target?: string;
+                relation?: "oneToOne";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "relation";
+                target?: string;
+                relation?: "oneToOne";
+                inversedBy?: string;
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "relation";
+                target?: string;
+                mappedBy?: string;
+                relation?: "oneToMany";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "relation";
+                target?: string;
+                relation?: "manyToOne";
+                inversedBy?: string;
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "relation";
+                target?: string;
+                relation?: "manyToMany";
+                inversedBy?: string;
+                mappedBy?: string;
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "relation";
+                target?: string;
+                relation?: "oneToMany";
+            } | {
+                type?: "relation";
+                relation?: "morphToMany";
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "component";
+                repeatable?: boolean;
+                component?: string;
+            } | {
+                __t4s_required?: boolean;
+                pluginOptions?: any;
+                required?: boolean;
+                type?: "dynamiczone";
+                components?: string[];
+            }>;
+            collectionName?: string;
+            options?: {
+                draftAndPublish?: boolean;
+            };
+            pluginOptions?: Record<string, any>;
+            uid?: string;
+        };
+    } & ({
+        namespace: "api" | "plugin";
+        collection: string;
+    } | {
+        namespace: "admin";
+        collection?: null;
+    })>>;
+    private readComponentSchema;
+    private readContentTypeSchema;
+    private getApiFolders;
+    private getComponentCategoryFolders;
+}

package/lib/readers/by-file.js

@@ -0,0 +1,116 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByFileContentTypeReader = void 0;
+const posix_1 = require("path/posix");
+const utils_1 = require("../utils");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const component_1 = require("./types/component");
+const content_type_1 = require("./types/content-type");
+class ByFileContentTypeReader {
+    constructor(strapiRoot) {
+        this.strapiSrcRoot = (0, posix_1.join)(strapiRoot, 'src');
+    }
+    readComponents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const categories = yield this.getComponentCategoryFolders();
+            const schemas = {};
+            const nestedSchemasPromises = categories.map((category) => __awaiter(this, void 0, void 0, function* () {
+                const schemaFilesPath = (0, posix_1.join)(this.strapiSrcRoot, 'components', category);
+                const schemaFiles = yield (0, utils_1.readDirFiltered)(schemaFilesPath);
+                const schemaNamesWithAttributesPromises = schemaFiles.map((file) => __awaiter(this, void 0, void 0, function* () {
+                    const schemaPath = (0, posix_1.join)(schemaFilesPath, file);
+                    const schema = yield this.readComponentSchema(schemaPath);
+                    const name = file.split('.')[0];
+                    schemas[`${category}.${name}`] = schema;
+                }));
+                yield Promise.all(schemaNamesWithAttributesPromises);
+            }));
+            yield Promise.all(nestedSchemasPromises);
+            return schemas;
+        });
+    }
+    readContentTypes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const apiFolders = yield this.getApiFolders();
+            const schemas = {};
+            const schemasWithAttributesPromises = apiFolders.map((apiFolder) => __awaiter(this, void 0, void 0, function* () {
+                const contentTypesFolder = (0, posix_1.join)(this.strapiSrcRoot, 'api', apiFolder, 'content-types');
+                if (!(0, fs_1.existsSync)(contentTypesFolder)) {
+                    return;
+                }
+                const contentTypesFolders = yield (0, utils_1.readDirFiltered)(contentTypesFolder);
+                const contentTypePromises = contentTypesFolders.map((contentTypeFolder) => __awaiter(this, void 0, void 0, function* () {
+                    const schemaPath = (0, posix_1.join)(this.strapiSrcRoot, 'api', apiFolder, 'content-types', contentTypeFolder, 'schema.json');
+                    const schema = yield this.readContentTypeSchema(schemaPath);
+                    const name = contentTypeFolder;
+                    schemas[`api::${apiFolder}.${name}`] = {
+                        collection: apiFolder,
+                        name,
+                        namespace: 'api',
+                        contentType: schema,
+                    };
+                }));
+                yield Promise.all(contentTypePromises);
+            }));
+            Promise.all(schemasWithAttributesPromises);
+            return schemas;
+        });
+    }
+    readComponentSchema(schemaPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemaData = yield (0, promises_1.readFile)(schemaPath);
+            try {
+                const object = JSON.parse(schemaData.toString());
+                const schema = component_1.strapiComponent.parse(object);
+                return schema;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Failed to parse schema: ${schemaPath}`);
+            }
+        });
+    }
+    readContentTypeSchema(schemaPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemaData = yield (0, promises_1.readFile)(schemaPath);
+            try {
+                const object = JSON.parse(schemaData.toString());
+                const schema = content_type_1.strapiContentType.parse(object);
+                return schema;
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Failed to parse schema: ${schemaPath}`);
+            }
+        });
+    }
+    getApiFolders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = (0, posix_1.join)(this.strapiSrcRoot, 'api');
+            const folders = yield (0, utils_1.readDirFiltered)(path);
+            return folders;
+        });
+    }
+    getComponentCategoryFolders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = (0, posix_1.join)(this.strapiSrcRoot, 'components');
+            // If there exists no components, just fallback to an empty array.
+            if (!(0, fs_1.existsSync)(path)) {
+                return [];
+            }
+            const folders = yield (0, utils_1.readDirFiltered)(path);
+            return folders;
+        });
+    }
+}
+exports.ByFileContentTypeReader = ByFileContentTypeReader;