@reliverse/dler 1.7.153 → 2.0.1

package/bin/impl/providers/better-t-stack/helpers/database-providers/neon-setup.js

@@ -1,168 +0,0 @@
-import path from "node:path";
-import { re } from "@reliverse/relico";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { cancel, createSpinner, isCancel, select, text } from "@reliverse/rempts";
-import { execa } from "execa";
-import {
-  addEnvVariablesToFile
-} from "../project-generation/env-setup.js";
-import { getPackageExecutionCommand } from "../../utils/get-package-execution-command.js";
-const NEON_REGIONS = [
-  { label: "AWS US East (N. Virginia)", value: "aws-us-east-1" },
-  { label: "AWS US East (Ohio)", value: "aws-us-east-2" },
-  { label: "AWS US West (Oregon)", value: "aws-us-west-2" },
-  { label: "AWS Europe (Frankfurt)", value: "aws-eu-central-1" },
-  { label: "AWS Asia Pacific (Singapore)", value: "aws-ap-southeast-1" },
-  { label: "AWS Asia Pacific (Sydney)", value: "aws-ap-southeast-2" },
-  { label: "Azure East US 2 region (Virginia)", value: "azure-eastus2" }
-];
-async function executeNeonCommand(packageManager, commandArgsString, spinnerText) {
-  const s = createSpinner({
-    text: spinnerText ?? `Running ${packageManager} command...`
-  });
-  try {
-    const fullCommand = getPackageExecutionCommand(packageManager, commandArgsString);
-    if (spinnerText) s.start(spinnerText);
-    const result = await execa(fullCommand, { shell: true });
-    if (spinnerText)
-      s.succeed(re.green(spinnerText.replace("...", "").replace("ing ", "ed ").trim()));
-    return result;
-  } catch (error) {
-    if (s) s.fail(re.red(`Failed: ${spinnerText || "Command execution"}`));
-    throw error;
-  }
-}
-async function createNeonProject(projectName, regionId, packageManager) {
-  try {
-    const commandArgsString = `neonctl projects create --name ${projectName} --region-id ${regionId} --output json`;
-    const { stdout } = await executeNeonCommand(
-      packageManager,
-      commandArgsString,
-      `Creating Neon project "${projectName}"...`
-    );
-    const response = JSON.parse(stdout);
-    if (response.project && response.connection_uris && response.connection_uris.length > 0 && response.connection_uris[0]?.connection_uri && response.connection_uris[0]?.connection_parameters) {
-      const projectId = response.project.id;
-      const connectionUri = response.connection_uris[0].connection_uri;
-      const params = response.connection_uris[0].connection_parameters;
-      return {
-        connectionString: connectionUri,
-        projectId,
-        dbName: params.database,
-        roleName: params.role
-      };
-    }
-    relinka("error", re.red("Failed to extract connection information from response"));
-    return null;
-  } catch (_error) {
-    relinka("error", re.red("Failed to create Neon project"));
-  }
-}
-async function writeEnvFile(projectDir, config) {
-  const envPath = path.join(projectDir, "apps/server", ".env");
-  const variables = [
-    {
-      key: "DATABASE_URL",
-      value: config?.connectionString ?? "postgresql://postgres:postgres@localhost:5432/mydb?schema=public",
-      condition: true
-    }
-  ];
-  await addEnvVariablesToFile(envPath, variables);
-  return true;
-}
-async function setupWithNeonDb(projectDir, packageManager) {
-  try {
-    const s = createSpinner({
-      text: "Creating Neon database using neondb..."
-    });
-    s.start("Creating Neon database using neondb...");
-    const serverDir = path.join(projectDir, "apps/server");
-    await fs.ensureDir(serverDir);
-    const packageCmd = getPackageExecutionCommand(packageManager, "neondb --yes");
-    await execa(packageCmd, {
-      shell: true,
-      cwd: serverDir
-    });
-    s.succeed(re.green("Neon database created successfully!"));
-    return true;
-  } catch (error) {
-    relinka("error", re.red("Failed to create database with neondb"));
-    throw error;
-  }
-}
-function displayManualSetupInstructions() {
-  relinka(
-    "info",
-    `Manual Neon PostgreSQL Setup Instructions:
-1. Visit https://neon.tech and create an account
-2. Create a new project from the dashboard
-3. Get your connection string
-4. Add the database URL to the .env file in apps/server/.env
-DATABASE_URL="your_connection_string"`
-  );
-}
-export async function setupNeonPostgres(config) {
-  const { packageManager, projectDir } = config;
-  try {
-    const setupMethod = await select({
-      message: "Choose your Neon setup method:",
-      options: [
-        {
-          label: "Quick setup with neondb",
-          value: "neondb",
-          hint: "fastest, no auth required"
-        },
-        {
-          label: "Custom setup with neonctl",
-          value: "neonctl",
-          hint: "More control - choose project name and region"
-        }
-      ],
-      initialValue: "neondb"
-    });
-    if (isCancel(setupMethod)) {
-      cancel(re.red("Operation cancelled"));
-      process.exit(0);
-    }
-    if (setupMethod === "neondb") {
-      await setupWithNeonDb(projectDir, packageManager);
-    } else {
-      const suggestedProjectName = path.basename(projectDir);
-      const projectName = await text({
-        message: "Enter a name for your Neon project:",
-        defaultValue: suggestedProjectName,
-        initialValue: suggestedProjectName
-      });
-      if (NEON_REGIONS.length === 0) {
-        throw new Error("No Neon regions available");
-      }
-      const regionId = await select({
-        message: "Select a region for your Neon project:",
-        options: NEON_REGIONS,
-        initialValue: NEON_REGIONS[0].value
-      });
-      if (isCancel(projectName) || isCancel(regionId)) {
-        cancel(re.red("Operation cancelled"));
-        process.exit(0);
-      }
-      const neonConfig = await createNeonProject(projectName, regionId, packageManager);
-      if (!neonConfig) {
-        throw new Error("Failed to create project - couldn't get connection information");
-      }
-      const finalSpinner = createSpinner({
-        text: "Configuring database connection"
-      });
-      finalSpinner.start("Configuring database connection");
-      await fs.ensureDir(path.join(projectDir, "apps/server"));
-      await writeEnvFile(projectDir, neonConfig);
-      finalSpinner.succeed("Neon database configured!");
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      relinka("error", re.red(error.message));
-    }
-    await writeEnvFile(projectDir);
-    displayManualSetupInstructions();
-  }
-}

