Merge pull request #273 from voidhashcom/agent/oss-mimic-db-cloudflare

GitOrigin-RevId: bbafb7a631045cb4ca318566d7ae3c9387606db8

Author: KingDoxik

apps/backend/package.json

@@ -15,6 +15,8 @@
     "@voidhash/backend": "workspace:*",
     "@voidhash/core": "workspace:*",
     "@voidhash/lib": "workspace:*",
+    "@voidhash/mimic-db": "workspace:*",
+    "@voidhash/mimic-schema": "workspace:*",
     "@voidhash/platform": "workspace:*",
     "@voidhash/platform-cloudflare": "workspace:*",
     "alchemy": "catalog:",

apps/backend/stack.ts

@@ -1,17 +1,30 @@
 import * as Alchemy from "alchemy";
 import * as Cloudflare from "alchemy/Cloudflare";
+import * as Output from "alchemy/Output";
+import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
 
 import { DatabaseHyperdrive } from "./infrastructure/Hyperdrive.ts";
 import { PaywallArtifactsBucket } from "./r2/PaywallArtifactsBucket.ts";
 import { PublicFileStorageBucket } from "./r2/PublicFileStorageBucket.ts";
 import { CommunityWebsite } from "./workers/WwwWorker.ts";
 import CommunityBackend from "./workers/BackendWorker.ts";
+import MimicDbWorker, { MIMIC_DB_DEV_PORT } from "./workers/MimicDbWorker.ts";
+
+const dieOnBlankWwwOrigin = (): never =>
+  Effect.runSync(
+    Effect.die(
+      new Error("www origin resolved empty — refusing to bind a blank CORS_ORIGINS on mimic-db"),
+    ),
+  );
 
 /** Resolved Community Cloudflare deployment outputs. */
 export interface CommunityStackOutput {
   readonly backendUrl: string;
   readonly hyperdriveId: string;
+  readonly mimicDbUrl: string;
   readonly wwwUrl: string;
 }
 
@@ -22,15 +35,101 @@ export default Alchemy.Stack(
     state: Cloudflare.state(),
   },
   Effect.gen(function* () {
+    const { stage } = yield* Alchemy.Stack;
+    const dev = Option.match(yield* Effect.serviceOption(Alchemy.AlchemyContext), {
+      onNone: () => false,
+      onSome: (context) => context.dev,
+    });
+    const isEphemeral = stage !== "production" && stage !== "preview";
     const hyperdrive = yield* DatabaseHyperdrive;
     yield* PaywallArtifactsBucket;
     yield* PublicFileStorageBucket;
     const backend = yield* CommunityBackend;
+    const mimicDb = yield* MimicDbWorker;
+    yield* backend.bind`MimicHostServiceBinding`({
+      bindings: [
+        {
+          type: "service",
+          name: "MIMIC_HOST",
+          service: mimicDb.workerName,
+        },
+      ],
+    });
     const www = yield* CommunityWebsite({ apiUrl: backend.url.as<string>() });
 
+    if (!dev) {
+      yield* mimicDb.bind`MimicPublicBaseUrl`({
+        bindings: [
+          {
+            type: "plain_text",
+            name: "MIMIC_PUBLIC_BASE_URL",
+            text: Output.map(mimicDb.url, (url) => url ?? ""),
+          },
+        ],
+      });
+    }
+
+    const mimicRootPassword = yield* Config.redacted("MIMIC_ROOT_PASSWORD").pipe(
+      Config.withDefault(Redacted.make("")),
+      Effect.flatMap((password) => {
+        if (Redacted.value(password) !== "") return Effect.succeed(password);
+        if (isEphemeral) return Effect.succeed(Redacted.make("password"));
+        return Effect.die(
+          new Error("MIMIC_ROOT_PASSWORD must be set for production/preview deploys"),
+        );
+      }),
+    );
+    const resolveMimicCorsOrigins = () => {
+      if (dev) {
+        return [
+          "http://localhost:3000",
+          "http://localhost:5173",
+          "http://localhost:4173",
+          "http://localhost:4460",
+          "http://localhost:3003",
+        ].join(",");
+      }
+      return Output.map(www.url, (url) => {
+        const origin = (url ?? "").replace(/\/+$/, "");
+        if (origin === "" && !isEphemeral) return dieOnBlankWwwOrigin();
+        return origin;
+      });
+    };
+    const mimicCorsOrigins = resolveMimicCorsOrigins();
+    const resolveMimicDbUrl = () => {
+      if (dev) return `http://localhost:${MIMIC_DB_DEV_PORT}`;
+      return Output.map(mimicDb.url, (url) => url ?? "");
+    };
+
+    yield* mimicDb.bind`MimicDbSecurity`({
+      bindings: [
+        {
+          type: "secret_text",
+          name: "ROOT_PASSWORD",
+          text: Redacted.value(mimicRootPassword),
+        },
+        { type: "plain_text", name: "CORS_ORIGINS", text: mimicCorsOrigins },
+      ],
+    });
+    yield* backend.bind`MimicDbCredentials`({
+      bindings: [
+        {
+          type: "plain_text",
+          name: "MIMIC_DB_URL",
+          text: resolveMimicDbUrl(),
+        },
+        {
+          type: "secret_text",
+          name: "MIMIC_ROOT_PASSWORD",
+          text: Redacted.value(mimicRootPassword),
+        },
+      ],
+    });
+
     return {
       backendUrl: backend.url,
       hyperdriveId: hyperdrive.hyperdriveId,
+      mimicDbUrl: mimicDb.url,
       wwwUrl: www.url,
     };
   }),

