alchemy 2.0.0-beta.2 → 2.0.0-beta.21

package/src/GitHub/Variable.ts

@@ -0,0 +1,159 @@
+import * as Effect from "effect/Effect";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import { GitHubCredentials } from "./Credentials.ts";
+import type * as GitHub from "./Providers.ts";
+
+export interface VariableProps {
+  /**
+   * Repository owner (user or organization).
+   */
+  owner: string;
+
+  /**
+   * Repository name.
+   */
+  repository: string;
+
+  /**
+   * Variable name (e.g. `AWS_ROLE_ARN`).
+   */
+  name: string;
+
+  /**
+   * Variable value.
+   */
+  value: string;
+}
+
+export interface Variable extends Resource<
+  "GitHub.Variable",
+  VariableProps,
+  {
+    /**
+     * ISO-8601 timestamp of the last update.
+     */
+    updatedAt: string;
+  },
+  never,
+  GitHub.Providers
+> {}
+
+/**
+ * A GitHub Actions repository variable.
+ *
+ * `Variable` manages the lifecycle of a plain-text configuration variable
+ * in GitHub Actions. Variables are visible in workflow logs and are
+ * suitable for non-sensitive configuration like region names, environment
+ * labels, or feature flags. For sensitive values, use `GitHub.Secret`
+ * instead.
+ *
+ * Authentication is resolved via the `GitHubCredentials` service supplied
+ * by `GitHub.providers()` (which uses the Alchemy AuthProvider — env,
+ * stored PAT, `gh` CLI, or OAuth). The token needs `repo` scope for
+ * private repositories or `public_repo` for public ones.
+ *
+ * @section Repository Variables
+ * Store variables accessible to all GitHub Actions workflows in the
+ * repository.
+ *
+ * @example Create a Repository Variable
+ * ```typescript
+ * yield* GitHub.Variable("aws-region", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   name: "AWS_REGION",
+ *   value: "us-east-1",
+ * });
+ * ```
+ *
+ * @section Wiring with Other Resources
+ * Pass output attributes from other resources into GitHub variables so
+ * that CI workflows can reference them.
+ *
+ * @example Store a Worker URL for CI
+ * ```typescript
+ * const worker = yield* Cloudflare.Worker("Api", { ... });
+ *
+ * yield* GitHub.Variable("api-url", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   name: "API_URL",
+ *   value: worker.url!,
+ * });
+ * ```
+ *
+ * @example Multiple Variables
+ * ```typescript
+ * yield* GitHub.Variable("region", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   name: "AWS_REGION",
+ *   value: "us-east-1",
+ * });
+ *
+ * yield* GitHub.Variable("stage", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   name: "DEPLOY_STAGE",
+ *   value: "production",
+ * });
+ * ```
+ */
+export const Variable = Resource<Variable>("GitHub.Variable");
+
+const getOctokit = Effect.gen(function* () {
+  const creds = yield* GitHubCredentials;
+  return creds.octokit();
+});
+
+export const VariableProvider = () =>
+  Provider.succeed(Variable, {
+    create: Effect.fn(function* ({ news }) {
+      const octokit = yield* getOctokit;
+
+      yield* Effect.tryPromise(() =>
+        octokit.rest.actions.createRepoVariable({
+          owner: news.owner,
+          repo: news.repository,
+          name: news.name,
+          value: news.value,
+        }),
+      );
+
+      return { updatedAt: new Date().toISOString() };
+    }),
+
+    update: Effect.fn(function* ({ news }) {
+      const octokit = yield* getOctokit;
+
+      yield* Effect.tryPromise(() =>
+        octokit.rest.actions.updateRepoVariable({
+          owner: news.owner,
+          repo: news.repository,
+          name: news.name,
+          value: news.value,
+        }),
+      );
+
+      return { updatedAt: new Date().toISOString() };
+    }),
+
+    delete: Effect.fn(function* ({ olds }) {
+      const octokit = yield* getOctokit;
+
+      yield* Effect.tryPromise(async () => {
+        try {
+          await octokit.rest.actions.deleteRepoVariable({
+            owner: olds.owner,
+            repo: olds.repository,
+            name: olds.name,
+          });
+        } catch (error: any) {
+          if (error.status !== 404) {
+            throw error;
+          }
+        }
+      });
+    }),
+  });

package/src/GitHub/index.ts

@@ -0,0 +1,7 @@
+export * as Auth from "./AuthProvider.ts";
+export * from "./Comment.ts";
+export { GitHubCredentials, fromEnv, fromToken } from "./Credentials.ts";
+export * from "./Providers.ts";
+export * from "./Secret.ts";
+export * from "./Secrets.ts";
+export * from "./Variable.ts";

package/src/Http.ts

@@ -25,7 +25,6 @@ export const serve = <Req = never>(
 ) =>
   Effect.serviceOption(HttpServer).pipe(
     Effect.map(Option.getOrUndefined),
-    Effect.tap((http) => Effect.logInfo("http", http)),
     Effect.flatMap((http) => (http ? http.serve(handler) : Effect.void)),
   );
 
