@percepta/create 3.0.0 → 3.1.0

package/templates/webapp/scripts/open-ryvn-deploy-pr.ts

@@ -0,0 +1,377 @@
+#!/usr/bin/env tsx
+/* eslint-disable no-console, n/no-process-env */
+
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+const APP_NAME = "__APP_NAME__";
+const DATABASE_SCHEMA = "__APP_NAME_SNAKE__";
+const ENVIRONMENT = "percepta-test";
+const INFRA_REMOTE = "git@github.com:Percepta-Core/infra.git";
+
+interface Options {
+  infraPath?: string;
+  yes: boolean;
+  noClone: boolean;
+}
+
+function parseArgs(argv: string[]): Options {
+  const options: Options = {
+    yes: false,
+    noClone: false,
+  };
+
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "--yes" || arg === "-y") {
+      options.yes = true;
+    } else if (arg === "--no-clone") {
+      options.noClone = true;
+    } else if (arg === "--infra") {
+      const value = argv[index + 1];
+      if (!value) throw new Error("--infra requires a path");
+      options.infraPath = path.resolve(value);
+      index++;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+function run(
+  command: string,
+  args: string[],
+  cwd: string,
+  stdio: "inherit" | "pipe" = "inherit",
+): string {
+  const result = execFileSync(command, args, {
+    cwd,
+    encoding: "utf8",
+    stdio,
+  });
+
+  return typeof result === "string" ? result.trim() : "";
+}
+
+function assertCommand(command: string): void {
+  try {
+    run(command, ["--version"], process.cwd(), "pipe");
+  } catch {
+    throw new Error(
+      `Required command not found or not authenticated: ${command}`,
+    );
+  }
+}
+
+function findUp(startDir: string, fileName: string): string | null {
+  let dir = startDir;
+  while (true) {
+    if (existsSync(path.join(dir, fileName))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+function isGitRepo(dir: string): boolean {
+  if (!existsSync(dir)) return false;
+  try {
+    run("git", ["rev-parse", "--is-inside-work-tree"], dir, "pipe");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function confirm(message: string): Promise<boolean> {
+  const rl = createInterface({ input, output });
+  try {
+    const answer = (await rl.question(`${message} [Y/n] `))
+      .trim()
+      .toLowerCase();
+    return answer === "" || answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+async function resolveInfraRepo(
+  options: Options,
+  defaultInfraPath: string,
+): Promise<string> {
+  const infraPath =
+    options.infraPath ?? process.env.INFRA_REPO ?? defaultInfraPath;
+
+  if (isGitRepo(infraPath)) {
+    console.log(`Using infra repo: ${infraPath}`);
+    return infraPath;
+  }
+
+  if (existsSync(infraPath)) {
+    throw new Error(`${infraPath} exists but is not a git repository`);
+  }
+
+  if (options.noClone) {
+    throw new Error(
+      `Infra repo not found at ${infraPath}. Re-run with --infra <path>.`,
+    );
+  }
+
+  if (!options.yes) {
+    if (!process.stdin.isTTY) {
+      throw new Error(
+        `Infra repo not found at ${infraPath}. Re-run with --yes to clone or --infra <path>.`,
+      );
+    }
+
+    const shouldClone = await confirm(
+      `Infra repo not found. Clone Percepta-Core/infra to ${infraPath}?`,
+    );
+    if (!shouldClone) {
+      throw new Error("Skipped cloning infra repo. Re-run with --infra <path>.");
+    }
+  }
+
+  await mkdir(path.dirname(infraPath), { recursive: true });
+  console.log(`Cloning ${INFRA_REMOTE} to ${infraPath}...`);
+  run("git", ["clone", INFRA_REMOTE, infraPath], process.cwd());
+  console.log(`Cloned infra repo: ${infraPath}`);
+  return infraPath;
+}
+
+function assertCleanGitWorktree(repoPath: string): void {
+  const status = run("git", ["status", "--porcelain"], repoPath, "pipe");
+  if (status.length === 0) return;
+
+  throw new Error(
+    `Infra repo has local changes. Commit/stash them first or use --infra with a clean checkout.\n${status}`,
+  );
+}
+
+function switchDeployBranch(repoPath: string): string {
+  const branchName = `deploy/${APP_NAME}-${ENVIRONMENT}`;
+  const currentBranch = run(
+    "git",
+    ["branch", "--show-current"],
+    repoPath,
+    "pipe",
+  );
+  if (currentBranch === branchName) return branchName;
+
+  let branchExists = false;
+  try {
+    run("git", ["rev-parse", "--verify", branchName], repoPath, "pipe");
+    branchExists = true;
+  } catch {
+    branchExists = false;
+  }
+
+  if (branchExists) {
+    run("git", ["switch", branchName], repoPath);
+  } else {
+    run("git", ["switch", "-c", branchName], repoPath);
+  }
+
+  return branchName;
+}
+
+async function writeIfChanged(
+  filePath: string,
+  content: string,
+): Promise<boolean> {
+  if (existsSync(filePath)) {
+    const existing = await readFile(filePath, "utf8");
+    if (existing === content) return false;
+  }
+
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+  return true;
+}
+
+async function copyDeployYaml(
+  packageDir: string,
+  infraRepo: string,
+): Promise<string[]> {
+  const serviceSource = path.join(
+    packageDir,
+    "deploy",
+    "ryvn",
+    `${APP_NAME}.service.yaml`,
+  );
+  const installationSource = path.join(
+    packageDir,
+    "deploy",
+    "ryvn",
+    "environments",
+    ENVIRONMENT,
+    "installations",
+    `${APP_NAME}.env.${ENVIRONMENT}.serviceinstallation.yaml`,
+  );
+
+  const serviceTarget = path.join(infraRepo, "ryvn", `${APP_NAME}.service.yaml`);
+  const installationTarget = path.join(
+    infraRepo,
+    "ryvn",
+    "environments",
+    ENVIRONMENT,
+    "installations",
+    `${APP_NAME}.env.${ENVIRONMENT}.serviceinstallation.yaml`,
+  );
+
+  const changed: string[] = [];
+  if (await writeIfChanged(serviceTarget, await readFile(serviceSource, "utf8"))) {
+    changed.push(path.relative(infraRepo, serviceTarget));
+  }
+  if (
+    await writeIfChanged(
+      installationTarget,
+      await readFile(installationSource, "utf8"),
+    )
+  ) {
+    changed.push(path.relative(infraRepo, installationTarget));
+  }
+
+  return changed;
+}
+
+async function ensureDatabaseSchema(infraRepo: string): Promise<string | null> {
+  const databasesPath = path.join(
+    infraRepo,
+    "terraform",
+    "percepta-internal",
+    "databases.tf",
+  );
+  const content = await readFile(databasesPath, "utf8");
+
+  if (
+    content.includes(`resource "postgresql_schema" "${DATABASE_SCHEMA}"`) ||
+    content.includes(`name     = "${DATABASE_SCHEMA}"`)
+  ) {
+    return null;
+  }
+
+  const block = `resource "postgresql_schema" "${DATABASE_SCHEMA}" {
+  provider = postgresql.percepta_internal
+  database = postgresql_database.demos.name
+  name     = "${DATABASE_SCHEMA}"
+}
+`;
+
+  await appendFile(
+    databasesPath,
+    `${content.endsWith("\n") ? "\n" : "\n\n"}${block}`,
+  );
+
+  return path.relative(infraRepo, databasesPath);
+}
+
+function hasStagedChanges(repoPath: string): boolean {
+  try {
+    run("git", ["diff", "--cached", "--quiet"], repoPath, "pipe");
+    return false;
+  } catch (error) {
+    const status =
+      typeof error === "object" && error !== null && "status" in error
+        ? (error as { status?: number }).status
+        : undefined;
+    if (status === 1) return true;
+    throw error;
+  }
+}
+
+function getPrUrl(repoPath: string, branchName: string): string | null {
+  try {
+    return run(
+      "gh",
+      ["pr", "view", branchName, "--json", "url", "--jq", ".url"],
+      repoPath,
+      "pipe",
+    );
+  } catch {
+    return null;
+  }
+}
+
+async function main(): Promise<void> {
+  const options = parseArgs(process.argv.slice(2));
+  assertCommand("git");
+  assertCommand("gh");
+
+  const packageDir = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "..",
+  );
+  const monorepoRoot = findUp(packageDir, "pnpm-workspace.yaml") ?? packageDir;
+  const defaultInfraPath = path.resolve(monorepoRoot, "..", "infra");
+  const infraRepo = await resolveInfraRepo(options, defaultInfraPath);
+
+  assertCleanGitWorktree(infraRepo);
+  const branchName = switchDeployBranch(infraRepo);
+
+  const changedPaths = await copyDeployYaml(packageDir, infraRepo);
+  const schemaPath = await ensureDatabaseSchema(infraRepo);
+  if (schemaPath) changedPaths.push(schemaPath);
+
+  if (changedPaths.length === 0) {
+    console.log(
+      "Infra repo already has the generated Ryvn files and database schema.",
+    );
+    return;
+  }
+
+  run("git", ["add", ...changedPaths], infraRepo);
+  if (!hasStagedChanges(infraRepo)) {
+    console.log("No infra changes to commit.");
+    return;
+  }
+
+  run(
+    "git",
+    ["commit", "-m", `Add ${APP_NAME} ${ENVIRONMENT} deployment`],
+    infraRepo,
+  );
+  run("git", ["push", "-u", "origin", branchName], infraRepo);
+
+  const existingPr = getPrUrl(infraRepo, branchName);
+  if (existingPr) {
+    console.log(`Infra PR: ${existingPr}`);
+    return;
+  }
+
+  const body = [
+    `Adds the Ryvn service and ${ENVIRONMENT} installation for ${APP_NAME}.`,
+    "",
+    `Also creates the ${DATABASE_SCHEMA} schema in the shared demos database.`,
+    "",
+    "After merge, Ryvn GitOps should create the installation and the release workflow can deploy the app.",
+  ].join("\n");
+
+  const prUrl = run(
+    "gh",
+    [
+      "pr",
+      "create",
+      "--title",
+      `Add ${APP_NAME} ${ENVIRONMENT} deployment`,
+      "--body",
+      body,
+    ],
+    infraRepo,
+    "pipe",
+  );
+
+  console.log(`Infra PR: ${prUrl}`);
+}
+
+void main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/templates/webapp/scripts/seed.ts

@@ -18,7 +18,7 @@ const DEFAULT_USER = {
 
 async function main(): Promise<void> {
   loadEnvConfig(process.cwd());
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
   (globalThis as any).AsyncLocalStorage = AsyncLocalStorage;
 
   const { auth } = await import("../src/lib/auth");

package/templates/webapp/scripts/setup-database.ts

@@ -2,6 +2,8 @@ import { loadEnvConfig } from "@next/env";
 import { Pool } from "pg";
 import { getEnvConfig } from "../src/config/getEnvConfig";
 
+const SHARED_DATABASES = new Set(["demos", "internal_apps"]);
+
 async function main(): Promise<void> {
   loadEnvConfig(process.cwd());
 
@@ -11,6 +13,7 @@ async function main(): Promise<void> {
     DATABASE_USERNAME: user,
     DATABASE_PASSWORD: password,
     DATABASE_NAME: database,
+    DATABASE_SCHEMA: databaseSchema,
     DATABASE_USE_SSL: useSSL,
   } = getEnvConfig();
 
@@ -18,6 +21,17 @@ async function main(): Promise<void> {
   console.log(`📍 Host: ${host}:${port}`);
   console.log(`👤 User: ${user}`);
 
+  if (SHARED_DATABASES.has(database)) {
+    console.log(
+      `✅ ${database} is a shared database; skipping CREATE DATABASE. ` +
+        "The database is managed by infra.",
+    );
+    if (databaseSchema) {
+      console.log(`📦 Using schema: ${databaseSchema}`);
+    }
+    return;
+  }
+
   // First, connect to the default 'postgres' database to create our target database
   const adminClient = new Pool({
     host,

package/templates/webapp/src/app/global-error.tsx

@@ -8,7 +8,9 @@ export default function GlobalError({
   reset: () => void;
 }) {
   try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
     const { faro } = require("@grafana/faro-web-sdk");
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
     faro.api?.pushError(error);
   } catch {
     // Faro may not be initialized yet — don't let reporting break the error page

package/templates/webapp/src/config/getEnvConfig.ts

@@ -16,6 +16,7 @@ export const { getEnvConfig, schema: ENV_CONFIG_SCHEMA } = createEnvConfig(
     DATABASE_USERNAME: z.string().default("postgres"),
     DATABASE_PASSWORD: z.string().default("postgres"),
     DATABASE_NAME: z.string().default("__DB_NAME__"),
+    DATABASE_SCHEMA: z.string().optional(),
     DATABASE_USE_SSL: z
       .string()
       .transform((value: string): boolean => value === "true")

package/templates/webapp/src/drizzle/db.ts

@@ -2,6 +2,7 @@ import { type NodePgDatabase, drizzle } from "drizzle-orm/node-postgres";
 import { Pool } from "pg";
 import { getEnvConfig } from "../config/getEnvConfig";
 import * as schema from "./schema";
+import { getPgSearchPathOption } from "./searchPath";
 
 export const { client, db } = createDb();
 
@@ -12,6 +13,7 @@ function createDb(): { client: Pool; db: NodePgDatabase<typeof schema> } {
     DATABASE_USERNAME: user,
     DATABASE_PASSWORD: password,
     DATABASE_NAME: database,
+    DATABASE_SCHEMA: databaseSchema,
     DATABASE_USE_SSL: useSSL,
   } = getEnvConfig();
 
@@ -22,6 +24,7 @@ function createDb(): { client: Pool; db: NodePgDatabase<typeof schema> } {
     password,
     database,
     ssl: useSSL,
+    options: getPgSearchPathOption(databaseSchema),
   });
 
   return { client: _client, db: drizzle(_client, { schema }) };

package/templates/webapp/src/drizzle/searchPath.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { getPgSearchPathOption } from "./searchPath";
+
+describe("getPgSearchPathOption", () => {
+  it("includes public so extension functions remain resolvable", () => {
+    expect(getPgSearchPathOption("my_app")).toBe(
+      "-c search_path=my_app,public",
+    );
+  });
+
+  it("returns undefined for blank schema names", () => {
+    expect(getPgSearchPathOption(undefined)).toBeUndefined();
+    expect(getPgSearchPathOption("   ")).toBeUndefined();
+  });
+
+  it("rejects unsafe unquoted identifiers", () => {
+    expect(() => getPgSearchPathOption("my-app")).toThrow(
+      "DATABASE_SCHEMA must be a valid unquoted Postgres identifier",
+    );
+  });
+});

package/templates/webapp/src/drizzle/searchPath.ts

@@ -0,0 +1,16 @@
+const POSTGRES_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+export function getPgSearchPathOption(
+  schemaName: string | undefined,
+): string | undefined {
+  const searchPath = schemaName?.trim();
+  if (!searchPath) return undefined;
+
+  if (!POSTGRES_IDENTIFIER_PATTERN.test(searchPath)) {
+    throw new Error(
+      `DATABASE_SCHEMA must be a valid unquoted Postgres identifier. Received: ${searchPath}`,
+    );
+  }
+
+  return `-c search_path=${searchPath},public`;
+}

package/templates/webapp/src/styles/globals.css

@@ -13,13 +13,6 @@
   --font-mono: var(--font-geist-mono);
 }
 
-@media (prefers-color-scheme: dark) {
-  :root {
-    --background: #0a0a0a;
-    --foreground: #ededed;
-  }
-}
-
 body {
   background: var(--background);
   color: var(--foreground);