alchemy-effect 0.6.0 → 0.6.3

package/src/Cloudflare/KV/Put.ts

@@ -0,0 +1,59 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Stream from "effect/Stream";
+import * as Binding from "../../Binding.ts";
+import { WorkerEnvironment } from "../Workers/Worker.ts";
+import { replaceEffectStream } from "../stream.ts";
+import type { Namespace } from "./Namespace.ts";
+import { NamespaceBinding } from "./NamespaceBinding.ts";
+
+export type PutValue =
+  | string
+  | ArrayBuffer
+  | ArrayBufferView
+  | runtime.ReadableStream
+  | Stream.Stream<any>;
+
+export interface PutOptions extends runtime.KVNamespacePutOptions {}
+
+export class Put extends Binding.Service<
+  Put,
+  (
+    namespace: Namespace,
+  ) => Effect.Effect<
+    (key: string, value: PutValue, options?: PutOptions) => Effect.Effect<void>
+  >
+>()("Cloudflare.KV.Put") {}
+
+export const PutLive = Layer.effect(
+  Put,
+  Effect.gen(function* () {
+    const Policy = yield* PutPolicy;
+    const env = yield* WorkerEnvironment;
+
+    return Effect.fn(function* (namespace: Namespace) {
+      yield* Policy(namespace);
+      const kvNamespace = (env as Record<string, runtime.KVNamespace>)[
+        namespace.LogicalId
+      ];
+
+      return Effect.fn(function* (
+        key: string,
+        value: PutValue,
+        options?: PutOptions,
+      ) {
+        return yield* Effect.promise(() =>
+          kvNamespace.put(key, replaceEffectStream(value), options),
+        );
+      });
+    });
+  }),
+);
+
+export class PutPolicy extends Binding.Policy<
+  PutPolicy,
+  (namespace: Namespace) => Effect.Effect<void>
+>()("Cloudflare.KV.Put") {}
+
+export const PutPolicyLive = PutPolicy.layer.succeed(NamespaceBinding);

package/src/Cloudflare/KV/index.ts

@@ -0,0 +1,6 @@
+export * from "./Delete.ts";
+export * from "./Get.ts";
+export * from "./GetWithMetadata.ts";
+export * from "./List.ts";
+export * from "./Namespace.ts";
+export * from "./Put.ts";

package/src/Cloudflare/Logs.ts

@@ -0,0 +1,122 @@
+import * as workers from "@distilled.cloud/cloudflare/workers";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import type { LogLine, LogsInput } from "../Provider.ts";
+
+const DEFAULT_LOOKBACK_MS = 1 * 60 * 60 * 1000;
+
+export interface TelemetryFilter {
+  key: string;
+  operation:
+    | "eq"
+    | "neq"
+    | "includes"
+    | "not_includes"
+    | "starts_with"
+    | "gt"
+    | "gte"
+    | "lt"
+    | "lte"
+    | "in"
+    | "not_in";
+  type: "string" | "number" | "boolean";
+  value?: string | number | boolean;
+}
+
+const parseEvents = (
+  response: workers.QueryObservabilityTelemetryResponse,
+): LogLine[] => {
+  const lines: LogLine[] = [];
+  if (response.events?.events) {
+    for (const event of response.events.events) {
+      const ts = new Date(event.timestamp);
+      const meta = event.$metadata;
+      const msg =
+        meta.message ??
+        (meta.level === "error"
+          ? `error: ${meta.error ?? "unknown"}`
+          : `${meta.level ?? "log"}`);
+      lines.push({ timestamp: ts, message: msg });
+    }
+  }
+  return lines;
+};
+
+export const CloudflareLogs = Effect.gen(function* () {
+  const queryTelemetry = yield* workers.queryObservabilityTelemetry;
+
+  const queryLogs = (opts: {
+    accountId: string;
+    filters: TelemetryFilter[];
+    options: LogsInput;
+  }) =>
+    Effect.gen(function* () {
+      const now = Date.now();
+      const limit = opts.options.limit ?? 100;
+
+      if (opts.options.since) {
+        const response = yield* queryTelemetry({
+          accountId: opts.accountId,
+          queryId: "events",
+          view: "events",
+          timeframe: { from: opts.options.since.getTime(), to: now },
+          limit,
+          parameters: {
+            filters: opts.filters,
+            // orderBy: { value: "timestamp", order: "desc" },
+          },
+        });
+        return parseEvents(response);
+      }
+
+      const response = yield* queryTelemetry({
+        accountId: opts.accountId,
+        queryId: "events",
+        view: "events",
+        timeframe: { from: now - DEFAULT_LOOKBACK_MS, to: now },
+        limit,
+        parameters: {
+          filters: opts.filters,
+        },
+      });
+
+      return parseEvents(response);
+    });
+
+  const tailStream = (opts: {
+    accountId: string;
+    filters: TelemetryFilter[];
+  }) => {
+    const poll = (since: number): Stream.Stream<LogLine, any> =>
+      Stream.unwrap(
+        Effect.gen(function* () {
+          yield* Effect.sleep("2 seconds");
+          const now = Date.now();
+
+          const response = yield* queryTelemetry({
+            accountId: opts.accountId,
+            queryId: "events",
+            view: "events",
+            timeframe: { from: since, to: now },
+            limit: 100,
+            parameters: {
+              filters: opts.filters,
+              orderBy: { value: "timestamp", order: "asc" },
+            },
+          });
+
+          const lines = parseEvents(response);
+          const nextSince =
+            lines.length > 0
+              ? Math.max(...lines.map((l) => l.timestamp.getTime())) + 1
+              : since;
+
+          return Stream.concat(Stream.fromIterable(lines), poll(nextSince));
+        }),
+      );
+
+    return poll(Date.now());
+  };
+
+  return { queryLogs, tailStream };
+});

