@vitnode/core 1.2.0-canary.60 → 1.2.0-canary.61

package/dist/scripts/get-config.js

@@ -0,0 +1,15 @@
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+export const getConfig = async ({ type = "config", }) => {
+    const configPath = join(process.cwd(), "src", `vitnode.${type}.ts`);
+    try {
+        const configUrl = pathToFileURL(configPath).href;
+        const loaded = await import(configUrl);
+        const config = type === "config" ? loaded.vitNodeConfig : loaded.vitNodeApiConfig;
+        return config;
+    }
+    catch (error) {
+        console.error("Failed to load config:", error);
+        process.exit(1);
+    }
+};

package/dist/scripts/plugin.js

@@ -0,0 +1,188 @@
+import chokidar from "chokidar";
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, } from "node:fs";
+import { basename, join, relative } from "node:path";
+import { buildInitialRouteMap, copyFile, findLocaleRoot, findRepoRoot, getAllFiles, isDirectoryEmpty, routeKey, } from "./shared/file-utils";
+const detectAppType = (appPath) => {
+    const hasWebConfig = existsSync(join(appPath, "src", "vitnode.config.ts"));
+    const hasApiConfig = existsSync(join(appPath, "src", "vitnode.api.config.ts"));
+    if (hasApiConfig && !hasWebConfig)
+        return "api";
+    if (hasWebConfig)
+        return "web";
+    return null;
+};
+const collectSources = (pluginDir, repoRoot, pluginName, pluginPathName) => {
+    const sources = [];
+    const appsDir = join(repoRoot, "apps");
+    const isMonorepo = existsSync(appsDir);
+    if (isMonorepo) {
+        const appDirs = existsSync(appsDir)
+            ? readdirSync(appsDir, { withFileTypes: true })
+                .filter(dirent => dirent.isDirectory())
+                .map(dirent => dirent.name)
+            : [];
+        for (const appName of appDirs) {
+            const appPath = join(repoRoot, "apps", appName);
+            const appType = detectAppType(appPath);
+            if (appType === "web") {
+                sources.push({
+                    sourceDir: join(pluginDir, "src", "app_admin"),
+                    destinationDir: join(appPath, "src", "app", "[locale]", "admin", "(auth)", join("(plugins)", `(${pluginPathName})`)),
+                }, {
+                    sourceDir: join(pluginDir, "src", "app"),
+                    destinationDir: join(appPath, "src", "app", "[locale]", "(main)", join("(plugins)", `(${pluginPathName})`)),
+                }, {
+                    sourceDir: join(pluginDir, "src", "locales"),
+                    destinationDir: join(appPath, "src", "locales", pluginName),
+                });
+            }
+            else if (appType === "api") {
+                sources.push({
+                    sourceDir: join(pluginDir, "src", "locales"),
+                    destinationDir: join(appPath, "src", "locales", pluginName),
+                });
+            }
+        }
+    }
+    else {
+        const cwd = process.cwd();
+        const projectType = detectAppType(cwd);
+        if (projectType === "web") {
+            sources.push({
+                sourceDir: join(pluginDir, "src", "app_admin"),
+                destinationDir: join(cwd, "src", "app", "[locale]", "admin", "(auth)", join("(plugins)", `(${pluginPathName})`)),
+            }, {
+                sourceDir: join(pluginDir, "src", "app"),
+                destinationDir: join(cwd, "src", "app", "[locale]", "(main)", join("(plugins)", `(${pluginPathName})`)),
+            }, {
+                sourceDir: join(pluginDir, "src", "locales"),
+                destinationDir: join(cwd, "src", "locales", pluginName),
+            });
+        }
+        else if (projectType === "api") {
+            sources.push({
+                sourceDir: join(pluginDir, "src", "locales"),
+                destinationDir: join(cwd, "src", "locales", pluginName),
+            });
+        }
+    }
+    return sources;
+};
+const ensureDestinationDirs = (sources) => {
+    for (const { sourceDir, destinationDir } of sources) {
+        if (existsSync(sourceDir) &&
+            !isDirectoryEmpty(sourceDir) &&
+            !existsSync(destinationDir)) {
+            mkdirSync(destinationDir, { recursive: true });
+        }
+    }
+};
+const createFileOps = (pluginName, routeMap, localeRoot, repoRoot) => {
+    const copyFileWrapper = (srcPath, destPath) => {
+        copyFile(srcPath, destPath, pluginName, routeMap, localeRoot, repoRoot);
+    };
+    const removeFile = (filePath) => {
+        try {
+            if (existsSync(filePath)) {
+                unlinkSync(filePath);
+                console.log(`\x1b[33mRemoved:\x1b[0m ${filePath}`);
+                if (/^page\.(tsx|ts|jsx|js)$/i.test(basename(filePath))) {
+                    const key = routeKey(filePath, localeRoot);
+                    if (routeMap.get(key) === filePath) {
+                        routeMap.delete(key);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`\x1b[31mError removing file:\x1b[0m ${filePath}`, error);
+        }
+    };
+    return { copyFileWrapper, removeFile };
+};
+const cleanupDeletedFiles = (sourceDir, destinationDir, removeFileFn) => {
+    if (!existsSync(destinationDir))
+        return;
+    const isLocaleDir = destinationDir.includes(join("src", "locales"));
+    if (isLocaleDir)
+        return;
+    const destFiles = getAllFiles(destinationDir);
+    for (const destFile of destFiles) {
+        const relativePath = relative(destinationDir, destFile);
+        const sourceFile = join(sourceDir, relativePath);
+        if (!existsSync(sourceFile)) {
+            removeFileFn(destFile);
+        }
+    }
+};
+const makeGetDestinationPaths = (sources) => {
+    return (srcPath) => {
+        const candidates = sources.filter(({ sourceDir }) => {
+            const normalizedSrcPath = srcPath.replace(/\\/g, "/");
+            const normalizedSourceDir = sourceDir.replace(/\\/g, "/");
+            return (normalizedSrcPath === normalizedSourceDir ||
+                normalizedSrcPath.startsWith(`${normalizedSourceDir}/`));
+        });
+        if (candidates.length === 0) {
+            throw new Error(`No matching source directory for: ${srcPath}`);
+        }
+        return candidates.map(sourceConfig => {
+            const relativePath = relative(sourceConfig.sourceDir, srcPath);
+            return join(sourceConfig.destinationDir, relativePath);
+        });
+    };
+};
+const setupWatcher = (sourceDirs, getDestinationPaths, copyFileWrapper, removeFile) => {
+    const watcher = chokidar.watch(sourceDirs, {
+        ignoreInitial: false,
+        persistent: true,
+    });
+    watcher
+        .on("add", filePath => {
+        const destPaths = getDestinationPaths(filePath);
+        destPaths.forEach(destPath => copyFileWrapper(filePath, destPath));
+    })
+        .on("change", filePath => {
+        const destPaths = getDestinationPaths(filePath);
+        destPaths.forEach(destPath => copyFileWrapper(filePath, destPath));
+    })
+        .on("unlink", filePath => {
+        const destPaths = getDestinationPaths(filePath);
+        destPaths.forEach(destPath => removeFile(destPath));
+    })
+        .on("error", error => {
+        console.error("\x1b[31mWatcher error:\x1b[0m", error);
+    });
+    return watcher;
+};
+export const processPlugin = ({ initMessage }) => {
+    const pluginDir = process.cwd();
+    const repoRoot = findRepoRoot(pluginDir);
+    const localeRoot = findLocaleRoot(repoRoot);
+    const routeMap = buildInitialRouteMap(localeRoot);
+    let pluginName = basename(pluginDir);
+    try {
+        const packageJsonPath = join(pluginDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            pluginName = packageJson.name ?? "";
+        }
+    }
+    catch (error) {
+        console.error("\x1b[31mError reading package.json:\x1b[0m", error);
+        return;
+    }
+    const pluginPathName = pluginName.replace(/\//g, "-").replace(/@/g, "");
+    const sources = collectSources(pluginDir, repoRoot, pluginName, pluginPathName);
+    ensureDestinationDirs(sources);
+    const { copyFileWrapper, removeFile } = createFileOps(pluginName, routeMap, localeRoot, repoRoot);
+    for (const { sourceDir, destinationDir } of sources) {
+        cleanupDeletedFiles(sourceDir, destinationDir, removeFile);
+    }
+    console.log(`${initMessage} \x1b[34mWatching for changes in plugins...\x1b[0m`);
+    const sourceDirs = sources
+        .map(s => s.sourceDir)
+        .filter(dir => existsSync(dir));
+    const getDestinationPaths = makeGetDestinationPaths(sources);
+    setupWatcher(sourceDirs, getDestinationPaths, copyFileWrapper, removeFile);
+};

package/dist/scripts/prepare-database.js

@@ -0,0 +1,177 @@
+import { count } from "drizzle-orm";
+import { core_admin_permissions } from "../src/database/admins.js";
+import { core_languages, core_languages_words } from "../src/database/languages.js";
+import { core_moderators_permissions } from "../src/database/moderators.js";
+import { core_roles } from "../src/database/roles.js";
+import { getConfig } from "./get-config.js";
+import { preparePluginsFiles } from "./prepare-plugins-files.js";
+import { runInteractiveShellCommand } from "./run-interactive-shell-command.js";
+export const generateDatabaseMigrations = async () => {
+    try {
+        await runInteractiveShellCommand("npm", ["run", "drizzle-kit", "up"]);
+        await runInteractiveShellCommand("npm", ["run", "drizzle-kit", "generate"]);
+    }
+    catch (err) {
+        console.error("\x1b[31m%s\x1b[0m", err);
+        process.exit(1);
+    }
+};
+export const runMigrations = async () => {
+    try {
+        await runInteractiveShellCommand("npm", ["run", "drizzle-kit", "migrate"]);
+    }
+    catch (err) {
+        console.error("\x1b[31m%s\x1b[0m", err);
+        process.exit(1);
+    }
+};
+export const initialDataForDatabase = async () => {
+    const config = await getConfig({ type: "api.config" });
+    const dbClient = config.dbProvider;
+    const [roleCount] = await dbClient
+        .select({
+        count: count(),
+    })
+        .from(core_roles)
+        .limit(1);
+    const [languageCount] = await dbClient
+        .select({
+        count: count(),
+    })
+        .from(core_languages);
+    if (languageCount.count === 0) {
+        await dbClient.insert(core_languages).values([
+            {
+                code: "en",
+                name: "English (USA)",
+                default: true,
+                protected: true,
+                timezone: "America/New_York",
+            },
+        ]);
+    }
+    if (roleCount.count === 0) {
+        const roles = await dbClient
+            .insert(core_roles)
+            .values([
+            {
+                protected: true,
+                guest: true,
+            },
+            {
+                protected: true,
+                default: true,
+            },
+            {
+                protected: true,
+                color: "hsl(122, 80%, 45%)",
+            },
+            {
+                protected: true,
+                root: true,
+                color: "hsl(0, 100%, 50%)",
+            },
+        ])
+            .returning({ id: core_roles.id });
+        await dbClient.insert(core_languages_words).values([
+            {
+                languageCode: "en",
+                pluginCode: "core",
+                itemId: roles[0].id,
+                value: "Guest",
+                tableName: "core_roles",
+                variable: "name",
+            },
+            {
+                languageCode: "en",
+                pluginCode: "core",
+                itemId: roles[1].id,
+                value: "Member",
+                tableName: "core_roles",
+                variable: "name",
+            },
+            {
+                languageCode: "en",
+                pluginCode: "core",
+                itemId: roles[2].id,
+                value: "Moderator",
+                tableName: "core_roles",
+                variable: "name",
+            },
+            {
+                languageCode: "en",
+                pluginCode: "core",
+                itemId: roles[3].id,
+                value: "Administrator",
+                tableName: "core_roles",
+                variable: "name",
+            },
+        ]);
+        await dbClient.insert(core_moderators_permissions).values([
+            {
+                roleId: roles[2].id,
+                protected: true,
+            },
+            {
+                roleId: roles[3].id,
+                protected: true,
+            },
+        ]);
+        await dbClient.insert(core_admin_permissions).values({
+            roleId: roles[3].id,
+            protected: true,
+        });
+    }
+};
+export const prepareDatabase = async ({ initMessage, flag, }) => {
+    const steps = [];
+    if (flag === "--web") {
+        steps.push({
+            label: "Prepare plugins files...",
+            action: async () => await preparePluginsFiles(flag),
+        });
+    }
+    else if (flag === "--api") {
+        steps.push({
+            label: "Prepare plugins files...",
+            action: async () => await preparePluginsFiles(flag),
+        }, {
+            label: "Generate migrations...",
+            action: generateDatabaseMigrations,
+        }, {
+            label: "Run migrations...",
+            action: runMigrations,
+        }, {
+            label: "Insert initial data...",
+            action: initialDataForDatabase,
+        });
+    }
+    else {
+        steps.push({
+            label: "Prepare plugins files...",
+            action: async () => await preparePluginsFiles(flag),
+        }, {
+            label: "Generate migrations...",
+            action: generateDatabaseMigrations,
+        }, {
+            label: "Run migrations...",
+            action: runMigrations,
+        }, {
+            label: "Insert initial data...",
+            action: initialDataForDatabase,
+        });
+    }
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const stepNum = `[${i + 1}/${steps.length}]`;
+        if (step.label === "Insert initial data...") {
+            console.log(`\n${initMessage} ${stepNum} ${step.label}`);
+        }
+        else {
+            console.log(`${initMessage} ${stepNum} ${step.label}`);
+        }
+        await step.action();
+    }
+    console.log(`${initMessage} \x1b[32mInitial setup completed.\x1b[0m`);
+    process.exit(0);
+};

package/dist/scripts/prepare-plugins-files.js

@@ -0,0 +1,134 @@
+import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { getConfig } from "./get-config";
+import { buildInitialRouteMap, copyDirectoryRecursive, findLocaleRoot, findRepoRoot, isDirectoryEmpty, } from "./shared/file-utils";
+export const preparePluginsFiles = async (flag) => {
+    const cwd = process.cwd();
+    const hasWebConfig = existsSync(join(cwd, "src", "vitnode.config.ts"));
+    const hasApiConfig = existsSync(join(cwd, "src", "vitnode.api.config.ts"));
+    let config;
+    if (flag === "--api" && hasApiConfig) {
+        config = await getConfig({ type: "api.config" });
+    }
+    else if (flag === "--web" && hasWebConfig) {
+        config = await getConfig({});
+    }
+    else if (hasApiConfig && !hasWebConfig) {
+        config = await getConfig({ type: "api.config" });
+    }
+    else if (hasWebConfig) {
+        config = await getConfig({});
+    }
+    else {
+        config = { plugins: [] };
+    }
+    const plugins = [
+        ...config.plugins.map(plugin => plugin.pluginId),
+        "@vitnode/core",
+    ];
+    const repoRoot = findRepoRoot(process.cwd());
+    const localeRoot = findLocaleRoot(repoRoot);
+    const routeMap = buildInitialRouteMap(localeRoot);
+    const baseDir = process.cwd();
+    const findPluginPath = (pluginName) => {
+        const cwd = process.cwd();
+        const cwdPluginPath = join(cwd, "node_modules", pluginName);
+        if (existsSync(cwdPluginPath)) {
+            return cwdPluginPath;
+        }
+        if (repoRoot && repoRoot !== cwd) {
+            const rootPluginPath = join(repoRoot, "node_modules", pluginName);
+            if (existsSync(rootPluginPath)) {
+                return rootPluginPath;
+            }
+        }
+        return null;
+    };
+    await Promise.all(plugins.map(async (pluginName) => {
+        const pluginPath = findPluginPath(pluginName);
+        if (!pluginPath) {
+            console.error(`\x1b[31mPlugin not found:\x1b[0m ${pluginName} in node_modules`);
+            return;
+        }
+        let packageName = "";
+        try {
+            const packageJsonPath = join(pluginPath, "package.json");
+            if (existsSync(packageJsonPath)) {
+                const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+                packageName = packageJson.name ?? "";
+            }
+        }
+        catch (error) {
+            console.error(`\x1b[31mError reading package.json for ${pluginName}:\x1b[0m`, error);
+            return;
+        }
+        const pluginPathName = pluginName.replace(/\//g, "-").replace(/@/g, "");
+        const detectAppType = (appPath) => {
+            const hasWebConfig = existsSync(join(appPath, "src", "vitnode.config.ts"));
+            const hasApiConfig = existsSync(join(appPath, "src", "vitnode.api.config.ts"));
+            if (hasApiConfig && !hasWebConfig)
+                return "api";
+            if (hasWebConfig)
+                return "web";
+            return null;
+        };
+        const appsDir = join(repoRoot, "apps");
+        const isMonorepo = existsSync(appsDir);
+        const sources = [];
+        if (isMonorepo) {
+            const appDirs = existsSync(appsDir)
+                ? readdirSync(appsDir, { withFileTypes: true })
+                    .filter(dirent => dirent.isDirectory())
+                    .map(dirent => dirent.name)
+                : [];
+            for (const appName of appDirs) {
+                const appPath = join(repoRoot, "apps", appName);
+                const appType = detectAppType(appPath);
+                if (appType === "web") {
+                    const mainDest = join(appPath, "src", "app", "[locale]", "(main)", join("(plugins)", `(${pluginPathName})`));
+                    const adminDest = join(appPath, "src", "app", "[locale]", "admin", "(auth)", join("(plugins)", `(${pluginPathName})`));
+                    const langDest = join(appPath, "src", "locales", pluginName);
+                    sources.push({
+                        sourceDir: join(pluginPath, "src", "app_admin"),
+                        destinationDir: adminDest,
+                    }, {
+                        sourceDir: join(pluginPath, "src", "app"),
+                        destinationDir: mainDest,
+                    }, {
+                        sourceDir: join(pluginPath, "src", "locales"),
+                        destinationDir: langDest,
+                    });
+                }
+                else if (appType === "api") {
+                    const apiLangDest = join(appPath, "src", "locales", pluginName);
+                    sources.push({
+                        sourceDir: join(pluginPath, "src", "locales"),
+                        destinationDir: apiLangDest,
+                    });
+                }
+            }
+        }
+        else {
+            const mainDest = join(baseDir, "src", "app", "[locale]", "(main)", join("(plugins)", `(${pluginPathName})`));
+            const adminDest = join(baseDir, "src", "app", "[locale]", "admin", "(auth)", join("(plugins)", `(${pluginPathName})`));
+            const langDest = join(baseDir, "src", "locales", pluginName);
+            sources.push({
+                sourceDir: join(pluginPath, "src", "app_admin"),
+                destinationDir: adminDest,
+            }, {
+                sourceDir: join(pluginPath, "src", "app"),
+                destinationDir: mainDest,
+            }, {
+                sourceDir: join(pluginPath, "src", "locales"),
+                destinationDir: langDest,
+            });
+        }
+        for (const { sourceDir, destinationDir } of sources) {
+            if (existsSync(sourceDir) && !isDirectoryEmpty(sourceDir)) {
+                console.log(`\x1b[36mCopying ${pluginName}:\x1b[0m ${relative(repoRoot, sourceDir)} → ${relative(repoRoot, destinationDir)}`);
+                copyDirectoryRecursive(sourceDir, destinationDir, packageName, routeMap, localeRoot, repoRoot, false);
+            }
+        }
+    }));
+};

package/dist/scripts/run-interactive-shell-command.js

@@ -0,0 +1,21 @@
+import { spawn } from "node:child_process";
+export const runInteractiveShellCommand = async (cmd, args = []) => {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            stdio: "inherit",
+            shell: true,
+            env: process.env,
+        });
+        child.on("error", error => {
+            reject(error);
+        });
+        child.on("close", code => {
+            if (code !== 0) {
+                reject(new Error(`Command failed with exit code ${code}`));
+            }
+            else {
+                resolve(true);
+            }
+        });
+    });
+};