alchemy 2.0.0-beta.62 → 2.0.0-beta.63

package/src/Planetscale/MySQL/MySQLDatabase.ts

@@ -18,6 +18,7 @@ import {
 } from "../Util.ts";
 import {
   ensureMySQLProductionBranchClusterSize,
+  observeDefaultKeyspaceReplicas,
   type MySQLClusterSize,
 } from "./MySQLClusterSize.ts";
 import { runMySQLImports, runMySQLMigrations } from "./MySQLMigrations.ts";
@@ -32,6 +33,16 @@ export interface MySQLDatabaseProps extends BaseDatabaseProps {
    */
   clusterSize: MySQLClusterSize;
 
+  /**
+   * Desired total number of replicas for the database's default keyspace.
+   * Each cluster size includes a fixed number of replicas (2 for
+   * production `PS_*` sizes); higher values add extra replicas. Changes
+   * are reconciled in place via PlanetScale's keyspace resize lifecycle —
+   * never by replacing the database.
+   * @see https://planetscale.com/docs/vitess/sharding/keyspaces
+   */
+  replicas?: number;
+
   /**
    * Whether to copy migration data to new branches and in deploy requests.
    */
@@ -67,6 +78,12 @@ export interface MySQLDatabaseProps extends BaseDatabaseProps {
  * Output attributes of a deployed MySQL PlanetScale database.
  */
 export interface MySQLDatabaseAttributes extends BaseDatabaseAttributes {
+  /**
+   * Observed total replica count of the default keyspace on the default
+   * branch, or `undefined` while the keyspace is still provisioning.
+   */
+  replicas: number | undefined;
+
   /**
    * Whether to copy migration data to new branches and in deploy requests.
    */
@@ -168,8 +185,14 @@ export const MySQLDatabaseProvider = () =>
       ) {
         return { action: "replace" } as const;
       }
-      if (news.replicas !== olds.replicas) {
-        return { action: "replace" } as const;
+      // Replicas reconcile in place via a keyspace resize — never a
+      // replacement. Diff against the observed keyspace replica count so
+      // an adopted database whose live state already matches plans no-op.
+      if (
+        news.replicas !== undefined &&
+        news.replicas !== (output?.replicas ?? olds.replicas)
+      ) {
+        return { action: "update" } as const;
       }
       if (news.migrationsDir) {
         const newHashes = yield* hashMigrations(news.migrationsDir);
@@ -203,46 +226,57 @@ export const MySQLDatabaseProvider = () =>
           database: databaseName,
         })
         .pipe(
-          Effect.flatMap((data) => {
-            if (data.kind !== "mysql") {
-              return Effect.fail(
-                new PlanetscaleConflict({
-                  message:
-                    `Planetscale database "${data.name}" has kind "${data.kind}" but this resource ` +
-                    `is a MySQLDatabase. Use Planetscale.${data.kind === "postgresql" ? "PostgresDatabase" : data.kind}() instead, ` +
-                    `or delete the existing database and retry.`,
-                }),
+          Effect.flatMap(
+            Effect.fn(function* (data) {
+              if (data.kind !== "mysql") {
+                return yield* Effect.fail(
+                  new PlanetscaleConflict({
+                    message:
+                      `Planetscale database "${data.name}" has kind "${data.kind}" but this resource ` +
+                      `is a MySQLDatabase. Use Planetscale.${data.kind === "postgresql" ? "PostgresDatabase" : data.kind}() instead, ` +
+                      `or delete the existing database and retry.`,
+                  }),
+                );
+              }
+              // Observe the default keyspace's live replica configuration
+              // so adopted databases diff against reality.
+              const replicas = yield* observeDefaultKeyspaceReplicas(
+                organization,
+                data.name,
+                data.default_branch ?? "main",
               );
-            }
-            return Effect.succeed({
-              id: data.id,
-              name: data.name,
-              organization,
-              state: data.state,
-              defaultBranch: data.default_branch ?? "main",
-              plan: data.plan ?? "hobby",
-              createdAt: data.created_at,
-              updatedAt: data.updated_at,
-              htmlUrl: data.html_url,
-              region: { slug: data.region.slug },
-              migrationsDir: output?.migrationsDir ?? olds?.migrationsDir,
-              migrationsTable: output?.migrationsTable ?? olds?.migrationsTable,
-              migrationsHashes: output?.migrationsHashes ?? {},
-              importHashes: output?.importHashes ?? {},
-              clusterSize: output?.clusterSize ?? "",
-              requireApprovalForDeploy:
-                data.require_approval_for_deploy ?? false,
-              restrictBranchRegion: data.restrict_branch_region ?? false,
-              insightsRawQueries: data.insights_raw_queries ?? false,
-              productionBranchWebConsole:
-                data.production_branch_web_console ?? false,
-              automaticMigrations: data.automatic_migrations ?? false,
-              migrationFramework: data.migration_framework ?? undefined,
-              migrationTableName: data.migration_table_name ?? undefined,
-              allowDataBranching: data.allow_data_branching ?? false,
-              allowForeignKeyConstraints: data.foreign_keys_enabled ?? false,
-            });
-          }),
+              return {
+                id: data.id,
+                name: data.name,
+                organization,
+                state: data.state,
+                defaultBranch: data.default_branch ?? "main",
+                replicas,
+                plan: data.plan ?? "hobby",
+                createdAt: data.created_at,
+                updatedAt: data.updated_at,
+                htmlUrl: data.html_url,
+                region: { slug: data.region.slug },
+                migrationsDir: output?.migrationsDir ?? olds?.migrationsDir,
+                migrationsTable:
+                  output?.migrationsTable ?? olds?.migrationsTable,
+                migrationsHashes: output?.migrationsHashes ?? {},
+                importHashes: output?.importHashes ?? {},
+                clusterSize: output?.clusterSize ?? "",
+                requireApprovalForDeploy:
+                  data.require_approval_for_deploy ?? false,
+                restrictBranchRegion: data.restrict_branch_region ?? false,
+                insightsRawQueries: data.insights_raw_queries ?? false,
+                productionBranchWebConsole:
+                  data.production_branch_web_console ?? false,
+                automaticMigrations: data.automatic_migrations ?? false,
+                migrationFramework: data.migration_framework ?? undefined,
+                migrationTableName: data.migration_table_name ?? undefined,
+                allowDataBranching: data.allow_data_branching ?? false,
+                allowForeignKeyConstraints: data.foreign_keys_enabled ?? false,
+              };
+            }),
+          ),
           Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
         );
     }),
@@ -272,13 +306,14 @@ export const MySQLDatabaseProvider = () =>
       // Ensure — if missing, create.
       if (!observed) {
         yield* session.note("Creating database...");
+        // Note: the API rejects the `replicas` param for mysql databases;
+        // replicas are converged below via the keyspace resize lifecycle.
         observed = yield* planetscale.createDatabase({
           organization,
           name: newName,
           region: news.region?.slug,
           kind: "mysql",
           cluster_size: clusterSize,
-          replicas: news.replicas,
         });
       }
 
@@ -345,13 +380,16 @@ export const MySQLDatabaseProvider = () =>
         default_branch: news.defaultBranch,
       });
 
