sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ AppRegistry/ AttributeGroupAssociation.ts

import * as appregistry from "@distilled.cloud/aws/service-catalog-appregistry";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import { AWSEnvironment } from "../Environment.ts";
import type { Providers } from "../Providers.ts";

export interface AttributeGroupAssociationProps {
  /**
   * The application to associate the attribute group with: its ID, name, or
   * ARN. Changing it replaces the association.
   */
  application: string;
  /**
   * The attribute group to associate: its ID, name, or ARN. Changing it
   * replaces the association.
   */
  attributeGroup: string;
}

export interface AttributeGroupAssociation extends Resource<
  "AWS.AppRegistry.AttributeGroupAssociation",
  AttributeGroupAssociationProps,
  {
    /** The ID of the associated application. */
    applicationId: string;
    /** The ARN of the associated application. */
    applicationArn: string;
    /** The ID of the associated attribute group. */
    attributeGroupId: string;
    /** The ARN of the associated attribute group. */
    attributeGroupArn: string;
  },
  never,
  Providers
> {}

/**
 * Associates an AppRegistry {@link AttributeGroup} with an
 * {@link Application} so the group's user-defined JSON metadata augments the
 * application's machine-readable description.
 *
 * ### Associating an Attribute Group
 * **Example:** Attach an Attribute Group to an Application
 * ```typescript
 * import * as AppRegistry from "@alchemy.run/aws/AppRegistry";
 *
 * const app = yield* AppRegistry.Application("Storefront", {});
 * const group = yield* AppRegistry.AttributeGroup("Ownership", {
 *   attributes: { owner: "commerce-team" },
 * });
 *
 * const association = yield* AppRegistry.AttributeGroupAssociation("Assoc", {
 *   application: app.applicationId,
 *   attributeGroup: group.attributeGroupId,
 * });
 * ```
 *
 * @resource
 */
export const AttributeGroupAssociation = Resource<AttributeGroupAssociation>(
  "AWS.AppRegistry.AttributeGroupAssociation",
);

export const AttributeGroupAssociationProvider = () =>
  Provider.effect(
    AttributeGroupAssociation,
    Effect.gen(function* () {
      // getApplication / getAttributeGroup both accept a name, ID, or ARN.
      const observeApplication = Effect.fn(function* (specifier: string) {
        return yield* appregistry
          .getApplication({ application: specifier })
          .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
      });
      const observeAttributeGroup = Effect.fn(function* (specifier: string) {
        return yield* appregistry
          .getAttributeGroup({ attributeGroup: specifier })
          .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
      });

      const isAssociated = Effect.fn(function* (applicationId: string, attributeGroupId: string) {
        const groupIds = yield* appregistry.listAssociatedAttributeGroups
          .pages({ application: applicationId })
          .pipe(
            Stream.runCollect,
            Effect.map((chunk) => Array.from(chunk).flatMap((page) => page.attributeGroups ?? [])),
          );
        return groupIds.includes(attributeGroupId);
      });

      return AttributeGroupAssociation.Provider.of({
        stables: ["applicationId", "applicationArn", "attributeGroupId", "attributeGroupArn"],
        // The application/attribute-group pair IS the association's identity —
        // changing either side replaces the association.
        diff: Effect.fn(function* ({ olds, news }) {
          if (!isResolved(news)) return undefined;
          if (
            olds !== undefined &&
            (olds.application !== news.application || olds.attributeGroup !== news.attributeGroup)
          ) {
            return { action: "replace" } as const;
          }
        }),
        read: Effect.fn(function* ({ olds, output }) {
          const applicationSpecifier = output?.applicationId ?? olds?.application;
          const attributeGroupSpecifier = output?.attributeGroupId ?? olds?.attributeGroup;
          if (applicationSpecifier === undefined || attributeGroupSpecifier === undefined) {
            return undefined;
          }
          const application = yield* observeApplication(applicationSpecifier);
          if (application?.id === undefined) return undefined;
          const attributeGroup = yield* observeAttributeGroup(attributeGroupSpecifier);
          if (attributeGroup?.id === undefined) return undefined;
          if (!(yield* isAssociated(application.id, attributeGroup.id))) {
            return undefined;
          }
          // Associations cannot carry tags; existence between our two parents
          // is the ownership signal.
          return {
            applicationId: application.id,
            applicationArn: application.arn!,
            attributeGroupId: attributeGroup.id,
            attributeGroupArn: attributeGroup.arn!,
          };
        }),
        reconcile: Effect.fn(function* ({ news, session }) {
          // 1. OBSERVE — resolve both sides to canonical IDs; a missing parent
          // surfaces its typed ResourceNotFoundException.
          const application = yield* appregistry.getApplication({
            application: news.application,
          });
          const attributeGroup = yield* appregistry.getAttributeGroup({
            attributeGroup: news.attributeGroup,
          });
          const applicationId = application.id!;
          const attributeGroupId = attributeGroup.id!;

          // 2. ENSURE — associate when missing; a ConflictException is a
          // concurrent-associate race, not a failure.
          if (!(yield* isAssociated(applicationId, attributeGroupId))) {
            yield* appregistry
              .associateAttributeGroup({
                application: applicationId,
                attributeGroup: attributeGroupId,
              })
              .pipe(Effect.catchTag("ConflictException", () => Effect.void));
          }

          yield* session.note(`${applicationId}/${attributeGroupId}`);
          return {
            applicationId,
            applicationArn: application.arn!,
            attributeGroupId,
            attributeGroupArn: attributeGroup.arn!,
          };
        }),
        delete: Effect.fn(function* ({ output }) {
          yield* appregistry
            .disassociateAttributeGroup({
              application: output.applicationId,
              attributeGroup: output.attributeGroupId,
            })
            .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.void));
        }),
        list: () =>
          Effect.gen(function* () {
            const { accountId, region } = yield* AWSEnvironment.current;
            const applications = yield* appregistry.listApplications.pages({}).pipe(
              Stream.runCollect,
              Effect.map((chunk) => Array.from(chunk).flatMap((page) => page.applications ?? [])),
            );
            const results: {
              applicationId: string;
              applicationArn: string;
              attributeGroupId: string;
              attributeGroupArn: string;
            }[] = [];
            for (const application of applications) {
              if (application.id === undefined) continue;
              const groupIds = yield* appregistry.listAssociatedAttributeGroups
                .pages({ application: application.id })
                .pipe(
                  Stream.runCollect,
                  Effect.map((chunk) =>
                    Array.from(chunk).flatMap((page) => page.attributeGroups ?? []),
                  ),
                );
              for (const attributeGroupId of groupIds) {
                results.push({
                  applicationId: application.id,
                  applicationArn: application.arn!,
                  attributeGroupId,
                  attributeGroupArn: `arn:aws:servicecatalog:${region}:${accountId}:/attribute-groups/${attributeGroupId}`,
                });
              }
            }
            return results;
          }),
      });
    }),
  );