sailfork / t3code-github / .repos/ alchemy-effect/ packages/ gcp/ src/ Vault/ MattersSavedQuery.ts

import * as vault from "@distilled.cloud/gcp/vault_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 { GcpEnvironment } from "../Environment.ts";
import type { Providers } from "../Providers.ts";
import {
  encodeOwnershipLine,
  findOwnedSavedQuery,
  findSavedQueryByName,
  getSavedQuery,
  hasOwnershipMarker,
  ignoreMissing,
  jsonEqual,
  listActiveMatters,
  listSavedQueries,
  MAX_SAVED_QUERY_NAME_LENGTH,
  ownedByAlchemy,
  ownershipLabels,
  parseOwnership,
  toGeneratedName,
} from "./internal.ts";

export type MattersSavedQueryProps = {
  /**
   * Parent matter id. Immutable — changing it replaces the saved query.
   */
  matterId: string;
  /**
   * Server-assigned saved query id. Leave blank on create. Immutable —
   * changing it replaces the saved query.
   */
  savedQueryId?: string;
  /**
   * Display name (max 100 characters including Alchemy's ownership
   * marker). Vault saved queries have no labels field, so ownership is
   * stored in a `[alchemy …]` prefix and stripped from attributes. Vault
   * has no saved-query update API — changing the name replaces the
   * query.
   */
  displayName?: string;
  /**
   * Search parameters. Required on create. Vault has no saved-query
   * update API — changing the query replaces the saved query.
   */
  query: vault.Query;
};

export type MattersSavedQuery = Resource<
  "GCP.Vault.MattersSavedQuery",
  MattersSavedQueryProps,
  {
    /** Server-assigned saved query id. */
    savedQueryId: string;
    /** Parent matter id. */
    matterId: string;
    /** Project id used when the saved query was reconciled. */
    project: string;
    /** User-facing name with the Alchemy ownership prefix stripped. */
    displayName: string | undefined;
    /** Search parameters. */
    query: vault.Query | undefined;
    /** RFC3339 create timestamp. */
    createTime: string | undefined;
  },
  never,
  Providers
>;

/**
 * A Google Vault saved query on a matter.
 *
 * Vault saved queries have no labels field, so Alchemy stamps ownership
 * into `displayName` for `list` / nuke. There is no update API — changing
 * the query or display name replaces the saved query (delete-first).
 *
 * ### Creating a Saved Query
 * **Example:** Mail search
 * ```typescript
 * const saved = yield* GCP.Vault.MattersSavedQuery("Contracts", {
 *   matterId: matter.matterId,
 *   query: {
 *     corpus: "MAIL",
 *     dataScope: "ALL_DATA",
 *     searchMethod: "ACCOUNT",
 *     accountInfo: { emails: ["user@example.com"] },
 *     terms: "subject:contract",
 *   },
 * });
 * ```
 *
 * **Example:** Named Drive search
 * ```typescript
 * const saved = yield* GCP.Vault.MattersSavedQuery("Drive", {
 *   matterId: matter.matterId,
 *   displayName: "shared-drives",
 *   query: {
 *     corpus: "DRIVE",
 *     dataScope: "ALL_DATA",
 *     searchMethod: "ENTIRE_ORG",
 *   },
 * });
 * ```
 *
 * @resource
 * @category Vault
 */
export const MattersSavedQuery = Resource<MattersSavedQuery>("GCP.Vault.MattersSavedQuery");

export class MattersSavedQueryNotResolved extends Data.TaggedError(
  "GCP.Vault.MattersSavedQueryNotResolved",
)<{
  matterId: string;
  savedQueryId: string;
}> {}

const toAttrs = (item: vault.SavedQuery, project: string) => ({
  savedQueryId: item.savedQueryId ?? "",
  matterId: item.matterId ?? "",
  project,
  displayName: parseOwnership(item.displayName).text,
  query: item.query,
  createTime: item.createTime,
});

