alchemy 2.0.0-beta.2 → 2.0.0-beta.4

package/src/GitHub/Variable.ts

@@ -0,0 +1,166 @@
+import { Octokit } from "@octokit/rest";
+import * as Effect from "effect/Effect";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.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;
+
+  /**
+   * GitHub API token. If not provided, falls back to
+   * `GITHUB_ACCESS_TOKEN` or `GITHUB_TOKEN` environment variables.
+   */
+  token?: string;
+}
+
+export interface Variable extends Resource<
+  "GitHub.Variable",
+  VariableProps,
+  {
+    /**
+     * ISO-8601 timestamp of the last update.
+     */
+    updatedAt: string;
+  }
+> {}
+
+/**
+ * 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 in order: explicit `token` prop,
+ * `GITHUB_ACCESS_TOKEN` env var, `GITHUB_TOKEN` env var. 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");
+
+function resolveToken(props: VariableProps): string | undefined {
+  return (
+    props.token ?? process.env.GITHUB_ACCESS_TOKEN ?? process.env.GITHUB_TOKEN
+  );
+}
+
+function createClient(props: VariableProps): Octokit {
+  return new Octokit({ auth: resolveToken(props) });
+}
+
+export const VariableProvider = () =>
+  Provider.succeed(Variable, {
+    create: Effect.fn(function* ({ news }) {
+      const octokit = createClient(news);
+
+      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 = createClient(news);
+
+      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 = createClient(olds);
+
+      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,3 @@
+export * from "./Comment.ts";
+export * from "./Secret.ts";
+export * from "./Variable.ts";

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

@@ -90,7 +90,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;

package/src/Platform.ts

@@ -33,7 +33,7 @@ export type Main<Services = never> = void | {
 };
 
 export type Rpc<Shape> = {
-  "~alchemy-effect/rpc": Shape;
+  "~alchemy/rpc": Shape;
 };
 
 // services provided to the Resource
@@ -220,10 +220,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>();

package/src/Resource.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<Input<R["Props"]>, never, PropsReq>,
+  ): Effect.Effect<R, never, PropsReq | Req>;
 };
 
 export type ResourceClassWithMethods<

package/src/Test/Vitest.ts

@@ -1,6 +1,6 @@
 import type * as aws from "@distilled.cloud/aws";
 import * as cf from "@distilled.cloud/cloudflare";
-import { NodeServices } from "@effect/platform-node";
+// import { NodeServices } from "@effect/platform-node";
 import { expect, it } from "@effect/vitest";
 import { Logger } from "effect";
 import * as Config from "effect/Config";
@@ -44,6 +44,7 @@ import * as Serverless from "../Serverless/index.ts";
 import * as Stack from "../Stack.ts";
 import * as Stage from "../Stage.ts";
 import * as State from "../State/index.ts";
+import { PlatformServices } from "../Util/PlatformServices.ts";
 import { TestCli } from "./TestCli.ts";
 
 export const expectEmptyObject = () =>
@@ -90,7 +91,7 @@ const quietLogger = Logger.make(() => {
 });
 
 const platform = Layer.mergeAll(
-  NodeServices.layer,
+  PlatformServices,
   FetchHttpClient.layer,
   Logger.layer([process.env.VERBOSE ? Logger.consolePretty() : quietLogger]),
 );
@@ -212,7 +213,7 @@ const runWithContext = <A, Err>(
       MinimumLogLevel,
       process.env.DEBUG ? "Debug" : "Info",
     ),
-    Effect.provide(NodeServices.layer),
+    Effect.provide(PlatformServices),
   );
 };
 

package/src/Util/Clank.ts

@@ -0,0 +1,77 @@
+import * as p from "@clack/prompts";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { ChildProcess } from "effect/unstable/process";
+
+export class PromptCancelled extends Data.TaggedError("PromptCancelled") {}
+export const retryIfCancelled = Effect.retry({
+  while: (e: unknown) => e instanceof PromptCancelled,
+});
+
+/**
+ * Wraps a clack prompt (which returns a `Promise<T | symbol>` where the
+ * symbol indicates user cancellation) in an Effect.
+ *
+ * Returns `undefined` if the user cancels (Ctrl+C / Escape).
+ *
+ * Uses `Effect.callback` so fiber interruption propagates via the abort
+ * signal to any async resources we own; the clack prompt itself is left
+ * to resolve — its result is ignored after interruption.
+ */
+export const prompt = <T>(
+  fn: () => Promise<T | symbol>,
+): Effect.Effect<T, PromptCancelled> =>
+  Effect.callback<T, PromptCancelled>((resume, signal) => {
+    let settled = false;
+    fn().then(
+      (result) => {
+        if (settled || signal.aborted) return;
+        settled = true;
+        if (p.isCancel(result)) {
+          resume(Effect.fail(new PromptCancelled()));
+        } else {
+          resume(Effect.succeed(result as T));
+        }
+      },
+      (err) => {
+        if (settled || signal.aborted) return;
+        settled = true;
+        resume(Effect.die(err));
+      },
+    );
+  });
+
+export const success = (str: string) => Effect.sync(() => p.log.success(str));
+export const warn = (str: string) => Effect.sync(() => p.log.warn(str));
+export const error = (str: string) => Effect.sync(() => p.log.error(str));
+export const info = (str: string) => Effect.sync(() => p.log.info(str));
+export const text = (opts: p.TextOptions) => prompt(() => p.text(opts));
+export const password = (opts: p.PasswordOptions) =>
+  prompt(() => p.password(opts));
+export const select = <Value>(opts: p.SelectOptions<Value>) =>
+  prompt(() => p.select<Value>(opts));
+export const confirm = (opts: p.ConfirmOptions) =>
+  prompt(() => p.confirm(opts));
+export const multiselect = <Value>(opts: p.MultiSelectOptions<Value>) =>
+  prompt(() => p.multiselect<Value>(opts));
+
+/**
+ * Open a URL in the user's default browser.
+ *
+ * On Windows, uses rundll32's FileProtocolHandler — a built-in shim that
+ * opens URLs in the default browser. It accepts the URL as a direct
+ * argument (no shell, no quoting of `&`). cmd.exe `start` would treat
+ * `&` in OAuth URLs as a command separator, and `explorer.exe` treats
+ * its arg as a path.
+ */
+export const openUrl = (url: string) =>
+  Effect.gen(function* () {
+    const [cmd, args] =
+      process.platform === "win32"
+        ? (["rundll32.exe", ["url.dll,FileProtocolHandler", url]] as const)
+        : process.platform === "darwin"
+          ? (["open", [url]] as const)
+          : (["xdg-open", [url]] as const);
+    const handle = yield* ChildProcess.make(cmd, [...args], { shell: false });
+    yield* handle.exitCode;
+  }).pipe(Effect.scoped);

