sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ Organizations/ DelegatedAdministrator.ts

import * as organizations from "@distilled.cloud/aws/organizations";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import type { Providers } from "../Providers.ts";
import { collectPages, retryOrganizations, unredact } from "./common.ts";

export class DelegatedAdministratorUnexpectedResponse extends Data.TaggedError(
  "DelegatedAdministratorUnexpectedResponse",
)<{
  readonly message: string;
  readonly cause?: unknown;
}> {}

export interface DelegatedAdministratorProps {
  /**
   * Member account registered as delegated administrator.
   */
  accountId: string;
  /**
   * Service principal delegated to the account.
   */
  servicePrincipal: string;
}

export interface DelegatedAdministrator extends Resource<
  "AWS.Organizations.DelegatedAdministrator",
  DelegatedAdministratorProps,
  {
    /**
     * 12-digit ID of the delegated administrator account.
     */
    accountId: string;
    /**
     * ARN of the delegated administrator account.
     */
    accountArn: string | undefined;
    /**
     * Friendly name of the delegated administrator account.
     */
    accountName: string | undefined;
    /**
     * Email address of the delegated administrator account.
     */
    accountEmail: string | undefined;
    /**
     * Service principal delegated to the account.
     */
    servicePrincipal: string;
    /**
     * When the delegation was enabled.
     */
    delegationEnabledDate: Date | undefined;
  },
  never,
  Providers
> {}

/**
 * Registers a member {@link Account} as the delegated administrator for a
 * trusted AWS service, letting that account manage the service org-wide
 * instead of the management account.
 *
 * Requires trusted access for the same service principal (see
 * {@link TrustedServiceAccess}). Existence-only resource: changing
 * `accountId` or `servicePrincipal` replaces the registration.
 * ### Delegating Administration
 * **Example:** Delegate GuardDuty to a Security Account
 * ```typescript
 * const security = yield* Account("Security", {
 *   name: "security",
 *   email: "aws-security@example.com",
 *   parentId: root.rootId,
 * });
 *
 * const guardDutyAccess = yield* TrustedServiceAccess("GuardDutyAccess", {
 *   servicePrincipal: "guardduty.amazonaws.com",
 * });
 *
 * yield* DelegatedAdministrator("GuardDutyAdmin", {
 *   accountId: security.accountId,
 *   servicePrincipal: guardDutyAccess.servicePrincipal,
 * });
 * ```
 *
 * @resource
 */
export const DelegatedAdministrator = Resource<DelegatedAdministrator>(
  "AWS.Organizations.DelegatedAdministrator",
);

