@checkstack/catalog-backend 1.2.0 → 1.3.0

package/src/catalog-entity.test.ts

@@ -0,0 +1,308 @@
+import { describe, it, expect } from "bun:test";
+import type {
+  EntityChanged,
+  EntityHandle,
+} from "@checkstack/automation-backend";
+import { SYSTEM_ACTOR } from "@checkstack/common";
+
+import {
+  CATALOG_GROUP_ENTITY_KIND,
+  CATALOG_GROUP_TRIGGER_EVENTS,
+  CATALOG_SYSTEM_ENTITY_KIND,
+  CATALOG_SYSTEM_TRIGGER_EVENTS,
+  catalogSystemChangeToPayload,
+  createCatalogGroupEntityRead,
+  createCatalogSystemEntityRead,
+  deriveCatalogGroupTriggerEvents,
+  deriveCatalogSystemTriggerEvents,
+  removeCatalogEntity,
+  toCatalogGroupState,
+  toCatalogSystemState,
+  writeCatalogGroupEntity,
+  writeCatalogSystemEntity,
+  type CatalogGroupState,
+  type CatalogSystemState,
+} from "./catalog-entity";
+import {
+  systemCreatedTrigger,
+  systemDeletedTrigger,
+  systemUpdatedTrigger,
+} from "./automations";
+import type { EntityService } from "./services/entity-service";
+
+function change(overrides: Partial<EntityChanged> = {}): EntityChanged {
+  return {
+    kind: CATALOG_SYSTEM_ENTITY_KIND,
+    id: "sys-1",
+    prev: { name: "old", description: null, metadata: {} },
+    next: { name: "new", description: null, metadata: {} },
+    delta: { name: "new" },
+    changedFields: ["name"],
+    actor: SYSTEM_ACTOR,
+    occurredAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe("CATALOG_SYSTEM_TRIGGER_EVENTS (must equal the trigger qualifiedIds)", () => {
+  it("emits the registered system trigger qualifiedIds, not the dotted hook ids", () => {
+    // The catalog system triggers have ids `created`/`updated`/`deleted`
+    // (pluginId `catalog`), so the deriver MUST emit `catalog.created` etc.,
+    // NOT the dotted hook ids `catalog.system.created`.
+    expect(CATALOG_SYSTEM_TRIGGER_EVENTS.created).toBe("catalog.created");
+    expect(CATALOG_SYSTEM_TRIGGER_EVENTS.updated).toBe("catalog.updated");
+    expect(CATALOG_SYSTEM_TRIGGER_EVENTS.deleted).toBe("catalog.deleted");
+  });
+});
+
+describe("deriveCatalogSystemTriggerEvents", () => {
+  it("maps a create (prev === null) to system.created", () => {
+    expect(
+      deriveCatalogSystemTriggerEvents(
+        change({ prev: null, next: { name: "n", description: null, metadata: {} } }),
+      ),
+    ).toEqual([CATALOG_SYSTEM_TRIGGER_EVENTS.created]);
+  });
+  it("maps a tombstone (next === null) to system.deleted", () => {
+    expect(
+      deriveCatalogSystemTriggerEvents(change({ next: null })),
+    ).toEqual([CATALOG_SYSTEM_TRIGGER_EVENTS.deleted]);
+  });
+  it("maps a field update to system.updated", () => {
+    expect(deriveCatalogSystemTriggerEvents(change())).toEqual([
+      CATALOG_SYSTEM_TRIGGER_EVENTS.updated,
+    ]);
+  });
+});
+
+describe("catalogSystemChangeToPayload — payloadSchema parity", () => {
+  it("a create payload validates against the created trigger's payloadSchema", () => {
+    const payload = catalogSystemChangeToPayload(
+      change({
+        prev: null,
+        next: { name: "new", description: null, metadata: {} },
+        delta: { name: "new" },
+        changedFields: ["name", "description", "metadata"],
+      }),
+    );
+    const parsed = systemCreatedTrigger.payloadSchema.parse(payload);
+    expect(parsed.systemId).toBe("sys-1");
+    expect(parsed.systemName).toBe("new");
+  });
+
+  it("an update payload validates against the updated trigger's payloadSchema with changedFields", () => {
+    const payload = catalogSystemChangeToPayload(
+      change({ changedFields: ["name", "metadata"] }),
+    );
+    const parsed = systemUpdatedTrigger.payloadSchema.parse(payload);
+    expect(parsed.systemId).toBe("sys-1");
+    expect(parsed.systemName).toBe("new");
+    expect(parsed.changedFields).toEqual(["name", "metadata"]);
+  });
+
+  it("a delete payload validates against the deleted trigger's payloadSchema (systemName omitted on tombstone)", () => {
+    const payload = catalogSystemChangeToPayload(change({ next: null }));
+    const parsed = systemDeletedTrigger.payloadSchema.parse(payload);
+    expect(parsed.systemId).toBe("sys-1");
+    expect(parsed.systemName).toBeUndefined();
+  });
+
+  it("drops non-enum changedFields (only name/description/metadata survive)", () => {
+    const payload = catalogSystemChangeToPayload(
+      change({ changedFields: ["name", "ownerId", "metadata"] }),
+    );
+    const parsed = systemUpdatedTrigger.payloadSchema.parse(payload);
+    expect(parsed.changedFields).toEqual(["name", "metadata"]);
+  });
+});
+
+describe("deriveCatalogGroupTriggerEvents", () => {
+  it("maps a create to group.created", () => {
+    expect(
+      deriveCatalogGroupTriggerEvents(
+        change({
+          kind: CATALOG_GROUP_ENTITY_KIND,
+          prev: null,
+          next: { name: "g", metadata: {} },
+        }),
+      ),
+    ).toEqual([CATALOG_GROUP_TRIGGER_EVENTS.created]);
+  });
+  it("maps a tombstone to group.deleted", () => {
+    expect(
+      deriveCatalogGroupTriggerEvents(
+        change({ kind: CATALOG_GROUP_ENTITY_KIND, next: null }),
+      ),
+    ).toEqual([CATALOG_GROUP_TRIGGER_EVENTS.deleted]);
+  });
+  it("fires nothing on a group update (no group.updated hook)", () => {
+    expect(
+      deriveCatalogGroupTriggerEvents(
+        change({
+          kind: CATALOG_GROUP_ENTITY_KIND,
+          prev: { name: "a", metadata: {} },
+          next: { name: "b", metadata: {} },
+        }),
+      ),
+    ).toEqual([]);
+  });
+});
+
+describe("toCatalogSystemState / toCatalogGroupState", () => {
+  it("projects a system, normalising null description + metadata", () => {
+    expect(
+      toCatalogSystemState({
+        name: "API",
+        description: undefined,
+        metadata: undefined,
+      }),
+    ).toEqual({ name: "API", description: null, metadata: {} });
+  });
+
+  it("projects a group, normalising null metadata", () => {
+    expect(
+      toCatalogGroupState({ name: "Team A", metadata: null }),
+    ).toEqual({ name: "Team A", metadata: {} });
+  });
+});
+
+describe("createCatalogSystemEntityRead", () => {
+  it("routes the batched read straight to the service (plugin-backed)", async () => {
+    const seen: ReadonlyArray<string>[] = [];
+    const service = {
+      async getManySystemEntityStates(ids: ReadonlyArray<string>) {
+        seen.push(ids);
+        return {
+          "sys-1": { name: "API", description: null, metadata: { tier: "1" } },
+        };
+      },
+    } as unknown as EntityService;
+    const read = createCatalogSystemEntityRead(service);
+    const out = await read(["sys-1", "sys-2"]);
+    expect(seen).toEqual([["sys-1", "sys-2"]]);
+    expect(out["sys-1"]).toEqual({
+      name: "API",
+      description: null,
+      metadata: { tier: "1" },
+    });
+  });
+});
+
+describe("createCatalogGroupEntityRead", () => {
+  it("routes the batched read straight to the service (plugin-backed)", async () => {
+    const seen: ReadonlyArray<string>[] = [];
+    const service = {
+      async getManyGroupEntityStates(ids: ReadonlyArray<string>) {
+        seen.push(ids);
+        return { "g-1": { name: "Team A", metadata: {} } };
+      },
+    } as unknown as EntityService;
+    const read = createCatalogGroupEntityRead(service);
+    const out = await read(["g-1"]);
+    expect(seen).toEqual([["g-1"]]);
+    expect(out["g-1"]).toEqual({ name: "Team A", metadata: {} });
+  });
+});
+
+describe("writeCatalogSystemEntity", () => {
+  it("drives the write through handle.mutate keyed by system id", async () => {
+    const calls: Array<{ id: string; next: CatalogSystemState }> = [];
+    const handle = {
+      kind: CATALOG_SYSTEM_ENTITY_KIND,
+      async mutate(input: {
+        id: string;
+        apply: () => Promise<CatalogSystemState>;
+      }) {
+        const next = await input.apply();
+        calls.push({ id: input.id, next });
+        return next;
+      },
+    } as unknown as EntityHandle<CatalogSystemState>;
+    let applied = false;
+    await writeCatalogSystemEntity({
+      handle,
+      systemId: "sys-9",
+      apply: async () => {
+        applied = true;
+        return { name: "API", description: null, metadata: {} };
+      },
+    });
+    expect(applied).toBe(true);
+    expect(calls).toEqual([
+      { id: "sys-9", next: { name: "API", description: null, metadata: {} } },
+    ]);
+  });
+
+  it("still runs the plugin write when no handle is wired", async () => {
+    let applied = false;
+    await writeCatalogSystemEntity({
+      handle: undefined,
+      systemId: "sys-9",
+      apply: async () => {
+        applied = true;
+        return { name: "API", description: null, metadata: {} };
+      },
+    });
+    expect(applied).toBe(true);
+  });
+});
+
+describe("writeCatalogGroupEntity", () => {
+  it("drives the write through handle.mutate keyed by group id", async () => {
+    const calls: Array<{ id: string; next: CatalogGroupState }> = [];
+    const handle = {
+      kind: CATALOG_GROUP_ENTITY_KIND,
+      async mutate(input: {
+        id: string;
+        apply: () => Promise<CatalogGroupState>;
+      }) {
+        const next = await input.apply();
+        calls.push({ id: input.id, next });
+        return next;
+      },
+    } as unknown as EntityHandle<CatalogGroupState>;
+    await writeCatalogGroupEntity({
+      handle,
+      groupId: "g-1",
+      apply: async () => ({ name: "Team A", metadata: { tier: "1" } }),
+    });
+    expect(calls).toEqual([
+      { id: "g-1", next: { name: "Team A", metadata: { tier: "1" } } },
+    ]);
+  });
+});
+
+describe("removeCatalogEntity", () => {
+  it("tombstones via handle.remove({ apply })", async () => {
+    const removed: string[] = [];
+    let deleted = false;
+    const handle = {
+      kind: CATALOG_SYSTEM_ENTITY_KIND,
+      async remove(input: { id: string; apply: () => Promise<void> }) {
+        await input.apply();
+        removed.push(input.id);
+      },
+    } as unknown as EntityHandle<Record<string, unknown>>;
+    await removeCatalogEntity({
+      handle,
+      id: "sys-9",
+      apply: async () => {
+        deleted = true;
+      },
+    });
+    expect(deleted).toBe(true);
+    expect(removed).toEqual(["sys-9"]);
+  });
+
+  it("still runs the delete when no handle is wired", async () => {
+    let deleted = false;
+    await removeCatalogEntity({
+      handle: undefined,
+      id: "x",
+      apply: async () => {
+        deleted = true;
+      },
+    });
+    expect(deleted).toBe(true);
+  });
+});

package/src/catalog-entity.ts

@@ -0,0 +1,274 @@
+/**
+ * The reactive `catalog-system` + `catalog-group` entities (reactive
+ * automation engine §10.4).
+ *
+ * Model B PLUGIN-BACKED entities: the catalog `systems` / `groups` tables
+ * are authoritative AND ARE the entities' current-state storage — there is
+ * NO framework `entity_state` row for a catalog system/group.
+ * `defineEntity({ read })` makes that plugin state reactive: every
+ * reactive-state write goes through `handle.mutate`, whose `apply()` performs
+ * the REAL `systems`/`groups` write via the catalog `EntityService` (the
+ * plugin's own db/tx) and returns the resulting reactive subset. The
+ * framework snapshots `prev` via `read`, appends the transition log (its own
+ * db), and emits `ENTITY_CHANGED`. The change → trigger-event derivers
+ * reproduce `catalog.created/.updated/.deleted` +
+ * `catalog.group.created/.deleted` so automations keep firing.
+ */
+import { z } from "zod";
+import type {
+  EntityChangeDeriver,
+  EntityChangePayloadMapper,
+  EntityHandle,
+  EntityMutationOpts,
+  EntityRead,
+} from "@checkstack/automation-backend";
+import {
+  withEntityRemove,
+  withEntityWrite,
+} from "@checkstack/automation-backend";
+
+import type { EntityService } from "./services/entity-service";
+
+export const CATALOG_SYSTEM_ENTITY_KIND = "catalog-system";
+export const CATALOG_GROUP_ENTITY_KIND = "catalog-group";
+
+/** Reactive state for a catalog system. */
+export const CatalogSystemStateSchema = z.object({
+  name: z.string(),
+  description: z.string().nullable(),
+  metadata: z.record(z.string(), z.unknown()),
+});
+export type CatalogSystemState = z.infer<typeof CatalogSystemStateSchema>;
+
+/** Reactive state for a catalog group. */
+export const CatalogGroupStateSchema = z.object({
+  name: z.string(),
+  metadata: z.record(z.string(), z.unknown()),
+});
+export type CatalogGroupState = z.infer<typeof CatalogGroupStateSchema>;
+
+/**
+ * Qualified TRIGGER event ids (`${pluginId}.${trigger.id}`) that automations
+ * store in `trigger.event` and Stage-1 routing matches on — NOT the dotted
+ * hook ids. The catalog system triggers use ids `created`/`updated`/`deleted`
+ * (pluginId `catalog`), so the deriver emits `catalog.created` etc., not the
+ * hook id `catalog.system.created`. (Verified against `automations.ts`.)
+ *
+ * There are NO registered catalog GROUP triggers today, so the group deriver
+ * fires nothing that any automation matches — kept for forward-compat + so
+ * group changes still drive scope/wake resolution as a known reactive kind.
+ */
+export const CATALOG_SYSTEM_TRIGGER_EVENTS = {
+  created: "catalog.created",
+  updated: "catalog.updated",
+  deleted: "catalog.deleted",
+} as const;
+
+export const CATALOG_GROUP_TRIGGER_EVENTS = {
+  created: "catalog.group.created",
+  deleted: "catalog.group.deleted",
+} as const;
+
+/**
+ * `catalog-system` change → trigger events. Create (`prev === null`),
+ * tombstone (`next === null`), or a field update map to the matching
+ * lifecycle event. A no-op diff never reaches a deriver (the handle
+ * suppresses it), so an update always carries a real change.
+ */
+export const deriveCatalogSystemTriggerEvents: EntityChangeDeriver = (
+  changed,
+) => {
+  if (changed.prev === null && changed.next !== null) {
+    return [CATALOG_SYSTEM_TRIGGER_EVENTS.created];
+  }
+  if (changed.next === null) {
+    return [CATALOG_SYSTEM_TRIGGER_EVENTS.deleted];
+  }
+  return [CATALOG_SYSTEM_TRIGGER_EVENTS.updated];
+};
+
+/**
+ * `catalog-group` change → trigger events. Only create + delete have
+ * matching hooks today (there is no `catalog.group.updated`), so a pure
+ * update diff fires nothing.
+ */
+export const deriveCatalogGroupTriggerEvents: EntityChangeDeriver = (
+  changed,
+) => {
+  if (changed.prev === null && changed.next !== null) {
+    return [CATALOG_GROUP_TRIGGER_EVENTS.created];
+  }
+  if (changed.next === null) {
+    return [CATALOG_GROUP_TRIGGER_EVENTS.deleted];
+  }
+  return [];
+};
+
+/** The catalog `system.updated` trigger's `changedFields` enum members. */
+const CATALOG_SYSTEM_CHANGED_FIELDS = ["name", "description", "metadata"] as const;
+
+function readName(state: Record<string, unknown> | null): string | undefined {
+  if (state === null) return undefined;
+  const name = state["name"];
+  return typeof name === "string" ? name : undefined;
+}
+
+/**
+ * Map a `catalog-system` change to the domain-named `trigger.payload` the
+ * catalog system triggers declare via `payloadSchema` (`systemId`,
+ * `systemName`, `changedFields`). Restores the keys operators read
+ * (`trigger.payload.systemId`, `.systemName`, `.changedFields`) that the
+ * generic change shape omits.
+ *
+ * `systemId` is the entity id; `systemName` is `next.name` (absent on a
+ * tombstone, where the `deleted` schema marks it optional); `changedFields` is
+ * the change's `changedFields` intersected with the system trigger enum
+ * (`name` / `description` / `metadata`).
+ */
+export const catalogSystemChangeToPayload: EntityChangePayloadMapper = (
+  changed,
+) => {
+  const changedFields = changed.changedFields.filter(
+    (f): f is (typeof CATALOG_SYSTEM_CHANGED_FIELDS)[number] =>
+      (CATALOG_SYSTEM_CHANGED_FIELDS as readonly string[]).includes(f),
+  );
+  const systemName = readName(changed.next);
+  return {
+    systemId: changed.id,
+    ...(systemName === undefined ? {} : { systemName }),
+    changedFields,
+  };
+};
+
+/**
+ * Map a `catalog-group` change to a domain-named `trigger.payload`
+ * (`groupId`, `groupName`). There are NO registered catalog GROUP triggers
+ * today, so this fires for no automation yet — it is supplied for forward
+ * compatibility + parity so a group change carries the same domain shape the
+ * other kinds do when group triggers are added.
+ */
+export const catalogGroupChangeToPayload: EntityChangePayloadMapper = (
+  changed,
+) => {
+  const groupName = readName(changed.next);
+  return {
+    groupId: changed.id,
+    ...(groupName === undefined ? {} : { groupName }),
+  };
+};
+
+/**
+ * Build the PLUGIN-BACKED `read` accessor for the `catalog-system` entity.
+ * Routes straight to the service's batched authoritative read over the
+ * `systems` table — no framework storage.
+ */
+export function createCatalogSystemEntityRead(
+  service: EntityService,
+): EntityRead<CatalogSystemState> {
+  return (ids) => service.getManySystemEntityStates(ids);
+}
+
+/**
+ * Build the PLUGIN-BACKED `read` accessor for the `catalog-group` entity.
+ * Routes straight to the service's batched authoritative read over the
+ * `groups` table — no framework storage.
+ */
+export function createCatalogGroupEntityRead(
+  service: EntityService,
+): EntityRead<CatalogGroupState> {
+  return (ids) => service.getManyGroupEntityStates(ids);
+}
+
+/**
+ * Project a catalog system row onto the reactive `{ name, description,
+ * metadata }` subset. The router's service writes return the full row; this
+ * is the `apply()` return for `handle.mutate`.
+ */
+export function toCatalogSystemState(system: {
+  name: string;
+  description: string | null | undefined;
+  metadata: Record<string, unknown> | null | undefined;
+}): CatalogSystemState {
+  return {
+    name: system.name,
+    description: system.description ?? null,
+    metadata: system.metadata ?? {},
+  };
+}
+
+/**
+ * Project a catalog group row onto the reactive `{ name, metadata }` subset.
+ */
+export function toCatalogGroupState(group: {
+  name: string;
+  metadata: Record<string, unknown> | null | undefined;
+}): CatalogGroupState {
+  return {
+    name: group.name,
+    metadata: group.metadata ?? {},
+  };
+}
+
+/**
+ * Drive a reactive-state `catalog-system` write through `handle.mutate`
+ * (§10.4). `apply` performs the REAL `systems` write via the service (the
+ * plugin's own db/tx) and returns the new reactive state. The framework
+ * snapshots `prev`, appends the transition log, and emits `ENTITY_CHANGED`
+ * (the deriver turns that into `catalog.created/.updated`).
+ *
+ * When no handle is available (tests construct the router without one), the
+ * write still runs — the entity reactivity is layered on top, never required
+ * for the underlying write to succeed.
+ */
+export async function writeCatalogSystemEntity(args: {
+  handle: EntityHandle<CatalogSystemState> | undefined;
+  systemId: string;
+  /**
+   * Mutation context (actor / runId). When the write originates inside a
+   * dispatch run (e.g. `system.update_metadata`), pass `opts: { runId }` so a
+   * run-resolved secret that lands in `metadata` is masked in the
+   * `entity_transitions` rows + the cluster-wide `ENTITY_CHANGED` — `metadata`
+   * is `z.record(z.string(), z.unknown())`, the only reactive catalog field
+   * that can carry an arbitrary secret string.
+   */
+  opts?: EntityMutationOpts;
+  apply: () => Promise<CatalogSystemState>;
+}): Promise<void> {
+  const { handle, systemId, opts, apply } = args;
+  await withEntityWrite({ handle, id: systemId, opts, apply });
+}
+
+/**
+ * Drive a reactive-state `catalog-group` write through `handle.mutate`
+ * (§10.4). Mirrors {@link writeCatalogSystemEntity} for the group kind.
+ */
+export async function writeCatalogGroupEntity(args: {
+  handle: EntityHandle<CatalogGroupState> | undefined;
+  groupId: string;
+  /** Mutation context (actor / runId) — see {@link writeCatalogSystemEntity}. */
+  opts?: EntityMutationOpts;
+  apply: () => Promise<CatalogGroupState>;
+}): Promise<void> {
+  const { handle, groupId, opts, apply } = args;
+  await withEntityWrite({ handle, id: groupId, opts, apply });
+}
+
+/**
+ * Drive a catalog entity tombstone through `handle.remove` (§10.4). `apply`
+ * performs the REAL delete via the service; the framework records the
+ * tombstone transition and emits a tombstone change (the deriver fires
+ * `catalog.deleted` / `catalog.group.deleted`). Without a handle, the delete
+ * still runs.
+ */
+export async function removeCatalogEntity<
+  TState extends Record<string, unknown>,
+>(args: {
+  handle: EntityHandle<TState> | undefined;
+  id: string;
+  /** Mutation context (actor / runId) — see {@link writeCatalogSystemEntity}. */
+  opts?: EntityMutationOpts;
+  apply: () => Promise<void>;
+}): Promise<void> {
+  const { handle, id, opts, apply } = args;
+  await withEntityRemove({ handle, id, opts, apply });
+}

package/src/hooks.ts

@@ -1,58 +1,14 @@
-import { createHook } from "@checkstack/backend-api";
-
 /**
- * Catalog hooks for cross-plugin communication
+ * Catalog cross-plugin hooks.
+ *
+ * The `catalog.system.created` / `.updated` / `.deleted` +
+ * `catalog.group.created` / `.deleted` hooks were removed in Phase 4
+ * (§10.4): catalog systems + groups are now the reactive `catalog-system`
+ * / `catalog-group` entities, whose change derivers fire the matching
+ * `catalog.created` / `.updated` / `.deleted` trigger events through
+ * Stage-1 routing, and cross-plugin cleanup reactors subscribe to the
+ * `catalog-system` tombstone via `onEntityChanged`. No cross-plugin hook
+ * remains, so this object is intentionally empty (kept for the stable
+ * `export { catalogHooks }` surface).
  */
-export const catalogHooks = {
-  /**
-   * Emitted when a system is created.
-   * Plugins can subscribe (work-queue mode) to bootstrap related state
-   * (e.g. per-system notification groups).
-   */
-  systemCreated: createHook<{
-    systemId: string;
-    systemName: string;
-  }>("catalog.system.created"),
-
-  /**
-   * Emitted when a system's name, description, or metadata changes.
-   *
-   * `changedFields` lists the keys the caller actually set on the
-   * update (excluding `id`), so subscribers can route on field-level
-   * changes (e.g. "only react to metadata edits") without diffing the
-   * full record.
-   */
-  systemUpdated: createHook<{
-    systemId: string;
-    systemName: string;
-    changedFields: Array<"name" | "description" | "metadata">;
-  }>("catalog.system.updated"),
-
-  /**
-   * Emitted when a system is deleted.
-   * Plugins can subscribe (work-queue mode) to clean up related data.
-   */
-  systemDeleted: createHook<{
-    systemId: string;
-    systemName?: string;
-  }>("catalog.system.deleted"),
-
-  /**
-   * Emitted when a catalog group is created.
-   * Plugins can subscribe to bootstrap related state (e.g. anomaly creates
-   * its own per-group notification group on this signal).
-   */
-  groupCreated: createHook<{
-    groupId: string;
-    groupName: string;
-  }>("catalog.group.created"),
-
-  /**
-   * Emitted when a group is deleted.
-   * Plugins can subscribe (work-queue mode) to clean up related data.
-   */
-  groupDeleted: createHook<{
-    groupId: string;
-    groupName?: string;
-  }>("catalog.group.deleted"),
-} as const;
+export const catalogHooks = {} as const;