package/src/Cloudflare/Providers.ts

@@ -0,0 +1,80 @@
+import * as Auth from "@distilled.cloud/cloudflare/Auth";
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as Socket from "effect/unstable/socket/Socket";
+import { CommandProvider } from "../Build/Command.ts";
+import type { Provider } from "../Provider.ts";
+import { RandomProvider } from "../Random.ts";
+import * as Account from "./Account.ts";
+import { ContainerProvider } from "./Container.ts";
+import * as D1 from "./D1/index.ts";
+import * as KV from "./KV/index.ts";
+import * as R2 from "./R2/index.ts";
+import { AssetsProvider } from "./Workers/Assets.ts";
+import { WorkerProvider } from "./Workers/Worker.ts";
+import { WorkflowProvider } from "./Workers/Workflow.ts";
+
+export type Providers = Extract<
+  Layer.Success<ReturnType<typeof providers>>,
+  Provider<any>
+>;
+
+/**
+ * Cloudflare providers, bindings, and credentials for Worker-based stacks.
+ */
+export const providers = () =>
+  pipe(
+    resources(),
+    Layer.provideMerge(bindings()),
+    Layer.provideMerge(utils()),
+    Layer.provideMerge(credentials()),
+    Layer.orDie,
+  );
+
+/**
+ * Cloudflare account credentials and auth context.
+ */
+export const credentials = () =>
+  Layer.mergeAll(
+    Account.fromStageConfig(),
+    Layer.provideMerge(Auth.fromEnv(), FetchHttpClient.layer),
+  );
+
+/**
+ * All Cloudflare resource providers.
+ */
+export const resources = () =>
+  Layer.mergeAll(
+    CommandProvider(),
+    RandomProvider(),
+    ContainerProvider(),
+    WorkerProvider(),
+    WorkflowProvider(),
+    D1.DatabaseProvider(),
+    KV.NamespaceProvider(),
+    R2.BucketProvider(),
+  );
+
+/**
+ * All Cloudflare binding policies.
+ */
+export const bindings = () =>
+  Layer.mergeAll(
+    D1.D1ConnectionPolicyLive,
+    R2.GetObjectPolicyLive,
+    R2.PutObjectPolicyLive,
+    R2.DeleteObjectPolicyLive,
+    R2.HeadObjectPolicyLive,
+    R2.ListObjectsPolicyLive,
+    R2.CreateMultipartUploadPolicyLive,
+    R2.ResumeMultipartUploadPolicyLive,
+    KV.GetPolicyLive,
+    KV.PutPolicyLive,
+    KV.DeletePolicyLive,
+    KV.ListPolicyLive,
+    KV.GetWithMetadataPolicyLive,
+  );
+
+const utils = () =>
+  Layer.mergeAll(AssetsProvider(), Socket.layerWebSocketConstructorGlobal);

package/src/Cloudflare/R2/Bucket.ts