export const DelegatedAdministratorProvider = () =>
  Provider.effect(
    DelegatedAdministrator,
    Effect.gen(function* () {
      return {
        stables: ["accountId", "servicePrincipal"],
        diff: Effect.fn(function* ({ olds, news }) {
          if (!isResolved(news)) return;
          if (
            olds?.accountId !== news.accountId ||
            olds?.servicePrincipal !== news.servicePrincipal
          ) {
            return { action: "replace" } as const;
          }
        }),
        read: Effect.fn(function* ({ olds, output }) {
          const accountId = output?.accountId ?? olds?.accountId;
          const servicePrincipal = output?.servicePrincipal ?? olds?.servicePrincipal;
          if (accountId === undefined || servicePrincipal === undefined) {
            // Output-valued props don't survive a `creating`-state round-trip
            // (they deserialize as `undefined`) — report "not found" so the
            // engine re-drives the create.
            return undefined;
          }
          return yield* readDelegatedAdministrator({
            accountId,
            servicePrincipal,
          });
        }),
        list: () =>
          Effect.gen(function* () {
            // Enumerate every delegated administrator account in the org. If
            // this account isn't an org management account (or lacks access),
            // Organizations enumeration isn't available here — return [].
            const admins = yield* retryOrganizations(
              collectPages(
                (NextToken) => organizations.listDelegatedAdministrators({ NextToken }),
                (page) => page.DelegatedAdministrators,
              ),
            ).pipe(
              Effect.catchTags({
                AWSOrganizationsNotInUseException: () =>
                  Effect.succeed<organizations.DelegatedAdministrator[]>([]),
                AccessDeniedException: () =>
                  Effect.succeed<organizations.DelegatedAdministrator[]>([]),
                UnsupportedAPIEndpointException: () =>
                  Effect.succeed<organizations.DelegatedAdministrator[]>([]),
              }),
            );

            // Fan out: each admin account may be delegated for multiple
            // services. The canonical `read` shape is one item per
            // (account, servicePrincipal), so expand each account into one
            // Attributes per delegated service.
            const rows = yield* Effect.forEach(
              admins.filter(
                (
                  admin,
                ): admin is organizations.DelegatedAdministrator & {
                  Id: string;
                } => admin.Id != null,
              ),
              (admin) =>
                retryOrganizations(
                  collectPages(
                    (NextToken) =>
                      organizations.listDelegatedServicesForAccount({
                        AccountId: admin.Id,
                        NextToken,
                      }),
                    (page) => page.DelegatedServices,
                  ),
                ).pipe(
                  // The account may be deregistered between the two calls — skip.
                  Effect.catchTags({
                    AccountNotFoundException: () =>
                      Effect.succeed<organizations.DelegatedService[]>([]),
                    AccountNotRegisteredException: () =>
                      Effect.succeed<organizations.DelegatedService[]>([]),
                  }),
                  Effect.map((services) =>
                    services
                      .filter(
                        (
                          service,
                        ): service is organizations.DelegatedService & {
                          ServicePrincipal: string;
                        } => service.ServicePrincipal != null,
                      )
                      .map(
                        (service) =>
                          ({
                            accountId: admin.Id,
                            accountArn: admin.Arn,
                            accountName: unredact(admin.Name),
                            accountEmail: unredact(admin.Email),
                            servicePrincipal: service.ServicePrincipal,
                            delegationEnabledDate:
                              service.DelegationEnabledDate ?? admin.DelegationEnabledDate,
                          }) satisfies DelegatedAdministrator["Attributes"],
                      ),
                  ),
                ),
              { concurrency: 10 },
            );

            return rows.flat();
          }),
        reconcile: Effect.fn(function* ({ news, session }) {
          // Observe — look up the live delegation. Replacement-only props
          // (`accountId`, `servicePrincipal`) mean the diff handles identity
          // changes; we just check whether the registration exists.
          let state = yield* readDelegatedAdministrator(news);

          // Ensure — register if missing. Tolerate
          // `AccountAlreadyRegisteredException` for idempotency under races
          // between observe and register.
          if (!state) {
            yield* retryOrganizations(
              organizations
                .registerDelegatedAdministrator({
                  AccountId: news.accountId,
                  ServicePrincipal: news.servicePrincipal,
                })
                .pipe(Effect.catchTag("AccountAlreadyRegisteredException", () => Effect.void)),
            );
            state = yield* readDelegatedAdministrator(news);
            if (!state) {
              return yield* new DelegatedAdministratorUnexpectedResponse({
                message: `delegated administrator '${news.accountId}' for '${news.servicePrincipal}' not found after create`,
              });
            }
          }

          yield* session.note(`${state.accountId}:${state.servicePrincipal}`);
          return state;
        }),
        delete: Effect.fn(function* ({ output }) {
          if (
            !(yield* readDelegatedAdministrator({
              accountId: output.accountId,
              servicePrincipal: output.servicePrincipal,
            }))
          ) {
            return;
          }

          yield* retryOrganizations(
            organizations.deregisterDelegatedAdministrator({
              AccountId: output.accountId,
              ServicePrincipal: output.servicePrincipal,
            }),
          );
        }),
      };
    }),
  );

const readDelegatedAdministrator = Effect.fn(function* ({
  accountId,
  servicePrincipal,
}: DelegatedAdministratorProps) {
  const [delegatedServices, delegatedAdmins] = yield* Effect.all([
    retryOrganizations(
      collectPages(
        (NextToken) =>
          organizations.listDelegatedServicesForAccount({
            AccountId: accountId,
            NextToken,
          }),
        (page) => page.DelegatedServices,
      ),
    ).pipe(
      Effect.catchTag(["AccountNotFoundException", "AccountNotRegisteredException"], () =>
        Effect.succeed<organizations.DelegatedService[]>([]),
      ),
    ),
    retryOrganizations(
      collectPages(
        (NextToken) =>
          organizations.listDelegatedAdministrators({
            ServicePrincipal: servicePrincipal,
            NextToken,
          }),
        (page) => page.DelegatedAdministrators,
      ),
    ),
  ]);

  const service = delegatedServices.find(
    (candidate) => candidate.ServicePrincipal === servicePrincipal,
  );
  const account = delegatedAdmins.find((candidate) => candidate.Id === accountId);

  return service && account
    ? ({
        accountId,
        accountArn: account.Arn,
        accountName: unredact(account.Name),
        accountEmail: unredact(account.Email),
        servicePrincipal,
        delegationEnabledDate: service.DelegationEnabledDate ?? account.DelegationEnabledDate,
      } satisfies DelegatedAdministrator["Attributes"])
    : undefined;
});