sailfork / t3code-github / .repos/ alchemy-effect/ packages/ gcp/ src/ CloudIdentity/ GroupsMembership.ts

import * as cloudidentity from "@distilled.cloud/gcp/cloudidentity_v1";
import { Unowned } from "alchemy/AdoptPolicy";
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 {
  expandGroup,
  getMembership,
  getMembershipByKey,
  lastSegment,
  listMemberships,
  listOwnedGroups,
  replaceOnIdentity,
  sameJson,
  sameText,
} from "./internal.ts";
import { resourceNameFromOperation, waitForOperation, waitUntilPresent } from "./operations.ts";

export type GroupsMembershipRole = {
  /** Role name: `OWNER`, `MANAGER`, or `MEMBER`. */
  name?: string;
  /** Expiry, only valid when `name` is `MEMBER`. */
  expiryDetail?: {
    expireTime?: string;
  };
};

export type GroupsMembershipProps = {
  /**
   * Parent group resource name (`groups/{group}`) or group id.
   * Immutable — changing it replaces the membership.
   */
  parent: string;
  /**
   * Member entity key id (user or group email). Immutable —
   * changing it replaces the membership.
   */
  memberKeyId: string;
  /**
   * Member entity-key namespace for external identities.
   */
  memberKeyNamespace?: string;
  /**
   * Roles for the membership. Defaults to a single `MEMBER` role.
   * `MEMBER` cannot be removed; drop `MANAGER` / `OWNER` in place.
   */
  roles?: GroupsMembershipRole[];
};

export type GroupsMembership = Resource<
  "GCP.CloudIdentity.GroupsMembership",
  GroupsMembershipProps,
  {
    /** Resource name `groups/{group}/memberships/{membership}`. */
    name: string;
    /** Membership id (last path segment). */
    membershipId: string;
    /** Parent group name. */
    parent: string;
    /** Member entity key id. */
    memberKeyId: string;
    /** Member entity-key namespace, if any. */
    memberKeyNamespace: string | undefined;
    /** Membership roles. */
    roles: GroupsMembershipRole[];
    /** Member type (`USER`, `GROUP`, …). */
    type: string | undefined;
    /** Delivery setting. */
    deliverySetting: string | undefined;
    /** RFC3339 creation timestamp. */
    createTime: string | undefined;
    /** RFC3339 last-update timestamp. */
    updateTime: string | undefined;
  },
  never,
  Providers
>;

/**
 * A Cloud Identity group membership.
 *
 * Memberships have no labels or description, so Alchemy lists
 * memberships of alchemy-owned groups (ownership stamped on the parent
 * group description) for `list` / nuke. Parent group and member key
 * are identity; roles update in place via `modifyMembershipRoles`.
 *
 * ### Creating a Membership
 * **Example:** Add a member
 * ```typescript
 * const membership = yield* GCP.CloudIdentity.GroupsMembership("Ada", {
 *   parent: group.name,
 *   memberKeyId: "ada@example.com",
 * });
 * ```
 *
 * **Example:** Manager role
 * ```typescript
 * const membership = yield* GCP.CloudIdentity.GroupsMembership("Ada", {
 *   parent: group.name,
 *   memberKeyId: "ada@example.com",
 *   roles: [{ name: "MEMBER" }, { name: "MANAGER" }],
 * });
 * ```
 *
 * @resource
 * @category CloudIdentity
 */
export const GroupsMembership = Resource<GroupsMembership>("GCP.CloudIdentity.GroupsMembership");

export class GroupsMembershipNotResolved extends Data.TaggedError(
  "GCP.CloudIdentity.GroupsMembershipNotResolved",
)<{
  parent: string;
  memberKeyId: string;
}> {}

const DEFAULT_ROLES: GroupsMembershipRole[] = [{ name: "MEMBER" }];

const rolesOf = (roles: cloudidentity.MembershipRoleList | undefined): GroupsMembershipRole[] =>
  (roles ?? DEFAULT_ROLES).map((role) => ({
    name: role.name,
    expiryDetail: role.expiryDetail ? { expireTime: role.expiryDetail.expireTime } : undefined,
  }));

const desiredRoles = (roles: GroupsMembershipRole[] | undefined) => {
  const next = roles !== undefined && roles.length > 0 ? roles : DEFAULT_ROLES;
  return next.map((role) => ({
    name: role.name ?? "MEMBER",
    expiryDetail: role.expiryDetail,
  }));
};

const roleNames = (roles: GroupsMembershipRole[]) =>
  [...roles].map((role) => role.name ?? "MEMBER").sort((left, right) => left.localeCompare(right));

const parentOfName = (name: string) => {
  const parts = name.split("/").filter((part) => part.length > 0);
  const index = parts.lastIndexOf("memberships");
  return index > 0 ? parts.slice(0, index).join("/") : expandGroup(name);
};

const toAttrs = (membership: cloudidentity.Membership, parent: string) => {
  const name = membership.name ?? "";
  return {
    name,
    membershipId: lastSegment(name),
    parent: parentOfName(name) || parent,
    memberKeyId: membership.preferredMemberKey?.id ?? "",
    memberKeyNamespace: membership.preferredMemberKey?.namespace,
    roles: rolesOf(membership.roles),
    type: membership.type,
    deliverySetting: membership.deliverySetting,
    createTime: membership.createTime,
    updateTime: membership.updateTime,
  };
};

const observeMembership = (input: {
  name?: string;
  parent: string;
  memberKeyId: string;
  memberKeyNamespace?: string;
}) =>
  Effect.gen(function* () {
    const byName = yield* getMembership(input.name ?? "");
    if (byName !== undefined) return byName;
    return yield* getMembershipByKey(input.parent, input.memberKeyId, input.memberKeyNamespace);
  });

