@alchemy.run/fly 0.0.0 → 2.0.0-beta.85

package/src/BucketBinding.ts

@@ -0,0 +1,128 @@
+import { Credentials, fromCredentials } from "@distilled.cloud/aws/Credentials";
+import * as AwsEndpoint from "@distilled.cloud/aws/Endpoint";
+import type { RegionName } from "@distilled.cloud/aws/Region";
+import * as Binding from "alchemy/Binding";
+import type { Resource } from "alchemy/Resource";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import * as Effect from "effect/Effect";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import type * as HttpClient from "effect/http/HttpClient";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import type { Bucket } from "./Bucket.ts";
+import { TigrisCredentialsMissing } from "./Errors.ts";
+import type { ServiceBinding } from "./MountVolume.ts";
+
+/**
+ * Shared scaffolding for Tigris S3 bindings.
+ *
+ * Tigris speaks the S3 API. Each `{Op}Http.ts` is a thin
+ * `Layer.effect(Cap, makeTigrisS3Binding({ operation }))` that:
+ * - registers the bucket on the host so Service reconcile can wait for
+ *   it and attach Tigris App secrets
+ * - `yield*`s credential Outputs so RuntimeContext.set runs
+ * - calls `@distilled.cloud/aws/s3` with those credentials and endpoint
+ *
+ * NOT exported from `index.ts`.
+ */
+export interface TigrisS3Scope {
+  bucketName: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  endpoint: string;
+  region: RegionName;
+}
+
+const isFlyHost = (value: unknown): value is Resource<string, any, any, ServiceBinding> =>
+  typeof value === "object" &&
+  value !== null &&
+  ((value as { Type?: string }).Type === "Fly.Service" ||
+    (value as { Type?: string }).Type === "Fly.Machine");
+
+const asPlain = (value: unknown): string | undefined => {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (Redacted.isRedacted(value)) return value.pipe(Redacted.value, asPlain);
+  return undefined;
+};
+
+const authorizeS3 = <A, E>(
+  scope: TigrisS3Scope,
+  operation: Effect.Effect<A, E, Credentials | HttpClient.HttpClient>,
+): Effect.Effect<A, E, RuntimeContext> =>
+  operation.pipe(
+    Effect.provide(
+      Layer.mergeAll(
+        fromCredentials(
+          {
+            accessKeyId: Redacted.make(scope.accessKeyId),
+            secretAccessKey: Redacted.make(scope.secretAccessKey),
+          },
+          scope.region,
+        ),
+        AwsEndpoint.of(scope.endpoint),
+        FetchHttpClient.layer,
+      ),
+    ),
+  ) as Effect.Effect<A, E, RuntimeContext>;
+
+export const makeTigrisS3Binding = <I extends { Bucket?: string }, A, E>(options: {
+  tag: string;
+  operation: (input: I) => Effect.Effect<A, E, Credentials | HttpClient.HttpClient>;
+}) =>
+  Effect.succeed(
+    Effect.fn(function* (bucket: Bucket) {
+      if (!globalThis.__ALCHEMY_RUNTIME__) {
+        const host = yield* Binding.Host;
+        if (isFlyHost(host)) {
+          // Pass the Bucket resource itself so waitForDeps waits for it
+          // and apply evaluates to attributes (including create-only
+          // Tigris credentials). PropExprs of `name` alone can resolve
+          // from the deterministic physical name without waiting.
+          yield* host.bind`${bucket}`({
+            bucket: bucket as unknown as { name: string; id?: string },
+          });
+        }
+      }
+
+      const bucketName = yield* bucket.bucketName;
+      const name = yield* bucket.name;
+      const accessKeyId = yield* bucket.accessKeyId;
+      const secretAccessKey = yield* bucket.secretAccessKey;
+      const endpoint = yield* bucket.endpoint;
+      const region = yield* bucket.region;
+
+      return Effect.fn(`${options.tag}(${bucket.LogicalId})`)(function* (
+        request?: Omit<I, "Bucket">,
+      ) {
+        const resolvedName = asPlain(yield* bucketName) ?? asPlain(yield* name);
+        const resolvedKey = asPlain(yield* accessKeyId);
+        const resolvedSecret = asPlain(yield* secretAccessKey);
+        const resolvedEndpoint = asPlain(yield* endpoint);
+        const resolvedRegion = asPlain(yield* region) ?? "auto";
+        if (
+          resolvedName === undefined ||
+          resolvedKey === undefined ||
+          resolvedSecret === undefined ||
+          resolvedEndpoint === undefined
+        ) {
+          return yield* new TigrisCredentialsMissing({
+            resourceName: resolvedName ?? bucket.LogicalId,
+          });
+        }
+        const scope = {
+          bucketName: resolvedName,
+          accessKeyId: resolvedKey,
+          secretAccessKey: resolvedSecret,
+          endpoint: resolvedEndpoint,
+          region: resolvedRegion as RegionName,
+        } satisfies TigrisS3Scope;
+        return yield* authorizeS3(
+          scope,
+          options.operation({
+            ...request,
+            Bucket: scope.bucketName,
+          } as I),
+        );
+      });
+    }),
+  );

package/src/Catalog.ts

@@ -0,0 +1,43 @@
+import type { MainRegionRow } from "@distilled.cloud/fly-io/machines";
+import * as machines from "@distilled.cloud/fly-io/machines";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { resolveOrgSlug } from "./Environment.ts";
+
+export type CatalogKind = "region" | "org";
+
+export class CatalogNotFound extends Data.TaggedError("Fly.CatalogNotFound")<{
+  kind: CatalogKind;
+  ref: string;
+}> {}
+
+const notFound = (kind: CatalogKind, ref: string) => new CatalogNotFound({ kind, ref });
+
+/**
+ * Current token organization slug (`getCurrentToken` → `tokens[0].org_slug`).
+ * Feeds `listApps({ org_slug })`. Not a resource.
+ */
+export const currentOrgSlug = resolveOrgSlug;
+
+/**
+ * List Fly platform regions via `getRegions`.
+ */
+export const listRegions = Effect.fn(function* () {
+  const { regions } = yield* machines.getRegions({});
+  return regions ?? [];
+});
+
+/**
+ * Resolve a Fly region by code (`iad`, `ord`, `sjc`, …).
+ */
+export const findRegion = (code: string) =>
+  Effect.gen(function* () {
+    const regions = yield* listRegions();
+    const found = regions.find((item) => item.code === code);
+    if (found === undefined) {
+      return yield* notFound("region", code);
+    }
+    return found;
+  });
+
+export type FlyRegion = MainRegionRow;