@percepta/create 3.1.3 → 3.1.5

package/templates/webapp/scripts/deploy-percepta-test.ts

@@ -81,6 +81,11 @@ interface Installation {
   name?: string;
   status?: string;
   health?: string;
+  release?: {
+    commitSha?: string;
+    currentVersion?: string;
+    targetVersion?: string;
+  };
 }
 
 interface VariableGroup {
@@ -91,6 +96,17 @@ interface VariableGroup {
   }>;
 }
 
+interface Release {
+  version?: string;
+  commit?: {
+    sha?: string;
+  };
+}
+
+interface ReleaseList {
+  releases?: Release[];
+}
+
 function parseArgs(argv: string[]): Options {
   const options: Options = {
     yes: false,
@@ -151,6 +167,22 @@ function run(
   return typeof result === "string" ? result.trim() : "";
 }
 
+function runWithInput(
+  command: string,
+  args: string[],
+  cwd: string,
+  inputText: string,
+): string {
+  const result = execFileSync(command, args, {
+    cwd,
+    encoding: "utf8",
+    input: inputText,
+    stdio: ["pipe", "inherit", "inherit"],
+  });
+
+  return typeof result === "string" ? result.trim() : "";
+}
+
 function runJson<T>(command: string, args: string[], cwd: string): T {
   const outputText = run(command, args, cwd, "pipe");
   return JSON.parse(outputText) as T;
@@ -248,7 +280,7 @@ async function ensureGitHubRepo(
         "repo",
         "create",
         repoSlug,
-        "--private",
+        "--internal",
         "--source",
         monorepoRoot,
         "--remote",
@@ -301,6 +333,10 @@ function upsertService(manifestPath: string, monorepoRoot: string): void {
   run("ryvn", ["replace", "-f", manifestPath], monorepoRoot);
 }
 
+function getCurrentCommitSha(monorepoRoot: string): string {
+  return run("git", ["rev-parse", "HEAD"], monorepoRoot, "pipe");
+}
+
 function getInstallation(
   name: string,
   monorepoRoot: string,
@@ -335,6 +371,39 @@ function installationExists(name: string, monorepoRoot: string): boolean {
   return getInstallation(name, monorepoRoot) !== null;
 }
 
+function isHealthyAtCommit(
+  installation: Installation | null,
+  commitSha: string,
+): boolean {
+  return (
+    installation?.status === "UP_TO_DATE" &&
+    installation.health === "HEALTHY" &&
+    installation.release?.commitSha === commitSha
+  );
+}
+
+function getReleaseForCommit(
+  serviceName: string,
+  commitSha: string,
+  monorepoRoot: string,
+): Release | null {
+  try {
+    const releaseList = runJson<ReleaseList>(
+      "ryvn",
+      ["get", "release", "--service", serviceName, "-o", "json"],
+      monorepoRoot,
+    );
+
+    return (
+      releaseList.releases?.find(
+        (release) => release.commit?.sha === commitSha,
+      ) ?? null
+    );
+  } catch {
+    return null;
+  }
+}
+
 function assertHealthyPlatformInstallation(
   installation: Installation | null,
   name: string,
@@ -429,19 +498,170 @@ function upsertInstallation(
   name: string,
   manifestPath: string,
   monorepoRoot: string,
+  expectedCommitSha: string,
+  manifestContents?: string,
+): void {
+  const existingInstallation = getInstallation(name, monorepoRoot);
+  if (isHealthyAtCommit(existingInstallation, expectedCommitSha)) {
+    console.log(
+      `${name} is already healthy at ${expectedCommitSha.slice(0, 7)}; skipping installation replace.`,
+    );
+    return;
+  }
+
+  const action = existingInstallation == null ? "create" : "replace";
+  try {
+    if (existingInstallation == null) {
+      if (manifestContents == null) {
+        run("ryvn", ["create", "-f", manifestPath], monorepoRoot);
+      } else {
+        runWithInput(
+          "ryvn",
+          ["create", "-f", "-"],
+          monorepoRoot,
+          manifestContents,
+        );
+      }
+    } else if (manifestContents == null) {
+      run("ryvn", ["replace", "-f", manifestPath], monorepoRoot);
+    } else {
+      runWithInput(
+        "ryvn",
+        ["replace", "-f", "-"],
+        monorepoRoot,
+        manifestContents,
+      );
+    }
+  } catch (error) {
+    const currentInstallation = getInstallation(name, monorepoRoot);
+    if (isHealthyAtCommit(currentInstallation, expectedCommitSha)) {
+      console.log(
+        `${name} ${action} returned an error, but Ryvn now reports it healthy at ${expectedCommitSha.slice(0, 7)}; continuing.`,
+      );
+      return;
+    }
+
+    throw error;
+  }
+}
+
+function printFailedWorkflowLog(
+  repoSlug: string,
+  runId: number,
+  monorepoRoot: string,
 ): void {
-  if (installationExists(name, monorepoRoot)) {
-    run("ryvn", ["replace", "-f", manifestPath], monorepoRoot);
-  } else {
-    run("ryvn", ["create", "-f", manifestPath], monorepoRoot);
+  try {
+    console.log("");
+    console.log(`Failed workflow log for ${runId}:`);
+    run(
+      "gh",
+      ["run", "view", String(runId), "--repo", repoSlug, "--log-failed"],
+      monorepoRoot,
+    );
+  } catch {
+    console.log(`Could not fetch failed workflow logs for ${runId}.`);
+  }
+}
+
+async function ensureReleaseForCurrentCommit(
+  serviceName: string,
+  repoSlug: string,
+  workflowFile: string,
+  monorepoRoot: string,
+  options: Options,
+  commitSha: string,
+): Promise<Release> {
+  const existingRelease = getReleaseForCommit(
+    serviceName,
+    commitSha,
+    monorepoRoot,
+  );
+  if (existingRelease != null) {
+    console.log(
+      `${serviceName} release ${existingRelease.version ?? "unknown"} already exists for ${commitSha.slice(0, 7)}.`,
+    );
+    return existingRelease;
+  }
+
+  await triggerWorkflow(
+    serviceName,
+    repoSlug,
+    workflowFile,
+    monorepoRoot,
+    options,
+    commitSha,
+  );
+
+  const release = getReleaseForCommit(serviceName, commitSha, monorepoRoot);
+  if (release == null) {
+    throw new Error(
+      `No Ryvn release for ${serviceName} at ${commitSha} after ${workflowFile}.`,
+    );
+  }
+
+  return release;
+}
+
+function assertReleaseExistsForSkippedWorkflow(
+  serviceName: string,
+  commitSha: string,
+  monorepoRoot: string,
+): Release {
+  const release = getReleaseForCommit(serviceName, commitSha, monorepoRoot);
+  if (release == null) {
+    throw new Error(
+      `--skip-workflows was set, but no ${serviceName} Ryvn release exists for commit ${commitSha}. Rerun without --skip-workflows or confirm the release was created.`,
+    );
+  }
+
+  return release;
+}
+
+function logReleaseSummary(serviceName: string, release: Release): void {
+  console.log(
+    `${serviceName} release ready: ${release.version ?? "unknown version"}.`,
+  );
+}
+
+function requireReleaseForCurrentCommit(
+  serviceName: string,
+  repoSlug: string,
+  workflowFile: string,
+  monorepoRoot: string,
+  options: Options,
+  commitSha: string,
+): Promise<Release> {
+  if (options.skipWorkflows) {
+    return Promise.resolve(
+      assertReleaseExistsForSkippedWorkflow(
+        serviceName,
+        commitSha,
+        monorepoRoot,
+      ),
+    );
   }
+
+  return ensureReleaseForCurrentCommit(
+    serviceName,
+    repoSlug,
+    workflowFile,
+    monorepoRoot,
+    options,
+    commitSha,
+  );
+}
+
+function isRetryableReleaseFailure(error: unknown): boolean {
+  return error instanceof Error;
 }
 
 async function triggerWorkflow(
+  serviceName: string,
   repoSlug: string,
   workflowFile: string,
   monorepoRoot: string,
   options: Options,
+  commitSha: string,
 ): Promise<void> {
   if (options.skipWorkflows) return;
 
@@ -501,18 +721,32 @@ async function triggerWorkflow(
   }
 
   console.log(`Watching ${runInfo.url}`);
-  run(
-    "gh",
-    [
-      "run",
-      "watch",
-      String(runInfo.databaseId),
-      "--repo",
-      repoSlug,
-      "--exit-status",
-    ],
-    monorepoRoot,
-  );
+  try {
+    run(
+      "gh",
+      [
+        "run",
+        "watch",
+        String(runInfo.databaseId),
+        "--repo",
+        repoSlug,
+        "--exit-status",
+      ],
+      monorepoRoot,
+    );
+  } catch (error) {
+    printFailedWorkflowLog(repoSlug, runInfo.databaseId, monorepoRoot);
+
+    const release = getReleaseForCommit(serviceName, commitSha, monorepoRoot);
+    if (release != null && isRetryableReleaseFailure(error)) {
+      console.log(
+        `${workflowFile} reported a failure, but ${serviceName} release ${release.version ?? "unknown"} exists for ${commitSha.slice(0, 7)}; continuing.`,
+      );
+      return;
+    }
+
+    throw error;
+  }
 }
 
 function latestTask(tasks: InstallationTask[]): InstallationTask | null {
@@ -619,12 +853,11 @@ function parseEnvFile(
     );
 }
 
-async function patchInstallationSecrets(
+async function readInstallationSecrets(
   packageDir: string,
-  monorepoRoot: string,
   options: Options,
-): Promise<void> {
-  if (options.skipSecrets) return;
+): Promise<Array<{ name: string; value: string }>> {
+  if (options.skipSecrets) return [];
 
   const secretsPath = path.join(
     packageDir,
@@ -636,20 +869,42 @@ async function patchInstallationSecrets(
     console.log(
       `No secrets file found at ${secretsPath}; skipping secret patch.`,
     );
-    return;
+    return [];
+  }
+
+  return parseEnvFile(await readFile(secretsPath, "utf8"));
+}
+
+function appendInstallationSecrets(
+  manifestContents: string,
+  secrets: Array<{ name: string; value: string }>,
+): string {
+  if (secrets.length === 0) return manifestContents;
+
+  const marker = "  variableGroups:\n";
+  if (!manifestContents.includes(marker)) {
+    throw new Error("Installation manifest is missing variableGroups marker.");
   }
 
-  const secrets = parseEnvFile(await readFile(secretsPath, "utf8"));
+  const secretYaml = [
+    "  secrets:",
+    ...secrets.flatMap(({ name, value }) => [
+      `    - name: ${name}`,
+      `      value: ${JSON.stringify(value)}`,
+    ]),
+    "",
+  ].join("\n");
+
+  return manifestContents.replace(marker, `${secretYaml}${marker}`);
+}
+
+function patchExistingInstallationSecrets(
+  secrets: Array<{ name: string; value: string }>,
+  monorepoRoot: string,
+): void {
   if (secrets.length === 0) return;
 
-  const secretEnv = secrets.map(({ name, value }) => ({
-    key: name,
-    value,
-    isSecret: true,
-  }));
-  // Strategic merge preserves existing non-secret env entries while upserting
-  // these generated secrets by key.
-  const patch = JSON.stringify({ spec: { env: secretEnv, secrets } });
+  const patch = JSON.stringify({ spec: { secrets } });
   const result = spawnSync(
     "ryvn",
     [
@@ -672,7 +927,7 @@ async function patchInstallationSecrets(
   );
 
   if (result.status !== 0) {
-    throw new Error(`Failed to patch secrets for ${APP_NAME}.`);
+    throw new Error(`Failed to patch generated app secrets for ${APP_NAME}.`);
   }
 }
 
@@ -776,6 +1031,7 @@ async function main(): Promise<void> {
 
   const repoSlug = await ensureGitHubRepo(monorepoRoot, options);
   ensureCleanAndPushed(monorepoRoot, options);
+  const commitSha = getCurrentCommitSha(monorepoRoot);
 
   const ryvnDir = path.join(packageDir, "deploy", "ryvn");
   const serviceManifest = path.join(ryvnDir, `${APP_NAME}.service.yaml`);
@@ -802,27 +1058,46 @@ async function main(): Promise<void> {
   upsertService(terraformServiceManifest, monorepoRoot);
   upsertService(serviceManifest, monorepoRoot);
 
-  await triggerWorkflow(
+  const terraformRelease = await requireReleaseForCurrentCommit(
+    TERRAFORM_SERVICE_NAME,
     repoSlug,
     `${TERRAFORM_SERVICE_NAME}-ryvn-release.yaml`,
     monorepoRoot,
     options,
+    commitSha,
   );
+  logReleaseSummary(TERRAFORM_SERVICE_NAME, terraformRelease);
   upsertInstallation(
     TERRAFORM_SERVICE_NAME,
     terraformInstallationManifest,
     monorepoRoot,
+    commitSha,
   );
   await waitForTerraformApply(monorepoRoot, options);
 
-  await triggerWorkflow(
+  const appRelease = await requireReleaseForCurrentCommit(
+    APP_NAME,
     repoSlug,
     `${APP_NAME}-ryvn-release.yaml`,
     monorepoRoot,
     options,
+    commitSha,
+  );
+  logReleaseSummary(APP_NAME, appRelease);
+  const secrets = await readInstallationSecrets(packageDir, options);
+  if (installationExists(APP_NAME, monorepoRoot)) {
+    patchExistingInstallationSecrets(secrets, monorepoRoot);
+  }
+  upsertInstallation(
+    APP_NAME,
+    installationManifest,
+    monorepoRoot,
+    commitSha,
+    appendInstallationSecrets(
+      await readFile(installationManifest, "utf8"),
+      secrets,
+    ),
   );
-  upsertInstallation(APP_NAME, installationManifest, monorepoRoot);
-  await patchInstallationSecrets(packageDir, monorepoRoot, options);
   await waitForHealthy(monorepoRoot, options);
 
   await verifyDeployment();

package/templates/webapp/scripts/generate-migrations.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env tsx
+
+import { execFileSync } from "node:child_process";
+import { readFileSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { normalizeSchemaRelativeReferences } from "../src/drizzle/migrationSql";
+
+const migrationsDir = path.resolve("src", "drizzle", "migrations");
+
+function main(): void {
+  execFileSync("drizzle-kit", ["generate"], {
+    cwd: process.cwd(),
+    stdio: "inherit",
+  });
+
+  for (const fileName of readdirSync(migrationsDir)) {
+    if (!fileName.endsWith(".sql")) continue;
+
+    const filePath = path.join(migrationsDir, fileName);
+    const original = readFileSync(filePath, "utf8");
+    const normalized = normalizeSchemaRelativeReferences(original);
+    if (normalized !== original) {
+      writeFileSync(filePath, normalized);
+    }
+  }
+}
+
+main();

package/templates/webapp/src/drizzle/__tests__/migrationSql.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { normalizeSchemaRelativeReferences } from "../migrationSql";
+
+describe("normalizeSchemaRelativeReferences", () => {
+  it("keeps generated foreign keys schema-relative for DATABASE_SCHEMA deploys", () => {
+    expect(
+      normalizeSchemaRelativeReferences(
+        'ALTER TABLE "child" ADD CONSTRAINT "child_parent_fk" FOREIGN KEY ("parent_id") REFERENCES "public"."parent"("id") ON DELETE cascade;',
+      ),
+    ).toBe(
+      'ALTER TABLE "child" ADD CONSTRAINT "child_parent_fk" FOREIGN KEY ("parent_id") REFERENCES "parent"("id") ON DELETE cascade;',
+    );
+  });
+
+  it("leaves already schema-relative references unchanged", () => {
+    expect(
+      normalizeSchemaRelativeReferences(
+        'ALTER TABLE "child" ADD CONSTRAINT "child_parent_fk" FOREIGN KEY ("parent_id") REFERENCES "parent"("id");',
+      ),
+    ).toBe(
+      'ALTER TABLE "child" ADD CONSTRAINT "child_parent_fk" FOREIGN KEY ("parent_id") REFERENCES "parent"("id");',
+    );
+  });
+});

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

@@ -0,0 +1,8 @@
+const PUBLIC_SCHEMA_REFERENCE_PATTERN = /REFERENCES\s+"public"\."([^"]+)"/g;
+
+export function normalizeSchemaRelativeReferences(sql: string): string {
+  return sql.replace(
+    PUBLIC_SCHEMA_REFERENCE_PATTERN,
+    (_match, tableName: string) => `REFERENCES "${tableName}"`,
+  );
+}

package/templates/webapp/src/services/inngest/AppWorkflowService.ts

@@ -0,0 +1,19 @@
+import { type AppInngest, InngestService } from "./InngestService";
+import { type ExampleEventPayload } from "./events/payloads/ExampleEventPayload";
+
+type AppWorkflowClient = Pick<AppInngest, "send">;
+
+export class AppWorkflowService {
+  public static create(): AppWorkflowService {
+    return new AppWorkflowService(InngestService.create().client);
+  }
+
+  public constructor(private inngestClient: AppWorkflowClient) {}
+
+  public async sendExampleEvent(payload: ExampleEventPayload): Promise<void> {
+    await this.inngestClient.send({
+      name: "app/example.event",
+      data: payload,
+    });
+  }
+}

package/templates/webapp/src/services/inngest/__tests__/AppWorkflowService.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it, vi } from "vitest";
+import { AppWorkflowService } from "../AppWorkflowService";
+import { AppEvents } from "../events/AppEvents";
+
+describe("AppWorkflowService", () => {
+  it("sends event data in the shape validated by AppEvents", async () => {
+    const payload = { exampleId: "example-1" };
+    const send = vi.fn().mockResolvedValue(undefined);
+    const service = new AppWorkflowService({ send } as never);
+
+    await service.sendExampleEvent(payload);
+
+    expect(AppEvents["app/example.event"].parse(payload)).toEqual(payload);
+    expect(send).toHaveBeenCalledWith({
+      name: "app/example.event",
+      data: payload,
+    });
+  });
+});

package/templates/webapp/src/services/inngest/events/AppEvents.ts

@@ -1,4 +1,3 @@
-import z from "zod";
 import { ExampleEventPayload } from "./payloads/ExampleEventPayload";
 
 /**
@@ -6,29 +5,24 @@ import { ExampleEventPayload } from "./payloads/ExampleEventPayload";
  *
  * Each event should have:
  * - A unique name (conventionally "app/event.name")
- * - A Zod schema for the event data
+ * - A Zod schema for event.data. Do not wrap the payload in another
+ *   `{ data: ... }` object here.
  *
  * @example
  * ```ts
  * export const AppEvents = {
  *   "app/user.created": z.object({
- *     data: z.object({
- *       userId: z.string(),
- *       email: z.string(),
- *     }),
+ *     userId: z.string(),
+ *     email: z.string(),
  *   }),
  *   "app/order.completed": z.object({
- *     data: z.object({
- *       orderId: z.string(),
- *       total: z.number(),
- *     }),
+ *     orderId: z.string(),
+ *     total: z.number(),
  *   }),
  * };
  * ```
  */
 export const AppEvents = {
   // Example event - replace with your actual events
-  "app/example.event": z.object({
-    data: ExampleEventPayload.SCHEMA,
-  }),
+  "app/example.event": ExampleEventPayload.SCHEMA,
 };

package/templates/webapp/src/services/inngest/events/payloads/ExampleEventPayload.ts

@@ -7,8 +7,6 @@ import z from "zod";
 export type ExampleEventPayload = z.infer<typeof ExampleEventPayload.SCHEMA>;
 export namespace ExampleEventPayload {
   export const SCHEMA = z.object({
-    // Add your event properties here
-    // exampleId: z.string(),
-    // data: z.record(z.unknown()),
+    exampleId: z.string(),
   });
 }