const syncRoles = (
  name: string,
  current: cloudidentity.Membership,
  desired: GroupsMembershipRole[],
) =>
  Effect.gen(function* () {
    const observed = rolesOf(current.roles);
    if (sameJson(observed, desired)) return current;

    const currentNames = new Set(roleNames(observed));
    const desiredNames = new Set(roleNames(desired));
    const addRoles = desired.filter((role) => !currentNames.has(role.name ?? "MEMBER"));
    const removeRoles = roleNames(observed).filter(
      (role) => role !== "MEMBER" && !desiredNames.has(role),
    );

    let next = current;
    if (addRoles.length > 0 || removeRoles.length > 0) {
      const modified = yield* cloudidentity.modifyMembershipRolesGroupsMemberships({
        name,
        body: {
          addRoles: addRoles.length > 0 ? addRoles : undefined,
          removeRoles: removeRoles.length > 0 ? removeRoles : undefined,
        },
      });
      next = modified.membership ?? next;
    }

    const memberExpiry = desired.find((role) => role.name === "MEMBER")?.expiryDetail?.expireTime;
    const observedExpiry = rolesOf(next.roles).find((role) => role.name === "MEMBER")?.expiryDetail
      ?.expireTime;
    if (!sameText(memberExpiry, observedExpiry) && memberExpiry !== undefined) {
      const modified = yield* cloudidentity.modifyMembershipRolesGroupsMemberships({
        name,
        body: {
          updateRolesParams: [
            {
              fieldMask: "expiry_detail.expire_time",
              membershipRole: {
                name: "MEMBER",
                expiryDetail: { expireTime: memberExpiry },
              },
            },
          ],
        },
      });
      next = modified.membership ?? next;
    }

    return next;
  });

export const GroupsMembershipProvider = () =>
  Provider.succeed(GroupsMembership, {
    stables: ["name", "membershipId", "parent", "memberKeyId", "createTime"],

    diff: Effect.fn(function* ({ news, olds, output }) {
      if (!isResolved(news)) return undefined;
      return replaceOnIdentity({
        previousId: olds?.memberKeyId ?? output?.memberKeyId,
        nextId: news.memberKeyId,
        previousParent: olds?.parent ?? output?.parent,
        nextParent: expandGroup(news.parent),
        extra:
          news.memberKeyNamespace !== undefined &&
          output?.memberKeyNamespace !== undefined &&
          news.memberKeyNamespace !== output.memberKeyNamespace,
      });
    }),

    read: Effect.fn(function* ({ olds, output }) {
      const parent = expandGroup(olds?.parent ?? output?.parent ?? "");
      const memberKeyId = olds?.memberKeyId ?? output?.memberKeyId ?? "";
      const existing = yield* observeMembership({
        name: output?.name,
        parent,
        memberKeyId,
        memberKeyNamespace: olds?.memberKeyNamespace ?? output?.memberKeyNamespace,
      });
      if (existing === undefined) return undefined;
      const attrs = toAttrs(existing, parent);
      return output !== undefined ? attrs : Unowned(attrs);
    }),

    list: () =>
      Effect.gen(function* () {
        const groups = yield* listOwnedGroups();
        const pages = yield* Effect.forEach(
          groups,
          (group) =>
            group.name
              ? listMemberships(group.name).pipe(
                  Effect.map((memberships) =>
                    memberships.map((membership) => toAttrs(membership, group.name ?? "")),
                  ),
                )
              : Effect.succeed([]),
          { concurrency: 4 },
        );
        return pages.flat();
      }),

    reconcile: Effect.fn(function* ({ news, output }) {
      const parent = expandGroup(news.parent);
      const memberKeyId = news.memberKeyId;
      const memberKeyNamespace = news.memberKeyNamespace;
      const roles = desiredRoles(news.roles);

      let current = yield* observeMembership({
        name: output?.name,
        parent,
        memberKeyId,
        memberKeyNamespace,
      });

      if (current === undefined) {
        const created = yield* cloudidentity
          .createGroupsMemberships({
            parent,
            body: {
              preferredMemberKey: {
                id: memberKeyId,
                namespace: memberKeyNamespace,
              },
              roles,
            },
          })
          .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
        if (created !== undefined) {
          yield* waitForOperation(created).pipe(
            Effect.catchTag("GCP.CloudIdentity.OperationPending", () => Effect.void),
          );
          const createdName = resourceNameFromOperation(created);
          if (createdName !== undefined) {
            current = yield* getMembership(createdName);
          }
        }
        if (current === undefined) {
          current = yield* waitUntilPresent(
            observeMembership({
              name: output?.name,
              parent,
              memberKeyId,
              memberKeyNamespace,
            }),
            memberKeyId,
          ).pipe(
            Effect.catchTag("GCP.CloudIdentity.OperationPending", () =>
              observeMembership({
                parent,
                memberKeyId,
                memberKeyNamespace,
              }),
            ),
          );
        }
      }

      if (current === undefined) {
        return yield* new GroupsMembershipNotResolved({
          parent,
          memberKeyId,
        });
      }

      const name = current.name ?? output?.name ?? "";
      if (name.length > 0) {
        current = yield* syncRoles(name, current, roles);
      }

      return toAttrs(current, parent);
    }),

    delete: Effect.fn(function* ({ output }) {
      if (output.name.length === 0) return;
      const deleted = yield* cloudidentity
        .deleteGroupsMemberships({ name: output.name })
        .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
      if (deleted !== undefined) {
        yield* waitForOperation(deleted, { notFoundOk: true });
      }
    }),
  });