sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ AppIntegrations/ BindingHttp.ts

/**
 * Shared HTTP-binding scaffolding for the AppIntegrations service.
 * NOT exported from the service barrel — each `{Op}Http.ts` is a thin
 * one-call `Layer.effect(Cap, makeAppIntegrations*HttpBinding({ ... }))`.
 */
import type { Input } from "alchemy/Input";
import type { Output } from "alchemy/Output";
import * as Effect from "effect/Effect";
import * as AWSBindings from "../AWSBindings.ts";
import { AWSEnvironment } from "../Environment.ts";

/** Deploy-time environment handed to the `resources` IAM builder. */
export interface AppIntegrationsIamEnv {
  region: string;
  accountId: string;
}

/**
 * Build the implementation effect for a resource-scoped AppIntegrations HTTP
 * binding: resolve the resource identifier at init, grant the IAM actions on
 * the host at deploy time, and inject the identifier into every request at
 * runtime under `requestKey`.
 */
export const makeAppIntegrationsHttpBinding = <
  Res extends { LogicalId: string },
  IdKey extends string,
  WireReq extends { [K in IdKey]?: unknown },
  Out,
  Err,
  OpR,
>(options: {
  /** Capability name used in the bind sid and runtime span. */
  name: string;
  /** The distilled AppIntegrations operation backing the binding. */
  operation: Effect.Effect<(input: WireReq) => Effect.Effect<Out, Err>, never, OpR>;
  /** Wire key the resolved resource identifier is injected under. */
  requestKey: IdKey;
  /** The resource attribute used as the wire identifier. */
  identifier: (resource: Res) => Output<string, never>;
  /** IAM actions granted on the host at deploy time. */
  iamActions: string[];
  /** IAM resources the actions are granted on. */
  resources: (resource: Res, env: AppIntegrationsIamEnv) => Input<string>[];
  /**
   * Dependent actions the AppIntegrations service invokes on the caller's
   * behalf (e.g. `appflow:CreateFlow` for data-integration associations).
   * Granted on `*` in a second statement — these AWS-managed side resources
   * have no stable ARN at deploy time.
   */
  dependentActions?: string[];
}) =>
  Effect.gen(function* () {
    const bind = yield* AWSBindings.Bind;
    const op = yield* AWSBindings.withCredentials(options.operation);

    return Effect.fn(function* (resource: Res) {
      const Identifier = yield* options.identifier(resource);
      if (!globalThis.__ALCHEMY_RUNTIME__) {
        const { accountId, region } = yield* AWSEnvironment.current as unknown as Effect.Effect<{
          accountId: string;
          region: string;
        }>;
        yield* bind`AWS.AppIntegrations.${options.name}(${resource})`({
          policyStatements: [
            {
              Effect: "Allow",
              Action: options.iamActions,
              Resource: options.resources(resource, { region, accountId }),
            },
            ...(options.dependentActions?.length
              ? [
                  {
                    Effect: "Allow" as const,
                    Action: options.dependentActions,
                    Resource: ["*"],
                  },
                ]
              : []),
          ],
        });
      }
      return Effect.fn(`AWS.AppIntegrations.${options.name}(${resource.LogicalId})`)(function* (
        request?: Omit<WireReq, IdKey>,
      ) {
        // The identifier key is re-added on top of the caller's request, so
        // the widened spread is exactly a WireReq.
        return yield* op({
          ...request,
          [options.requestKey]: yield* Identifier,
        } as unknown as WireReq);
      });
    });
  });

/**
 * Build the implementation effect for an account-scoped AppIntegrations HTTP
 * binding (no resource argument): grant the IAM actions on `*` at deploy time
 * and forward requests to the operation at runtime.
 */
export const makeAppIntegrationsAccountHttpBinding = <WireReq, Out, Err, OpR>(options: {
  /** Capability name used in the bind sid and runtime span. */
  name: string;
  /** The distilled AppIntegrations operation backing the binding. */
  operation: Effect.Effect<(input: WireReq) => Effect.Effect<Out, Err>, never, OpR>;
  /** IAM actions granted on the host at deploy time. */
  iamActions: string[];
}) =>
  Effect.gen(function* () {
    const bind = yield* AWSBindings.Bind;
    const op = yield* AWSBindings.withCredentials(options.operation);

    return Effect.fn(function* () {
      if (!globalThis.__ALCHEMY_RUNTIME__) {
        yield* bind`AWS.AppIntegrations.${options.name}()`({
          policyStatements: [
            {
              Effect: "Allow",
              Action: options.iamActions,
              Resource: ["*"],
            },
          ],
        });
      }
      return Effect.fn(`AWS.AppIntegrations.${options.name}`)(function* (request?: WireReq) {
        // List requests are all-optional structs; an absent request is the
        // empty request.
        return yield* op((request ?? {}) as WireReq);
      });
    });
  });