@@ -0,0 +1,173 @@
+import * as r2 from "@distilled.cloud/cloudflare/r2";
+import * as Effect from "effect/Effect";
+
+import { isResolved } from "../../Diff.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
+import { Resource } from "../../Resource.ts";
+import { Account } from "../Account.ts";
+
+export type BucketName = string;
+
+export type BucketProps = {
+  /**
+   * Name of the bucket. If omitted, a unique name will be generated.
+   * @default ${app}-${stage}-${id}
+   */
+  name?: string;
+  /**
+   * Storage class for newly uploaded objects.
+   * @default "Standard"
+   */
+  storageClass?: Bucket.StorageClass;
+  /**
+   * Jurisdiction where objects in this bucket are guaranteed to be stored.
+   * @default "default"
+   */
+  jurisdiction?: Bucket.Jurisdiction;
+  /**
+   * Location hint for the bucket.
+   */
+  locationHint?: Bucket.Location;
+};
+
+export interface Bucket extends Resource<
+  "Cloudflare.R2.Bucket",
+  BucketProps,
+  {
+    bucketName: BucketName;
+    storageClass: Bucket.StorageClass;
+    jurisdiction: Bucket.Jurisdiction;
+    location: Bucket.Location | undefined;
+    accountId: string;
+  }
+> {}
+
+export const Bucket = Resource<Bucket>("Cloudflare.R2.Bucket");
+
+export declare namespace Bucket {
+  export type StorageClass = "Standard" | "InfrequentAccess";
+  export type Jurisdiction = "default" | "eu" | "fedramp";
+  export type Location = "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc";
+}
+
+export const BucketProvider = () =>
+  Bucket.provider.effect(
+    Effect.gen(function* () {
+      const accountId = yield* Account;
+      const createBucket = yield* r2.createBucket;
+      const patchBucket = yield* r2.patchBucket;
+      const deleteBucket = yield* r2.deleteBucket;
+      const getBucket = yield* r2.getBucket;
+
+      const createBucketName = (id: string, name: string | undefined) =>
+        Effect.gen(function* () {
+          if (name) return name;
+          return (yield* createPhysicalName({
+            id,
+            maxLength: 63,
+          })).toLowerCase();
+        });
+
+      const normalizeLocation = (
+        location: string | undefined | null,
+      ): Bucket.Location | undefined => {
+        if (!location) return undefined;
+        return location.toLowerCase() as Bucket.Location;
+      };
+
+      return {
+        stables: ["bucketName", "accountId"],
+        diff: Effect.fn(function* ({ id, olds = {}, news = {}, output }) {
+          if (!isResolved(news)) return undefined;
+          const name = yield* createBucketName(id, news.name);
+          const oldName = output?.bucketName
+            ? output.bucketName
+            : yield* createBucketName(id, olds.name);
+          const oldJurisdiction =
+            output?.jurisdiction ?? olds.jurisdiction ?? "default";
+          const oldStorageClass =
+            output?.storageClass ?? olds.storageClass ?? "Standard";
+          if (
+            (output?.accountId ?? accountId) !== accountId ||
+            oldName !== name ||
+            oldJurisdiction !== (news.jurisdiction ?? "default") ||
+            olds.locationHint !== news.locationHint
+          ) {
+            return { action: "replace" } as const;
+          }
+          if (oldStorageClass !== (news.storageClass ?? "Standard")) {
+            return {
+              action: "update",
+              stables: oldName === name ? ["bucketName"] : undefined,
+            } as const;
+          }
+        }),
+        create: Effect.fn(function* ({ id, news = {} }) {
+          const name = yield* createBucketName(id, news.name);
+          const bucket = yield* createBucket({
+            accountId,
+            name,
+            storageClass: news.storageClass,
+            jurisdiction: news.jurisdiction,
+            locationHint: news.locationHint,
+          }).pipe(
+            Effect.catchTag("BucketAlreadyExists", () =>
+              getBucket({
+                accountId,
+                bucketName: name,
+                jurisdiction: news.jurisdiction,
+              }),
+            ),
+          );
+          return {
+            bucketName: bucket.name!,
+            storageClass: bucket.storageClass ?? "Standard",
+            jurisdiction: bucket.jurisdiction ?? "default",
+            location: normalizeLocation(bucket.location),
+            accountId,
+          };
+        }),
+        update: Effect.fn(function* ({ news = {}, output }) {
+          const bucket = yield* patchBucket({
+            accountId: output.accountId,
+            bucketName: output.bucketName,
+            storageClass: news.storageClass ?? output.storageClass,
+            jurisdiction: output.jurisdiction,
+          });
+          return {
+            bucketName: bucket.name!,
+            storageClass: bucket.storageClass ?? "Standard",
+            jurisdiction: bucket.jurisdiction ?? "default",
+            location: normalizeLocation(bucket.location),
+            accountId: output.accountId,
+          };
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* deleteBucket({
+            accountId: output.accountId,
+            bucketName: output.bucketName,
+            jurisdiction: output.jurisdiction,
+          }).pipe(Effect.catchTag("NoSuchBucket", () => Effect.void));
+        }),
+        read: Effect.fn(function* ({ id, output, olds }) {
+          const name =
+            output?.bucketName ?? (yield* createBucketName(id, olds?.name));
+          const acct = output?.accountId ?? accountId;
+          return yield* getBucket({
+            accountId: acct,
+            bucketName: name,
+            jurisdiction: output?.jurisdiction ?? olds?.jurisdiction,
+          }).pipe(
+            Effect.map((bucket) => ({
+              bucketName: bucket.name!,
+              storageClass: bucket.storageClass ?? "Standard",
+              jurisdiction: bucket.jurisdiction ?? "default",
+              location: normalizeLocation(bucket.location),
+              accountId: acct,
+            })),
+            Effect.catchTag("NoSuchBucket", () => Effect.succeed(undefined)),
+          );
+        }),
+      };
+    }),
+  );

