sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ Cognito/ IdentityPool.ts

import * as ci from "@distilled.cloud/aws/cognito-identity";
import { Unowned } from "alchemy/AdoptPolicy";
import { createPhysicalName } from "alchemy/PhysicalName";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import { createInternalTags, diffTags, hasAlchemyTags } from "alchemy/Tags";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import { AWSEnvironment } from "../Environment.ts";
import type { Providers } from "../Providers.ts";

/** A Cognito user pool provider entry for an identity pool. */
export interface IdentityPoolCognitoProvider {
  /**
   * The user pool provider name:
   * `cognito-idp.<region>.amazonaws.com/<userPoolId>`.
   */
  providerName: string;
  /** The app client ID allowed to exchange tokens. */
  clientId: string;
  /**
   * Whether Cognito checks with the user pool that the token was not
   * globally signed out.
   * @default false
   */
  serverSideTokenCheck?: boolean;
}

export interface IdentityPoolProps {
  /**
   * Name of the identity pool. If omitted, a deterministic physical name is
   * generated from the app, stage, and logical ID. Mutable in place.
   */
  identityPoolName?: string;
  /**
   * Whether the pool vends credentials to unauthenticated (guest)
   * identities.
   * @default false
   */
  allowUnauthenticatedIdentities?: boolean;
  /**
   * Enables the legacy basic (classic) credentials flow.
   * @default false
   */
  allowClassicFlow?: boolean;
  /**
   * Social login providers keyed by their domain, e.g.
   * `{ "accounts.google.com": "<client-id>" }`.
   */
  supportedLoginProviders?: Record<string, string>;
  /**
   * Domain for developer-authenticated identities. Letters, digits, periods,
   * underscores, and dashes.
   */
  developerProviderName?: string;
  /**
   * ARNs of IAM OpenID Connect providers this pool trusts.
   */
  openIdConnectProviderArns?: string[];
  /**
   * Cognito user pools this identity pool federates.
   */
  cognitoIdentityProviders?: IdentityPoolCognitoProvider[];
  /**
   * ARNs of IAM SAML providers this pool trusts.
   */
  samlProviderArns?: string[];
  /**
   * Tags to apply to the identity pool. Merged with internal Alchemy tags.
   */
  tags?: Record<string, string>;
}

export interface IdentityPool extends Resource<
  "AWS.Cognito.IdentityPool",
  IdentityPoolProps,
  {
    /** The generated identity pool ID, e.g. `us-west-2:xxxx-...`. */
    identityPoolId: string;
    /** The ARN of the identity pool. */
    identityPoolArn: string;
    /** The name of the identity pool. */
    identityPoolName: string;
  },
  never,
  Providers
> {}

/**
 * An Amazon Cognito identity pool (federated identities) — exchanges tokens
 * from user pools, social providers, OIDC/SAML IdPs, or developer backends
 * for temporary AWS credentials.
 * ### Creating an Identity Pool
 * **Example:** Identity Pool Federating a User Pool
 * ```typescript
 * import * as Cognito from "@alchemy.run/aws/Cognito";
 * import * as Output from "alchemy/Output";
 *
 * const pool = yield* Cognito.UserPool("Users", {});
 * const client = yield* Cognito.UserPoolClient("Web", {
 *   userPoolId: pool.userPoolId,
 * });
 * const identities = yield* Cognito.IdentityPool("Identities", {
 *   cognitoIdentityProviders: [
 *     {
 *       providerName: Output.interpolate`cognito-idp.us-west-2.amazonaws.com/${pool.userPoolId}`,
 *       clientId: client.clientId,
 *     },
 *   ],
 * });
 * ```
 *
 * **Example:** Guest (Unauthenticated) Access
 * ```typescript
 * const identities = yield* Cognito.IdentityPool("Identities", {
 *   allowUnauthenticatedIdentities: true,
 * });
 * ```
 *
 * ### Roles
 * **Example:** Attach Authenticated/Unauthenticated Roles
 * ```typescript
 * yield* Cognito.IdentityPoolRoleAttachment("Roles", {
 *   identityPoolId: identities.identityPoolId,
 *   roles: { authenticated: role.roleArn },
 * });
 * ```
 *
 * @resource
 */
export const IdentityPool = Resource<IdentityPool>("AWS.Cognito.IdentityPool");

const tagRecordOf = (
  tags: { [key: string]: string | undefined } | undefined,
): Record<string, string> =>
  Object.fromEntries(
    Object.entries(tags ?? {}).filter((entry): entry is [string, string] => entry[1] !== undefined),
  );

