sailfork / t3code-github / .repos/ alchemy-effect/ packages/ gcp/ src/ Apigee/ EnvironmentsApisRevisionsDebugsession.ts

import * as apigee from "@distilled.cloud/gcp/apigee_v1";
import { unownedUnlessPrevious } 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 * as Stream from "effect/Stream";
import { GcpEnvironment } from "../Environment.ts";
import type { Providers } from "../Providers.ts";
import {
  emptyOnMissing,
  environmentIdOf,
  environmentNameOf,
  lastSegment,
  listProjectEnvironments,
  missingToUndefined,
  organizationIdOf,
  organizationNameOf,
  sameText,
  segmentAfter,
  toResourceId,
} from "./common.ts";

export type EnvironmentsApisRevisionsDebugsessionProps = {
  /**
   * Apigee organization id or `organizations/{org}`. Defaults to the
   * current GCP project id. Immutable — changing it replaces the session.
   */
  organization?: string;
  /**
   * Environment id or `organizations/{org}/environments/{env}`. Immutable —
   * changing it replaces the session.
   */
  environment: string;
  /**
   * API proxy id. Immutable — changing it replaces the session.
   */
  api: string;
  /**
   * Deployed revision id. Immutable — changing it replaces the session.
   */
  revision: string;
  /**
   * Debug session id. If omitted, a unique name is generated. Sessions
   * have no labels; Alchemy uses this id as the ownership marker for
   * `list` / nuke. Immutable — changing it replaces the session.
   */
  debugsessionId?: string;
  /**
   * Seconds after which the session ends. Overrides `timeout` query
   * when both are set.
   */
  timeout?: string;
  /**
   * Condition evaluated against the request to decide whether to trace
   * it. Syntax matches an API proxy flow Condition.
   */
  filter?: string;
  /**
   * Seconds the session stays valid in the control plane. Min 1, max 15,
   * default 10.
   */
  validity?: number;
  /**
   * Number of requests to trace. Min 1, max 15, default 10.
   */
  count?: number;
  /**
   * Maximum bytes captured from the response payload. Min 0, max 5120,
   * default 5120.
   */
  tracesize?: number;
};

export type EnvironmentsApisRevisionsDebugsession = Resource<
  "GCP.Apigee.EnvironmentsApisRevisionsDebugsession",
  EnvironmentsApisRevisionsDebugsessionProps,
  {
    /** Full resource name `…/apis/{api}/revisions/{revision}/debugsessions/{id}`. */
    name: string;
    /** Debug session id. */
    debugsessionId: string;
    /** Apigee organization id. */
    organizationId: string;
    /** Environment id. */
    environmentId: string;
    /** API proxy id. */
    api: string;
    /** Revision id. */
    revision: string;
    /** Timeout seconds, if set. */
    timeout: string | undefined;
    /** Trace filter, if set. */
    filter: string | undefined;
    /** Validity seconds. */
    validity: number | undefined;
    /** Request count. */
    count: number | undefined;
    /** Trace size bytes. */
    tracesize: number | undefined;
    /** First transaction creation timestamp. */
    createTime: string | undefined;
  },
  never,
  Providers
>;

/**
 * An Apigee debug session for a deployed API proxy revision.
 *
 * Sessions are short-lived (max 15s validity) and have no labels.
 * Alchemy generates a stable session id from the stack so `list` can
 * match it. Delete clears captured data (`debugsessions.deleteData`);
 * it does not cancel an already-running session.
 *
 * ### Creating a Debug Session
 * **Example:** Trace ten requests
 * ```typescript
 * const session = yield* GCP.Apigee.EnvironmentsApisRevisionsDebugsession("Trace", {
 *   environment: "eval",
 *   api: "hello",
 *   revision: "1",
 *   count: 10,
 * });
 * ```
 *
 * @resource
 * @category Apigee
 */
export const EnvironmentsApisRevisionsDebugsession =
  Resource<EnvironmentsApisRevisionsDebugsession>(
    "GCP.Apigee.EnvironmentsApisRevisionsDebugsession",
  );

export class EnvironmentsApisRevisionsDebugsessionNotResolved extends Data.TaggedError(
  "GCP.Apigee.EnvironmentsApisRevisionsDebugsessionNotResolved",
)<{
  resourceName: string;
}> {}

