@reliverse/dler 1.7.92 → 1.7.94

package/bin/app/init/init-utils/mm-deprecated/editor-menu.js

@@ -0,0 +1,404 @@
+import { re } from "@reliverse/relico";
+import { relinka } from "@reliverse/relinka";
+import { inputPrompt, runCmd, selectPrompt } from "@reliverse/rempts";
+import { getAuthCmd } from "@/app/cmds";
+import { useLanguine } from "../../../add/add-local/i18n/languine.js";
+import { getProjectContent } from "../../../config/cfg-content.js";
+import { envArgImpl } from "../../../env/env-impl.js";
+import { manageDrizzleSchema } from "../../mm-deprecated/drizzle/manageDrizzleSchema.js";
+import { handleIntegrations } from "../../mm-deprecated/editor-impl.js";
+import { manageShadcn } from "../../mm-deprecated/shadcn/shadcn-mod.js";
+import { deployProject } from "../../use-template/cp-modules/git-deploy-prompts/deploy.js";
+import {
+  createCommit,
+  handleGithubRepo,
+  initGitDir,
+  pushGitCommits
+} from "../../use-template/cp-modules/git-deploy-prompts/git.js";
+import { checkGithubRepoOwnership } from "../../use-template/cp-modules/git-deploy-prompts/github.js";
+import { ensureDbInitialized } from "../../use-template/cp-modules/git-deploy-prompts/helpers/handlePkgJsonScripts.js";
+import { checkVercelDeployment } from "../../use-template/cp-modules/git-deploy-prompts/vercel/vercel-check.js";
+import { experimental } from "../../../utils/badgeNotifiers.js";
+import {
+  convertDatabaseProvider,
+  convertPrismaToDrizzle
+} from "../../../utils/codemods/convertDatabase.js";
+import { handleCleanup } from "../../../utils/handlers/handleCleanup.js";
+import { handleCodemods } from "../../../utils/handlers/handleCodemods.js";
+import { initGithubSDK } from "../../../utils/instanceGithub.js";
+import { initVercelSDK } from "../../../utils/instanceVercel.js";
+import { checkScriptExists } from "../../../utils/pkgJsonHelpers.js";
+import { askInstallDeps } from "../../../utils/prompts/askInstallDeps.js";
+import { askUsernameFrontend } from "../../../utils/prompts/askUsernameFrontend.js";
+export async function handleOpenProjectMenu(projects, isDev, memory, cwd, maskInput, config) {
+  const frontendUsername = await askUsernameFrontend(config, false);
+  if (!frontendUsername) {
+    throw new Error(
+      "Failed to determine your frontend username. Please try again or notify the CLI developers."
+    );
+  }
+  let selectedProject;
+  if (projects.length === 1) {
+    selectedProject = projects[0];
+  } else {
+    const projectOptions = projects.map((project) => ({
+      label: project.name,
+      value: project.path,
+      ...project.needsDepsInstall ? { hint: re.dim("no deps found, <enter> to install") } : project.hasGit && project.gitStatus ? {
+        hint: re.dim(
+          `${project.gitStatus?.uncommittedChanges ?? 0} uncommitted changes, ${project.gitStatus?.unpushedCommits ?? 0} unpushed commits`
+        )
+      } : {}
+    }));
+    const selectedPath = await selectPrompt({
+      title: "Select a project to manage",
+      options: [...projectOptions, { label: "Exit", value: "exit" }]
+    });
+    if (selectedPath === "exit") return;
+    selectedProject = projects.find((p) => p.path === selectedPath);
+  }
+  if (!selectedProject) {
+    relinka("error", "Project not found");
+    return;
+  }
+  let hasNodeModules = false;
+  if (selectedProject.needsDepsInstall) {
+    const depsStillMissing = await askInstallDeps(selectedProject.path);
+    if (!depsStillMissing) {
+      selectedProject.needsDepsInstall = false;
+      hasNodeModules = true;
+    }
+  }
+  const projectContent = await getProjectContent(selectedProject.path);
+  if (!hasNodeModules) {
+    hasNodeModules = projectContent.optionalContent.dirNodeModules;
+  }
+  const gitStatusInfo = selectedProject.hasGit ? ` (${selectedProject.gitStatus?.uncommittedChanges ?? 0} uncommitted changes, ${selectedProject.gitStatus?.unpushedCommits ?? 0} unpushed commits)` : "";
+  const depsWarning = hasNodeModules ? "" : "Some addons were disabled because dependencies are not installed.";
+  const action = await selectPrompt({
+    title: `[@reliverse/relifso] Managing project: ${selectedProject.name}${gitStatusInfo}`,
+    content: depsWarning ? re.bold(depsWarning) : "",
+    options: [
+      {
+        label: "Generate BetterAuth schema",
+        value: "better-auth",
+        hint: re.dim("better better-auth cli")
+      },
+      {
+        label: "Git and deploy operations",
+        value: "git-deploy",
+        hint: re.dim("commit and push changes")
+      },
+      {
+        label: "Translate selected project",
+        value: "languine",
+        hint: re.dim("powerful i18n addon")
+      },
+      {
+        label: "Compose .env file",
+        value: "env",
+        hint: re.dim("create .env file")
+      },
+      {
+        label: !hasNodeModules ? re.gray(`Code modifications ${experimental}`) : `Code modifications ${experimental}`,
+        value: "codemods",
+        hint: re.dim("apply code transformations"),
+        disabled: !hasNodeModules
+      },
+      {
+        label: !hasNodeModules ? re.gray(`Integrations ${experimental}`) : `Integrations ${experimental}`,
+        value: "integrations",
+        hint: re.dim("manage project integrations"),
+        disabled: !hasNodeModules
+      },
+      {
+        label: !hasNodeModules ? re.gray(`Database operations ${experimental}`) : `Database operations ${experimental}`,
+        value: "convert-db",
+        hint: re.dim("convert between database types"),
+        disabled: !hasNodeModules
+      },
+      {
+        label: !hasNodeModules ? re.gray(`Add shadcn/ui components ${experimental}`) : `Add shadcn/ui components ${experimental}`,
+        value: "shadcn",
+        hint: re.dim("manage ui components"),
+        disabled: !hasNodeModules
+      },
+      {
+        label: !hasNodeModules ? re.gray(`Drizzle schema ${experimental}`) : `Drizzle schema ${experimental}`,
+        value: "drizzle-schema",
+        hint: re.dim("manage database schema"),
+        disabled: !hasNodeModules
+      },
+      {
+        label: !hasNodeModules ? re.gray(`Cleanup project ${experimental}`) : `Cleanup project ${experimental}`,
+        value: "cleanup",
+        hint: re.dim("clean up project files"),
+        disabled: !hasNodeModules
+      },
+      {
+        label: "\u{1F448} Exit",
+        value: "exit",
+        hint: re.dim("press ctrl+c at any time")
+      }
+    ]
+  });
+  if (action === "exit") return;
+  switch (action) {
+    case "better-auth": {
+      relinka("info", "The following args will be passed to the rse auth command:");
+      relinka("log", `--config ${selectedProject.path}/src/lib/auth.ts`);
+      relinka("log", `--output ${selectedProject.path}/src/db/schema/user/tables.ts`);
+      await runCmd(await getAuthCmd(), [
+        `--config ${selectedProject.path}/src/lib/auth.ts --output ${selectedProject.path}/src/db/schema/user/tables.ts`
+      ]);
+      break;
+    }
+    case "git-deploy": {
+      const githubResult = await initGithubSDK(memory, frontendUsername, maskInput);
+      if (!githubResult) {
+        throw new Error("Failed to initialize GitHub SDK. Please notify the CLI developers.");
+      }
+      const [githubToken, githubInstance, githubUsername] = githubResult;
+      const vercelResult = await initVercelSDK(memory, maskInput);
+      if (!vercelResult) {
+        throw new Error("Failed to initialize Vercel SDK. Please notify the CLI developers.");
+      }
+      const [vercelToken, vercelInstance] = vercelResult;
+      let showCreateGithubOption = true;
+      let hasGithubRepo = false;
+      const hasDbPush = await checkScriptExists(selectedProject.path, "db:push");
+      const shouldRunDbPush = false;
+      const { exists, isOwner } = await checkGithubRepoOwnership(
+        githubInstance,
+        githubUsername,
+        selectedProject.name
+      );
+      showCreateGithubOption = !exists;
+      hasGithubRepo = exists && isOwner;
+      const gitOptions = [
+        ...selectedProject.hasGit ? [
+          { label: "Create commit", value: "commit" },
+          ...selectedProject.gitStatus?.unpushedCommits && hasGithubRepo ? [
+            {
+              label: `Push ${selectedProject.gitStatus.unpushedCommits} commits`,
+              value: "push"
+            }
+          ] : []
+        ] : [{ label: "Initialize Git repository", value: "init" }],
+        ...showCreateGithubOption ? [
+          {
+            label: "Re/init git and create GitHub repository",
+            value: "github"
+          }
+        ] : [],
+        ...selectedProject.hasGit && hasGithubRepo ? [{ label: "Deploy project", value: "deploy" }] : [],
+        { label: "\u{1F448} Exit", value: "exit" }
+      ];
+      const gitAction = await selectPrompt({
+        title: "Git and Deploy Operations",
+        options: gitOptions
+      });
+      if (gitAction === "exit") return;
+      if (gitAction === "init") {
+        relinka("verbose", "[A] initGitDir");
+        const success = await initGitDir({
+          cwd,
+          isDev,
+          projectPath: selectedProject.path,
+          projectName: selectedProject.name,
+          allowReInit: true,
+          createCommit: true,
+          config: selectedProject.config,
+          isTemplateDownload: false
+        });
+        if (success) {
+          relinka("success", "Git repository initialized successfully");
+          selectedProject.hasGit = true;
+        }
+      } else if (gitAction === "commit") {
+        const message = await inputPrompt({ title: "Enter commit message" });
+        if (message) {
+          const success = await createCommit({
+            cwd,
+            isDev,
+            projectPath: selectedProject.path,
+            projectName: selectedProject.name,
+            message,
+            config: selectedProject.config,
+            isTemplateDownload: false
+          });
+          if (success) {
+            relinka("success", "Commit created successfully");
+            if (selectedProject.gitStatus) {
+              selectedProject.gitStatus.unpushedCommits = (selectedProject.gitStatus.unpushedCommits || 0) + 1;
+              selectedProject.gitStatus.uncommittedChanges = 0;
+            }
+          }
+        }
+      } else if (gitAction === "push") {
+        const success = await pushGitCommits({
+          cwd,
+          isDev,
+          projectName: selectedProject.name,
+          projectPath: selectedProject.path
+        });
+        if (success) {
+          relinka("success", "Commits pushed successfully");
+          if (selectedProject.gitStatus) {
+            selectedProject.gitStatus.unpushedCommits = 0;
+          }
+        }
+      } else if (gitAction === "github") {
+        const success = await handleGithubRepo({
+          skipPrompts: false,
+          cwd,
+          isDev,
+          memory,
+          config,
+          projectName: selectedProject.name,
+          projectPath: selectedProject.path,
+          maskInput,
+          githubUsername,
+          selectedTemplate: "blefnk/relivator-nextjs-template",
+          isTemplateDownload: false,
+          githubInstance,
+          githubToken
+        });
+        if (success) {
+          relinka("success", "GitHub repository created successfully");
+        }
+      } else if (gitAction === "deploy") {
+        const dbStatus = await ensureDbInitialized(
+          hasDbPush,
+          shouldRunDbPush,
+          !hasNodeModules,
+          selectedProject.path
+        );
+        if (dbStatus === "cancel") {
+          relinka("info", "Deployment cancelled.");
+          return;
+        }
+        const isDeployed = await checkVercelDeployment(
+          selectedProject.name,
+          githubUsername,
+          githubToken,
+          githubInstance
+        );
+        if (isDeployed) {
+          relinka(
+            "success",
+            "Project already has Vercel deployments configured on GitHub.",
+            "New deployments are automatically triggered on new commits."
+          );
+          return;
+        }
+        relinka("info", "No existing deployment found. Initializing new deployment...");
+        const { deployService } = await deployProject(
+          githubInstance,
+          vercelInstance,
+          vercelToken,
+          githubToken,
+          false,
+          selectedProject.name,
+          selectedProject.config,
+          selectedProject.path,
+          "",
+          memory,
+          "update",
+          githubUsername
+        );
+        if (deployService !== "none") {
+          relinka(
+            "success",
+            `Project deployed successfully to ${deployService.charAt(0).toUpperCase() + deployService.slice(1)}`
+          );
+        }
+      }
+      break;
+    }
+    case "languine": {
+      await useLanguine(selectedProject.path);
+      break;
+    }
+    case "codemods": {
+      await handleCodemods(selectedProject.config, selectedProject.path);
+      break;
+    }
+    case "integrations": {
+      await handleIntegrations(selectedProject.path, isDev);
+      break;
+    }
+    case "convert-db": {
+      const conversionType = await selectPrompt({
+        title: "What kind of conversion would you like to perform?",
+        options: [
+          {
+            label: "Convert from Prisma to Drizzle",
+            value: "prisma-to-drizzle"
+          },
+          { label: "Convert database provider", value: "change-provider" }
+        ]
+      });
+      if (conversionType === "prisma-to-drizzle") {
+        const targetDb = await selectPrompt({
+          title: "Select target database type:",
+          options: [
+            { label: "PostgreSQL", value: "postgres" },
+            { label: "MySQL", value: "mysql" },
+            { label: "SQLite", value: "sqlite" }
+          ]
+        });
+        await convertPrismaToDrizzle(selectedProject.path, targetDb);
+      } else if (conversionType === "change-provider") {
+        const fromProvider = await selectPrompt({
+          title: "Convert from:",
+          options: [
+            { label: "PostgreSQL", value: "postgres" },
+            { label: "MySQL", value: "mysql" },
+            { label: "SQLite", value: "sqlite" }
+          ]
+        });
+        const toProviderOptions = [
+          { label: "PostgreSQL", value: "postgres" },
+          { label: "MySQL", value: "mysql" },
+          { label: "SQLite", value: "sqlite" }
+        ];
+        if (fromProvider === "postgres") {
+          toProviderOptions.push({ label: "LibSQL/Turso", value: "libsql" });
+        }
+        const toProvider = await selectPrompt({
+          title: "Convert to:",
+          options: toProviderOptions.filter((opt) => opt.value !== fromProvider)
+        });
+        await convertDatabaseProvider(selectedProject.path, fromProvider, toProvider);
+      }
+      break;
+    }
+    case "shadcn": {
+      await manageShadcn(selectedProject.path);
+      break;
+    }
+    case "drizzle-schema": {
+      await manageDrizzleSchema(selectedProject.path, false);
+      break;
+    }
+    case "cleanup": {
+      await handleCleanup(cwd, selectedProject.path, isDev);
+      break;
+    }
+    case "env": {
+      await envArgImpl(isDev, selectedProject.path);
+      break;
+    }
+    case "updater": {
+      break;
+    }
+    case "i18n": {
+      break;
+    }
+    default: {
+      relinka("error", "Invalid action selected");
+      break;
+    }
+  }
+}

