alchemy 2.0.0-beta.65 → 2.0.0-beta.66

package/src/Planetscale/OAuthClient.ts

@@ -46,7 +46,8 @@ export const OAUTH_CLIENT_ID = "pscale_app_aa12e3938baebb788aac443f66e422da";
 export const OAUTH_CLIENT_SECRET =
   "pscale_app_secret_yyZ3Q8oe99GP9_yA5wrA5er6RuN6Lz9dC66Bj1OJzpg";
 
-export const OAUTH_REDIRECT_URI = "http://localhost:9976/auth/callback";
+export const OAUTH_REDIRECT_URI = "https://alchemy.run/auth/callback";
+export const OAUTH_LOCAL_CALLBACK_URI = "http://localhost:9976/auth/callback";
 export const OAUTH_ENDPOINTS = {
   // PlanetScale's own .well-known OAuth discovery doc declares this as
   // the authorization_endpoint — NOT auth.planetscale.com/oauth/authorize
@@ -182,6 +183,46 @@ export const refresh = (
     client_secret: OAUTH_CLIENT_SECRET,
   });
 
+/**
+ * Exchange a code copied from the hosted relay page, or extract the code from
+ * either the hosted or loopback callback URL.
+ */
+export const exchangeCallbackInput = (
+  input: string,
+  authorization: Authorization,
+): Effect.Effect<OAuthCredentials, OAuthError> =>
+  Effect.gen(function* () {
+    const value = input.trim();
+    let code = value;
+    let state: string | null = null;
+
+    try {
+      const url = new URL(value);
+      code = url.searchParams.get("code") ?? "";
+      state = url.searchParams.get("state");
+    } catch {
+      const separator = value.lastIndexOf("#");
+      if (separator >= 0) {
+        code = value.slice(0, separator);
+        state = value.slice(separator + 1);
+      }
+    }
+
+    if (!code) {
+      return yield* new OAuthError({
+        error: "invalid_request",
+        errorDescription: "The authorization code is missing.",
+      });
+    }
+    if (state !== null && state !== authorization.state) {
+      return yield* new OAuthError({
+        error: "invalid_request",
+        errorDescription: "The authorization state does not match.",
+      });
+    }
+    return yield* exchange(code);
+  });
+
 /**
  * Start a local HTTP server to listen for the OAuth callback, exchange
  * the authorization code, and return the credentials.
@@ -192,7 +233,7 @@ export const callback = (
   authorization: Authorization,
 ): Effect.Effect<OAuthCredentials, OAuthError> =>
   Effect.tryPromise({
-    try: () => callbackPromise(authorization),
+    try: (signal) => callbackPromise(authorization, signal),
     catch: (err) => {
       if (err instanceof OAuthError) return err;
       return new OAuthError({
@@ -204,13 +245,25 @@ export const callback = (
 
 function callbackPromise(
   authorization: Authorization,
+  signal: AbortSignal,
 ): Promise<OAuthCredentials> {
-  const { pathname, port } = new URL(OAUTH_REDIRECT_URI);
+  const { pathname, port } = new URL(OAUTH_LOCAL_CALLBACK_URI);
 
   return new Promise<OAuthCredentials>((resolve, reject) => {
     const server = http.createServer(async (req, res) => {
       const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
 
+      if (url.pathname === "/auth/ping") {
+        res.writeHead(req.method === "OPTIONS" ? 204 : 200, {
+          "Access-Control-Allow-Origin": new URL(OAUTH_REDIRECT_URI).origin,
+          "Access-Control-Allow-Methods": "GET, OPTIONS",
+          "Access-Control-Allow-Private-Network": "true",
+          "Cache-Control": "no-store",
+        });
+        res.end();
+        return;
+      }
+
       if (url.pathname !== pathname) {
         res.statusCode = 404;
         res.end("Not Found");
@@ -289,9 +342,12 @@ function callbackPromise(
 
     function cleanup() {
       clearTimeout(timeout);
+      signal.removeEventListener("abort", cleanup);
       server.close();
     }
 
+    signal.addEventListener("abort", cleanup, { once: true });
+
     server.on("error", (err) => {
       cleanup();
       reject(

package/src/Planetscale/Postgres/PostgresDatabase.ts

@@ -2,7 +2,7 @@ import { Credentials } from "@distilled.cloud/planetscale/Credentials";
 import * as planetscale from "@distilled.cloud/planetscale/Operations";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
-import { isResolved } from "../../Diff.ts";
+import { havePropsChanged, isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
@@ -110,6 +110,25 @@ export const PostgresDatabaseProvider = () =>
     diff: Effect.fn(function* ({ news, olds, output }) {
       if (!isResolved(news)) return undefined;
 
+      // Database names are rename-mutable (reconcile folds `new_name`
+      // into the settings sync), so `name` cannot live in the
+      // provider-level stables. Almost no update is a rename though —
+      // for those, advertise `name` as stable on the update so
+      // downstream consumers (branches, roles) still resolve
+      // `database.name` at plan time instead of seeing `undefined` and
+      // falsely planning a replacement. The name only changes when the
+      // `name` prop itself changes: an explicit name renames iff it
+      // differs from the observed name, and an omitted name is
+      // engine-generated deterministically (stable across updates).
+      const nameIsStable =
+        output?.name !== undefined &&
+        (news.name !== undefined
+          ? news.name === output.name
+          : olds?.name === undefined);
+      const stables = nameIsStable
+        ? ["id", "organization", "region", "name"]
+        : undefined;
+
       if (
         news.region?.slug &&
         output?.region?.slug &&
@@ -130,23 +149,32 @@ export const PostgresDatabaseProvider = () =>
       if (news.migrationsDir) {
         const newHashes = yield* hashMigrations(news.migrationsDir);
         if (!recordsEqual(newHashes, output?.migrationsHashes ?? {})) {
-          return { action: "update" } as const;
+          return { action: "update", stables } as const;
         }
         if (
           (news.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE) !==
           (output?.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE)
         ) {
-          return { action: "update" } as const;
+          return { action: "update", stables } as const;
         }
       }
       if (news.importFiles?.length) {
         const newHashes = yield* hashImports(news.importFiles, yield* rootDir);
         if (!recordsEqual(newHashes, output?.importHashes ?? {})) {
-          return { action: "update" } as const;
+          return { action: "update", stables } as const;
         }
       }
 
-      // Otherwise allow the engine to apply the default update logic.
+      // Remaining prop changes (rename, settings, clusterSize, …) are
+      // in-place updates. Decide them here instead of falling back to
+      // the engine's default deep-compare so the conditional `name`
+      // stable above is attached — the default path uses the
+      // provider-level stables, which strip `name` from downstream plan
+      // resolution.
+      if (havePropsChanged(olds, news)) {
+        return { action: "update", stables } as const;
+      }
+
       return undefined;
     }),
 

package/src/Platform.ts

@@ -344,6 +344,21 @@ export const Platform = <
         constructor(id, props, impl, true);
     } else if (!impl) {
       const cls = makeClass(id);
+      // A resource declared without an inline impl is "external": there is
+      // no Effect-native entry to inject (an ordinary bundled worker, or an
+      // assets-only worker with no script at all).
+      const externalProps = () => {
+        const transformed = applyTransformProps(id, props);
+        return Effect.isEffect(transformed)
+          ? Effect.map(transformed, (p: any) => ({
+              ...p,
+              isExternal: true,
+            }))
+          : {
+              ...transformed,
+              isExternal: true,
+            };
+      };
       const evaluate = () =>
         (!isTag
           ? // this is a non-tagged resource yielded without providing an implementation
@@ -356,27 +371,24 @@ export const Platform = <
             //     return new Response("Hello, world!");
             //   }
             // }
-            resource(
-              id,
-              (() => {
-                const transformed = applyTransformProps(id, props);
-                return Effect.isEffect(transformed)
-                  ? Effect.map(transformed, (p: any) => ({
-                      ...p,
-                      isExternal: true,
-                    }))
-                  : {
-                      ...transformed,
-                      isExternal: true,
-                    };
-              })(),
-            )
+            resource(id, externalProps())
           : Effect.flatMap(
               // this is a tagged resource
               Effect.serviceOption(cls.Self),
               Option.match({
-                // we are likely running at runtime, so we create
-                onNone: () => resource(id, applyTransformProps(id, props)),
+                // we are likely running at runtime, so we create.
+                // A tagged class WITH props and no impl is the class form of
+                // the external resource above (e.g.
+                // `class Site extends Worker<Site>()("Site", { assets }) {}`)
+                // — same isExternal marking; without props, this is a bare
+                // tag whose props/impl arrive later via `.make`.
+                onNone: () =>
+                  resource(
+                    id,
+                    props === undefined
+                      ? applyTransformProps(id, props)
+                      : externalProps(),
+                  ),
                 onSome: Effect.succeed,
               }),
             )

package/src/Prisma/App.ts

@@ -0,0 +1,420 @@
+import * as Effect from "effect/Effect";
+import { Unowned } from "../AdoptPolicy.ts";
+import { deepEqual, isResolved } from "../Diff.ts";
+import { createPhysicalName } from "../PhysicalName.ts";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import {
+  PrismaClient,
+  isConflict,
+  isNotFound,
+  type PrismaManagementClient,
+} from "./Client.ts";
+import { destroyApp } from "./ComputeLifecycle.ts";
+import { ensureAppImmutableIdentity } from "./Internal/AppIdentity.ts";
+import type { Project } from "./Project.ts";
+import type { Providers } from "./Providers.ts";
+import {
+  concreteIdsChanged,
+  isInputObject,
+  isPrismaDevId,
+  resolveProjectId,
+  unresolvedProjectIdOf,
+} from "./Refs.ts";
+import type { App as ApiApp, PrismaRegionId } from "./Types.ts";
+
+export interface AppProps {
+  /**
+   * Project ID or `project.projectId` output that owns this App.
+   */
+  project: string | Project;
+  /**
+   * App display name. If omitted, Alchemy generates a stable physical name.
+   */
+  displayName?: string;
+  /**
+   * Region where the App is placed.
+   *
+   * @default The project's default region, falling back to "us-east-1"
+   */
+  regionId?: PrismaRegionId;
+  /**
+   * Branch ID to attach the App to. Mutually exclusive with branchGitName.
+   */
+  branchId?: string;
+  /**
+   * Branch git name to attach the App to. Mutually exclusive with branchId.
+   */
+  branchGitName?: string;
+}
+
+export interface App extends Resource<
+  "Prisma.App",
+  AppProps,
+  {
+    /**
+     * Prisma App ID.
+     */
+    appId: string;
+    /**
+     * App display name.
+     */
+    name: string;
+    /**
+     * Project ID that owns the App.
+     */
+    projectId: string;
+    /**
+     * Region ID where the App is placed.
+     */
+    regionId: string;
+    /**
+     * Branch ID attached to the App, or null when unassigned.
+     */
+    branchId: string | null;
+    /**
+     * Latest promoted deployment ID, when available.
+     */
+    latestDeploymentId: string | null;
+    /**
+     * Stable App endpoint domain.
+     */
+    appEndpointDomain: string;
+    /**
+     * ISO timestamp when the App was created.
+     */
+    createdAt: string;
+  },
+  never,
+  Providers
+> {}
+
+/**
+ * A Prisma App, the long-lived application configuration that owns deployments.
+ *
+ * @resource
+ * @section Creating an App
+ * @example App attached to a branch
+ * ```typescript
+ * const app = yield* Prisma.App("web", {
+ *   project: project.projectId,
+ *   branchGitName: "main",
+ * });
+ * ```
+ */
+export const App = Resource<App>("Prisma.App");
+
+const desiredBranchId = Effect.fn(function* (
+  client: PrismaManagementClient,
+  projectId: string,
+  props: Pick<AppProps, "branchId" | "branchGitName">,
+) {
+  if (props.branchId !== undefined && !isPrismaDevId(props.branchId)) {
+    return { resolved: true as const, id: props.branchId };
+  }
+  if (props.branchGitName !== undefined) {
+    const branches = yield* client.listBranches(projectId, {
+      gitName: props.branchGitName,
+      limit: 100,
+    });
+    if (branches.length > 1) {
+      return yield* Effect.fail(
+        new Error(
+          `Prisma returned multiple branches named '${props.branchGitName}' in project '${projectId}'; refusing an ambiguous App match.`,
+        ),
+      );
+    }
+    return branches[0]
+      ? { resolved: true as const, id: branches[0].id }
+      : { resolved: false as const };
+  }
+  const branches = yield* client.listBranches(projectId, { limit: 100 });
+  const defaults = branches.filter((branch) => branch.isDefault);
+  if (defaults.length > 1) {
+    return yield* Effect.fail(
+      new Error(
+        `Prisma returned multiple default branches for project '${projectId}'; refusing an ambiguous App match.`,
+      ),
+    );
+  }
+  const defaultBranch = defaults[0];
+  return defaultBranch
+    ? { resolved: true as const, id: defaultBranch.id }
+    : { resolved: false as const };
+});
+
+const createDisplayName = (id: string, displayName: string | undefined) =>
+  displayName === undefined
+    ? createPhysicalName({ id })
+    : Effect.succeed(displayName);
+
+const findApp = Effect.fn(function* (
+  client: PrismaManagementClient,
+  projectId: string,
+  displayName: string,
+  props: Pick<AppProps, "branchId" | "branchGitName">,
+) {
+  const candidates = (yield* client.listApps({
+    projectId,
+    limit: 100,
+  })).filter((app) => app.name === displayName);
+  if (candidates.length === 0) return undefined;
+  const branch = yield* desiredBranchId(client, projectId, props);
+  if (!branch.resolved) return undefined;
+  const matches = candidates.filter((app) => app.branchId === branch.id);
+  if (matches.length > 1) {
+    return yield* Effect.fail(
+      new Error(
+        `Prisma returned multiple Apps named '${displayName}' on branch '${branch.id}' in project '${projectId}'; refusing an ambiguous ownership match.`,
+      ),
+    );
+  }
+  return matches[0];
+});
+
+const attrsFrom = (app: ApiApp): App["Attributes"] => ({
+  appId: app.id,
+  name: app.name,
+  projectId: app.projectId,
+  regionId: app.region.id,
+  branchId: app.branchId,
+  latestDeploymentId: app.latestDeploymentId,
+  appEndpointDomain: app.appEndpointDomain,
+  createdAt: app.createdAt,
+});
+
+const branchNeedsSync = Effect.fn(function* (
+  client: PrismaManagementClient,
+  projectId: string,
+  app: ApiApp,
+  props: AppProps,
+) {
+  if (props.branchId !== undefined && !isPrismaDevId(props.branchId)) {
+    return app.branchId !== props.branchId;
+  }
+  if (props.branchGitName === undefined) {
+    const branch = yield* desiredBranchId(client, projectId, props);
+    return !branch.resolved || app.branchId !== branch.id;
+  }
+  const branch = yield* desiredBranchId(client, projectId, props);
+  return !branch.resolved || branch.id !== app.branchId;
+});
+
+const validateAppProps = (props: AppProps) =>
+  Effect.gen(function* () {
+    if (props.branchId !== undefined && props.branchGitName !== undefined) {
+      return yield* Effect.fail(
+        new Error("branchId and branchGitName are mutually exclusive."),
+      );
+    }
+    if (props.branchId === null || props.branchGitName === null) {
+      return yield* Effect.fail(
+        new Error(
+          "Prisma.App requires an attached branch because the Management API cannot create an unassigned App atomically. Omit both fields to use the project default branch, or provide branchId/branchGitName.",
+        ),
+      );
+    }
+  });
+
+export const AppProvider = () =>
+  Provider.effect(
+    App,
+    Effect.gen(function* () {
+      const client = yield* PrismaClient;
+      return {
+        stables: ["appId"],
+        list: () =>
+          client.listApps().pipe(Effect.map((apps) => apps.map(attrsFrom))),
+        diff: Effect.fn(function* ({ id, olds, news, output }) {
+          if (!isInputObject(news)) return undefined;
+          if (isPrismaDevId(output?.appId)) {
+            return { action: "update" } as const;
+          }
+          const oldProjectId =
+            output?.projectId ?? unresolvedProjectIdOf(olds.project);
+          const newProjectId = isResolved(news.project)
+            ? unresolvedProjectIdOf(news.project)
+            : undefined;
+          if (concreteIdsChanged(oldProjectId, newProjectId)) {
+            return { action: "replace" } as const;
+          }
+          if (isResolved(news.regionId) && news.regionId !== undefined) {
+            const currentRegionId = output?.regionId ?? olds.regionId;
+            if (
+              currentRegionId !== undefined &&
+              news.regionId !== currentRegionId
+            ) {
+              return yield* Effect.fail(
+                new Error(
+                  `Prisma App region is immutable and the Management API cannot atomically move an App without deleting its serving endpoint first. Create a second App with a different display name in the target region, cut traffic over, then remove this App.`,
+                ),
+              );
+            }
+          }
+          const updateProps = {
+            displayName: news.displayName,
+            branchId: news.branchId,
+            branchGitName: news.branchGitName,
+          };
+          if (!isResolved(updateProps)) return undefined;
+          const resolvedUpdateProps = {
+            ...(updateProps as Pick<
+              AppProps,
+              "displayName" | "branchId" | "branchGitName"
+            >),
+            displayName: yield* createDisplayName(
+              id,
+              (updateProps as Pick<AppProps, "displayName">).displayName,
+            ),
+          };
+          if (!output) {
+            return deepEqual(resolvedUpdateProps, {
+              displayName: yield* createDisplayName(id, olds.displayName),
+              branchId: olds.branchId,
+              branchGitName: olds.branchGitName,
+            })
+              ? undefined
+              : ({ action: "update" } as const);
+          }
+          if (output.name !== resolvedUpdateProps.displayName) {
+            return { action: "update" } as const;
+          }
+          const branch = yield* desiredBranchId(
+            client,
+            newProjectId ?? output.projectId,
+            resolvedUpdateProps,
+          );
+          return !branch.resolved || output.branchId !== branch.id
+            ? ({ action: "update" } as const)
+            : undefined;
+        }),
+        read: Effect.fn(function* ({ id, output, olds }) {
+          const appId = isPrismaDevId(output?.appId)
+            ? undefined
+            : output?.appId;
+          const app = appId
+            ? yield* client
+                .getApp(appId)
+                .pipe(
+                  Effect.catchIf(isNotFound, () => Effect.succeed(undefined)),
+                )
+            : yield* Effect.gen(function* () {
+                const projectId = unresolvedProjectIdOf(olds.project);
+                return projectId
+                  ? yield* findApp(
+                      client,
+                      projectId,
+                      yield* createDisplayName(id, olds.displayName),
+                      olds,
+                    )
+                  : undefined;
+              });
+          if (!app) return undefined;
+          const attrs = attrsFrom(app);
+          return appId ? attrs : Unowned(attrs);
+        }),
+        reconcile: Effect.fn(function* ({ id, news, output }) {
+          yield* validateAppProps(news);
+          const projectId = yield* resolveProjectId(news.project);
+          const displayName = yield* createDisplayName(id, news.displayName);
+          const branch = yield* desiredBranchId(client, projectId, news);
+          if (!branch.resolved) {
+            return yield* Effect.fail(
+              new Error(
+                news.branchGitName === undefined
+                  ? `Prisma project '${projectId}' has no default branch to attach App '${displayName}'. Create or promote a default branch, or specify branchId/branchGitName.`
+                  : `Prisma project '${projectId}' has no branch named '${news.branchGitName}' to attach App '${displayName}'.`,
+              ),
+            );
+          }
+          const appId = isPrismaDevId(output?.appId)
+            ? undefined
+            : output?.appId;
+          let app = appId
+            ? yield* client
+                .getApp(appId)
+                .pipe(
+                  Effect.catchIf(isNotFound, () => Effect.succeed(undefined)),
+                )
+            : undefined;
+          if (!app) {
+            const result = yield* client
+              .createApp({
+                projectId,
+                displayName,
+                regionId: news.regionId,
+                branchId: branch.id,
+                branchGitName: undefined,
+              })
+              .pipe(
+                Effect.map((app: ApiApp) => ({
+                  app,
+                  created: true,
+                })),
+                Effect.catchIf(isConflict, (conflict) =>
+                  findApp(client, projectId, displayName, news).pipe(
+                    Effect.flatMap((app) =>
+                      app &&
+                      output?.appId !== undefined &&
+                      app.id === output.appId
+                        ? Effect.succeed({ app, created: false })
+                        : Effect.fail(
+                            new Error(
+                              `Prisma app '${displayName}' already exists on the requested branch but is not owned by this App resource. Import it with explicit adoption or choose a different display name.`,
+                              { cause: conflict },
+                            ),
+                          ),
+                    ),
+                  ),
+                ),
+              );
+            app = result.app;
+          }
+          yield* ensureAppImmutableIdentity(
+            app,
+            projectId,
+            news.regionId ?? output?.regionId ?? app.region.id,
+          );
+          const needsBranchSync = yield* branchNeedsSync(
+            client,
+            projectId,
+            app,
+            news,
+          );
+          if (app.name !== displayName || needsBranchSync) {
+            app = yield* client.updateApp(app.id, {
+              displayName,
+              branchId: branch.id,
+              branchGitName: undefined,
+            });
+          }
+          if (app.name !== displayName || app.branchId !== branch.id) {
+            return yield* Effect.fail(
+              new Error(
+                `Prisma App '${app.id}' did not converge to display name '${displayName}' and branch '${branch.id ?? "null"}'. Refusing to persist mismatched App state.`,
+              ),
+            );
+          }
+          return attrsFrom(app);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          if (isPrismaDevId(output.appId)) return;
+          const app = yield* client
+            .getApp(output.appId)
+            .pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)));
+          if (!app) return;
+          if (
+            app.projectId !== output.projectId ||
+            app.region.id !== output.regionId
+          ) {
+            return yield* Effect.fail(
+              new Error(
+                `Prisma App '${app.id}' no longer matches its persisted immutable project and region identity. Refusing to delete a mismatched App.`,
+              ),
+            );
+          }
+          yield* destroyApp(client, output.appId);
+        }),
+      };
+    }),
+  );