package/src/Util/PlatformServices.ts

@@ -0,0 +1,21 @@
+import type { BunServices } from "@effect/platform-bun/BunServices";
+import type { NodeServices } from "@effect/platform-node/NodeServices";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+const isBun = typeof Bun !== "undefined";
+
+export const PlatformServices: Layer.Layer<
+  NodeServices | BunServices,
+  never,
+  never
+> = Effect.promise(() => {
+  if (isBun) {
+    return import("@effect/platform-bun").then(
+      (platform) => platform.BunServices.layer,
+    );
+  }
+  return import("@effect/platform-node").then(
+    (platform) => platform.NodeServices.layer,
+  );
+}).pipe(Layer.unwrap);

package/src/Util/dedent.ts

@@ -0,0 +1,59 @@
+/**
+ * Tagged template literal for removing indentation from a block of text.
+ *
+ * If the first line is empty, it will be ignored.
+ */
+export function dedent(
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+): string;
+export function dedent(text: string): string;
+export function dedent(
+  stringsOrText: TemplateStringsArray | string,
+  ...values: unknown[]
+): string {
+  const raw =
+    typeof stringsOrText === "string"
+      ? stringsOrText
+      : String.raw({ raw: stringsOrText }, ...values);
+
+  let lines = raw.split("\n");
+
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines = lines.slice(1);
+  }
+
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines = lines.slice(0, lines.length - 1);
+  }
+
+  if (lines.length === 0) {
+    return "";
+  }
+
+  let minIndentLength = Number.POSITIVE_INFINITY;
+  for (const line of lines) {
+    if (line.trim() !== "") {
+      const indent = line.match(/^[ \t]*/)?.[0];
+      if (indent != null && indent.length < minIndentLength) {
+        minIndentLength = indent.length;
+      }
+    }
+  }
+
+  if (minIndentLength === Number.POSITIVE_INFINITY) {
+    return lines.join("\n");
+  }
+
+  lines = lines.map((line) => {
+    if (line.trim() === "") {
+      return line;
+    }
+    return line.startsWith(" ".repeat(minIndentLength)) ||
+      line.startsWith("\t".repeat(minIndentLength))
+      ? line.substring(minIndentLength)
+      : line;
+  });
+
+  return lines.join("\n");
+}

package/src/Util/index.ts

@@ -3,6 +3,7 @@ export * from "./base32.ts";
 export * from "./camel.ts";
 export * from "./class.ts";
 export * from "./data.ts";
+export * from "./dedent.ts";
 export * from "./instance.ts";
 export * from "./pointer.ts";
 export * from "./schema-to-type.ts";