package/bin/app/init/mm-deprecated/drizzle/manageDrizzleConstants.d.ts

@@ -0,0 +1,2 @@
+import type { DatabaseProvider } from "../../../types/mod.js";
+export declare const COLUMN_TYPES: Record<DatabaseProvider, string[]>;

package/bin/app/init/mm-deprecated/drizzle/manageDrizzleConstants.js

@@ -0,0 +1,36 @@
+export const COLUMN_TYPES = {
+  postgres: [
+    "serial",
+    "integer",
+    "bigint",
+    "text",
+    "varchar",
+    "boolean",
+    "timestamp",
+    "timestamptz",
+    "date",
+    "time",
+    "uuid",
+    "json",
+    "jsonb",
+    "decimal",
+    "real",
+    "double"
+  ],
+  mysql: [
+    "int",
+    "bigint",
+    "varchar",
+    "text",
+    "boolean",
+    "timestamp",
+    "datetime",
+    "date",
+    "time",
+    "json",
+    "decimal",
+    "float",
+    "double"
+  ],
+  sqlite: ["integer", "text", "blob", "real", "numeric", "boolean", "datetime"]
+};

package/bin/app/init/mm-deprecated/drizzle/manageDrizzleSchema.d.ts

@@ -0,0 +1 @@
+export declare function manageDrizzleSchema(cwd: string, isDev: boolean): Promise<void>;

