sailfork / t3code-github / .repos/ alchemy-effect/ packages/ gcp/ src/ DataLabeling/ DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage.ts

import * as datalabeling from "@distilled.cloud/gcp/datalabeling_v1beta1";
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 { GcpEnvironment } from "../Environment.ts";
import { createInternalLabels } from "../Labels.ts";
import type { Providers } from "../Providers.ts";
import {
  encodeOwnership,
  findOwned,
  hasOwnershipMarker,
  ignoreGone,
  listAllFeedbackMessages,
  MAX_FEEDBACK_BODY_LENGTH,
  noRetryLayer,
  ownedByAlchemy,
  parseOwnership,
  parseResourceName,
  replaceOnIdentity,
  retryDelete,
  retryTransient,
  sameText,
  waitForVisible,
  waitUntilGone,
} from "./internal.ts";
import { resourceNameFromOperation, waitForOperation } from "./operations.ts";

export type DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessageProps = {
  /**
   * Parent feedback thread resource name
   * `projects/{project}/datasets/{dataset}/annotatedDatasets/{annotatedDataset}/feedbackThreads/{feedbackThread}`.
   * Immutable — changing it replaces the message.
   */
  parent: string;
  /**
   * Feedback message id (the last path segment). Server-assigned on
   * create. Immutable — changing it replaces the message.
   */
  feedbackMessageId?: string;
  /**
   * String content of the feedback. Maximum 10,000 characters. Messages
   * have no labels field, so Alchemy stamps ownership into this field.
   * Immutable — changing it replaces the message.
   */
  body?: string;
  /**
   * Image payload for this feedback, if the comment is an image.
   * Immutable — changing it replaces the message.
   */
  image?: string;
};

export type DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage = Resource<
  "GCP.DataLabeling.DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage",
  DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessageProps,
  {
    /**
     * Full resource name
     * `.../feedbackThreads/{thread}/feedbackMessages/{message}`.
     */
    name: string;
    /** Feedback message id (last path segment). */
    feedbackMessageId: string;
    /** Parent feedback thread resource name. */
    parent: string;
    /** Project id. */
    project: string;
    /** Dataset id. */
    datasetId: string;
    /** User body with the Alchemy ownership prefix stripped. */
    body: string | undefined;
    /** Image payload, if any. */
    image: string | undefined;
    /** RFC3339 creation timestamp. */
    createTime: string | undefined;
  },
  never,
  Providers
>;

/**
 * A Data Labeling feedback message on a labeling-task feedback thread.
 *
 * Create is a long-running operation. Message ids are server-assigned.
 * Parent thread, body, and image are immutable — changing them replaces
 * the message. There is no labels API, so Alchemy stamps ownership into
 * `body` so `list` / nuke can find them.
 *
 * ### Creating a Feedback Message
 * **Example:** Text comment on a thread
 * ```typescript
 * const message = yield* GCP.DataLabeling.DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage(
 *   "Note",
 *   {
 *     parent: threadName,
 *     body: "please relabel the occluded boxes",
 *   },
 * );
 * ```
 *
 * **Example:** Ownership-only body
 * ```typescript
 * const message = yield* GCP.DataLabeling.DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage(
 *   "Note",
 *   {
 *     parent: threadName,
 *   },
 * );
 * ```
 *
 * @resource
 * @category DataLabeling
 */
export const DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage =
  Resource<DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage>(
    "GCP.DataLabeling.DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage",
  );

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

const resourceNameOf = (parent: string, feedbackMessageId: string) =>
  `${parent}/feedbackMessages/${feedbackMessageId}`;

const expandParent = (parent: string, project: string) =>
  parent.includes("/")
    ? parent.replace(/\/+$/, "")
    : `projects/${project}/datasets/_/annotatedDatasets/_/feedbackThreads/${parent}`;