package/bin/impl/providers/better-t-stack/helpers/database-providers/prisma-postgres-setup.d.ts

@@ -1,2 +0,0 @@
-import type { ProjectConfig } from "../../types.js";
-export declare function setupPrismaPostgres(config: ProjectConfig): Promise<void>;

package/bin/impl/providers/better-t-stack/helpers/database-providers/prisma-postgres-setup.js

@@ -1,161 +0,0 @@
-import path from "node:path";
-import { re } from "@reliverse/relico";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { cancel, createSpinner, isCancel, password } from "@reliverse/rempts";
-import { execa } from "execa";
-import {
-  addEnvVariablesToFile
-} from "../project-generation/env-setup.js";
-import { addPackageDependency } from "../../utils/add-package-deps.js";
-import { getPackageExecutionCommand } from "../../utils/get-package-execution-command.js";
-async function initPrismaDatabase(serverDir, packageManager) {
-  const s = createSpinner({
-    text: "Initializing Prisma PostgreSQL..."
-  });
-  try {
-    s.start("Initializing Prisma PostgreSQL...");
-    const prismaDir = path.join(serverDir, "prisma");
-    await fs.ensureDir(prismaDir);
-    s.succeed("Prisma PostgreSQL initialized. Follow the prompts below:");
-    const prismaInitCommand = getPackageExecutionCommand(packageManager, "prisma init --db");
-    await execa(prismaInitCommand, {
-      cwd: serverDir,
-      stdio: "inherit",
-      shell: true
-    });
-    relinka(
-      "info",
-      re.yellow(
-        "Please copy the Prisma Postgres URL from the output above.\nIt looks like: prisma+postgres://accelerate.prisma-data.net/?api_key=..."
-      )
-    );
-    const databaseUrl = await password({
-      message: "Paste your Prisma Postgres database URL:",
-      validate(value) {
-        if (!value) return "Please enter a database URL";
-        if (!value.startsWith("prisma+postgres://")) {
-          return "URL should start with prisma+postgres://";
-        }
-      }
-    });
-    if (isCancel(databaseUrl)) {
-      cancel("Database setup cancelled");
-      return null;
-    }
-    return {
-      databaseUrl
-    };
-  } catch (error) {
-    s.fail(re.red("Prisma PostgreSQL initialization failed"));
-    if (error instanceof Error) {
-      relinka("error", error.message);
-    }
-    return null;
-  }
-}
-async function writeEnvFile(projectDir, config) {
-  try {
-    const envPath = path.join(projectDir, "apps/server", ".env");
-    const variables = [
-      {
-        key: "DATABASE_URL",
-        value: config?.databaseUrl ?? "postgresql://postgres:postgres@localhost:5432/mydb?schema=public",
-        condition: true
-      }
-    ];
-    await addEnvVariablesToFile(envPath, variables);
-  } catch (_error) {
-    relinka("error", "Failed to update environment configuration");
-  }
-}
-function displayManualSetupInstructions() {
-  relinka(
-    "info",
-    `Manual Prisma PostgreSQL Setup Instructions:
-1. Visit https://console.prisma.io and create an account
-2. Create a new PostgreSQL database from the dashboard
-3. Get your database URL
-4. Add the database URL to the .env file in apps/server/.env
-DATABASE_URL="your_database_url"`
-  );
-}
-async function addPrismaAccelerateExtension(serverDir) {
-  try {
-    await addPackageDependency({
-      dependencies: ["@prisma/extension-accelerate"],
-      projectDir: serverDir
-    });
-    const prismaIndexPath = path.join(serverDir, "prisma/index.ts");
-    const prismaIndexContent = `
-import { PrismaClient } from "./generated/client";
-import { withAccelerate } from "@prisma/extension-accelerate";
-const prisma = new PrismaClient().$extends(withAccelerate());
-export default prisma;
-`;
-    await fs.writeFile(prismaIndexPath, prismaIndexContent.trim());
-    const dbFilePath = path.join(serverDir, "src/db/index.ts");
-    if (await fs.pathExists(dbFilePath)) {
-      let dbFileContent = await fs.readFile(dbFilePath, "utf8");
-      if (!dbFileContent.includes("@prisma/extension-accelerate")) {
-        dbFileContent = `import { withAccelerate } from "@prisma/extension-accelerate";
-${dbFileContent}`;
-        dbFileContent = dbFileContent.replace(
-          "export const db = new PrismaClient();",
-          "export const db = new PrismaClient().$extends(withAccelerate());"
-        );
-        await fs.writeFile(dbFilePath, dbFileContent);
-      }
-    }
-    return true;
-  } catch (_error) {
-    relinka("warn", re.yellow("Could not add Prisma Accelerate extension automatically"));
-    return false;
-  }
-}
-export async function setupPrismaPostgres(config) {
-  const { packageManager, projectDir } = config;
-  const serverDir = path.join(projectDir, "apps/server");
-  const s = createSpinner({
-    text: "Setting up Prisma PostgreSQL..."
-  });
-  s.start("Setting up Prisma PostgreSQL...");
-  try {
-    await fs.ensureDir(serverDir);
-    s.succeed("Prisma PostgreSQL setup ready");
-    const config2 = await initPrismaDatabase(serverDir, packageManager);
-    if (config2) {
-      await writeEnvFile(projectDir, config2);
-      await addPrismaAccelerateExtension(serverDir);
-      relinka("success", re.green("Prisma PostgreSQL database configured successfully!"));
-      relinka(
-        "info",
-        re.cyan(
-          'NOTE: Make sure to uncomment `import "dotenv/config";` in `apps/server/src/prisma.config.ts` to load environment variables.'
-        )
-      );
-    } else {
-      const fallbackSpinner = createSpinner({
-        text: "Setting up fallback configuration..."
-      });
-      fallbackSpinner.start("Setting up fallback configuration...");
-      await writeEnvFile(projectDir);
-      fallbackSpinner.succeed("Fallback configuration ready");
-      displayManualSetupInstructions();
-    }
-  } catch (error) {
-    s.fail(re.red("Prisma PostgreSQL setup failed"));
-    relinka(
-      "error",
-      re.red(
-        `Error during Prisma PostgreSQL setup: ${error instanceof Error ? error.message : String(error)}`
-      )
-    );
-    try {
-      await writeEnvFile(projectDir);
-      displayManualSetupInstructions();
-    } catch {
-    }
-    relinka("info", "Setup completed with manual configuration required.");
-  }
-}