package/bin/app/init/mm-deprecated/drizzle/manageDrizzleSchema.js

@@ -0,0 +1,81 @@
+import path from "@reliverse/pathkit";
+import { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt, selectPrompt } from "@reliverse/rempts";
+import {
+  addNewTable,
+  detectDatabaseProvider,
+  manageRelations,
+  removeTable,
+  renameTable,
+  setupDrizzle
+} from "./manageDrizzleSchemaUtils.js";
+export async function manageDrizzleSchema(cwd, isDev) {
+  const singleSchemaDir = isDev ? path.join(cwd, "src/app/db") : path.join(cwd, "src/db");
+  const multiSchemaDir = path.join(singleSchemaDir, "schema");
+  let provider = await detectDatabaseProvider(cwd);
+  if (!provider) {
+    provider = await setupDrizzle(cwd, isDev);
+    if (!provider) {
+      relinka("error", "Failed to set up Drizzle.");
+      return;
+    }
+  }
+  const useMultipleFiles = await confirmPrompt({
+    title: "Would you like to use multiple files for schema (one file per table)?",
+    content: "This will organize tables in src/db/schema/* instead of a single schema.ts file",
+    defaultValue: false
+  });
+  if (useMultipleFiles) {
+    await ensuredir(multiSchemaDir);
+  } else {
+    await ensuredir(singleSchemaDir);
+  }
+  const action = await selectPrompt({
+    title: "What would you like to do?",
+    options: [
+      { label: "Add new table", value: "add" },
+      { label: "Remove table", value: "remove" },
+      { label: "Rename table", value: "rename" },
+      { label: "Manage relations", value: "relations" }
+    ]
+  });
+  switch (action) {
+    case "add":
+      await addNewTable(
+        cwd,
+        useMultipleFiles,
+        provider
+        // singleSchemaDir,
+        // multiSchemaDir,
+      );
+      break;
+    case "remove":
+      await removeTable(
+        cwd,
+        useMultipleFiles,
+        provider
+        // singleSchemaDir,
+        // multiSchemaDir,
+      );
+      break;
+    case "rename":
+      await renameTable(
+        cwd,
+        useMultipleFiles,
+        provider
+        // singleSchemaDir,
+        // multiSchemaDir,
+      );
+      break;
+    case "relations":
+      await manageRelations(
+        cwd,
+        useMultipleFiles,
+        provider
+        // singleSchemaDir,
+        // multiSchemaDir,
+      );
+      break;
+  }
+}