const revisionParent = (
  organizationId: string,
  environmentId: string,
  api: string,
  revision: string,
) => `${environmentNameOf(organizationId, environmentId)}/apis/${api}/revisions/${revision}`;

const sessionName = (parent: string, debugsessionId: string) =>
  `${parent}/debugsessions/${debugsessionId}`;

const parseSessionName = (name: string) => ({
  organizationId: segmentAfter(name, "organizations") ?? "",
  environmentId: segmentAfter(name, "environments") ?? "",
  api: segmentAfter(name, "apis") ?? "",
  revision: segmentAfter(name, "revisions") ?? "",
  debugsessionId: segmentAfter(name, "debugsessions") ?? lastSegment(name),
});

const toAttrs = (
  session: apigee.GoogleCloudApigeeV1DebugSession,
  organizationId: string,
  environmentId: string,
  api: string,
  revision: string,
) => {
  const raw = session.name ?? "";
  const parsed = parseSessionName(raw.includes("/") ? raw : "");
  const debugsessionId = parsed.debugsessionId || lastSegment(raw) || raw;
  const parent = revisionParent(
    parsed.organizationId || organizationId,
    parsed.environmentId || environmentId,
    parsed.api || api,
    parsed.revision || revision,
  );
  return {
    name: raw.includes("/") ? raw : sessionName(parent, debugsessionId),
    debugsessionId,
    organizationId: parsed.organizationId || organizationId,
    environmentId: parsed.environmentId || environmentId,
    api: parsed.api || api,
    revision: parsed.revision || revision,
    timeout: session.timeout,
    filter: session.filter,
    validity: session.validity,
    count: session.count,
    tracesize: session.tracesize,
    createTime: session.createTime,
  };
};

const getByName = (name: string) =>
  name.length === 0
    ? Effect.undefined
    : missingToUndefined(
        apigee.getOrganizationsEnvironmentsApisRevisionsDebugsessions({
          name,
        }),
      );

const listOrgApis = (organizationId: string) =>
  emptyOnMissing(
    apigee.listOrganizationsApis({
      parent: organizationNameOf(organizationId),
      includeMetaData: false,
    }),
    { proxies: [] as apigee.GoogleCloudApigeeV1ApiProxyList },
  ).pipe(Effect.map((page) => page.proxies ?? []));

const listApiSessions = (apiName: string) =>
  apigee.listOrganizationsApisDebugsessions.pages({ parent: apiName, pageSize: 100 }).pipe(
    Stream.flatMap((page) => Stream.fromIterable(page.sessions ?? [])),
    Stream.runCollect,
    Effect.map((chunk) => Array.from(chunk)),
    Effect.catchTag(["NotFound", "ApigeeResourceNotFound"], () =>
      Effect.succeed([] as apigee.GoogleCloudApigeeV1ApiDebugSession[]),
    ),
  );

const isAlchemySessionId = (id: string | undefined) =>
  (id ?? "").startsWith("alch-") || (id ?? "").includes("alchemy");