@@ -45,22 +44,38 @@ export class HttpServer extends Context.Service<
   }
 >()("HttpServer") {}
 
-export const safeHttpEffect = <Req = never>(handler: HttpEffect<Req>) =>
-  Effect.catchCause(handler, (cause) => {
-    const message = Option.match(Cause.findErrorOption(cause), {
-      onNone: () => "Internal Server Error",
-      onSome: (error) => error.message ?? "Internal Server Error",
-    });
+export const safeHttpEffect = <Req = never>(
+  handler: HttpEffect<Req> | Effect.Effect<HttpEffect<Req>>,
+): Effect.Effect<
+  HttpServerResponse.HttpServerResponse,
+  never,
+  Req | HttpServerRequest | Scope
+> =>
+  Effect.catchCause(
+    handler.pipe(
+      // @ts-expect-error
+      Effect.flatMap((response) =>
+        HttpServerResponse.isHttpServerResponse(response)
+          ? Effect.succeed(response)
+          : response,
+      ),
+    ) as any as HttpEffect<Req>,
+    (cause) => {
+      const message = Option.match(Cause.findErrorOption(cause), {
+        onNone: () => "Internal Server Error",
+        onSome: (error) => error.message ?? "Internal Server Error",
+      });
 
-    return Effect.map(
-      Effect.all([Effect.logInfo(message), Effect.logInfo(cause)]),
-      () =>
-        HttpServerResponse.text(message, {
-          status: 500,
-          statusText: message,
-        }),
-    );
-  });
+      return Effect.map(
+        Effect.all([Effect.logError(message), Effect.logError(cause)]),
+        () =>
+          HttpServerResponse.text(message, {
+            status: 500,
+            statusText: message,
+          }),
+      );
+    },
+  );
 
 export const resolvePort = (options: { port?: number } | undefined) =>
   options?.port !== undefined

package/src/Kubernetes/client.ts

@@ -1,6 +1,6 @@
-import { AwsClient } from "aws4fetch";
 import { Credentials } from "@distilled.cloud/aws/Credentials";
 import { Region } from "@distilled.cloud/aws/Region";
+import { AwsClient } from "aws4fetch";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
@@ -28,7 +28,7 @@ export interface KubernetesClusterConnection {
   certificateAuthorityData: string;
 }
 