package/src/Cloudflare/R2/BucketBinding.ts

@@ -0,0 +1,31 @@
+import * as Effect from "effect/Effect";
+import * as Output from "../../Output.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker } from "../Workers/Worker.ts";
+import type { Bucket } from "./Bucket.ts";
+
+export const BucketBinding = Effect.fn(function* (
+  host: ResourceLike,
+  bucket: Bucket,
+) {
+  if (isWorker(host)) {
+    yield* host.bind`Bind(${bucket})`({
+      bindings: [
+        {
+          type: "r2_bucket",
+          name: bucket.LogicalId,
+          bucketName: bucket.bucketName,
+          jurisdiction: bucket.jurisdiction.pipe(
+            Output.map((jurisdiction) =>
+              jurisdiction === "default" ? undefined : jurisdiction,
+            ),
+          ),
+        },
+      ],
+    });
+  } else {
+    return yield* Effect.die(
+      new Error(`BucketBinding does not support runtime '${host.Type}'`),
+    );
+  }
+});

package/src/Cloudflare/R2/CreateMultipartUpload.ts

@@ -0,0 +1,59 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { WorkerEnvironment } from "../Workers/Worker.ts";
+import type { Bucket } from "./Bucket.ts";
+import { BucketBinding } from "./BucketBinding.ts";
+import {
+  type MultipartUploadClient,
+  makeMultipartUploadClient,
+} from "./MultipartUploadClient.ts";
+
+export interface CreateMultipartUploadOptions
+  extends runtime.R2MultipartOptions {}
+
+export class CreateMultipartUpload extends Binding.Service<
+  CreateMultipartUpload,
+  (
+    bucket: Bucket,
+  ) => Effect.Effect<
+    (
+      key: string,
+      options?: CreateMultipartUploadOptions,
+    ) => Effect.Effect<MultipartUploadClient>
+  >
+>()("Cloudflare.R2.CreateMultipartUpload") {}
+
+export const CreateMultipartUploadLive = Layer.effect(
+  CreateMultipartUpload,
+  Effect.gen(function* () {
+    const Policy = yield* CreateMultipartUploadPolicy;
+    const env = yield* WorkerEnvironment;
+
+    return Effect.fn(function* (bucket: Bucket) {
+      yield* Policy(bucket);
+      const r2Bucket = (env as Record<string, runtime.R2Bucket>)[
+        bucket.LogicalId
+      ];
+
+      return Effect.fn(function* (
+        key: string,
+        options?: CreateMultipartUploadOptions,
+      ) {
+        const multipartUpload = yield* Effect.promise(() =>
+          r2Bucket.createMultipartUpload(key, options),
+        );
+        return makeMultipartUploadClient(multipartUpload);
+      });
+    });
+  }),
+);
+
+export class CreateMultipartUploadPolicy extends Binding.Policy<
+  CreateMultipartUploadPolicy,
+  (bucket: Bucket) => Effect.Effect<void>
+>()("Cloudflare.R2.CreateMultipartUpload") {}
+
+export const CreateMultipartUploadPolicyLive =
+  CreateMultipartUploadPolicy.layer.succeed(BucketBinding);

package/src/Cloudflare/R2/DeleteObject.ts

