sailfork / t3code-github / .repos/ alchemy-effect/ packages/ neon/ src/ StorageObjectBinding.ts

import { createHash } from "node:crypto";
import { isResource } from "alchemy/Resource";
import { CurrentRuntimeContext } from "alchemy/RuntimeContext";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import { bindBackendEnvironment } from "./BackendConnection.ts";
import type { Bucket } from "./Bucket.ts";
import {
  ObjectDecodeError,
  serializeObjectValue,
  storageBodyBytes,
  type Object,
} from "./Object.ts";
import type { ReadObjectClient, ObjectValue } from "./ReadObject.ts";
import {
  makeStorageBinding,
  StorageBindingError,
  type StorageBindingOptions,
} from "./StorageBinding.ts";
import type { WriteObjectClient } from "./WriteObject.ts";

const isBucket = (value: unknown): value is Bucket =>
  isResource(value) && value.Type === "Neon.Bucket";

export const makeReadObjectHttp = () =>
  Effect.gen(function* () {
    const bind = yield* makeStorageBinding("storage:read");
    const runtime = yield* CurrentRuntimeContext;
    if (!runtime)
      return yield* Effect.die(
        new StorageBindingError({
          message: "Object bindings require a Platform host",
        }),
      );
    return Effect.fn(function* <T>(object: Object<T>, options?: StorageBindingOptions) {
      const target = object.Props.bucket;
      if (!isBucket(target))
        return yield* Effect.die(
          new StorageBindingError({
            message: "Object bindings require a Neon.Bucket resource reference",
          }),
        );
      const bucket = yield* bind(target, options);
      const name = yield* Effect.sync(
        () =>
          `NEON_OBJECT_${createHash("sha256").update(object.FQN).digest("hex").slice(0, 24).toUpperCase()}_KEY`,
      );
      yield* bindBackendEnvironment(`${object.FQN}:ReadObject`, {
        [name]: object.key,
      });
      const key = runtime.get<string>(name).pipe(
        Effect.flatMap((key) =>
          key === undefined
            ? Effect.fail(
                new StorageBindingError({
                  message: "Object key was not bound",
                }),
              )
            : Effect.succeed(key),
        ),
      );
      const bytes = Effect.gen(function* () {
        const object = yield* bucket.get(yield* key);
        return object ? yield* storageBodyBytes(object.Body) : undefined;
      });
      const get = Effect.gen(function* () {
        const body = yield* bytes;
        if (body === undefined) return undefined;
        if (!("value" in object.Props)) return body as ObjectValue<T>;
        const parsed: unknown = yield* Effect.try({
          try: () => JSON.parse(new TextDecoder().decode(body)),
          catch: () =>
            new ObjectDecodeError({
              message: "Stored object is not valid JSON",
            }),
        });
        if (!object.Props.schema) return parsed as ObjectValue<T>;
        return (yield* Schema.decodeUnknownEffect(object.Props.schema)(parsed).pipe(
          Effect.mapError(
            () =>
              new ObjectDecodeError({
                message: "Stored JSON does not satisfy the object's schema",
              }),
          ),
        )) as ObjectValue<T>;
      });
      return {
        get: () => get,
        bytes: () => bytes,
      } satisfies ReadObjectClient<T>;
    });
  });

export const makeWriteObjectHttp = () =>
  Effect.gen(function* () {
    const bind = yield* makeStorageBinding("storage:write");
    const runtime = yield* CurrentRuntimeContext;
    if (!runtime)
      return yield* Effect.die(
        new StorageBindingError({
          message: "Object bindings require a Platform host",
        }),
      );
    return Effect.fn(function* <T>(object: Object<T>, options?: StorageBindingOptions) {
      const target = object.Props.bucket;
      if (!isBucket(target))
        return yield* Effect.die(
          new StorageBindingError({
            message: "Object bindings require a Neon.Bucket resource reference",
          }),
        );
      const bucket = yield* bind(target, options);
      const name = yield* Effect.sync(
        () =>
          `NEON_OBJECT_${createHash("sha256").update(object.FQN).digest("hex").slice(0, 24).toUpperCase()}_KEY`,
      );
      yield* bindBackendEnvironment(`${object.FQN}:WriteObject`, {
        [name]: object.key,
      });
      const put = Effect.fn(function* (value: [T] extends [never] ? string | Uint8Array : T) {
        const key = yield* runtime.get<string>(name);
        if (key === undefined)
          return yield* new StorageBindingError({
            message: "Object key was not bound",
          });
        const observed = yield* bucket.head(key);
        const metadata = {
          ContentType: observed?.ContentType,
          CacheControl: observed?.CacheControl,
          ContentDisposition: observed?.ContentDisposition,
          ContentEncoding: observed?.ContentEncoding,
          Metadata: observed?.Metadata,
        };
        if (!("value" in object.Props)) {
          return yield* bucket.put(key, value as string | Uint8Array, metadata);
        }
        const checked = object.Props.schema
          ? yield* Schema.decodeUnknownEffect(object.Props.schema)(value).pipe(
              Effect.mapError(
                () =>
                  new ObjectDecodeError({
                    message: "Written JSON does not satisfy the object's schema",
                  }),
              ),
            )
          : value;
        return yield* bucket.put(key, yield* serializeObjectValue(checked), {
          ...metadata,
          ContentType: metadata.ContentType ?? "application/json",
        });
      });
      return { put } satisfies WriteObjectClient<T>;
    });
  });