apps/backend/workers/BackendWorker.ts

@@ -4,14 +4,14 @@ import { RuntimeContext } from "alchemy/RuntimeContext";
 import { EventCaptureApi } from "@voidhash/api-contracts/event-capture";
 import {
   BackendComponentCompilerStubLive,
-  BackendMimicHostStubLive,
   BackendNoopIdentityProjectionPublisherLive,
   BackendPaymentProviderStubsLive,
   BackendSnapshotImageRendererStubLive,
   NoBackendFeatures,
   NoBackendRpcExtension,
   buildBackendFetch,
 } from "@voidhash/backend/BackendApp";
+import { makeMimicHostLive } from "@voidhash/backend/MimicHostLive";
 import { RpcAuthLive } from "@voidhash/backend/RpcMiddlewares";
 import { EventCaptureGroupLive } from "@voidhash/backend/routes/event-capture";
 import { AnalyticsEventStore } from "@voidhash/core/services/analytics/AnalyticsEventStore";
@@ -211,7 +211,7 @@ export default Cloudflare.Worker(
       publicFileStore,
       BackendPaymentProviderStubsLive,
       BackendNoopIdentityProjectionPublisherLive,
-      BackendMimicHostStubLive,
+      makeMimicHostLive(environment),
       BackendComponentCompilerStubLive,
       BackendSnapshotImageRendererStubLive,
       ProjectSchemaCacheLive,

apps/backend/workers/MimicDbWorker.ts

@@ -0,0 +1,16 @@
+import { makeMimicDbWorker } from "@voidhash/mimic-db/cloudflare/MimicDbWorker";
+import { PaywallMigrationRegistry } from "@voidhash/mimic-schema";
+
+import { DatabaseHyperdrive } from "../infrastructure/Hyperdrive.ts";
+
+export const MIMIC_DB_DEV_PORT = 5001;
+
+/** Community deployment composition for the mimic-db Cloudflare Worker. */
+const MimicDbWorker: ReturnType<typeof makeMimicDbWorker> = makeMimicDbWorker({
+  devPort: MIMIC_DB_DEV_PORT,
+  hyperdrive: DatabaseHyperdrive,
+  main: import.meta.filename,
+  migrations: PaywallMigrationRegistry,
+});
+
+export default MimicDbWorker;