@rebasepro/server-postgresql 0.0.1-canary.000dc36

package/src/schema/generate-drizzle-schema.ts

@@ -0,0 +1,151 @@
+import { promises as fsPromises } from "fs";
+import * as fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import chokidar from "chokidar";
+import { generateSchema } from "./generate-drizzle-schema-logic";
+import { EntityCollection } from "@rebasepro/types";
+
+// --- Helper Functions ---
+
+const formatTerminalText = (text: string, options: {
+    bold?: boolean;
+    backgroundColor?: "blue" | "green" | "red" | "yellow" | "cyan" | "magenta";
+    textColor?: "white" | "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan";
+} = {}): string => {
+    let codes = "";
+    if (options.bold) codes += "\x1b[1m";
+    if (options.backgroundColor) {
+        const bgColors = {
+            blue: "\x1b[44m",
+            green: "\x1b[42m",
+            red: "\x1b[41m",
+            yellow: "\x1b[43m",
+            cyan: "\x1b[46m",
+            magenta: "\x1b[45m"
+        } as const;
+        codes += bgColors[options.backgroundColor];
+    }
+    if (options.textColor) {
+        const textColors = {
+            white: "\x1b[37m",
+            black: "\x1b[30m",
+            red: "\x1b[31m",
+            green: "\x1b[32m",
+            yellow: "\x1b[33m",
+            blue: "\x1b[34m",
+            magenta: "\x1b[35m",
+            cyan: "\x1b[36m"
+        } as const;
+        codes += textColors[options.textColor];
+    }
+    return `${codes}${text}\x1b[0m`;
+};
+
+// --- Execution and Watch Logic ---
+
+const runGeneration = async (collectionsFilePath?: string, outputPath?: string) => {
+    try {
+        if (!collectionsFilePath) {
+            console.error("Error: No collections file path provided. Skipping schema generation.");
+            return;
+        }
+
+        const resolvedPath = path.resolve(collectionsFilePath);
+        let collections: EntityCollection[] = [];
+        const stats = fs.statSync(resolvedPath);
+
+        if (stats.isDirectory()) {
+            const files = fs.readdirSync(resolvedPath);
+            for (const file of files) {
+                if ((file.endsWith(".ts") || file.endsWith(".js")) &&
+                    !file.includes(".test.") &&
+                    !file.endsWith(".d.ts") &&
+                    file !== "index.ts" && file !== "index.js") {
+
+                    const filePath = path.join(resolvedPath, file);
+                    try {
+                        const fileUrl = pathToFileURL(filePath).href;
+                        const dynamicImport = new Function("url", "return import(url)");
+                        const module = await dynamicImport(fileUrl);
+                        if (module && module.default) {
+                            collections.push(module.default);
+                        }
+                    } catch (err: unknown) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        console.error(`Error loading ${file}:`, message);
+                    }
+                }
+            }
+        } else {
+            const fileUrl = pathToFileURL(resolvedPath).href + `?t=${Date.now()}`;
+            const dynamicImport = new Function("url", "return import(url)");
+            const imported = await dynamicImport(fileUrl);
+            collections = imported.backendCollections || imported.collections;
+        }
+
+        if (!collections || !Array.isArray(collections) || collections.length === 0) {
+            console.error("Error: Could not find collections array or failed to load directory.");
+            return;
+        }
+
+        const schemaContent = await generateSchema(collections);
+
+        if (outputPath) {
+            const outputDir = path.dirname(outputPath);
+            await fsPromises.mkdir(outputDir, { recursive: true });
+            await fsPromises.writeFile(outputPath, schemaContent);
+            console.log("✅ Drizzle schema generated successfully at", outputPath);
+        } else {
+            console.log("✅ Drizzle schema generated successfully.");
+            console.log(schemaContent);
+        }
+
+        console.log(`You can now run ${formatTerminalText("rebase db generate", {
+            bold: true,
+            backgroundColor: "blue",
+            textColor: "black"
+        })} to generate the SQL migration files.`);
+
+    } catch (error) {
+        console.error("Error generating schema:", error);
+    }
+};
+
+const main = () => {
+    const collectionsFilePathArg = process.argv.find(arg => arg.startsWith("--collections="));
+    const collectionsFilePath = collectionsFilePathArg ? collectionsFilePathArg.split("=")[1] : process.argv[2];
+
+    const outputPathArg = process.argv.find(arg => arg.startsWith("--output="));
+    const outputPath = outputPathArg ? outputPathArg.split("=")[1] : undefined;
+
+    const watch = process.argv.includes("--watch");
+
+    if (!collectionsFilePath) {
+        console.log("Usage: ts-node generate-drizzle-schema.ts <path-to-collections-file> [--output <path-to-output-file>] [--watch]");
+        return;
+    }
+
+    const resolvedPath = path.resolve(process.cwd(), collectionsFilePath);
+    const resolvedOutputPath = outputPath ? path.resolve(process.cwd(), outputPath) : undefined;
+
+    if (watch) {
+        console.log(`Watching for changes in ${resolvedPath}...`);
+        const watcher = chokidar.watch(resolvedPath, {
+            persistent: true,
+            ignoreInitial: false
+        });
+
+        watcher.on("all", (event, filePath) => {
+            console.log(`[${event}] ${filePath}. Regenerating schema...`);
+            runGeneration(resolvedPath, resolvedOutputPath);
+        });
+    } else {
+        runGeneration(resolvedPath, resolvedOutputPath);
+    }
+};
+
+// This check ensures the script only runs when executed directly
+if (import.meta.url.endsWith(process.argv[1])) {
+    main();
+}