alchemy 2.0.0-beta.81 → 2.0.0-beta.82

package/src/Local/Sidecar.ts

@@ -21,7 +21,8 @@ RpcServer.launch((group) =>
   Effect.promise(() => import(group)).pipe(
     Effect.flatMap((module: { default?: unknown }) =>
       Layer.isLayer(module.default)
-        ? Effect.succeed(module.default as RpcServer.ProviderLayer)
+        ? // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- dynamically imported provider group module
+          Effect.succeed(module.default as RpcServer.ProviderLayer)
         : Effect.fail(
             new Error(`Provider group module ${group} must default-export its provider Layer`),
           ),

package/src/Neon/Branch.ts

@@ -211,6 +211,21 @@ export type Branch = Resource<
  * });
  * ```
  *
+ * ### Configuring the default branch
+ * Adopt the project's default branch to manage its compute. Destroying the
+ * stack leaves the branch to be removed with its project, since Neon does
+ * not delete a project's root or default branch on its own.
+ *
+ * **Example:** Adopt the default branch
+ * ```typescript
+ * const project = yield* Neon.Project("my-project");
+ * const main = yield* Neon.Branch("main", {
+ *   project,
+ *   name: "main",
+ *   endpoints: [{ type: "read_write", autoscalingLimitMaxCu: 1 }],
+ * }).pipe(adopt(true));
+ * ```
+ *
  * ### Migrations on a branch
  * **Example:** Apply migrations on the branch only
  * ```typescript
@@ -251,14 +266,29 @@ export const BranchProvider = () =>
       if (oldProjectId !== undefined && oldProjectId !== newProjectId) {
         return { action: "replace" } as const;
       }
-      if (!isResolved(news)) return undefined;
+      const pending = news as Partial<BranchProps>;
       const replacement = {
         action: "replace",
         deleteFirst:
-          news.name !== undefined &&
-          news.name === (output?.branchName ?? olds.name) &&
+          pending.name !== undefined &&
+          pending.name === (output?.branchName ?? olds.name) &&
           oldProjectId === newProjectId,
       } as const;
+      // A fork point only known at apply time cannot be proven unchanged, and
+      // `reconcile` never re-forks an existing branch, so an update would
+      // silently keep the old data.
+      if (
+        output &&
+        !isResolved([
+          pending.parentBranch,
+          pending.parentLsn,
+          pending.parentTimestamp,
+          pending.initSource,
+        ])
+      ) {
+        return replacement;
+      }
+      if (!isResolved(news)) return undefined;
       if (
         olds.parentLsn !== news.parentLsn ||
         olds.parentTimestamp !== news.parentTimestamp ||
@@ -400,7 +430,7 @@ export const BranchProvider = () =>
             findBranchByName(projectId, newName).pipe(
               Effect.flatMap(
                 Effect.fn(function* (matches) {
-                  if (matches.length !== 1) return yield* Effect.fail(error);
+                  if (matches.length !== 1) return yield* error;
                   const branch = yield* authorize(matches[0]!);
                   return { branch, operations: [] };
                 }),
@@ -476,11 +506,22 @@ export const BranchProvider = () =>
       };
     }),
     delete: Effect.fn(function* ({ output }) {
-      yield* Effect.gen(function* () {
+      const retained = yield* Effect.gen(function* () {
         const { branch } = yield* getProjectBranch({
           project_id: output.projectId,
           branch_id: output.branchId,
         });
+        // Neon refuses to delete a project's root or default branch (an
+        // adopted `main`, say); it is removed together with the project.
+        // Schema-only branches are parentless too, but they are deletable.
+        if (
+          branch.default ||
+          (branch.parent_id === undefined &&
+            branch.init_source !== "parent-schema" &&
+            branch.init_source !== "schema-only")
+        ) {
+          return true;
+        }
         if (branch.protected) {
           const updated = yield* updateProjectBranch({
             project_id: output.projectId,
@@ -494,7 +535,9 @@ export const BranchProvider = () =>
           branch_id: output.branchId,
         });
         yield* waitForOperations(deleted.operations);
-      }).pipe(Effect.catchTag("NotFound", () => Effect.void));
+        return false;
+      }).pipe(Effect.catchTag("NotFound", () => Effect.succeed(false)));
+      if (retained) return;
       yield* getProjectBranch({
         project_id: output.projectId,
         branch_id: output.branchId,

package/src/Neon/Connect.ts

@@ -8,7 +8,7 @@ import type { ResourceLike } from "../Resource.ts";
 import { CurrentRuntimeContext, type RuntimeContext } from "../RuntimeContext.ts";
 import type { Branch } from "./Branch.ts";
 import { resolveBranchScope } from "./BranchScope.ts";
-import type { Function } from "./Function.ts";
+import { branchScopeOf, type Function } from "./Function.ts";
 import type { Project } from "./Project.ts";
 
 /** Postgres connection accessors. Resolving these Effects does not acquire a socket or pool. */
@@ -96,7 +96,7 @@ const stringOutput = (value: string | Output.Output<string>) =>
 
 const injectedScope = (host: ResourceLike | undefined, database: Branch | Project) => {
   if (!isFunction(host)) return Output.literal(false);
-  const scope = host.Props;
+  const scope = branchScopeOf(host.Props);
   const targetBranch =
     database.Type === "Neon.Branch" ? database.branchId : database.defaultBranchId;
   if (scope.branch) {

package/src/Neon/Credentials.ts

@@ -32,11 +32,10 @@ export const fromAuthProvider = () =>
               apiKey: creds.apiKey,
               apiBaseUrl: DEFAULT_BASE_URL,
             })),
-            Effect.mapError(
-              (e) =>
-                new ConfigError({
-                  message: `Failed to resolve Neon credentials from ${profileName === undefined ? "the CI environment" : `profile '${profileName}'`}: ${(e as { message?: string }).message ?? String(e)}`,
-                }),
+            Effect.mapError((e) =>
+              ConfigError.make({
+                message: `Failed to resolve Neon credentials from ${profileName === undefined ? "the CI environment" : `profile '${profileName}'`}: ${(e as { message?: string }).message ?? String(e)}`,
+              }),
             ),
           ),
         ),

package/src/Neon/Function.ts

@@ -1,5 +1,7 @@
+import * as Effect from "effect/Effect";
 import type * as Redacted from "effect/Redacted";
 import type { BundleConfig } from "../Bundle/Bundle.ts";
+import type { Input } from "../Input.ts";
 import { Platform, type Main, type PlatformProps } from "../Platform.ts";
 import type { Resource } from "../Resource.ts";
 import type { BranchScope } from "./BranchScope.ts";
@@ -23,6 +25,32 @@ export type FunctionArtifact =
     }
   | { /** Path to an existing ZIP archive. */ zip: string; directory?: never };
 
+/**
+ * {@link BranchScope} where the branch or project may also be an Effect that
+ * produces it, so `{ branch: Main }` and `{ branch: yield* Main }` both
+ * type-check.
+ */
+export type FunctionBranchScope =
+  | {
+      /** Branch resource or explicit branch identity, or an Effect producing one. */
+      branch:
+        | { projectId: string; branchId: string }
+        | Effect.Effect<Input<{ projectId: string; branchId: string }>, never, any>;
+      project?: never;
+    }
+  | {
+      /** Project whose default branch is selected at reconciliation time, or an Effect producing one. */
+      project: { projectId: string } | Effect.Effect<Input<{ projectId: string }>, never, any>;
+      branch?: never;
+    };
+
+/**
+ * The scope as providers see it. `transformProps` yields an Effect-valued
+ * `branch` or `project` before any lifecycle operation runs, so only the
+ * resolved shape reaches the provider.
+ */
+export const branchScopeOf = <P extends FunctionBranchScope>(props: P) => props as P & BranchScope;
+
 export interface FunctionCommonProps extends PlatformProps {
   /** Immutable lowercase alphanumeric identifier, at most 20 characters. Generated when omitted. */
   slug?: string;
@@ -36,7 +64,7 @@ export interface FunctionCommonProps extends PlatformProps {
   dev?: { command?: string; port?: number };
 }
 
-export type FunctionProps = BranchScope &
+export type FunctionProps = FunctionBranchScope &
   FunctionCommonProps &
   (
     | {
@@ -130,4 +158,19 @@ export const Function: Platform<
   FunctionRuntimeContext
 > = Platform<Function>("Neon.Function", {
   createRuntimeContext: makeFunctionRuntimeContext,
+  // `{ branch: Main }` at module scope is an Effect. Yield it here so the
+  // branch (or project) is registered and resolved at reconcile (same as
+  // `yield* Main` inside Effect.gen).
+  transformProps: (_id, props) =>
+    Effect.gen(function* () {
+      if (globalThis.__ALCHEMY_RUNTIME__) return props;
+      const yieldRef = (value: unknown) =>
+        // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- props refs are declaration Effects resolved by the engine
+        Effect.isEffect(value) ? (value as Effect.Effect<unknown>) : Effect.succeed(value);
+      return {
+        ...props,
+        ...(props.branch !== undefined ? { branch: yield* yieldRef(props.branch) } : {}),
+        ...(props.project !== undefined ? { project: yield* yieldRef(props.project) } : {}),
+      };
+    }),
 });

package/src/Neon/FunctionBridge.ts

@@ -21,13 +21,11 @@ import type { FunctionRuntimeContext } from "./FunctionRuntimeContext.ts";
 import { FunctionUpgradeSockets } from "./FunctionUpgrade.ts";
 
 const closeRequestScope = (scope: Scope.Closeable) => {
-  nativeWaitUntil(
-    Effect.runPromise(
-      Scope.close(scope, Exit.void).pipe(
-        Effect.timeout("15 seconds"),
-        Effect.ignoreCause({ log: "Error" }),
-      ),
-    ),
+  Scope.close(scope, Exit.void).pipe(
+    Effect.timeout("15 seconds"),
+    Effect.ignoreCause({ log: "Error" }),
+    Effect.runPromise,
+    nativeWaitUntil,
   );
 };
 

package/src/Neon/FunctionProvider.ts

@@ -11,7 +11,7 @@ import { Stack } from "../Stack.ts";
 import { Stage } from "../Stage.ts";
 import { sha256Object } from "../Util/sha256.ts";
 import { resolveBranchScope, type ResolvedBranchScope } from "./BranchScope.ts";
-import { Function, type FunctionAttributes } from "./Function.ts";
+import { branchScopeOf, Function, type FunctionAttributes } from "./Function.ts";
 import { buildFunctionArtifact } from "./FunctionArtifact.ts";
 import { functionEnvironment, functionSlug } from "./FunctionConfig.ts";
 import { LocalFunctionProvider } from "./LocalFunctionProvider.ts";
@@ -182,7 +182,7 @@ export const FunctionProviderLive = () =>
     }),
     diff: Effect.fn(function* ({ id, news, output }) {
       if (!isResolved(news)) return;
-      const scope = yield* resolveBranchScope(news);
+      const scope = yield* resolveBranchScope(branchScopeOf(news));
       if (
         output &&
         (scope.projectId !== output.projectId ||
@@ -197,11 +197,11 @@ export const FunctionProviderLive = () =>
     read: Effect.fn(function* ({ id, olds, output }) {
       if (
         !output &&
-        !(olds?.branch?.projectId && olds.branch.branchId) &&
-        !olds?.project?.projectId
+        !(olds && branchScopeOf(olds).branch?.projectId && branchScopeOf(olds).branch?.branchId) &&
+        !(olds && branchScopeOf(olds).project?.projectId)
       )
         return undefined;
-      const scope = output ?? (yield* resolveBranchScope(olds!));
+      const scope = output ?? (yield* resolveBranchScope(branchScopeOf(olds!)));
       const slug = output?.slug ?? (yield* functionSlug(id, olds?.slug));
       const found = yield* observeFunction(scope, slug);
       if (!found) return undefined;
@@ -216,7 +216,7 @@ export const FunctionProviderLive = () =>
       return output ? attrs : Unowned(attrs);
     }),
     reconcile: Effect.fn(function* ({ id, news, output, bindings }) {
-      const scope = yield* resolveBranchScope(news);
+      const scope = yield* resolveBranchScope(branchScopeOf(news));
       const slug = news.slug ?? output?.slug ?? (yield* functionSlug(id));
       yield* functionSlug(id, slug);
       const observed = yield* observeFunction(scope, slug);

package/src/Neon/FunctionRuntimeContext.ts

@@ -38,6 +38,7 @@ export const makeFunctionRuntimeContext = (id: string): FunctionRuntimeContext =
       }),
     serve: (next) =>
       Effect.gen(function* () {
+        // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- the dispatcher provides the request service at call time
         handler = next as HttpEffect;
         context = Context.omit(Layer.CurrentMemoMap)(yield* Effect.context<never>());
       }),

package/src/Neon/LanguageModel.ts

@@ -108,7 +108,7 @@ export const makeLanguageModel = ({
         const response = yield* http.execute(request).pipe(
           Effect.mapError(() =>
             error(
-              new AiError.NetworkError({
+              AiError.NetworkError.make({
                 reason: "TransportError",
                 request: {
                   method: "POST",
@@ -141,7 +141,7 @@ export const makeLanguageModel = ({
           const message = choice.message;
           if (message.refusal)
             return yield* error(
-              new AiError.ContentPolicyError({
+              AiError.ContentPolicyError.make({
                 description: "Model refused the request",
               }),
             );
@@ -184,9 +184,9 @@ const error = (reason: AiError.AiError["reason"]) =>
     reason,
   });
 const invalidOutput = (description: string) =>
-  error(new AiError.InvalidOutputError({ description }));
+  error(AiError.InvalidOutputError.make({ description }));
 const invalidRequest = (description: string) =>
-  error(new AiError.InvalidRequestError({ description }));
+  error(AiError.InvalidRequestError.make({ description }));
 const decode = <S extends Schema.ConstraintDecoder<unknown>>(schema: S, value: unknown) =>
   Schema.decodeUnknownEffect(schema)(value).pipe(
     Effect.mapError(() => invalidOutput("Invalid Chat Completions response shape")),
@@ -200,11 +200,13 @@ const TokenCount = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
 const Usage = Schema.Struct({
   prompt_tokens: Schema.optional(TokenCount),
   completion_tokens: Schema.optional(TokenCount),
-  prompt_tokens_details: Schema.optional(
-    Schema.NullOr(Schema.Struct({ cached_tokens: Schema.optional(TokenCount) })),
+  prompt_tokens_details: Schema.Struct({ cached_tokens: Schema.optional(TokenCount) }).pipe(
+    Schema.NullOr,
+    Schema.optional,
   ),
-  completion_tokens_details: Schema.optional(
-    Schema.NullOr(Schema.Struct({ reasoning_tokens: Schema.optional(TokenCount) })),
+  completion_tokens_details: Schema.Struct({ reasoning_tokens: Schema.optional(TokenCount) }).pipe(
+    Schema.NullOr,
+    Schema.optional,
   ),
 });
 const Content = Schema.NullOr(
@@ -219,53 +221,45 @@ const Completion = Schema.Struct({
       finish_reason: Schema.NullOr(Schema.String),
       message: Schema.Struct({
         content: Schema.optional(Content),
-        reasoning_content: Schema.optional(Schema.NullOr(Schema.String)),
-        refusal: Schema.optional(Schema.NullOr(Schema.String)),
-        tool_calls: Schema.optional(
-          Schema.Array(
-            Schema.Struct({
-              id: Schema.String,
-              type: Schema.Literal("function"),
-              function: Schema.Struct({
-                name: Schema.String,
-                arguments: Schema.String,
-              }),
-            }),
-          ),
-        ),
+        reasoning_content: Schema.String.pipe(Schema.NullOr, Schema.optional),
+        refusal: Schema.String.pipe(Schema.NullOr, Schema.optional),
+        tool_calls: Schema.Struct({
+          id: Schema.String,
+          type: Schema.Literal("function"),
+          function: Schema.Struct({
+            name: Schema.String,
+            arguments: Schema.String,
+          }),
+        }).pipe(Schema.Array, Schema.optional),
       }),
     }),
   ),
-  usage: Schema.optional(Schema.NullOr(Usage)),
+  usage: Usage.pipe(Schema.NullOr, Schema.optional),
 });
 const Chunk = Schema.Struct({
   choices: Schema.Array(
     Schema.Struct({
       index: TokenCount,
-      finish_reason: Schema.optional(Schema.NullOr(Schema.String)),
+      finish_reason: Schema.String.pipe(Schema.NullOr, Schema.optional),
       delta: Schema.Struct({
-        content: Schema.optional(Schema.NullOr(Schema.String)),
-        reasoning_content: Schema.optional(Schema.NullOr(Schema.String)),
-        refusal: Schema.optional(Schema.NullOr(Schema.String)),
-        tool_calls: Schema.optional(
-          Schema.Array(
+        content: Schema.String.pipe(Schema.NullOr, Schema.optional),
+        reasoning_content: Schema.String.pipe(Schema.NullOr, Schema.optional),
+        refusal: Schema.String.pipe(Schema.NullOr, Schema.optional),
+        tool_calls: Schema.Struct({
+          index: TokenCount,
+          id: Schema.optional(Schema.String),
+          type: Schema.optional(Schema.Literal("function")),
+          function: Schema.optional(
             Schema.Struct({
-              index: TokenCount,
-              id: Schema.optional(Schema.String),
-              type: Schema.optional(Schema.Literal("function")),
-              function: Schema.optional(
-                Schema.Struct({
-                  name: Schema.optional(Schema.String),
-                  arguments: Schema.optional(Schema.String),
-                }),
-              ),
+              name: Schema.optional(Schema.String),
+              arguments: Schema.optional(Schema.String),
             }),
           ),
-        ),
+        }).pipe(Schema.Array, Schema.optional),
       }),
     }),
   ),
-  usage: Schema.optional(Schema.NullOr(Usage)),
+  usage: Usage.pipe(Schema.NullOr, Schema.optional),
 });
 const ErrorBody = Schema.Struct({
   error: Schema.Struct({
@@ -281,14 +275,14 @@ const httpError = (
     // Never retain upstream bodies, headers or request objects in public errors.
     const body = yield* response.json.pipe(
       Effect.flatMap(Schema.decodeUnknownEffect(ErrorBody)),
-      Effect.catch(() => Effect.succeed(undefined)),
+      Effect.orElseSucceed(() => undefined),
     );
     const status = response.status;
     if (status === 403 && body?.error.message === "ai gateway not enabled for account")
-      return yield* error(new AiError.QuotaExhaustedError({}));
+      return yield* error(AiError.QuotaExhaustedError.make({}));
     if (status === 401 || status === 403)
       return yield* error(
-        new AiError.AuthenticationError({
+        AiError.AuthenticationError.make({
           kind: status === 401 ? "InvalidKey" : "InsufficientPermissions",
         }),
       );
@@ -297,11 +291,11 @@ const httpError = (
       body?.error.code === "REQUEST_LIMIT_EXCEEDED" ||
       body?.error.code === "insufficient_quota"
     )
-      return yield* error(new AiError.QuotaExhaustedError({}));
+      return yield* error(AiError.QuotaExhaustedError.make({}));
     if (status === 429) {
       const seconds = Number(response.headers["retry-after"]);
       return yield* error(
-        new AiError.RateLimitError({
+        AiError.RateLimitError.make({
           ...(Number.isFinite(seconds) && seconds >= 0
             ? { retryAfter: Duration.seconds(seconds) }
             : {}),
@@ -310,7 +304,7 @@ const httpError = (
     }
     if (status >= 500)
       return yield* error(
-        new AiError.InternalProviderError({
+        AiError.InternalProviderError.make({
           description: `Neon AI Gateway returned HTTP ${status}`,
         }),
       );
@@ -341,7 +335,7 @@ const usage = (value: typeof Usage.Type | null | undefined) => {
   const cached = value?.prompt_tokens_details?.cached_tokens;
   const output = value?.completion_tokens;
   const reasoning = value?.completion_tokens_details?.reasoning_tokens;
-  return new Response.Usage({
+  return Response.Usage.make({
     inputTokens: {
       total: input,
       uncached: input === undefined ? undefined : Math.max(0, input - (cached ?? 0)),
@@ -449,7 +443,7 @@ const requestBody = (
             try: () => toCodecOpenAI(responseFormat.schema).jsonSchema,
             catch: () =>
               error(
-                new AiError.UnsupportedSchemaError({
+                AiError.UnsupportedSchemaError.make({
                   description: "Schema is not supported by OpenAI structured output",
                 }),
               ),
@@ -528,7 +522,7 @@ const completionStream = (
             if (!event.data) return parts;
             if (event.event === "error")
               return yield* error(
-                new AiError.InternalProviderError({
+                AiError.InternalProviderError.make({
                   description: "Neon AI Gateway stream reported an error",
                 }),
               );
@@ -542,7 +536,7 @@ const completionStream = (
               const delta = choice.delta;
               if (delta.refusal)
                 return yield* error(
-                  new AiError.ContentPolicyError({
+                  AiError.ContentPolicyError.make({
                     description: "Model refused the request",
                   }),
                 );

package/src/Neon/LocalFunctionProvider.ts

@@ -10,7 +10,7 @@ import { Stack } from "../Stack.ts";
 import { Stage } from "../Stage.ts";
 import { moduleExtension } from "../Util/Node.ts";
 import { sha256 } from "../Util/sha256.ts";
-import { Function } from "./Function.ts";
+import { branchScopeOf, Function } from "./Function.ts";
 import { buildFunctionArtifact, validateFunctionZip } from "./FunctionArtifact.ts";
 import { FunctionConfigurationError, functionEnvironment, functionSlug } from "./FunctionConfig.ts";
 
@@ -150,8 +150,9 @@ export const LocalFunctionProvider = () =>
               Effect.forkScoped,
             );
           }
-          const projectId = news.branch?.projectId ?? news.project?.projectId ?? "local";
-          const branchId = news.branch?.branchId ?? "local";
+          const scope = branchScopeOf(news);
+          const projectId = scope.branch?.projectId ?? scope.project?.projectId ?? "local";
+          const branchId = scope.branch?.branchId ?? "local";
           return {
             projectId,
             branchId,

package/src/Neon/Migrations.ts

@@ -54,7 +54,7 @@ export const withPgClient = <A, E, R>(
       try: async () => {
         const { Client } = await importPg();
         const client = new Client({
-          connectionString: stripSslQueryParams(Redacted.value(connectionUri)),
+          connectionString: connectionUri.pipe(Redacted.value, stripSslQueryParams),
           ssl: { rejectUnauthorized: false },
         });
         await client.connect();

package/src/Neon/Project.ts

@@ -372,7 +372,7 @@ export const ProjectProvider = () =>
             findProjectByName(name, news.orgId).pipe(
               Effect.flatMap(
                 Effect.fn(function* (matches) {
-                  if (matches.length !== 1) return yield* Effect.fail(error);
+                  if (matches.length !== 1) return yield* error;
                   const project = yield* authorize(matches[0]!);
                   return { project, operations: [] };
                 }),

package/src/Neon/ProjectMemberRole.ts

@@ -383,7 +383,7 @@ export const ProjectMemberRoleProvider = () =>
         Effect.catchTag("NotFound", (error) =>
           Effect.gen(function* () {
             if (yield* projectAbsenceProven(output, members)) return undefined;
-            return yield* Effect.fail(error);
+            return yield* error;
           }),
         ),
       );

package/src/Neon/Providers.ts

@@ -35,6 +35,7 @@ import {
 import { Project, ProjectProvider } from "./Project.ts";
 import { ProjectMemberRole, ProjectMemberRoleProvider } from "./ProjectMemberRole.ts";
 import { ProjectVPCEndpoint, ProjectVPCEndpointProvider } from "./ProjectVPCEndpoint.ts";
+import { Role, RoleProvider } from "./Role.ts";
 import { WebsiteArtifact, WebsiteArtifactProvider } from "./Website/Artifact.ts";
 
 export class Providers extends Provider.ProviderCollection<Providers>()("Neon") {}
@@ -79,6 +80,7 @@ export const providers = () =>
       ProjectVPCEndpoint,
       Branch,
       Credential,
+      Role,
       Bucket,
       Object,
       Auth,
@@ -103,6 +105,7 @@ export const providers = () =>
         ProjectVPCEndpointProvider(),
         BranchProvider(),
         CredentialProvider(),
+        RoleProvider(),
         BucketProvider(),
         ObjectProvider(),
         AuthProvider(),