export const EnvironmentsApisRevisionsDebugsessionProvider = () =>
  Provider.succeed(EnvironmentsApisRevisionsDebugsession, {
    stables: [
      "name",
      "debugsessionId",
      "organizationId",
      "environmentId",
      "api",
      "revision",
      "createTime",
    ],

    diff: Effect.fn(function* ({ news, olds, output }) {
      if (!isResolved(news)) return undefined;
      const previousOrg = olds?.organization ?? output?.organizationId;
      const previousEnv = olds?.environment ?? output?.environmentId;
      const previousApi = olds?.api ?? output?.api;
      const previousRevision = olds?.revision ?? output?.revision;
      const previousId = olds?.debugsessionId ?? output?.debugsessionId;
      if (
        (previousOrg !== undefined &&
          news.organization !== undefined &&
          organizationIdOf(news.organization, "") !== organizationIdOf(previousOrg, "")) ||
        (previousEnv !== undefined &&
          environmentIdOf(news.environment) !== environmentIdOf(previousEnv)) ||
        (previousApi !== undefined && news.api !== previousApi) ||
        (previousRevision !== undefined && news.revision !== previousRevision) ||
        (previousId !== undefined &&
          news.debugsessionId !== undefined &&
          news.debugsessionId !== previousId)
      ) {
        return { action: "replace" as const, deleteFirst: true };
      }
      return undefined;
    }),

    read: Effect.fn(function* ({ id, olds, output, previous }) {
      const { project } = yield* GcpEnvironment.current;
      const organizationId = organizationIdOf(
        olds?.organization ?? output?.organizationId,
        project,
      );
      const environmentId = environmentIdOf(olds?.environment ?? output?.environmentId ?? "");
      const api = olds?.api ?? output?.api ?? "";
      const revision = olds?.revision ?? output?.revision ?? "";
      const debugsessionId = yield* toResourceId(id, olds?.debugsessionId, output?.debugsessionId, {
        maxLength: 63,
        rfc1035: true,
      });
      const name =
        output?.name ??
        sessionName(revisionParent(organizationId, environmentId, api, revision), debugsessionId);
      const existing = yield* getByName(name);
      if (existing === undefined) return undefined;
      const attrs = toAttrs(existing, organizationId, environmentId, api, revision);
      return output !== undefined || isAlchemySessionId(attrs.debugsessionId)
        ? attrs
        : unownedUnlessPrevious(attrs, previous, "name");
    }),

    list: () =>
      Effect.gen(function* () {
        const environments = yield* listProjectEnvironments();
        const found: EnvironmentsApisRevisionsDebugsession["Attributes"][] = [];
        const orgs = Array.from(new Set(environments.map((item) => item.organizationId)));
        const apis = yield* Effect.forEach(orgs, listOrgApis, {
          concurrency: 2,
        });
        const sessions = yield* Effect.forEach(
          apis.flat(),
          (proxy) =>
            proxy.name
              ? listApiSessions(proxy.name)
              : Effect.succeed([] as apigee.GoogleCloudApigeeV1ApiDebugSession[]),
          { concurrency: 4 },
        );
        for (const [proxy, listed] of apis
          .flat()
          .map((proxy, index) => [proxy, sessions[index] ?? []] as const)) {
          const organizationId = segmentAfter(proxy.name ?? "", "organizations") ?? "";
          const api = lastSegment(proxy.name ?? "");
          for (const session of listed) {
            if (!isAlchemySessionId(session.id)) continue;
            const environmentId = session.environmentId ?? "";
            const revision = session.apiProxyRevisionId ?? "";
            const debugsessionId = session.id ?? "";
            found.push({
              name: sessionName(
                revisionParent(organizationId, environmentId, api, revision),
                debugsessionId,
              ),
              debugsessionId,
              organizationId,
              environmentId,
              api,
              revision,
              timeout: undefined,
              filter: undefined,
              validity: undefined,
              count: undefined,
              tracesize: undefined,
              createTime: session.createTime,
            });
          }
        }
        return found;
      }),

    reconcile: Effect.fn(function* ({ id, news, output }) {
      const { project } = yield* GcpEnvironment.current;
      const organizationId = organizationIdOf(news.organization, project);
      const environmentId = environmentIdOf(news.environment);
      const api = news.api;
      const revision = news.revision;
      const debugsessionId = yield* toResourceId(id, news.debugsessionId, output?.debugsessionId, {
        maxLength: 63,
        rfc1035: true,
      });
      const parent = revisionParent(organizationId, environmentId, api, revision);
      const name = sessionName(parent, debugsessionId);

      let current = yield* getByName(output?.name ?? name);
      if (current !== undefined && !sameText(lastSegment(current.name ?? ""), debugsessionId)) {
        current = undefined;
      }

      if (current === undefined) {
        const created = yield* apigee
          .createOrganizationsEnvironmentsApisRevisionsDebugsessions({
            parent,
            timeout: news.timeout,
            body: {
              name: debugsessionId,
              timeout: news.timeout,
              filter: news.filter,
              validity: news.validity,
              count: news.count,
              tracesize: news.tracesize,
            },
          })
          .pipe(Effect.catchTag("Conflict", () => getByName(name)));
        current = created ?? undefined;
      }

      if (current === undefined) {
        return yield* new EnvironmentsApisRevisionsDebugsessionNotResolved({
          resourceName: name,
        });
      }

      return toAttrs(current, organizationId, environmentId, api, revision);
    }),

    delete: Effect.fn(function* ({ output }) {
      if (!output.name) return;
      yield* apigee
        .deleteDataOrganizationsEnvironmentsApisRevisionsDebugsessions({
          name: output.name,
        })
        .pipe(Effect.catchTag(["NotFound", "ApigeeResourceNotFound"], () => Effect.void));
    }),
  });