const identityPoolArnOf = (region: string, accountId: string, id: string) =>
  `arn:aws:cognito-identity:${region}:${accountId}:identitypool/${id}`;

/** The full desired wire configuration (update resets omitted fields). */
const desiredConfig = (name: string, news: IdentityPoolProps) => ({
  IdentityPoolName: name,
  AllowUnauthenticatedIdentities: news.allowUnauthenticatedIdentities ?? false,
  AllowClassicFlow: news.allowClassicFlow,
  SupportedLoginProviders: news.supportedLoginProviders,
  DeveloperProviderName: news.developerProviderName,
  OpenIdConnectProviderARNs: news.openIdConnectProviderArns,
  CognitoIdentityProviders: news.cognitoIdentityProviders?.map((p) => ({
    ProviderName: p.providerName,
    ClientId: p.clientId,
    ServerSideTokenCheck: p.serverSideTokenCheck,
  })),
  SamlProviderARNs: news.samlProviderArns,
});

const canonical = (value: unknown) =>
  JSON.stringify(value, (_, v) =>
    v !== null && typeof v === "object" && !Array.isArray(v)
      ? Object.fromEntries(
          Object.entries(v as Record<string, unknown>)
            .filter(([, x]) => x !== undefined)
            .sort(([a], [b]) => a.localeCompare(b)),
        )
      : v,
  );

const hasDrift = (name: string, news: IdentityPoolProps, observed: ci.IdentityPool) => {
  const desired = desiredConfig(name, news);
  const observedSubset = {
    IdentityPoolName: observed.IdentityPoolName,
    AllowUnauthenticatedIdentities: observed.AllowUnauthenticatedIdentities,
    AllowClassicFlow:
      desired.AllowClassicFlow === undefined ? undefined : (observed.AllowClassicFlow ?? false),
    SupportedLoginProviders:
      desired.SupportedLoginProviders === undefined
        ? undefined
        : tagRecordOf(observed.SupportedLoginProviders),
    DeveloperProviderName:
      desired.DeveloperProviderName === undefined ? undefined : observed.DeveloperProviderName,
    OpenIdConnectProviderARNs:
      desired.OpenIdConnectProviderARNs === undefined
        ? undefined
        : (observed.OpenIdConnectProviderARNs ?? []),
    CognitoIdentityProviders:
      desired.CognitoIdentityProviders === undefined
        ? undefined
        : (observed.CognitoIdentityProviders ?? []).map((p) => ({
            ProviderName: p.ProviderName,
            ClientId: p.ClientId,
            ServerSideTokenCheck: p.ServerSideTokenCheck ?? undefined,
          })),
    SamlProviderARNs:
      desired.SamlProviderARNs === undefined ? undefined : (observed.SamlProviderARNs ?? []),
  };
  const normalizedDesired = {
    ...desired,
    CognitoIdentityProviders: desired.CognitoIdentityProviders?.map((p) => ({
      ...p,
      ServerSideTokenCheck: p.ServerSideTokenCheck ?? false,
    })),
  };
  const normalizedObserved = {
    ...observedSubset,
    CognitoIdentityProviders: observedSubset.CognitoIdentityProviders?.map((p) => ({
      ...p,
      ServerSideTokenCheck: p.ServerSideTokenCheck ?? false,
    })),
  };
  return canonical(normalizedDesired) !== canonical(normalizedObserved);
};