-      // Sync cluster size on the active default branch.
+      // Sync cluster size and replicas on the active default branch —
+      // both converge in place via PlanetScale's keyspace resize
+      // lifecycle, diffed against the observed default keyspace.
       const branch = news.defaultBranch ?? updated.default_branch ?? "main";
-      yield* ensureMySQLProductionBranchClusterSize(
+      const keyspace = yield* ensureMySQLProductionBranchClusterSize(
         organization,
         updated.name,
         branch,
         news.clusterSize,
+        news.replicas,
       );
 
       const migrationTarget = {
@@ -394,6 +432,7 @@ export const MySQLDatabaseProvider = () =>
         htmlUrl: updated.html_url,
         region: { slug: updated.region.slug },
         clusterSize,
+        replicas: keyspace.replicas,
         migrationsDir: news.migrationsDir,
         migrationsTable: news.migrationsDir ? migrationsTable : undefined,
         migrationsHashes,
@@ -445,6 +484,7 @@ export const MySQLDatabaseProvider = () =>
                 migrationsHashes: {},
                 importHashes: {},
                 clusterSize: "",
+                replicas: undefined,
                 requireApprovalForDeploy:
                   data.require_approval_for_deploy ?? false,
                 restrictBranchRegion: data.restrict_branch_region ?? false,

package/src/Platform.ts

@@ -385,15 +385,24 @@ export const Platform = <
       // e.g.
       // export default Cloudflare.Worker("id", { main: "./src/worker.ts" }, Effect.gen(function* () { .. })
       const cls = makeClass(id);
-      return cls.Self.pipe(
-        provideClassLayer(cls.make(props, impl)),
-        effectClass,
+      return Object.assign(
+        cls.Self.pipe(provideClassLayer(cls.make(props, impl)), effectClass),
+        // Expose the logical id statically (mirrors `makeClass`) so a class
+        // reference identifies its resource without being yielded.
+        { LogicalId: id },
       );
     }
   };
 
   const makeClass = (id: string) => {
     class Platform {
+      /**
+       * Logical id of the resource this class declares. Statically readable
+       * — e.g. `DurableObjectProps.transferredFrom` accepts a Worker class
+       * and takes its identity from here without yielding it (yielding
+       * would add a dependency edge on the referenced resource).
+       */
+      static readonly LogicalId = id;
       static readonly Self = Self(`${type}<${id}>`);
       static readonly Platform = Context.Service<Platform, Platform>(
         `Platform<${type}<${id}>>`,

package/src/Runtime.ts

@@ -6,7 +6,10 @@
  * surface tiny and dependency-light.
  */
 
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import { isRedactedMarker, sanitizeKey } from "./RuntimeContext.ts";
 import { asEffect } from "./Util/types.ts";
 
 /**
@@ -32,3 +35,92 @@ export const makeEntrypointLayer = (
   }
   return Layer.effect(tag, asEffect(entrypoint));
 };
+
+/**
+ * Unwrap the `{"_tag":"Redacted","value":...}` marker that the deploy-time
+ * `Config` interceptor (see `Platform.ts`) and `RuntimeContext.set` use to
+ * preserve `Redacted`-ness across the env-var boundary. Returns the inner
+ * source value as a string, or `undefined` when `raw` is not a marker.
+ */
+const parseRedactedMarker = (raw: string): string | undefined => {
+  if (!raw.startsWith("{")) {
+    return undefined;
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (isRedactedMarker(parsed)) {
+      return typeof parsed.value === "string"
+        ? parsed.value
+        : JSON.stringify(parsed.value);
+    }
+  } catch {
+    // not JSON — plain env value, fall through
+  }
+  return undefined;
+};
+
+/**
+ * Reify an env-var string the way `RuntimeContext.get` does: unwrap the
+ * `Redacted` marker, unquote a JSON-stringified string, and pass anything
+ * else through verbatim.
+ */
+const reifyEnvString = (raw: string): string => {
+  const marker = parseRedactedMarker(raw);
+  if (marker !== undefined) {
+    return marker;
+  }
+  if (raw.startsWith('"')) {
+    try {
+      const parsed: unknown = JSON.parse(raw);
+      if (typeof parsed === "string") {
+        return parsed;
+      }
+    } catch {
+      // not JSON — plain env value, fall through
+    }
+  }
+  return raw;
+};
+
+/**
+ * Wrap a runtime's env-backed `ConfigProvider` so values that were
+ * auto-bound by the deploy-time `Config` interceptor decode transparently.
+ *
+ * The engine can't know which config values are sensitive, so the
+ * interceptor binds every `Config` read during Init onto the deploy target
+ * as a secret, serialized as a `{"_tag":"Redacted","value":<source>}`
+ * marker. The interceptor's runtime branch reifies those markers for reads
+ * during Init, but effects that run later (request handlers, nested
+ * layers) resolve `Config` against the raw env-backed provider — without
+ * this wrapper, `Config.number("PORT")` inside a handler sees the marker
+ * JSON instead of the source value and fails with a schema error.
+ *
+ * Two behaviors:
+ * - Leaf values that carry the marker are unwrapped to the raw source
+ *   string before `Config` schemas decode them; everything else passes
+ *   through untouched.
+ * - On a miss, falls back to the flat `sanitizeKey`-canonicalized key
+ *   (`my.key` → `my_key`) that the interceptor bound the value under, so
+ *   config names with non-alphanumeric characters resolve at runtime too.
+ */
+export const reifyBoundConfigProvider = (
+  base: ConfigProvider.ConfigProvider,
+  env: Record<string, unknown>,
+): ConfigProvider.ConfigProvider =>
+  ConfigProvider.make((path) =>
+    base.load(path).pipe(
+      Effect.map((node) => {
+        if (node?._tag === "Value") {
+          const value = parseRedactedMarker(node.value);
+          return value === undefined ? node : ConfigProvider.makeValue(value);
+        }
+        if (node === undefined) {
+          const raw = env[sanitizeKey(path.map((p) => p.toString()).join("_"))];
+          if (typeof raw === "string") {
+            return ConfigProvider.makeValue(reifyEnvString(raw));
+          }
+        }
+        return node;
+      }),
+    ),
+  );

package/src/RuntimeContext.ts

@@ -2,6 +2,7 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
 import type { HttpEffect } from "./Http.ts";
 import type { Output } from "./Output.ts";
 
@@ -43,6 +44,84 @@ export interface BaseRuntimeContext {
 export const sanitizeKey = (key: string): string =>
   key.replaceAll(/[^a-zA-Z0-9]/g, "_");
 
+/**
+ * The wire format `RuntimeContext.set`/`get` use to carry a `Redacted` value
+ * through an environment variable. `JSON.stringify(Redacted)` emits the
+ * literal string `"<redacted>"` and loses the value, so secrets are
+ * serialized as this marker and the runtime `get` path rebuilds the wrapper.
+ */
+export interface RedactedMarker {
+  readonly _tag: "Redacted";
+  readonly value: unknown;
+}
+
+/**
+ * Detect the (already JSON-parsed) {@link RedactedMarker} shape. After
+ * `JSON.parse` the marker is a plain object — `Redacted.isRedacted` is
+ * always `false` on it — so detection is structural.
+ */
+export const isRedactedMarker = (value: unknown): value is RedactedMarker =>
+  typeof value === "object" &&
+  value !== null &&
+  (value as { _tag?: unknown })._tag === "Redacted" &&
+  "value" in value;
+
+/**
+ * Serialize a binding value for an env var: `Redacted` values are packed as
+ * a {@link RedactedMarker}, everything else is plain `JSON.stringify`.
+ */
+export const packEnvValue = (value: unknown): string =>
+  Redacted.isRedacted(value)
+    ? JSON.stringify({
+        _tag: "Redacted",
+        value: Redacted.value(value),
+      } satisfies RedactedMarker)
+    : JSON.stringify(value);
+
+/**
+ * Like {@link packEnvValue}, but a `Redacted` input keeps its `Redacted`
+ * wrapper on the *outside* of the packed string, so deploy-time code can
+ * route secrets through a dedicated channel (Cloudflare `secret_text`,
+ * Secrets Store) instead of leaking them as plain env vars. The inner
+ * payload still carries the marker for the runtime `get` accessor.
+ */
+export const packEnvValueKeepRedacted = (
+  value: unknown,
+): string | Redacted.Redacted<string> =>
+  Redacted.isRedacted(value)
+    ? Redacted.make(packEnvValue(value))
+    : packEnvValue(value);
+
+/**
+ * Parse an env-var string produced by {@link packEnvValue} back into its
+ * value: rebuild `Redacted` from the marker, return other JSON values
+ * as-is, and fall back to the raw string for non-JSON input (e.g. an env
+ * var the user set directly). `undefined` passes through.
+ *
+ * Runtime `get` accessors MUST feed this from the raw environment
+ * (`process.env[key]` / the platform env object) — never through
+ * `Config.string`: the ambient runtime `ConfigProvider` reifies bound
+ * values (unwrapping the marker before it could be detected here), and
+ * during init the ambient provider is the interceptor installed in
+ * `Platform.ts`, whose runtime branch calls back into `ctx.get(key)` —
+ * resolving through `Config` would re-enter it for the same key and
+ * recurse forever.
+ */
+export const unpackEnvValue = <T>(raw: string | undefined): T | undefined => {
+  if (raw === undefined) {
+    return undefined;
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (isRedactedMarker(parsed)) {
+      return Redacted.make(parsed.value) as unknown as T;
+    }
+    return parsed as T;
+  } catch {
+    return raw as unknown as T; // assume it's just a string
+  }
+};
+
 /**
  * Context of the runtime environment.
  *

package/src/Server/Process.ts

@@ -1,4 +1,3 @@
-import * as Config from "effect/Config";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import { FileSystem } from "effect/FileSystem";
@@ -9,7 +8,11 @@ import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSp
 import type { HttpEffect } from "../Http.ts";
 import * as Http from "../Http.ts";
 import * as Output from "../Output.ts";
-import type { BaseRuntimeContext } from "../RuntimeContext.ts";
+import {
+  packEnvValue,
+  unpackEnvValue,
+  type BaseRuntimeContext,
+} from "../RuntimeContext.ts";
 
 export type ProcessServices =
   | ChildProcessSpawner
@@ -74,25 +77,15 @@ export const createHostRuntimeContext =
       set: (bindingId: string, output: Output.Output) =>
         Effect.sync(() => {
           const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
-          env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
+          // `packEnvValue` marker-packs Redacted values so they survive the
+          // Output → env round-trip.
+          env[key] = output.pipe(Output.map(packEnvValue));
           return key;
         }),
       get: <T>(key: string) =>
-        Config.string(key).pipe(
-          Effect.flatMap((value) =>
-            Effect.try({
-              try: () => JSON.parse(value) as T,
-              catch: (error) => error as Error,
-            }),
-          ),
-          Effect.catch((cause) =>
-            Effect.die(
-              new Error(`Failed to get environment variable: ${key}`, {
-                cause,
-              }),
-            ),
-          ),
-        ),
+        // Read straight from `process.env` — see `unpackEnvValue` for why
+        // this must never resolve through `Config.string`.
+        Effect.sync(() => unpackEnvValue<T>(process.env[key]) as T),
       run: (effect: Effect.Effect<void, never, any>) =>
         Effect.sync(() => {
           runners.push(effect);

package/src/Stack.ts

@@ -238,7 +238,7 @@ export const make =
                 `    providers: Cloudflare.providers(),\n` +
                 `    state: Cloudflare.state(), // <-- required\n` +
                 `  }, ...)\n` +
-                `See https://v2.alchemy.run/state-store for available state stores.`,
+                `See https://alchemy.run/state-store for available state stores.`,
             ),
           );
         }