alchemy 2.0.0-beta.37 → 2.0.0-beta.39

package/src/Namespace.ts

@@ -40,10 +40,10 @@ export const set = (namespace: string | NamespaceNode) =>
   );
 
 export const CurrentNamespace = Effect.serviceOption(Namespace)
-  .asEffect()
+
   .pipe(Effect.map(Option.getOrUndefined));
 
-export const CurrentChain = CurrentNamespace.asEffect().pipe(
+export const CurrentChain = CurrentNamespace.pipe(
   Effect.map(function findRoot(ns): string[] {
     if (ns?.Parent) {
       return [ns.Id, ...findRoot(ns.Parent)];
@@ -52,9 +52,9 @@ export const CurrentChain = CurrentNamespace.asEffect().pipe(
   }),
 );
 
-export const Parent = Namespace.asEffect().pipe(Effect.map((ns) => ns?.Parent));
+export const Parent = Namespace.pipe(Effect.map((ns) => ns?.Parent));
 
-export const Root = Namespace.asEffect().pipe(
+export const Root = Namespace.pipe(
   Effect.map(function findRoot(ns) {
     if (ns.Parent) {
       return findRoot(ns.Parent);

package/src/Neon/Branch.ts

@@ -1,16 +1,43 @@
+import {
+  createProjectBranch,
+  deleteProjectBranch,
+  getConnectionURI,
+  getProjectBranch,
+  listProjectBranchDatabases,
+  listProjectBranches,
+  type ListProjectBranchesOutput,
+  updateProjectBranch,
+} from "@distilled.cloud/neon";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import { isResolved } from "../Diff.ts";
 import { createPhysicalName } from "../PhysicalName.ts";
 import * as Provider from "../Provider.ts";
 import { Resource } from "../Resource.ts";
-import * as api from "./api.ts";
 import { applyMigrations, runSql } from "./Migrations.ts";
 import { parsePostgresOrigin, type PostgresOrigin } from "./PostgresOrigin.ts";
-import type { Project } from "./Project.ts";
+import { type Project, waitForOperations } from "./Project.ts";
 import type { Providers } from "./Providers.ts";
 import { listSqlFiles, readSqlFile } from "./SqlFile.ts";
 
+const findBranchByName = (projectId: string, name: string) =>
+  Effect.gen(function* () {
+    const matches: ListProjectBranchesOutput["branches"][number][] = [];
+    let cursor: string | undefined;
+    do {
+      const page = yield* listProjectBranches({
+        project_id: projectId,
+        search: name,
+        ...(cursor !== undefined ? { cursor } : {}),
+      });
+      for (const b of page.branches) {
+        if (b.name === name) matches.push(b);
+      }
+      cursor = page.pagination?.next;
+    } while (cursor);
+    return matches;
+  });
+
 const DEFAULT_MIGRATIONS_TABLE = "neon_migrations";
 
 export type BranchSource =
@@ -202,7 +229,7 @@ const resolveParentBranchId = (
       return source.branchId as unknown as string;
     }
     if ("name" in source && source.name) {
-      const matches = yield* api.findBranchByName(projectId, source.name);
+      const matches = yield* findBranchByName(projectId, source.name);
       if (matches.length === 0) {
         return yield* Effect.die(
           `Parent branch "${source.name}" not found in project ${projectId}`,
@@ -218,9 +245,7 @@ const resolveParentBranchId = (
     return undefined as string | undefined;
   });
 
-const buildEndpoints = (
-  endpoints: BranchEndpointConfig[] | undefined,
-): api.CreateBranchEndpoint[] => {
+const buildEndpoints = (endpoints: BranchEndpointConfig[] | undefined) => {
   const list = endpoints ?? [{ type: "read_write" as const }];
   return list.map((e) => ({
     type: e.type,
@@ -237,13 +262,15 @@ const fetchConnection = (
   roleName: string,
 ) =>
   Effect.gen(function* () {
-    const direct = yield* api.getConnectionUri(projectId, {
+    const direct = yield* getConnectionURI({
+      project_id: projectId,
       branch_id: branchId,
       database_name: databaseName,
       role_name: roleName,
       pooled: false,
     });
-    const pooled = yield* api.getConnectionUri(projectId, {
+    const pooled = yield* getConnectionURI({
+      project_id: projectId,
       branch_id: branchId,
       database_name: databaseName,
       role_name: roleName,
@@ -318,31 +345,30 @@ export const BranchProvider = () =>
         }),
         read: Effect.fn(function* ({ id, output, olds }) {
           if (output?.branchId) {
-            return yield* api
-              .getProjectBranch(output.projectId, output.branchId)
-              .pipe(
-                Effect.map(({ branch }) => ({
-                  ...output,
-                  branchName: branch.name,
-                  protected: branch.protected,
-                  default: branch.default,
-                  expiresAt: branch.expires_at,
-                })),
-                Effect.catchTag("BranchNotFound", () =>
-                  Effect.succeed(undefined),
-                ),
-              );
+            return yield* getProjectBranch({
+              project_id: output.projectId,
+              branch_id: output.branchId,
+            }).pipe(
+              Effect.map(({ branch }) => ({
+                ...output,
+                branchName: branch.name,
+                protected: branch.protected,
+                default: branch.default,
+                expiresAt: branch.expires_at,
+              })),
+              Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+            );
           }
           if (!olds?.project) return undefined;
           const projectId = resolveProjectId(olds.project as BranchSource);
           const name = yield* createBranchName(id, olds.name);
-          const matches = yield* api.findBranchByName(projectId, name);
+          const matches = yield* findBranchByName(projectId, name);
           const match = matches[0];
           if (!match) return undefined;
-          const dbs = yield* api.listProjectBranchDatabases(
-            projectId,
-            match.id,
-          );
+          const dbs = yield* listProjectBranchDatabases({
+            project_id: projectId,
+            branch_id: match.id,
+          });
           const db = dbs.databases[0];
           if (!db) return undefined;
           const conn = yield* fetchConnection(
@@ -383,31 +409,33 @@ export const BranchProvider = () =>
           // otherwise sync the mutable scalar fields on the existing
           // branch via updateProjectBranch.
           const branchInfo = output
-            ? yield* api
-                .updateProjectBranch(output.projectId, output.branchId, {
+            ? yield* updateProjectBranch({
+                project_id: output.projectId,
+                branch_id: output.branchId,
+                branch: {
                   name: newName !== output.branchName ? newName : undefined,
                   protected: news.protected,
                   expires_at: news.expiresAt ?? null,
-                })
-                .pipe(
-                  Effect.map((r) => ({
-                    branchId: output.branchId,
-                    branchName: r.branch.name,
-                    projectId: output.projectId,
-                    parentBranchId: output.parentBranchId,
-                    parentLsn: output.parentLsn,
-                    parentTimestamp: output.parentTimestamp,
-                    initSource: output.initSource,
-                    protected: r.branch.protected,
-                    default: output.default,
-                    expiresAt: r.branch.expires_at,
-                    databaseName: output.databaseName,
-                    roleName: output.roleName,
-                    connectionUri: output.connectionUri,
-                    pooledConnectionUri: output.pooledConnectionUri,
-                    origin: output.origin,
-                  })),
-                )
+                },
+              }).pipe(
+                Effect.map((r) => ({
+                  branchId: output.branchId,
+                  branchName: r.branch.name,
+                  projectId: output.projectId,
+                  parentBranchId: output.parentBranchId,
+                  parentLsn: output.parentLsn,
+                  parentTimestamp: output.parentTimestamp,
+                  initSource: output.initSource,
+                  protected: r.branch.protected,
+                  default: output.default,
+                  expiresAt: r.branch.expires_at,
+                  databaseName: output.databaseName,
+                  roleName: output.roleName,
+                  connectionUri: output.connectionUri,
+                  pooledConnectionUri: output.pooledConnectionUri,
+                  origin: output.origin,
+                })),
+              )
             : yield* Effect.gen(function* () {
                 const projectId = resolveProjectId(
                   news.project as BranchSource,
@@ -416,17 +444,20 @@ export const BranchProvider = () =>
                   news.parentBranch as ParentBranchSource | undefined,
                   projectId,
                 );
-                const created = yield* api.createProjectBranch(projectId, {
-                  name: newName,
-                  parent_id: parentBranchId,
-                  parent_lsn: news.parentLsn,
-                  parent_timestamp: news.parentTimestamp,
-                  init_source: news.initSource,
-                  protected: news.protected,
-                  expires_at: news.expiresAt,
+                const created = yield* createProjectBranch({
+                  project_id: projectId,
+                  branch: {
+                    name: newName,
+                    parent_id: parentBranchId,
+                    parent_lsn: news.parentLsn,
+                    parent_timestamp: news.parentTimestamp,
+                    init_source: news.initSource,
+                    protected: news.protected,
+                    expires_at: news.expiresAt,
+                  },
                   endpoints: buildEndpoints(news.endpoints),
                 });
-                yield* api.waitForOperations(created.operations);
+                yield* waitForOperations(created.operations);
 
                 const db = created.databases[0];
                 if (!db) {
@@ -492,7 +523,10 @@ export const BranchProvider = () =>
           };
         }),
         delete: Effect.fn(function* ({ output }) {
-          yield* api.deleteProjectBranch(output.projectId, output.branchId);
+          yield* deleteProjectBranch({
+            project_id: output.projectId,
+            branch_id: output.branchId,
+          }).pipe(Effect.catchTag("NotFound", () => Effect.void));
         }),
       };
     }),

package/src/Neon/Credentials.ts

@@ -1,5 +1,5 @@
-import { Credentials } from "@distilled.cloud/neon/Credentials";
 import { ConfigError } from "@distilled.cloud/core/errors";
+import { Credentials } from "@distilled.cloud/neon";
 import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -11,7 +11,7 @@ import {
   type NeonResolvedCredentials,
 } from "./AuthProvider.ts";
 
-export { Credentials } from "@distilled.cloud/neon/Credentials";
+export { Credentials } from "@distilled.cloud/neon";
 
 const DEFAULT_BASE_URL = "https://console.neon.tech/api/v2";
 

package/src/Neon/Project.ts

@@ -1,15 +1,148 @@
+import {
+  type CreateProjectOutput,
+  deleteProject,
+  getConnectionURI,
+  getProject,
+  getProjectOperation,
+  listProjectBranchDatabases,
+  listProjectBranches,
+  type ListProjectsOutput,
+  listProjects,
+  createProject as sdkCreateProject,
+  updateProject,
+} from "@distilled.cloud/neon";
+import * as Data from "effect/Data";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
+import * as Schedule from "effect/Schedule";
 import { isResolved } from "../Diff.ts";
 import { createPhysicalName } from "../PhysicalName.ts";
 import * as Provider from "../Provider.ts";
 import { Resource } from "../Resource.ts";
-import * as api from "./api.ts";
 import { applyMigrations, runSql } from "./Migrations.ts";
 import { parsePostgresOrigin, type PostgresOrigin } from "./PostgresOrigin.ts";
 import type { Providers } from "./Providers.ts";
 import { listSqlFiles, readSqlFile } from "./SqlFile.ts";
 
+type NeonOperationStatus =
+  | "scheduling"
+  | "running"
+  | "finished"
+  | "failed"
+  | "error"
+  | "cancelling"
+  | "cancelled"
+  | "skipped";
+
+export class OperationFailed extends Data.TaggedError("OperationFailed")<{
+  operationId: string;
+  action: string;
+  status: NeonOperationStatus;
+  error?: string;
+}> {}
+
+class OperationPending extends Data.TaggedError("OperationPending")<{
+  operationId: string;
+}> {}
+
+const isOperationComplete = (status: NeonOperationStatus): boolean =>
+  status === "finished" ||
+  status === "failed" ||
+  status === "error" ||
+  status === "cancelled" ||
+  status === "skipped";
+
+/**
+ * Wait for the given operations to reach a terminal state. Polls every
+ * 500ms with exponential backoff up to ~30s per operation.
+ */
+export const waitForOperations = (
+  operations: ReadonlyArray<{
+    readonly id: string;
+    readonly project_id: string;
+    readonly action: string;
+    readonly status: NeonOperationStatus;
+    readonly error?: string;
+  }>,
+) =>
+  Effect.gen(function* () {
+    for (const op of operations) {
+      if (isOperationComplete(op.status)) {
+        if (op.status === "failed" || op.status === "error") {
+          return yield* new OperationFailed({
+            operationId: op.id,
+            action: op.action,
+            status: op.status,
+            error: op.error,
+          });
+        }
+        continue;
+      }
+      yield* getProjectOperation({
+        project_id: op.project_id,
+        operation_id: op.id,
+      }).pipe(
+        Effect.flatMap(
+          ({
+            operation,
+          }): Effect.Effect<void, OperationFailed | OperationPending> => {
+            const status = operation.status as NeonOperationStatus;
+            if (status === "failed" || status === "error") {
+              return Effect.fail(
+                new OperationFailed({
+                  operationId: operation.id,
+                  action: operation.action,
+                  status,
+                  error: operation.error,
+                }),
+              );
+            }
+            if (!isOperationComplete(status)) {
+              return Effect.fail(new OperationPending({ operationId: op.id }));
+            }
+            return Effect.void;
+          },
+        ),
+        Effect.retry({
+          while: (e: unknown) => {
+            const tag = (e as { _tag?: string })._tag;
+            return (
+              tag === "OperationPending" ||
+              tag === "TooManyRequests" ||
+              tag === "ServiceUnavailable" ||
+              tag === "InternalServerError" ||
+              tag === "BadGateway" ||
+              tag === "GatewayTimeout"
+            );
+          },
+          schedule: Schedule.both(
+            Schedule.exponential(Duration.millis(500), 1.5),
+            Schedule.recurs(60),
+          ),
+        }),
+        Effect.catchTag("OperationPending", () => Effect.void),
+      );
+    }
+  });
+
+const findProjectByName = (name: string) =>
+  Effect.gen(function* () {
+    const matches: ListProjectsOutput["projects"][number][] = [];
+    let cursor: string | undefined;
+    do {
+      const page = yield* listProjects({
+        search: name,
+        ...(cursor !== undefined ? { cursor } : {}),
+      });
+      for (const p of page.projects) {
+        if (p.name === name) matches.push(p);
+      }
+      cursor = page.pagination?.cursor;
+    } while (cursor);
+    return matches;
+  });
+
 export type NeonRegion =
   | "aws-us-east-1"
   | "aws-us-east-2"
@@ -184,22 +317,12 @@ export type Project = Resource<
  */
 export const Project = Resource<Project>("Neon.Project");
 
-const getRoleName = (creation: api.CreateProjectOutput) =>
+const getRoleName = (creation: CreateProjectOutput) =>
   creation.roles.find((r) => !r.protected)?.name ?? creation.roles[0]?.name;
 
-const getDatabaseName = (creation: api.CreateProjectOutput) =>
+const getDatabaseName = (creation: CreateProjectOutput) =>
   creation.databases[0]?.name ?? "neondb";
 
-const buildConnectionUri = (
-  uri: string,
-  pooledHost: string,
-): { uri: string; pooled: string } => {
-  const url = new URL(uri);
-  const pooledUrl = new URL(uri);
-  pooledUrl.host = pooledHost;
-  return { uri: url.toString(), pooled: pooledUrl.toString() };
-};
-
 const resolveConnection = (
   projectId: string,
   branchId: string,
@@ -207,13 +330,15 @@ const resolveConnection = (
   roleName: string,
 ) =>
   Effect.gen(function* () {
-    const direct = yield* api.getConnectionUri(projectId, {
+    const direct = yield* getConnectionURI({
+      project_id: projectId,
       branch_id: branchId,
       database_name: databaseName,
       role_name: roleName,
       pooled: false,
     });
-    const pooled = yield* api.getConnectionUri(projectId, {
+    const pooled = yield* getConnectionURI({
+      project_id: projectId,
       branch_id: branchId,
       database_name: databaseName,
       role_name: roleName,
@@ -286,7 +411,7 @@ export const ProjectProvider = () =>
         }),
         read: Effect.fn(function* ({ id, output, olds }) {
           if (output?.projectId) {
-            return yield* api.getProject(output.projectId).pipe(
+            return yield* getProject({ project_id: output.projectId }).pipe(
               Effect.map(({ project }) => ({
                 ...output,
                 projectName: project.name,
@@ -294,25 +419,24 @@ export const ProjectProvider = () =>
                 enableLogicalReplication:
                   project.settings?.enable_logical_replication === true,
               })),
-              Effect.catchTag("ProjectNotFound", () =>
-                Effect.succeed(undefined),
-              ),
+              Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
             );
           }
           const name = yield* createProjectName(id, olds?.name);
-          const matches = yield* api.findProjectByName(name);
+          const matches = yield* findProjectByName(name);
           const match = matches[0];
           if (!match) return undefined;
-          const branches = yield* api.listProjectBranches(match.id, {
+          const branches = yield* listProjectBranches({
+            project_id: match.id,
             search: olds?.defaultBranchName ?? "main",
           });
           const defaultBranch =
             branches.branches.find((b) => b.default) ?? branches.branches[0];
           if (!defaultBranch) return undefined;
-          const databases = yield* api.listProjectBranchDatabases(
-            match.id,
-            defaultBranch.id,
-          );
+          const databases = yield* listProjectBranchDatabases({
+            project_id: match.id,
+            branch_id: defaultBranch.id,
+          });
           const db = databases.databases[0];
           if (!db) return undefined;
           const conn = yield* resolveConnection(
@@ -333,7 +457,7 @@ export const ProjectProvider = () =>
             connectionUri: conn.uri,
             pooledConnectionUri: conn.pooled,
             origin: parsePostgresOrigin(conn.uri),
-            historyRetentionSeconds: match.history_retention_seconds,
+            historyRetentionSeconds: match.history_retention_seconds ?? 86400,
             enableLogicalReplication:
               match.settings?.enable_logical_replication === true,
             migrationsDir: olds?.migrationsDir,
@@ -347,8 +471,9 @@ export const ProjectProvider = () =>
           // (and let `read` upstream decide adoption); otherwise update
           // the mutable scalar fields on the existing project.
           const projectInfo = output
-            ? yield* api
-                .updateProject(output.projectId, {
+            ? yield* updateProject({
+                project_id: output.projectId,
+                project: {
                   name: news.name,
                   history_retention_seconds: news.historyRetentionSeconds,
                   settings:
@@ -359,45 +484,47 @@ export const ProjectProvider = () =>
                             news.enableLogicalReplication ?? false,
                         }
                       : undefined,
-                })
-                .pipe(
-                  Effect.map((r) => ({
-                    projectId: output.projectId,
-                    projectName: r.project.name,
-                    region: output.region,
-                    pgVersion: output.pgVersion,
-                    defaultBranchId: output.defaultBranchId,
-                    defaultBranchName: output.defaultBranchName,
-                    databaseName: output.databaseName,
-                    roleName: output.roleName,
-                    connectionUri: output.connectionUri,
-                    pooledConnectionUri: output.pooledConnectionUri,
-                    origin: output.origin,
-                    historyRetentionSeconds:
-                      r.project.history_retention_seconds ??
-                      output.historyRetentionSeconds,
-                    enableLogicalReplication:
-                      r.project.settings?.enable_logical_replication === true,
-                  })),
-                )
+                },
+              }).pipe(
+                Effect.map((r) => ({
+                  projectId: output.projectId,
+                  projectName: r.project.name,
+                  region: output.region,
+                  pgVersion: output.pgVersion,
+                  defaultBranchId: output.defaultBranchId,
+                  defaultBranchName: output.defaultBranchName,
+                  databaseName: output.databaseName,
+                  roleName: output.roleName,
+                  connectionUri: output.connectionUri,
+                  pooledConnectionUri: output.pooledConnectionUri,
+                  origin: output.origin,
+                  historyRetentionSeconds:
+                    r.project.history_retention_seconds ??
+                    output.historyRetentionSeconds,
+                  enableLogicalReplication:
+                    r.project.settings?.enable_logical_replication === true,
+                })),
+              )
             : yield* Effect.gen(function* () {
                 const name = yield* createProjectName(id, news.name);
-                const created = yield* api.createProject({
-                  name,
-                  region_id: news.region,
-                  pg_version: news.pgVersion,
-                  default_branch: {
-                    name: news.defaultBranchName,
-                    role_name: news.roleName,
-                    database_name: news.databaseName,
+                const created = yield* sdkCreateProject({
+                  project: {
+                    name,
+                    region_id: news.region,
+                    pg_version: news.pgVersion,
+                    branch: {
+                      name: news.defaultBranchName,
+                      role_name: news.roleName,
+                      database_name: news.databaseName,
+                    },
+                    history_retention_seconds: news.historyRetentionSeconds,
+                    org_id: news.orgId,
+                    settings: news.enableLogicalReplication
+                      ? { enable_logical_replication: true }
+                      : undefined,
                   },
-                  history_retention_seconds: news.historyRetentionSeconds,
-                  org_id: news.orgId,
-                  settings: news.enableLogicalReplication
-                    ? { enable_logical_replication: true }
-                    : undefined,
                 });
-                yield* api.waitForOperations(created.operations);
+                yield* waitForOperations(created.operations);
 
                 const branchId = created.branch.id;
                 const databaseName = getDatabaseName(created);
@@ -458,7 +585,9 @@ export const ProjectProvider = () =>
           };
         }),
         delete: Effect.fn(function* ({ output }) {
-          yield* api.deleteProject(output.projectId);
+          yield* deleteProject({ project_id: output.projectId }).pipe(
+            Effect.catchTag("NotFound", () => Effect.void),
+          );
         }),
       };
     }),

package/src/Output.ts

@@ -1,5 +1,4 @@
 import * as Data from "effect/Data";
-import type { Yieldable } from "effect/Effect";
 import * as Effect from "effect/Effect";
 import { pipe } from "effect/Function";
 import type { Pipeable } from "effect/Pipeable";
@@ -48,7 +47,7 @@ export interface Output<A = any, Req = any> extends Pipeable {
   readonly req: Req;
   /** @internal phantom */
   [Symbol.iterator](): Iterator<
-    Yieldable<any, void, never, Req>,
+    Effect.Effect<void, never, Req>,
     Accessor<A>,
     void
   >;
@@ -100,12 +99,12 @@ export abstract class BaseExpr<A = any, Req = any> implements Output<A, Req> {
   }
 
   [Symbol.iterator](): Iterator<
-    Yieldable<any, void, never, Req>,
+    Effect.Effect<void, never, Req>,
     Accessor<A>,
     void
   > {
     // @ts-expect-error - TODO(sam): fix this (works at runtime, but maybe indicates a bad assumption)
-    return new SingleShotGen(this);
+    return new SingleShotGen(this.asEffect());
   }
 
   asEffect(): any {
@@ -113,7 +112,7 @@ export abstract class BaseExpr<A = any, Req = any> implements Output<A, Req> {
   }
 
   public bind(id: string): any {
-    return RuntimeContext.asEffect().pipe(
+    return RuntimeContext.pipe(
       Effect.flatMap((ctx) =>
         Effect.map(ctx.set(id, this), (key) => ctx.get<A>(key)),
       ),
@@ -264,7 +263,7 @@ export const isNamedExpr = <A = any, Req = any>(
 /**
  * Wraps another `Expr` and overrides its `toString()` / inspect output.
  *
- * `BaseExpr.asEffect()` derives the binding id from `this.toString()`, so
+ * `BaseExpr` derives the binding id from `this.toString()`, so
  * wrapping an expression in `NamedExpr` makes that derived id stable and
  * caller-controlled (e.g. an env var name like `"API_KEY"`).
  */
@@ -565,7 +564,10 @@ export const evaluate: <A, Req = never>(
             }),
           );
         }
-        return resource.attr;
+        // RefExpr targets persisted resources; tasks aren't cross-stack
+        // referenceable. Return the resource's output attrs, otherwise the
+        // task's output value, otherwise undefined.
+        return (resource as any).attr ?? (resource as any).output;
       } else if (isStackRefExpr(expr)) {
         const state = yield* State.State;
         const stack = expr.stack;