export const IdentityPoolProvider = () =>
  Provider.effect(
    IdentityPool,
    Effect.gen(function* () {
      const createName = Effect.fn(function* (
        id: string,
        props: Pick<IdentityPoolProps, "identityPoolName">,
      ) {
        return props.identityPoolName ?? (yield* createPhysicalName({ id, maxLength: 128 }));
      });

      const describePool = Effect.fn(function* (identityPoolId: string) {
        return yield* ci
          .describeIdentityPool({ IdentityPoolId: identityPoolId })
          .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
      });

      const findPoolsByName = Effect.fn(function* (name: string) {
        const pages = yield* ci.listIdentityPools.pages({ MaxResults: 60 }).pipe(Stream.runCollect);
        const candidates = Array.from(pages)
          .flatMap((page) => page.IdentityPools ?? [])
          .filter((pool) => pool.IdentityPoolName === name && pool.IdentityPoolId !== undefined);
        return yield* Effect.forEach(
          candidates,
          (candidate) => describePool(candidate.IdentityPoolId!),
          { concurrency: 3 },
        ).pipe(Effect.map((pools) => pools.filter((p) => p !== undefined)));
      });

      return IdentityPool.Provider.of({
        stables: ["identityPoolId", "identityPoolArn"],

        list: () =>
          Effect.gen(function* () {
            const { accountId, region } = yield* AWSEnvironment.current;
            const pages = yield* ci.listIdentityPools
              .pages({ MaxResults: 60 })
              .pipe(Stream.runCollect);
            return Array.from(pages)
              .flatMap((page) => page.IdentityPools ?? [])
              .filter((pool) => pool.IdentityPoolId !== undefined)
              .map((pool) => ({
                identityPoolId: pool.IdentityPoolId!,
                identityPoolArn: identityPoolArnOf(region, accountId, pool.IdentityPoolId!),
                identityPoolName: pool.IdentityPoolName ?? "",
              }));
          }),

        read: Effect.fn(function* ({ id, olds, output }) {
          const { accountId, region } = yield* AWSEnvironment.current;
          const attributesOf = (pool: ci.IdentityPool) => ({
            identityPoolId: pool.IdentityPoolId,
            identityPoolArn: identityPoolArnOf(region, accountId, pool.IdentityPoolId),
            identityPoolName: pool.IdentityPoolName,
          });
          if (output?.identityPoolId !== undefined) {
            const pool = yield* describePool(output.identityPoolId);
            if (pool === undefined) return undefined;
            const attrs = attributesOf(pool);
            const tags = tagRecordOf(pool.IdentityPoolTags);
            return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
          }
          const name = yield* createName(id, olds ?? {});
          const pools = yield* findPoolsByName(name);
          if (pools.length === 0) return undefined;
          for (const pool of pools) {
            if (yield* hasAlchemyTags(id, tagRecordOf(pool.IdentityPoolTags))) {
              return attributesOf(pool);
            }
          }
          return Unowned(attributesOf(pools[0]!));
        }),

        reconcile: Effect.fn(function* ({ id, news = {}, output, session }) {
          const { accountId, region } = yield* AWSEnvironment.current;
          const name = yield* createName(id, news);
          const internalTags = yield* createInternalTags(id);
          const desiredTags = { ...news.tags, ...internalTags };

          // 1. OBSERVE — the id in output is only a cache.
          let observed =
            output?.identityPoolId !== undefined
              ? yield* describePool(output.identityPoolId)
              : undefined;
          if (observed === undefined) {
            const candidates = yield* findPoolsByName(name);
            for (const candidate of candidates) {
              if (yield* hasAlchemyTags(id, tagRecordOf(candidate.IdentityPoolTags))) {
                observed = candidate;
                break;
              }
            }
          }

          // 2. ENSURE
          if (observed === undefined) {
            observed = yield* ci.createIdentityPool({
              ...desiredConfig(name, news),
              IdentityPoolTags: desiredTags,
            });
          } else if (hasDrift(name, news, observed)) {
            // 3. SYNC — UpdateIdentityPool resets omitted fields to their
            //    defaults, so send the full desired configuration.
            observed = yield* ci.updateIdentityPool({
              IdentityPoolId: observed.IdentityPoolId,
              ...desiredConfig(name, news),
            });
          }

          const identityPoolId = observed.IdentityPoolId;
          const identityPoolArn = identityPoolArnOf(region, accountId, identityPoolId);

          // 3b. SYNC TAGS against OBSERVED cloud tags.
          const observedTags = yield* ci.listTagsForResource({ ResourceArn: identityPoolArn }).pipe(
            Effect.map((r) => tagRecordOf(r.Tags)),
            Effect.catchTag("ResourceNotFoundException", () =>
              Effect.succeed({} as Record<string, string>),
            ),
          );
          const { upsert, removed } = diffTags(observedTags, desiredTags);
          if (upsert.length > 0) {
            yield* ci.tagResource({
              ResourceArn: identityPoolArn,
              Tags: Object.fromEntries(upsert.map((t) => [t.Key, t.Value])),
            });
          }
          if (removed.length > 0) {
            yield* ci.untagResource({
              ResourceArn: identityPoolArn,
              TagKeys: removed,
            });
          }

          yield* session.note(identityPoolId);
          return {
            identityPoolId,
            identityPoolArn,
            identityPoolName: name,
          };
        }),

        delete: Effect.fn(function* ({ output }) {
          yield* ci
            .deleteIdentityPool({ IdentityPoolId: output.identityPoolId })
            .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.void));
        }),
      });
    }),
  );