@@ -0,0 +1,41 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { WorkerEnvironment } from "../Workers/Worker.ts";
+import type { Bucket } from "./Bucket.ts";
+import { BucketBinding } from "./BucketBinding.ts";
+
+export class DeleteObject extends Binding.Service<
+  DeleteObject,
+  (
+    bucket: Bucket,
+  ) => Effect.Effect<(keys: string | string[]) => Effect.Effect<void>>
+>()("Cloudflare.R2.DeleteObject") {}
+
+export const DeleteObjectLive = Layer.effect(
+  DeleteObject,
+  Effect.gen(function* () {
+    const Policy = yield* DeleteObjectPolicy;
+    const env = yield* WorkerEnvironment;
+
+    return Effect.fn(function* (bucket: Bucket) {
+      yield* Policy(bucket);
+      const r2Bucket = (env as Record<string, runtime.R2Bucket>)[
+        bucket.LogicalId
+      ];
+
+      return Effect.fn(function* (keys: string | string[]) {
+        return yield* Effect.promise(() => r2Bucket.delete(keys));
+      });
+    });
+  }),
+);
+
+export class DeleteObjectPolicy extends Binding.Policy<
+  DeleteObjectPolicy,
+  (bucket: Bucket) => Effect.Effect<void>
+>()("Cloudflare.R2.DeleteObject") {}
+
+export const DeleteObjectPolicyLive =
+  DeleteObjectPolicy.layer.succeed(BucketBinding);

package/src/Cloudflare/R2/GetObject.ts

@@ -0,0 +1,47 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { WorkerEnvironment } from "../Workers/Worker.ts";
+import type { Bucket } from "./Bucket.ts";
+import { BucketBinding } from "./BucketBinding.ts";
+
+export interface GetObjectOptions extends runtime.R2GetOptions {}
+
+export class GetObject extends Binding.Service<
+  GetObject,
+  (
+    bucket: Bucket,
+  ) => Effect.Effect<
+    (
+      key: string,
+      options?: GetObjectOptions,
+    ) => Effect.Effect<runtime.R2ObjectBody | null>
+  >
+>()("Cloudflare.R2.GetObject") {}
+
+export const GetObjectLive = Layer.effect(
+  GetObject,
+  Effect.gen(function* () {
+    const Policy = yield* GetObjectPolicy;
+    const env = yield* WorkerEnvironment;
+
+    return Effect.fn(function* (bucket: Bucket) {
+      yield* Policy(bucket);
+      const r2Bucket = (env as Record<string, runtime.R2Bucket>)[
+        bucket.LogicalId
+      ];
+
+      return Effect.fn(function* (key: string, options?: GetObjectOptions) {
+        return yield* Effect.promise(() => r2Bucket.get(key, options));
+      });
+    });
+  }),
+);
+
+export class GetObjectPolicy extends Binding.Policy<
+  GetObjectPolicy,
+  (bucket: Bucket) => Effect.Effect<void>
+>()("Cloudflare.R2.GetObject") {}
+
+export const GetObjectPolicyLive = GetObjectPolicy.layer.succeed(BucketBinding);

package/src/Cloudflare/R2/HeadObject.ts

@@ -0,0 +1,41 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { WorkerEnvironment } from "../Workers/Worker.ts";
+import type { Bucket } from "./Bucket.ts";
+import { BucketBinding } from "./BucketBinding.ts";
+
+export class HeadObject extends Binding.Service<
+  HeadObject,
+  (
+    bucket: Bucket,
+  ) => Effect.Effect<(key: string) => Effect.Effect<runtime.R2Object | null>>
+>()("Cloudflare.R2.HeadObject") {}
+
+export const HeadObjectLive = Layer.effect(
+  HeadObject,
+  Effect.gen(function* () {
+    const Policy = yield* HeadObjectPolicy;
+    const env = yield* WorkerEnvironment;
+
+    return Effect.fn(function* (bucket: Bucket) {
+      yield* Policy(bucket);
+      const r2Bucket = (env as Record<string, runtime.R2Bucket>)[
+        bucket.LogicalId
+      ];
+
+      return Effect.fn(function* (key: string) {
+        return yield* Effect.promise(() => r2Bucket.head(key));
+      });
+    });
+  }),
+);
+
+export class HeadObjectPolicy extends Binding.Policy<
+  HeadObjectPolicy,
+  (bucket: Bucket) => Effect.Effect<void>
+>()("Cloudflare.R2.HeadObject") {}
+
+export const HeadObjectPolicyLive =
+  HeadObjectPolicy.layer.succeed(BucketBinding);