alchemy 2.0.0-beta.65 → 2.0.0-beta.67

package/src/Prisma/Connect.ts

@@ -0,0 +1,433 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Binding from "../Binding.ts";
+import * as Output from "../Output.ts";
+import type { Resource, ResourceLike } from "../Resource.ts";
+import { RuntimeContext } from "../RuntimeContext.ts";
+import type { Connection } from "./Connection.ts";
+import { envName } from "./Internal/EnvName.ts";
+
+/**
+ * The typed runtime client returned by {@link Connect}.
+ */
+export interface ConnectClient {
+  /**
+   * Conventional application database URL, redacted.
+   *
+   * Resolves to the pooled Postgres URL first, then direct Postgres, then
+   * Accelerate — the serverless-safe default for application traffic. Dies
+   * with a descriptive defect when the connection carries no URL at all.
+   *
+   * Feed it straight into `SQL.Postgres` / `Drizzle.Postgres`:
+   *
+   * ```typescript
+   * const db = yield* Prisma.Connect(connection);
+   * const sql = yield* SQL.Postgres({ url: db.databaseUrl });
+   * ```
+   */
+  databaseUrl: Effect.Effect<Redacted.Redacted<string>, never, RuntimeContext>;
+  /**
+   * Prisma connection/API key ID.
+   */
+  connectionId: Effect.Effect<string, never, RuntimeContext>;
+  /**
+   * Database ID this connection belongs to.
+   */
+  databaseId: Effect.Effect<string, never, RuntimeContext>;
+  /**
+   * Direct Postgres connection string, when available.
+   */
+  directConnectionString: Effect.Effect<
+    Redacted.Redacted<string> | undefined,
+    never,
+    RuntimeContext
+  >;
+  /**
+   * Pooled Prisma Postgres connection string, when available.
+   */
+  pooledConnectionString: Effect.Effect<
+    Redacted.Redacted<string> | undefined,
+    never,
+    RuntimeContext
+  >;
+  /**
+   * Accelerate connection string, when available.
+   */
+  accelerateConnectionString: Effect.Effect<
+    Redacted.Redacted<string> | undefined,
+    never,
+    RuntimeContext
+  >;
+  /**
+   * Direct database host, when available.
+   */
+  host: Effect.Effect<string | null | undefined, never, RuntimeContext>;
+  /**
+   * Direct database user, when available.
+   */
+  user: Effect.Effect<string | null | undefined, never, RuntimeContext>;
+  /**
+   * Direct database password, when available.
+   */
+  password: Effect.Effect<
+    Redacted.Redacted<string> | undefined,
+    never,
+    RuntimeContext
+  >;
+}
+
+/**
+ * Bind a {@link Connection} to a Prisma Compute app, AWS Lambda Function, or
+ * Cloudflare Worker and obtain the typed runtime client.
+ *
+ * `Connect` is a single identifier that is simultaneously the binding's
+ * Context tag, its type, and the callable —
+ * `yield* Prisma.Connect(connection)`.
+ *
+ * Provide `Prisma.ConnectBinding` on the host implementation so Alchemy can
+ * register the deploy-time binding and resolve the client at runtime.
+ *
+ * @section Binding a Connection
+ * @example Use a connection inside Prisma Compute
+ * ```typescript
+ * export default Prisma.Compute(
+ *   "api",
+ *   { project, main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     const db = yield* Prisma.Connect(connection);
+ *     const sql = yield* SQL.Postgres({ url: db.databaseUrl });
+ *
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const users = yield* sql`SELECT * FROM users`;
+ *         return yield* HttpServerResponse.json(users);
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Prisma.ConnectBinding)),
+ * );
+ * ```
+ *
+ * @binding
+ */
+export interface Connect extends Binding.Service<
+  Connect,
+  "Prisma.Connect",
+  (connection: Connection) => Effect.Effect<ConnectClient>
+> {}
+
+export const Connect = Binding.Service<Connect>("Prisma.Connect");
+
+export interface ConnectEnvKeys {
+  connectionId: string;
+  databaseId: string;
+  directConnectionString: string;
+  pooledConnectionString: string;
+  accelerateConnectionString: string;
+  host: string;
+  user: string;
+  password: string;
+}
+
+/**
+ * Derive the env var names {@link Connect} uses to carry a Connection's
+ * outputs into the host runtime.
+ */
+export const connectEnvKeys = (
+  connection: Pick<Connection, "FQN" | "LogicalId">,
+): ConnectEnvKeys => {
+  const name =
+    connection.FQN === connection.LogicalId
+      ? connection.LogicalId
+      : connection.FQN;
+  const prefix = `PRISMA_${envName(name)}`;
+  return {
+    connectionId: `${prefix}_CONNECTION_ID`,
+    databaseId: `${prefix}_DATABASE_ID`,
+    directConnectionString: `${prefix}_DIRECT_CONNECTION_STRING`,
+    pooledConnectionString: `${prefix}_POOLED_CONNECTION_STRING`,
+    accelerateConnectionString: `${prefix}_ACCELERATE_CONNECTION_STRING`,
+    host: `${prefix}_HOST`,
+    user: `${prefix}_USER`,
+    password: `${prefix}_PASSWORD`,
+  };
+};
+
+type ConnectEnvValue = Output.Output<
+  string | Redacted.Redacted<string> | undefined
+>;
+
+type ConnectEnvBindingHost = Resource<
+  string,
+  object | undefined,
+  object,
+  { env?: Record<string, ConnectEnvValue> }
+>;
+
+type ConnectWorkerTextBinding =
+  | {
+      type: "plain_text";
+      name: string;
+      text: string;
+    }
+  | {
+      type: "secret_text";
+      name: string;
+      text: string;
+    };
+
+type ConnectWorkerBindingHost = Resource<
+  "Cloudflare.Worker",
+  object | undefined,
+  object,
+  { bindings?: ConnectWorkerTextBinding[] }
+>;
+
+const supportsConnectEnvBinding = (
+  host: ResourceLike,
+): host is ConnectEnvBindingHost =>
+  host.Type === "Prisma.Compute" || host.Type === "AWS.Lambda.Function";
+
+const supportsConnectWorkerBinding = (
+  host: ResourceLike,
+): host is ConnectWorkerBindingHost => host.Type === "Cloudflare.Worker";
+
+// Compute env sync omits undefined and treats null as deletion. Connection
+// bindings need both values to round-trip into the typed runtime client.
+const ENCODED_CONNECTION_PREFIX = "__ALCHEMY_PRISMA_CONNECTION_VALUE__:";
+
+type EncodedConnectionValue =
+  | { readonly kind: "undefined" }
+  | { readonly kind: "null" }
+  | { readonly kind: "value"; readonly value: string };
+
+const encodeConnectionValue = (value: EncodedConnectionValue) =>
+  `${ENCODED_CONNECTION_PREFIX}${JSON.stringify(value)}`;
+
+const escapePrefixedValue = <A extends string | Redacted.Redacted<string>>(
+  value: A,
+): A | string | Redacted.Redacted<string> => {
+  const raw = typeof value === "string" ? value : String(Redacted.value(value));
+  if (!raw.startsWith(ENCODED_CONNECTION_PREFIX)) return value;
+  const encoded = encodeConnectionValue({ kind: "value", value: raw });
+  return Redacted.isRedacted(value) ? Redacted.make(encoded) : encoded;
+};
+
+const encodeOptionalValue = <A extends string | Redacted.Redacted<string>>(
+  output: Output.Output<A | null | undefined>,
+): Output.Output<A | string | Redacted.Redacted<string>> =>
+  output.pipe(
+    Output.map((value) =>
+      value === undefined
+        ? encodeConnectionValue({ kind: "undefined" })
+        : value === null
+          ? encodeConnectionValue({ kind: "null" })
+          : escapePrefixedValue(value),
+    ),
+  ) as Output.Output<A | string | Redacted.Redacted<string>>;
+
+const encodedConnectEnv = (connection: Connection) => ({
+  connectionId: connection.connectionId,
+  databaseId: connection.databaseId,
+  directConnectionString: encodeOptionalValue(
+    connection.directConnectionString,
+  ),
+  pooledConnectionString: encodeOptionalValue(
+    connection.pooledConnectionString,
+  ),
+  accelerateConnectionString: encodeOptionalValue(
+    connection.accelerateConnectionString,
+  ),
+  host: encodeOptionalValue(connection.host),
+  user: encodeOptionalValue(connection.user),
+  password: encodeOptionalValue(connection.password),
+});
+
+const connectEnv = (connection: Connection) => {
+  const keys = connectEnvKeys(connection);
+  const env = encodedConnectEnv(connection);
+  return {
+    [keys.connectionId]: env.connectionId,
+    [keys.databaseId]: env.databaseId,
+    [keys.directConnectionString]: env.directConnectionString,
+    [keys.pooledConnectionString]: env.pooledConnectionString,
+    [keys.accelerateConnectionString]: env.accelerateConnectionString,
+    [keys.host]: env.host,
+    [keys.user]: env.user,
+    [keys.password]: env.password,
+  };
+};
+
+const workerBindingValue = (
+  name: string,
+  value: ConnectEnvValue,
+): Output.Output<ConnectWorkerTextBinding> =>
+  value.pipe(
+    Output.map((resolved) => {
+      if (Redacted.isRedacted(resolved)) {
+        return {
+          type: "secret_text",
+          name,
+          text: Redacted.value(resolved),
+        };
+      }
+      return {
+        type: "plain_text",
+        name,
+        text: resolved ?? encodeConnectionValue({ kind: "undefined" }),
+      };
+    }),
+  );
+
+const connectWorkerBindings = (
+  connection: Connection,
+): Output.Output<ConnectWorkerTextBinding>[] => {
+  const keys = connectEnvKeys(connection);
+  const env = encodedConnectEnv(connection);
+  return [
+    workerBindingValue(keys.connectionId, env.connectionId),
+    workerBindingValue(keys.databaseId, env.databaseId),
+    workerBindingValue(keys.directConnectionString, env.directConnectionString),
+    workerBindingValue(keys.pooledConnectionString, env.pooledConnectionString),
+    workerBindingValue(
+      keys.accelerateConnectionString,
+      env.accelerateConnectionString,
+    ),
+    workerBindingValue(keys.host, env.host),
+    workerBindingValue(keys.user, env.user),
+    workerBindingValue(keys.password, env.password),
+  ];
+};
+
+const redactedToString = (
+  value: Redacted.Redacted<string> | string | undefined,
+): string | undefined =>
+  Redacted.isRedacted(value) ? Redacted.value(value) : value;
+
+const runtimeOutput = <A>(
+  key: string,
+  output: Output.Output<A>,
+): Effect.Effect<A, never, RuntimeContext> =>
+  output.bind(key).pipe(Effect.flatMap((effect) => effect));
+
+const decodeConnectionValue = (
+  value: Redacted.Redacted<string> | string,
+): string | null | undefined => {
+  const raw = redactedToString(value);
+  if (raw === undefined || !raw.startsWith(ENCODED_CONNECTION_PREFIX)) {
+    return raw;
+  }
+  try {
+    const parsed = JSON.parse(raw.slice(ENCODED_CONNECTION_PREFIX.length));
+    if (typeof parsed !== "object" || parsed === null || !("kind" in parsed)) {
+      return raw;
+    }
+    if (parsed.kind === "undefined") return undefined;
+    if (parsed.kind === "null") return null;
+    if (parsed.kind === "value" && typeof parsed.value === "string") {
+      return parsed.value;
+    }
+    return raw;
+  } catch {
+    return raw;
+  }
+};
+
+const optionalString = (
+  value: Redacted.Redacted<string> | string,
+): string | undefined => decodeConnectionValue(value) ?? undefined;
+
+const optionalRedacted = (
+  value: Redacted.Redacted<string> | string,
+): Redacted.Redacted<string> | undefined => {
+  const decoded = optionalString(value);
+  return decoded === undefined ? undefined : Redacted.make(decoded);
+};
+
+const nullableString = (
+  value: Redacted.Redacted<string> | string,
+): string | null | undefined => decodeConnectionValue(value);
+
+/**
+ * Implementation layer for {@link Connect}. Provide it on the host
+ * Function/Worker Effect:
+ *
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const db = yield* Prisma.Connect(connection);
+ *   // ...
+ * }).pipe(Effect.provide(Prisma.ConnectBinding))
+ * ```
+ */
+export const ConnectBinding = Layer.effect(
+  Connect,
+  Effect.gen(function* () {
+    return Effect.fn(function* (connection: Connection) {
+      if (!globalThis.__ALCHEMY_RUNTIME__) {
+        const host = yield* Binding.Host;
+        if (supportsConnectEnvBinding(host)) {
+          yield* host.bind`${connection}`({
+            env: connectEnv(connection),
+          });
+        } else if (supportsConnectWorkerBinding(host)) {
+          yield* host.bind`${connection}`({
+            bindings: connectWorkerBindings(connection),
+          });
+        } else {
+          return yield* Effect.die(
+            new Error(
+              `Prisma.Connect supports Prisma.Compute, AWS.Lambda.Function, and Cloudflare.Worker runtimes, got '${host.Type}'`,
+            ),
+          );
+        }
+      }
+      const keys = connectEnvKeys(connection);
+      const env = encodedConnectEnv(connection);
+      const directConnectionString = runtimeOutput(
+        keys.directConnectionString,
+        env.directConnectionString,
+      ).pipe(Effect.map(optionalRedacted));
+      const pooledConnectionString = runtimeOutput(
+        keys.pooledConnectionString,
+        env.pooledConnectionString,
+      ).pipe(Effect.map(optionalRedacted));
+      const accelerateConnectionString = runtimeOutput(
+        keys.accelerateConnectionString,
+        env.accelerateConnectionString,
+      ).pipe(Effect.map(optionalRedacted));
+      const databaseUrl = Effect.all([
+        pooledConnectionString,
+        directConnectionString,
+        accelerateConnectionString,
+      ]).pipe(
+        Effect.flatMap(([pooled, direct, accelerate]) => {
+          const url = pooled ?? direct ?? accelerate;
+          return url === undefined
+            ? Effect.die(
+                new Error(
+                  "Prisma connection carries no connection URL (no pooled, direct, or Accelerate endpoint was bound)",
+                ),
+              )
+            : Effect.succeed(url);
+        }),
+      );
+      return {
+        databaseUrl,
+        connectionId: runtimeOutput(keys.connectionId, env.connectionId),
+        databaseId: runtimeOutput(keys.databaseId, env.databaseId),
+        directConnectionString,
+        pooledConnectionString,
+        accelerateConnectionString,
+        host: runtimeOutput(keys.host, env.host).pipe(
+          Effect.map(nullableString),
+        ),
+        user: runtimeOutput(keys.user, env.user).pipe(
+          Effect.map(nullableString),
+        ),
+        password: runtimeOutput(keys.password, env.password).pipe(
+          Effect.map(optionalRedacted),
+        ),
+      } satisfies ConnectClient;
+    });
+  }),
+);