everything-dev 1.16.1 → 1.16.2

package/src/cli/infra.ts

@@ -0,0 +1,190 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import type { RuntimeConfig } from "../types";
+
+const POSTGRES_USER = "everythingdev";
+const POSTGRES_PASSWORD = "everythingdev";
+const API_DATABASE_SECRET = "API_DATABASE_URL";
+const AUTH_DATABASE_SECRET = "AUTH_DATABASE_URL";
+const BASE_DATABASE_PORT = 5434;
+
+interface DatabaseSecretConfig {
+  secret: string;
+  slug: string;
+  port: number;
+  serviceName: string;
+  databaseName: string;
+  volumeName: string;
+  url: string;
+}
+
+function uniqueSecrets(values: Array<string | undefined>): string[] {
+  const secrets: string[] = [];
+  const seen = new Set<string>();
+
+  for (const value of values) {
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    secrets.push(value);
+  }
+
+  return secrets;
+}
+
+function getRuntimeSecrets(runtimeConfig: RuntimeConfig): string[] {
+  const pluginSecrets = Object.values(runtimeConfig.plugins ?? {}).flatMap(
+    (plugin) => plugin.secrets ?? [],
+  );
+
+  return uniqueSecrets([
+    API_DATABASE_SECRET,
+    AUTH_DATABASE_SECRET,
+    ...(runtimeConfig.api.secrets ?? []),
+    ...(runtimeConfig.auth?.secrets ?? []),
+    ...pluginSecrets,
+  ]);
+}
+
+function normalizeDatabaseSlug(secret: string): string {
+  return secret.replace(/_DATABASE_URL$/, "").toLowerCase();
+}
+
+function buildDatabaseConfigs(secrets: string[]): DatabaseSecretConfig[] {
+  const databaseSecrets = uniqueSecrets(
+    secrets.filter((secret) => secret.endsWith("_DATABASE_URL")),
+  );
+
+  const additionalSecrets = databaseSecrets
+    .filter((secret) => secret !== API_DATABASE_SECRET && secret !== AUTH_DATABASE_SECRET)
+    .sort((a, b) => a.localeCompare(b));
+
+  const orderedSecrets = [API_DATABASE_SECRET, AUTH_DATABASE_SECRET, ...additionalSecrets];
+
+  return orderedSecrets.map((secret, index) => {
+    const slug = normalizeDatabaseSlug(secret);
+    const port =
+      secret === API_DATABASE_SECRET
+        ? 5432
+        : secret === AUTH_DATABASE_SECRET
+          ? 5433
+          : BASE_DATABASE_PORT + index - 2;
+
+    return {
+      secret,
+      slug,
+      port,
+      serviceName: `postgres-${slug.replace(/_/g, "-")}`,
+      databaseName: `${slug}_db`,
+      volumeName: `postgres_${slug}_data`,
+      url: `postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost:${port}/${slug}_db`,
+    };
+  });
+}
+
+function defaultSecretValue(
+  secret: string,
+  databases: Map<string, DatabaseSecretConfig>,
+  options: { forExample: boolean },
+): string {
+  if (secret === "BETTER_AUTH_SECRET") {
+    return options.forExample ? "" : randomBytes(32).toString("base64url");
+  }
+
+  if (secret === "CORS_ORIGIN") {
+    return "http://localhost:3000";
+  }
+
+  return databases.get(secret)?.url ?? "";
+}
+
+function renderEnvFile(
+  secrets: string[],
+  databases: DatabaseSecretConfig[],
+  options: { forExample: boolean },
+): string {
+  const databaseMap = new Map(databases.map((entry) => [entry.secret, entry]));
+  const lines = [
+    "# Generated from configured bos secrets",
+    "# Update values as needed for your local environment",
+    "",
+  ];
+
+  for (const secret of secrets) {
+    lines.push(`${secret}=${defaultSecretValue(secret, databaseMap, options)}`);
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function renderDockerCompose(databases: DatabaseSecretConfig[]): string {
+  const lines = [
+    "x-pg-common: &pg-common",
+    "  image: postgres:17-alpine",
+    "  environment: &pg-env",
+    `    POSTGRES_USER: ${POSTGRES_USER}`,
+    `    POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}`,
+    "  healthcheck:",
+    '    test: ["CMD-SHELL", "pg_isready -U everythingdev"]',
+    "    interval: 3s",
+    "    timeout: 3s",
+    "    retries: 5",
+    "",
+    "services:",
+  ];
+
+  for (const database of databases) {
+    lines.push(`  ${database.serviceName}:`);
+    lines.push("    <<: *pg-common");
+    lines.push("    environment:");
+    lines.push("      <<: *pg-env");
+    lines.push(`      POSTGRES_DB: ${database.databaseName}`);
+    lines.push("    ports:");
+    lines.push(`      - "${database.port}:5432"`);
+    lines.push("    volumes:");
+    lines.push(`      - ${database.volumeName}:/var/lib/postgresql/data`);
+    lines.push("");
+  }
+
+  lines.push("volumes:");
+  for (const database of databases) {
+    lines.push(`  ${database.volumeName}:`);
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+export function writeGeneratedInfra(configDir: string, runtimeConfig: RuntimeConfig): string[] {
+  const secrets = getRuntimeSecrets(runtimeConfig);
+  const databases = buildDatabaseConfigs(secrets);
+  const envExamplePath = join(configDir, ".env.example");
+  const dockerComposePath = join(configDir, "docker-compose.yml");
+
+  writeFileSync(envExamplePath, renderEnvFile(secrets, databases, { forExample: true }));
+  writeFileSync(dockerComposePath, renderDockerCompose(databases));
+
+  return secrets;
+}
+
+export function ensureEnvFile(configDir: string): void {
+  const envPath = join(configDir, ".env");
+  const examplePath = join(configDir, ".env.example");
+
+  if (existsSync(envPath) || !existsSync(examplePath)) return;
+
+  const content = readFileSync(examplePath, "utf-8");
+  const lines = content.split("\n");
+  const secret = randomBytes(32).toString("base64url");
+  const updated = lines
+    .map((line) => {
+      if (/^BETTER_AUTH_SECRET=/.test(line)) {
+        return `BETTER_AUTH_SECRET=${secret}`;
+      }
+      return line;
+    })
+    .join("\n");
+
+  writeFileSync(envPath, updated);
+  p.log.info("Created .env from generated .env.example with generated BETTER_AUTH_SECRET");
+}

package/src/cli/init.ts

@@ -609,6 +609,10 @@ export async function runTypesGen(destination: string): Promise<void> {
   await execCommand("node_modules/.bin/bos", ["types", "gen"], destination);
 }
 
+export async function runDockerComposeUp(destination: string): Promise<void> {
+  await execCommand("docker", ["compose", "up", "-d", "--wait"], destination);
+}
+
 const WORKSPACE_LOCAL_PATHS: Record<string, string> = {
   "everything-dev": "packages/everything-dev",
   "every-plugin": "packages/every-plugin",

package/src/cli/sync.ts

@@ -9,6 +9,7 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 import { glob } from "glob";
+import { loadConfig } from "../config";
 import type { SyncOptions, SyncResult } from "../contract";
 import {
   isPlainObject as isPlainObjectFromMerge,
@@ -17,6 +18,7 @@ import {
 } from "../merge";
 import type { BosPluginRef } from "../types";
 import { isPathExcluded } from "../utils/path-match";
+import { writeGeneratedInfra } from "./infra";
 import {
   personalizeConfig,
   readTemplatekeep,
@@ -27,10 +29,12 @@ import {
 import { readSnapshot, writeSnapshot } from "./snapshot";
 
 const FRAMEWORK_OWNED_SYNC_FILES = new Set([
+  ".env.example",
   ".gitignore",
   "biome.json",
   "bos.config.json",
   "package.json",
+  "docker-compose.yml",
   ".github/renovate.json",
   ".github/workflows/ci.yml",
   ".github/workflows/release-sync.yml",
@@ -494,6 +498,11 @@ export async function syncTemplate(projectDir: string, options: SyncOptions): Pr
       mode: "sync",
     });
 
+    const syncedConfig = await loadConfig({ cwd: projectDir });
+    if (syncedConfig?.runtime) {
+      writeGeneratedInfra(projectDir, syncedConfig.runtime);
+    }
+
     if (!options.noInstall) {
       await runBunInstall(projectDir);
       await runTypesGen(projectDir);

package/src/plugin.ts

@@ -1,10 +1,10 @@
-import { randomBytes } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import * as p from "@clack/prompts";
 import { Effect } from "effect";
 import { syncApiContractBridge } from "./api-contract";
 import { buildRuntimeConfig, detectLocalPackages, prepareDevelopmentRuntimeConfig } from "./app";
+import { ensureEnvFile, writeGeneratedInfra } from "./cli/infra";
 import {
   copyFilteredFiles,
   fetchParentConfig,
@@ -13,6 +13,7 @@ import {
   readTemplatekeep,
   resolveSourceDir,
   runBunInstall,
+  runDockerComposeUp,
   runTypesGen,
   writeInitSnapshot,
 } from "./cli/init";
@@ -57,38 +58,6 @@ import { run } from "./utils/run";
 import { saveBosConfig } from "./utils/save-config";
 import { colors } from "./utils/theme";
 
-function ensureEnvFile(configDir: string, opts?: { domain?: string }): void {
-  const envPath = join(configDir, ".env");
-  const examplePath = join(configDir, ".env.example");
-
-  if (existsSync(envPath)) return;
-
-  if (!existsSync(examplePath)) return;
-
-  const content = readFileSync(examplePath, "utf-8");
-  const lines = content.split("\n");
-
-  const secret = randomBytes(32).toString("base64url");
-  const corsOrigin = opts?.domain
-    ? `http://localhost:3000,https://${opts.domain}`
-    : "http://localhost:3000";
-
-  const updated = lines
-    .map((line) => {
-      if (/^BETTER_AUTH_SECRET=/.test(line)) {
-        return `BETTER_AUTH_SECRET=${secret}`;
-      }
-      if (/^CORS_ORIGIN=/.test(line)) {
-        return `CORS_ORIGIN=${corsOrigin}`;
-      }
-      return line;
-    })
-    .join("\n");
-
-  writeFileSync(envPath, updated);
-  p.log.info(`Created .env from .env.example with generated BETTER_AUTH_SECRET`);
-}
-
 const buildCommands: Record<string, { cmd: string; args: string[] }> = {
   host: { cmd: "bun", args: ["run", "build"] },
   ui: { cmd: "bun", args: ["run", "build"] },
@@ -1342,6 +1311,7 @@ export default createPlugin({
         }
 
         directory = directory || domain || extendsGateway;
+        const targetDir = resolve(directory);
         plugins = plugins ?? [];
 
         if (!parentConfig) {
@@ -1405,13 +1375,13 @@ export default createPlugin({
           const s = p.spinner();
           s.start("Setting up project");
 
-          const filesCopied = await copyFilteredFiles(sourceDir, directory, patterns, {
+          const filesCopied = await copyFilteredFiles(sourceDir, targetDir, patterns, {
             withHost,
             plugins,
             pluginRoutes,
           });
 
-          await personalizeConfig(directory, {
+          await personalizeConfig(targetDir, {
             extendsAccount,
             extendsGateway,
             account: account || extendsAccount,
@@ -1422,27 +1392,51 @@ export default createPlugin({
             withHost,
           });
 
-          await writeInitSnapshot(directory, extendsAccount, extendsGateway, sourceDir, patterns, {
+          await writeInitSnapshot(targetDir, extendsAccount, extendsGateway, sourceDir, patterns, {
             withHost,
             plugins,
             pluginRoutes,
           });
 
-          ensureEnvFile(directory, { domain });
+          const initConfig = await loadConfig({ cwd: targetDir });
+          if (initConfig?.runtime) {
+            writeGeneratedInfra(targetDir, initConfig.runtime);
+          }
+          ensureEnvFile(targetDir);
 
           if (!input.noInstall) {
-            await runBunInstall(directory);
-            await runTypesGen(directory);
-            await generateDatabaseMigrations(directory);
+            await runBunInstall(targetDir);
+            await runTypesGen(targetDir);
+            await generateDatabaseMigrations(targetDir);
           }
 
-          const initConfig = await loadConfig({ cwd: directory });
           if (initConfig?.config) {
-            await generateCodeArtifacts(directory, initConfig.config);
+            await generateCodeArtifacts(targetDir, initConfig.config);
           }
 
           s.stop("Project initialized");
 
+          if (!input.noInteractive) {
+            const shouldStartDocker = await p.confirm({
+              message: "Run docker compose up -d --wait?",
+              initialValue: true,
+            });
+
+            if (shouldStartDocker === true) {
+              const dockerSpinner = p.spinner();
+              dockerSpinner.start("Starting Docker services");
+              try {
+                await runDockerComposeUp(targetDir);
+                dockerSpinner.stop("Docker services ready");
+              } catch (error) {
+                dockerSpinner.stop("Docker services not started");
+                p.log.warn(
+                  `docker compose up -d --wait failed: ${error instanceof Error ? error.message : error}`,
+                );
+              }
+            }
+          }
+
           return {
             status: "initialized" as const,
             directory,