const toAttrs = (
  message: datalabeling.GoogleCloudDatalabelingV1beta1FeedbackMessage,
  project: string,
) => {
  const name = message.name ?? "";
  const parsed = parseResourceName(
    name.replace(/\/feedbackMessage\//, "/feedbackMessages/"),
    "feedbackMessages",
  );
  const fallback = parseResourceName(name, "feedbackMessage");
  const collection = parsed.id.length > 0 ? parsed : fallback;
  return {
    name,
    feedbackMessageId: collection.id,
    parent: collection.parent,
    project: collection.project || project,
    datasetId: collection.datasetId,
    body: parseOwnership(message.body).text,
    image: message.image,
    createTime: message.createTime,
  };
};

const getByName = (name: string) =>
  name.length === 0
    ? Effect.undefined
    : datalabeling
        .getProjectsDatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessages({
          name,
        })
        .pipe(
          Effect.provide(noRetryLayer),
          Effect.catchTags({
            NotFound: () => Effect.undefined,
            BadGateway: () => Effect.undefined,
          }),
        );

const findByOwnership = (id: string, project: string) =>
  Effect.gen(function* () {
    const rows = yield* listAllFeedbackMessages(project);
    return yield* findOwned(id, rows, (row) => row.body);
  });

export const DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessageProvider = () =>
  Provider.succeed(DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage, {
    stables: ["name", "feedbackMessageId", "parent", "project", "datasetId", "createTime"],

    diff: Effect.fn(function* ({ news, olds, output }) {
      if (!isResolved(news)) return undefined;
      const extra =
        (olds !== undefined && !sameText(news.body, output?.body)) ||
        (output !== undefined && !sameText(news.image, output.image));
      return replaceOnIdentity({
        previousId: olds?.feedbackMessageId ?? output?.feedbackMessageId,
        nextId: news.feedbackMessageId,
        previousParent: olds?.parent ?? output?.parent,
        nextParent: news.parent,
        extra,
      });
    }),

    read: Effect.fn(function* ({ id, olds, output }) {
      const env = yield* GcpEnvironment.current;
      const parent =
        olds?.parent !== undefined
          ? expandParent(olds.parent, env.project)
          : (output?.parent ?? "");
      const feedbackMessageId =
        olds?.feedbackMessageId ??
        output?.feedbackMessageId ??
        (output?.name
          ? parseResourceName(
              output.name.replace(/\/feedbackMessage\//, "/feedbackMessages/"),
              "feedbackMessages",
            ).id
          : "");
      const name =
        output?.name ??
        (parent.length > 0 && feedbackMessageId.length > 0
          ? resourceNameOf(parent, feedbackMessageId)
          : "");
      const existing = (yield* getByName(name)) ?? (yield* findByOwnership(id, env.project));
      if (existing === undefined) return undefined;
      const attrs = toAttrs(existing, env.project);
      return (yield* ownedByAlchemy(id, existing.body)) ? attrs : Unowned(attrs);
    }),

    list: () =>
      Effect.gen(function* () {
        const env = yield* GcpEnvironment.current;
        const rows = yield* listAllFeedbackMessages(env.project);
        return rows
          .filter((row) => hasOwnershipMarker(row.body))
          .map((row) => toAttrs(row, env.project));
      }),

    reconcile: Effect.fn(function* ({ id, news, output }) {
      const env = yield* GcpEnvironment.current;
      const parent = expandParent(news.parent, env.project);
      const feedbackMessageId = news.feedbackMessageId ?? output?.feedbackMessageId;
      const name =
        output?.name ??
        (feedbackMessageId !== undefined ? resourceNameOf(parent, feedbackMessageId) : "");
      const ownership = yield* createInternalLabels(id);
      const body = encodeOwnership(ownership, news.body, MAX_FEEDBACK_BODY_LENGTH);

      let current = (yield* getByName(name)) ?? (yield* findByOwnership(id, env.project));

      if (current === undefined) {
        const created = yield* retryTransient(
          datalabeling.createProjectsDatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessages({
            parent,
            body: {
              body,
              image: news.image,
              requesterFeedbackMetadata: {},
            },
          }),
        ).pipe(Effect.catchTag("Conflict", () => Effect.undefined));
        if (created !== undefined) {
          const done = yield* waitForOperation(created);
          const createdName = resourceNameFromOperation(done);
          if (createdName !== undefined) {
            current = yield* waitForVisible(getByName(createdName));
          }
        }
        if (current === undefined) {
          current = yield* findByOwnership(id, env.project);
        }
      }

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

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

    delete: Effect.fn(function* ({ output }) {
      if (!output.name) return;
      yield* datalabeling
        .deleteProjectsDatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessages({
          name: output.name,
        })
        .pipe(retryDelete, ignoreGone);
      yield* waitUntilGone(getByName(output.name));
    }),
  });