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

package/lib/readers/load-strapi/index.d.ts

@@ -0,0 +1,319 @@
+import { ContentTypeReader } from '../types/content-type-reader';
+export declare class LoadStrapiReader implements ContentTypeReader {
+    private strapiRoot;
+    private loadStrapiPromise;
+    constructor(strapiRoot: 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;
+    })>>;
+    readComponents(): Promise<Record<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;
+    }>>;
+    private loadStrapi;
+}

package/lib/readers/load-strapi/index.js

@@ -0,0 +1,106 @@
+"use strict";
+// This reader works by loading Strapi and accessing the content types directly on the instance
+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.LoadStrapiReader = void 0;
+const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const posix_1 = require("path/posix");
+const zod_1 = require("zod");
+const component_1 = require("../types/component");
+const content_type_1 = require("../types/content-type");
+const schema = zod_1.z.tuple([
+    zod_1.z.record(content_type_1.strapiContentType),
+    zod_1.z.record(component_1.strapiComponent),
+]);
+class LoadStrapiReader {
+    constructor(strapiRoot) {
+        this.strapiRoot = strapiRoot;
+        this.loadStrapiPromise = this.loadStrapi();
+    }
+    readContentTypes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = (yield this.loadStrapiPromise)[0];
+            const newData = {};
+            Object.entries(data).forEach(([strapiName, schema]) => {
+                const [namespace, collectionAndBase] = strapiName.split('::');
+                if (namespace === 'admin') {
+                    newData[strapiName] = {
+                        namespace: namespace,
+                        name: collectionAndBase,
+                        contentType: schema,
+                    };
+                    return;
+                }
+                const [collection, base] = collectionAndBase.split('.');
+                newData[strapiName] = {
+                    namespace: namespace,
+                    collection,
+                    name: base,
+                    contentType: schema,
+                };
+            });
+            return newData;
+        });
+    }
+    readComponents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = (yield this.loadStrapiPromise)[1];
+            return data;
+        });
+    }
+    loadStrapi() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const localRemoteFile = (0, posix_1.join)(__dirname, 'remote.js');
+            const remoteRemoteFile = (0, posix_1.join)(process.cwd(), this.strapiRoot, '.t4s.remote.js');
+            // Plant the remote execution file in the strapi project
+            yield (0, promises_1.cp)(localRemoteFile, remoteRemoteFile);
+            const output = yield new Promise((resolve, reject) => {
+                const remote = (0, child_process_1.spawn)('node', [remoteRemoteFile], {
+                    cwd: this.strapiRoot,
+                });
+                const data = [];
+                remote.stdout.on('data', (chunk) => {
+                    data.push(chunk);
+                });
+                remote.stderr.on('data', (chunk) => {
+                    console.error(chunk.toString());
+                });
+                remote.on('close', () => {
+                    resolve(data.map((b) => b === null || b === void 0 ? void 0 : b.toString()).join(''));
+                });
+                remote.on('error', (err) => {
+                    reject(err);
+                });
+            });
+            let jsonParsed;
+            try {
+                jsonParsed = JSON.parse(output);
+            }
+            catch (err) {
+                console.error(err, output.slice(0, 100));
+                throw new Error('Failed to parse output from remote strapi');
+            }
+            let parsed;
+            try {
+                parsed = schema.parse(jsonParsed);
+            }
+            catch (err) {
+                console.error(err);
+                throw new Error('Failed to parse output from remote strapi, something may be malformed');
+            }
+            // Remove the remote execution file after we're done
+            yield (0, promises_1.rm)(remoteRemoteFile);
+            return parsed;
+        });
+    }
+}
+exports.LoadStrapiReader = LoadStrapiReader;

package/lib/readers/load-strapi/remote.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/readers/load-strapi/remote.js

@@ -0,0 +1,29 @@
+// remote.js should be started with it's cwd in the strapi project's root
+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());
+    });
+};
+const Strapi = require('@strapi/strapi');
+(() => __awaiter(this, void 0, void 0, function* () {
+    const base = yield Strapi({
+        distDir: 'dist',
+    });
+    // Do not remove log.error since it writes to stderr
+    base.log.warn = () => { };
+    base.log.info = () => { };
+    const instance = yield base.load();
+    yield instance.server.mount();
+    console.log(JSON.stringify([instance.contentTypes, instance.components]));
+    const dbSettings = instance.config.get('database.connection');
+    //close server to release the db-file
+    yield instance.server.httpServer.close();
+    // close the connection to the database before deletion
+    yield instance.db.connection.destroy();
+    // Force exit, because else it hangs
+    process.exit(0);
+}))();