package/bin/app/init/mm-deprecated/drizzle/manageDrizzleSchemaUtils.d.ts

@@ -0,0 +1,16 @@
+import type { ColumnType, DatabaseProvider, TableSchema } from "../../../types/mod.js";
+export declare function detectDatabaseProvider(cwd: string): Promise<DatabaseProvider | null>;
+export declare function setupDrizzle(cwd: string, isDev: boolean): Promise<DatabaseProvider | null>;
+export declare function getAvailableTables(cwd: string, useMultipleFiles: boolean): Promise<string[]>;
+export declare function addNewTable(cwd: string, useMultipleFiles: boolean, provider: DatabaseProvider): Promise<void>;
+export declare function removeTable(cwd: string, useMultipleFiles: boolean, provider: DatabaseProvider): Promise<void>;
+export declare function renameTable(cwd: string, useMultipleFiles: boolean, provider: DatabaseProvider): Promise<void>;
+export declare function manageRelations(cwd: string, useMultipleFiles: boolean, provider: DatabaseProvider): Promise<void>;
+export declare function generateTableFile(filePath: string, schema: TableSchema, provider: DatabaseProvider): Promise<void>;
+export declare function updateSchemaIndex(indexPath: string, tableName: string): Promise<void>;
+export declare function appendTableToSchema(filePath: string, schema: TableSchema, provider: DatabaseProvider): Promise<void>;
+export declare function removeFromSchemaIndex(indexPath: string, tableName: string): Promise<void>;
+export declare function removeTableFromSchema(filePath: string, tableName: string, provider: DatabaseProvider): Promise<void>;
+export declare function renameTableInSchema(filePath: string, oldName: string, newName: string, provider: DatabaseProvider): Promise<void>;
+export declare function updateTableNameInIndex(indexPath: string, oldName: string, newName: string): Promise<void>;
+export declare function addColumnToTable(filePath: string, tableName: string, column: ColumnType, provider: DatabaseProvider): Promise<void>;