export const MattersSavedQueryProvider = () =>
  Provider.succeed(MattersSavedQuery, {
    stables: ["savedQueryId", "matterId", "project", "createTime"],

    diff: Effect.fn(function* ({ news, olds, output }) {
      if (!isResolved(news)) return undefined;
      const previousMatter = olds?.matterId ?? output?.matterId;
      if (previousMatter !== undefined && news.matterId !== previousMatter) {
        return { action: "replace" as const, deleteFirst: true };
      }
      const previousId = olds?.savedQueryId ?? output?.savedQueryId;
      if (
        previousId !== undefined &&
        news.savedQueryId !== undefined &&
        news.savedQueryId !== previousId
      ) {
        return { action: "replace" as const, deleteFirst: true };
      }
      const previousName = olds?.displayName ?? output?.displayName;
      if (
        news.displayName !== undefined &&
        previousName !== undefined &&
        news.displayName !== previousName
      ) {
        return { action: "replace" as const, deleteFirst: true };
      }
      const previousQuery = olds?.query ?? output?.query;
      if (previousQuery !== undefined && !jsonEqual(previousQuery, news.query)) {
        return { action: "replace" as const, deleteFirst: true };
      }
      return undefined;
    }),

    read: Effect.fn(function* ({ id, olds, output, previous }) {
      const env = yield* GcpEnvironment.current;
      const matterId = olds?.matterId ?? output?.matterId ?? "";
      const savedQueryId = olds?.savedQueryId ?? output?.savedQueryId ?? "";
      let existing = yield* getSavedQuery(matterId, savedQueryId);
      if (existing === undefined) {
        const ownership = yield* ownershipLabels(id);
        const displayName = encodeOwnershipLine(
          ownership,
          olds?.displayName ?? output?.displayName,
          MAX_SAVED_QUERY_NAME_LENGTH,
        );
        existing = yield* findSavedQueryByName(matterId, displayName);
      }
      if (existing === undefined) {
        existing = yield* findOwnedSavedQuery(id, matterId);
      }
      if (existing === undefined) return undefined;
      const attrs = toAttrs(existing, env.project);
      return (yield* ownedByAlchemy(id, existing.displayName))
        ? attrs
        : unownedUnlessPrevious(attrs, previous, "savedQueryId");
    }),

    list: () =>
      Effect.gen(function* () {
        const env = yield* GcpEnvironment.current;
        const matters = yield* listActiveMatters();
        const pages = yield* Effect.forEach(
          matters,
          (matter) =>
            listSavedQueries(matter.matterId ?? "").pipe(
              Effect.map((items) =>
                items
                  .filter((item) => hasOwnershipMarker(item.displayName))
                  .map((item) => toAttrs(item, env.project)),
              ),
            ),
          { concurrency: 4 },
        );
        return pages.flat();
      }),

    reconcile: Effect.fn(function* ({ id, news, output }) {
      const env = yield* GcpEnvironment.current;
      const matterId = news.matterId;
      const ownership = yield* ownershipLabels(id);
      const generated = yield* toGeneratedName(id, news.displayName, output?.displayName, 40);
      const displayName = encodeOwnershipLine(ownership, generated, MAX_SAVED_QUERY_NAME_LENGTH);
      const desired: vault.SavedQuery = {
        displayName,
        query: news.query,
      };

      let current = yield* getSavedQuery(matterId, news.savedQueryId ?? output?.savedQueryId ?? "");
      if (current === undefined) {
        current = yield* findSavedQueryByName(matterId, displayName);
      }
      if (current === undefined) {
        current = yield* findOwnedSavedQuery(id, matterId);
      }

      if (current === undefined) {
        const created = yield* vault
          .createMattersSavedQueries({
            matterId,
            body: desired,
          })
          .pipe(Effect.catchTag("Conflict", () => findSavedQueryByName(matterId, displayName)));
        current = created ?? undefined;
      }

      if (current === undefined) {
        return yield* new MattersSavedQueryNotResolved({
          matterId,
          savedQueryId: news.savedQueryId ?? output?.savedQueryId ?? displayName,
        });
      }

      return toAttrs(current, env.project);
    }),

    delete: Effect.fn(function* ({ output }) {
      if (output.matterId.length === 0 || output.savedQueryId.length === 0) {
        return;
      }
      yield* ignoreMissing(
        vault.deleteMattersSavedQueries({
          matterId: output.matterId,
          savedQueryId: output.savedQueryId,
        }),
      );
    }),
  });