package/bin/impl/providers/better-t-stack/helpers/database-providers/supabase-setup.d.ts

@@ -1,2 +0,0 @@
-import type { ProjectConfig } from "../../types.js";
-export declare function setupSupabase(config: ProjectConfig): Promise<void>;

package/bin/impl/providers/better-t-stack/helpers/database-providers/supabase-setup.js

@@ -1,162 +0,0 @@
-import path from "node:path";
-import { re } from "@reliverse/relico";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { execa } from "execa";
-import {
-  addEnvVariablesToFile
-} from "../project-generation/env-setup.js";
-import { getPackageExecutionCommand } from "../../utils/get-package-execution-command.js";
-async function writeSupabaseEnvFile(projectDir, databaseUrl) {
-  try {
-    const envPath = path.join(projectDir, "apps/server", ".env");
-    const dbUrlToUse = databaseUrl || "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
-    const variables = [
-      {
-        key: "DATABASE_URL",
-        value: dbUrlToUse,
-        condition: true
-      },
-      {
-        key: "DIRECT_URL",
-        value: dbUrlToUse,
-        condition: true
-      }
-    ];
-    await addEnvVariablesToFile(envPath, variables);
-    return true;
-  } catch (error) {
-    relinka("error", re.red("Failed to update .env file for Supabase."));
-    if (error instanceof Error) {
-      relinka("error", error.message);
-    }
-    return false;
-  }
-}
-function extractDbUrl(output) {
-  const dbUrlMatch = /DB URL:\s*(postgresql:\/\/[^\s]+)/.exec(output);
-  const url = dbUrlMatch?.[1];
-  if (url) {
-    return url;
-  }
-  return null;
-}
-async function initializeSupabase(serverDir, packageManager) {
-  relinka("info", "Initializing Supabase project...");
-  try {
-    const supabaseInitCommand = getPackageExecutionCommand(packageManager, "supabase init");
-    await execa(supabaseInitCommand, {
-      cwd: serverDir,
-      stdio: "inherit",
-      shell: true
-    });
-    relinka("success", "Supabase project initialized");
-    return true;
-  } catch (error) {
-    relinka("error", re.red("Failed to initialize Supabase project."));
-    if (error instanceof Error) {
-      relinka("error", error.message);
-    } else {
-      relinka("error", String(error));
-    }
-    if (error instanceof Error && error.message.includes("ENOENT")) {
-      relinka(
-        "error",
-        re.red("Supabase CLI not found. Please install it globally or ensure it's in your PATH.")
-      );
-      relinka("info", "You can install it using: npm install -g supabase");
-    }
-    return false;
-  }
-}
-async function startSupabase(serverDir, packageManager) {
-  relinka("info", "Starting Supabase services (this may take a moment)...");
-  const supabaseStartCommand = getPackageExecutionCommand(packageManager, "supabase start");
-  try {
-    const subprocess = execa(supabaseStartCommand, {
-      cwd: serverDir,
-      shell: true
-    });
-    let stdoutData = "";
-    if (subprocess.stdout) {
-      subprocess.stdout.on("data", (data) => {
-        const text = data.toString();
-        process.stdout.write(text);
-        stdoutData += text;
-      });
-    }
-    if (subprocess.stderr) {
-      subprocess.stderr.pipe(process.stderr);
-    }
-    await subprocess;
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    return stdoutData;
-  } catch (error) {
-    relinka("error", re.red("Failed to start Supabase services."));
-    const execaError = error;
-    if (execaError?.message) {
-      relinka("error", `Error details: ${execaError.message}`);
-      if (execaError.message.includes("Docker is not running")) {
-        relinka("error", re.red("Docker is not running. Please start Docker and try again."));
-      }
-    } else {
-      relinka("error", String(error));
-    }
-    return null;
-  }
-}
-function displayManualSupabaseInstructions(output) {
-  relinka(
-    "info",
-    `"Manual Supabase Setup Instructions:"
-1. Ensure Docker is installed and running.
-2. Install the Supabase CLI (e.g., \`npm install -g supabase\`).
-3. Run \`supabase init\` in your project's \`apps/server\` directory.
-4. Run \`supabase start\` in your project's \`apps/server\` directory.
-5. Copy the 'DB URL' from the output.${output ? `
-${re.bold("Relevant output from `supabase start`:")}
-${re.dim(output)}` : ""}
-6. Add the DB URL to the .env file in \`apps/server/.env\` as \`DATABASE_URL\`:
-			${re.gray('DATABASE_URL="your_supabase_db_url"')}`
-  );
-}
-export async function setupSupabase(config) {
-  const { projectDir, packageManager } = config;
-  const serverDir = path.join(projectDir, "apps", "server");
-  try {
-    await fs.ensureDir(serverDir);
-    const initialized = await initializeSupabase(serverDir, packageManager);
-    if (!initialized) {
-      displayManualSupabaseInstructions();
-      return;
-    }
-    const supabaseOutput = await startSupabase(serverDir, packageManager);
-    if (!supabaseOutput) {
-      displayManualSupabaseInstructions();
-      return;
-    }
-    const dbUrl = extractDbUrl(supabaseOutput);
-    if (dbUrl) {
-      const envUpdated = await writeSupabaseEnvFile(projectDir, dbUrl);
-      if (envUpdated) {
-        relinka("success", re.green("Supabase local development setup ready!"));
-      } else {
-        relinka(
-          "error",
-          re.red("Supabase setup completed, but failed to update .env automatically.")
-        );
-        displayManualSupabaseInstructions(supabaseOutput);
-      }
-    } else {
-      relinka("error", re.yellow("Supabase started, but could not extract DB URL automatically."));
-      displayManualSupabaseInstructions(supabaseOutput);
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      relinka("error", re.red(`Error during Supabase setup: ${error.message}`));
-    } else {
-      relinka("error", re.red(`An unknown error occurred during Supabase setup: ${String(error)}`));
-    }
-    displayManualSupabaseInstructions();
-  }
-}

package/bin/impl/providers/better-t-stack/helpers/database-providers/turso-setup.d.ts

@@ -1,2 +0,0 @@
-import type { ProjectConfig } from "../../types.js";
-export declare function setupTurso(config: ProjectConfig): Promise<void>;