-const fieldManager = "alchemy-effect";
+const fieldManager = "alchemy";
 
 const createBearerToken = Effect.fn(function* (clusterName: string) {
   const credentials = yield* yield* Credentials;

package/src/Output.ts

@@ -3,6 +3,7 @@ import type { Yieldable } from "effect/Effect";
 import * as Effect from "effect/Effect";
 import { pipe } from "effect/Function";
 import type { Pipeable } from "effect/Pipeable";
+import * as Redacted from "effect/Redacted";
 import { SingleShotGen } from "effect/Utils";
 import { ExecutionContext } from "./ExecutionContext.ts";
 import { getRefMetadata, isRef, ref as stageRef, type Ref } from "./Ref.ts";
@@ -90,7 +91,7 @@ export abstract class BaseExpr<A = any, Req = any> implements Output<A, Req> {
   declare readonly A: A;
   declare readonly src: ResourceLike;
   declare readonly req: Req;
-  // we use a kind tag instead of instanceof to protect ourselves from duplicate alchemy-effect module imports
+  // we use a kind tag instead of instanceof to protect ourselves from duplicate alchemy module imports
   constructor() {}
   as<T>(): Output<T, Req> {
     return this as any;
@@ -208,8 +209,6 @@ export const map: {
         new ApplyExpr(output as Expr<A, Req>, args[0]) as any
     : new ApplyExpr(args[0] as any, args[1])) as any;
 
-type _ = Parameters<typeof map>;
-
 //Output.ApplyExpr<any, any, ResourceLike, any>
 export const isApplyExpr = <In = any, Out = any, Req = any>(
   node: Output<Out, Req>,
@@ -354,7 +353,7 @@ function proxy(self: any): any {
       prop === ExprSymbol || prop === inspect ? true : prop in self,
     get: (target, prop) =>
       prop === Symbol.toPrimitive
-        ? (hint: string) => (hint === "string" ? self.toString() : self)
+        ? (hint: string) => (hint === "number" ? Number.NaN : self.toString())
         : prop === ExprSymbol
           ? self
           : prop === inspect
@@ -470,6 +469,8 @@ export const evaluate: <A, Req = never>(
     }
     if (Array.isArray(expr)) {
       return yield* Effect.all(expr.map((item) => evaluate(item, upstream)));
+    } else if (Redacted.isRedacted(expr)) {
+      return expr;
     } else if (typeof expr === "object" && expr !== null) {
       return Object.fromEntries(
         yield* Effect.all(

package/src/Plan.ts

@@ -1,6 +1,7 @@
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
 import { asEffect } from ".//Util/types.ts";
 import {
   Artifacts,
@@ -271,6 +272,8 @@ export const make = <A>(
           return input;
         } else if (Output.isExpr(input)) {
           return yield* resolveOutput(input);
+        } else if (Redacted.isRedacted(input)) {
+          return input;
         } else if (Array.isArray(input)) {
           return yield* Effect.all(input.map(resolveInput), {
             concurrency: "unbounded",
@@ -394,7 +397,7 @@ export const make = <A>(
     const resourceGraph = Object.fromEntries(
       (yield* Effect.all(
         resources.map(
-          Effect.fn(function* (resource) {
+          Effect.fn("plan.diff.resource")(function* (resource) {
             const provider = yield* findProviderByType(resource.Type);
             const id = resource.LogicalId;
             const fqn = resource.FQN;
@@ -720,8 +723,7 @@ export const make = <A>(
     const deletions = Object.fromEntries(
       (yield* Effect.all(
         (yield* state.list({ stack: stackName, stage: stage })).map(
-          Effect.fn(function* (fqn) {
-            // Check if this FQN is in the new resources
+          Effect.fn("plan.diff.deletion")(function* (fqn) {
             if (newResourceFqns.has(fqn)) {
               return;
             }
@@ -802,7 +804,17 @@ export const make = <A>(
       deletions,
       output: stack.output,
     } satisfies Plan<A> as Plan<A>;
-  }).pipe(ensureArtifactStore);
+  }).pipe(
+    ensureArtifactStore,
+    Effect.withSpan("plan.make", {
+      attributes: {
+        "alchemy.stack": stack.name,
+        "alchemy.stage": stack.stage,
+        "alchemy.resources.count": Object.keys(stack.resources).length,
+        "alchemy.force": !!options.force,
+      },
+    }),
+  );
 
 const providePlanScope =
   (fqn: string, instanceId: string) =>

package/src/Platform.ts

@@ -28,12 +28,18 @@ export interface PlatformProps {
   isExternal?: boolean;
 }
 
-export type Main<Services = never> = void | {
-  fetch: HttpEffect<Services | PlatformServices>;
+export type Main<InitServices = never> = void | {
+  fetch:
+    | HttpEffect<InitServices | PlatformServices>
+    | Effect.Effect<
+        HttpEffect<InitServices | PlatformServices>,
+        never,
+        InitServices | PlatformServices
+      >;
 };
 
 export type Rpc<Shape> = {
-  "~alchemy-effect/rpc": Shape;
+  "~alchemy/rpc": Shape;
 };
 
 // services provided to the Resource
@@ -159,7 +165,7 @@ export interface Platform<
   ): Effect.Effect<
     Resource & Rpc<Shape>,
     never,
-    | Provider<Resource>
+    | Resource["Providers"]
     | PropsReq
     | Exclude<InitReq, Services | PlatformServices>
   >;
@@ -220,10 +226,15 @@ export const Platform = <
             //     return new Response("Hello, world!");
             //   }
             // }
-            resource(id, {
-              ...props,
-              isExternal: true,
-            })
+            resource(
+              id,
+              Effect.isEffect(props)
+                ? Effect.map(props, (p: any) => ({ ...p, isExternal: true }))
+                : {
+                    ...props,
+                    isExternal: true,
+                  },
+            )
           : Effect.flatMap(
               // this is a tagged resource
               Effect.serviceOption(cls.Self),

package/src/Provider.ts

@@ -369,7 +369,7 @@ export const tryFindProviderByType: {
   const Tag = Provider<R>(resourceType) as Context.Service<Provider<R>, any>;
   const direct = yield* Effect.serviceOption(Tag);
   if (Option.isSome(direct)) {
-    return direct.value;
+    return direct;
   }
 
   const context = yield* Effect.context<never>();
@@ -381,7 +381,5 @@ export const tryFindProviderByType: {
       }
     }
   }
-
-  console.log(context.mapUnsafe.keys());
   return Option.none();
 }) as any;

package/src/Resource.ts

@@ -3,7 +3,7 @@ import * as Option from "effect/Option";
 import { pipeArguments, type Pipeable } from "effect/Pipeable";
 import { SingleShotGen } from "effect/Utils";
 import { toFqn } from "./FQN.ts";
-import type { Input } from "./Input.ts";
+import type { Input, InputProps } from "./Input.ts";
 import { CurrentNamespace, type NamespaceNode } from "./Namespace.ts";
 import * as Output from "./Output.ts";
 import { Provider } from "./Provider.ts";
@@ -31,10 +31,10 @@ export type ResourceConstructor<R extends ResourceLike, Req = never> = {
           },
         ]
   ): Effect.Effect<R, never, Req>;
-  // <PropsReq = never>(
-  //   id: string,
-  //   props: Effect.Effect<Input<R["Props"]>, never, PropsReq>,
-  // ): Effect.Effect<R, never, PropsReq | Req>;
+  <PropsReq = never>(
+    id: string,
+    props: Effect.Effect<InputProps<R["Props"]>, never, PropsReq>,
+  ): Effect.Effect<R, never, PropsReq | Req>;
 };
 
 export type ResourceClassWithMethods<