@checkstack/catalog-backend 0.2.9 → 0.2.10

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @checkstack/catalog-backend
 
+## 0.2.10
+
+### Patch Changes
+
+- Updated dependencies [e5079e1]
+  - @checkstack/catalog-common@1.2.6
+
 ## 0.2.9
 
 ### Patch Changes

package/drizzle/0001_early_madrox.sql

@@ -0,0 +1,13 @@
+CREATE TYPE "contact_type" AS ENUM('user', 'mailbox');--> statement-breakpoint
+CREATE TABLE "system_contacts" (
+	"id" text PRIMARY KEY NOT NULL,
+	"system_id" text NOT NULL,
+	"type" "contact_type" NOT NULL,
+	"user_id" text,
+	"email" text,
+	"label" text,
+	"created_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "system_contacts" ADD CONSTRAINT "system_contacts_system_id_systems_id_fk" FOREIGN KEY ("system_id") REFERENCES "systems"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "systems" DROP COLUMN "owner";

package/drizzle/meta/0001_snapshot.json

@@ -0,0 +1,309 @@
+{
+  "id": "72cd2f27-3627-475c-96f6-778b75a35418",
+  "prevId": "79e86bc7-76a2-429f-815c-2d6c263aab8f",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.groups": {
+      "name": "groups",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'{}'::json"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.system_contacts": {
+      "name": "system_contacts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "contact_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "system_contacts_system_id_systems_id_fk": {
+          "name": "system_contacts_system_id_systems_id_fk",
+          "tableFrom": "system_contacts",
+          "tableTo": "systems",
+          "columnsFrom": [
+            "system_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.systems": {
+      "name": "systems",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'{}'::json"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.systems_groups": {
+      "name": "systems_groups",
+      "schema": "",
+      "columns": {
+        "system_id": {
+          "name": "system_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "systems_groups_system_id_systems_id_fk": {
+          "name": "systems_groups_system_id_systems_id_fk",
+          "tableFrom": "systems_groups",
+          "tableTo": "systems",
+          "columnsFrom": [
+            "system_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "systems_groups_group_id_groups_id_fk": {
+          "name": "systems_groups_group_id_groups_id_fk",
+          "tableFrom": "systems_groups",
+          "tableTo": "groups",
+          "columnsFrom": [
+            "group_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "systems_groups_system_id_group_id_pk": {
+          "name": "systems_groups_system_id_group_id_pk",
+          "columns": [
+            "system_id",
+            "group_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.views": {
+      "name": "views",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "json",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::json"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.contact_type": {
+      "name": "contact_type",
+      "schema": "public",
+      "values": [
+        "user",
+        "mailbox"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle/meta/_journal.json

@@ -8,6 +8,13 @@
       "when": 1767319091249,
       "tag": "0000_purple_doomsday",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1769034170052,
+      "tag": "0001_early_madrox",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/catalog-backend",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
@@ -10,21 +10,23 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.5.1",
-    "@checkstack/catalog-common": "1.2.4",
-    "@checkstack/command-backend": "0.1.7",
-    "@checkstack/notification-common": "0.2.3",
+    "@checkstack/backend-api": "0.5.2",
+    "@checkstack/auth-common": "0.5.4",
+    "@checkstack/catalog-common": "1.2.5",
+    "@checkstack/command-backend": "0.1.8",
+    "@checkstack/auth-backend": "0.4.5",
+    "@checkstack/notification-common": "0.2.4",
     "@orpc/server": "^1.13.2",
     "drizzle-orm": "^0.45.1",
     "hono": "^4.0.0",
     "uuid": "^13.0.0",
     "zod": "^4.2.1",
-    "@checkstack/common": "0.6.0"
+    "@checkstack/common": "0.6.1"
   },
   "devDependencies": {
-    "@checkstack/drizzle-helper": "0.0.2",
-    "@checkstack/scripts": "0.1.0",
-    "@checkstack/tsconfig": "0.0.2",
+    "@checkstack/drizzle-helper": "0.0.3",
+    "@checkstack/scripts": "0.1.1",
+    "@checkstack/tsconfig": "0.0.3",
     "@types/bun": "^1.3.5",
     "@types/node": "^20.0.0",
     "@types/uuid": "^11.0.0",

package/src/index.ts

@@ -12,8 +12,11 @@ import {
 } from "@checkstack/catalog-common";
 import { createCatalogRouter } from "./router";
 import { NotificationApi } from "@checkstack/notification-common";
+import { AuthApi } from "@checkstack/auth-common";
+import { authHooks } from "@checkstack/auth-backend";
 import { resolveRoute, type InferClient } from "@checkstack/common";
 import { registerSearchProvider } from "@checkstack/command-backend";
+import { EntityService } from "./services/entity-service";
 
 // Database schema is still needed for types in creating the router
 import * as schema from "./schema";
@@ -43,11 +46,13 @@ export default createBackendPlugin({
 
         // Get notification client for group management and sending notifications
         const notificationClient = rpcClient.forPlugin(NotificationApi);
+        const authClient = rpcClient.forPlugin(AuthApi);
 
-        // Register oRPC router with notification client
+        // Register oRPC router with notification client and auth client
         const catalogRouter = createCatalogRouter({
           database: typedDb,
           notificationClient,
+          authClient,
           pluginId: pluginMetadata.pluginId,
         });
         rpc.registerRouter(catalogRouter, catalogContract);
@@ -108,12 +113,24 @@ export default createBackendPlugin({
         logger.debug("✅ Catalog Backend initialized.");
       },
       // Phase 3: Safe to make RPC calls after all plugins are ready
-      afterPluginsReady: async ({ database, rpcClient, logger }) => {
+      afterPluginsReady: async ({ database, rpcClient, logger, onHook }) => {
         const typedDb = database as SafeDatabase<typeof schema>;
         const notificationClient = rpcClient.forPlugin(NotificationApi);
 
         // Bootstrap: Create notification groups for existing systems and groups
         await bootstrapNotificationGroups(typedDb, notificationClient, logger);
+
+        // Subscribe to user deletion to clean up user contacts
+        onHook(
+          authHooks.userDeleted,
+          async ({ userId }) => {
+            logger.debug(`Cleaning up contacts for deleted user: ${userId}`);
+            const entityService = new EntityService(typedDb);
+            await entityService.deleteContactsByUserId(userId);
+            logger.debug(`Cleaned up contacts for user: ${userId}`);
+          },
+          { mode: "work-queue", workerGroup: "user-cleanup" },
+        );
       },
     });
   },

package/src/router.ts

@@ -1,10 +1,14 @@
 import { implement, ORPCError } from "@orpc/server";
 import { autoAuthMiddleware, type RpcContext } from "@checkstack/backend-api";
-import { catalogContract } from "@checkstack/catalog-common";
+import {
+  catalogContract,
+  type SystemContact,
+} from "@checkstack/catalog-common";
 import { EntityService } from "./services/entity-service";
 import type { SafeDatabase } from "@checkstack/backend-api";
 import * as schema from "./schema";
 import { NotificationApi } from "@checkstack/notification-common";
+import { AuthApi } from "@checkstack/auth-common";
 import type { InferClient } from "@checkstack/common";
 import { catalogHooks } from "./hooks";
 import { eq } from "drizzle-orm";
@@ -22,12 +26,14 @@ const os = implement(catalogContract)
 export interface CatalogRouterDeps {
   database: SafeDatabase<typeof schema>;
   notificationClient: InferClient<typeof NotificationApi>;
+  authClient: InferClient<typeof AuthApi>;
   pluginId: string;
 }
 
 export const createCatalogRouter = ({
   database,
   notificationClient,
+  authClient,
   pluginId,
 }: CatalogRouterDeps) => {
   const entityService = new EntityService(database);
@@ -36,7 +42,7 @@ export const createCatalogRouter = ({
   const createNotificationGroup = async (
     type: "system" | "group",
     id: string,
-    name: string
+    name: string,
   ) => {
     try {
       await notificationClient.createGroup({
@@ -49,7 +55,7 @@ export const createCatalogRouter = ({
       // Log but don't fail the operation
       console.warn(
         `Failed to create notification group for ${type} ${id}:`,
-        error
+        error,
       );
     }
   };
@@ -57,7 +63,7 @@ export const createCatalogRouter = ({
   // Helper to delete notification group for an entity
   const deleteNotificationGroup = async (
     type: "system" | "group",
-    id: string
+    id: string,
   ) => {
     try {
       await notificationClient.deleteGroup({
@@ -68,7 +74,7 @@ export const createCatalogRouter = ({
       // Log but don't fail the operation
       console.warn(
         `Failed to delete notification group for ${type} ${id}:`,
-        error
+        error,
       );
     }
   };
@@ -134,14 +140,11 @@ export const createCatalogRouter = ({
     const cleanData: Partial<{
       name: string;
       description?: string;
-      owner?: string;
       metadata?: Record<string, unknown>;
     }> = {};
     if (input.data.name !== undefined) cleanData.name = input.data.name;
     if (input.data.description !== undefined)
       cleanData.description = input.data.description ?? undefined;
-    if (input.data.owner !== undefined)
-      cleanData.owner = input.data.owner ?? undefined;
     if (input.data.metadata !== undefined)
       cleanData.metadata = input.data.metadata ?? undefined;
 
@@ -231,7 +234,7 @@ export const createCatalogRouter = ({
     async ({ input }) => {
       await entityService.removeSystemFromGroup(input);
       return { success: true };
-    }
+    },
   );
 
   const getViews = os.getViews.handler(async () => entityService.getViews());
@@ -244,6 +247,97 @@ export const createCatalogRouter = ({
     });
   });
 
+  // System Contacts handlers
+  const getSystemContacts = os.getSystemContacts.handler(async ({ input }) => {
+    const rawContacts = await entityService.getContactsForSystem(
+      input.systemId,
+    );
+
+    // Resolve user profiles for user-type contacts
+    const enrichedContacts: SystemContact[] = await Promise.all(
+      rawContacts.map(async (contact) => {
+        if (contact.type === "user" && contact.userId) {
+          // Resolve user profile via auth service
+          const user = await authClient.getUserById({ userId: contact.userId });
+          return {
+            id: contact.id,
+            systemId: contact.systemId,
+            type: "user" as const,
+            userId: contact.userId,
+            label: contact.label,
+            userName: user?.name ?? undefined,
+            userEmail: user?.email ?? undefined,
+            createdAt: contact.createdAt,
+          };
+        }
+        // Mailbox contact
+        return {
+          id: contact.id,
+          systemId: contact.systemId,
+          type: "mailbox" as const,
+          email: contact.email ?? "",
+          label: contact.label,
+          createdAt: contact.createdAt,
+        };
+      }),
+    );
+
+    return enrichedContacts;
+  });
+
+  const addSystemContact = os.addSystemContact.handler(async ({ input }) => {
+    // Validate input based on type
+    if (input.type === "user" && !input.userId) {
+      throw new ORPCError("BAD_REQUEST", {
+        message: "userId is required for user-type contacts",
+      });
+    }
+    if (input.type === "mailbox" && !input.email) {
+      throw new ORPCError("BAD_REQUEST", {
+        message: "email is required for mailbox-type contacts",
+      });
+    }
+
+    const result = await entityService.addContact({
+      systemId: input.systemId,
+      type: input.type,
+      userId: input.type === "user" ? input.userId : undefined,
+      email: input.type === "mailbox" ? input.email : undefined,
+      label: input.label,
+    });
+
+    // Return the enriched contact
+    if (result.type === "user" && result.userId) {
+      const user = await authClient.getUserById({ userId: result.userId });
+      return {
+        id: result.id,
+        systemId: result.systemId,
+        type: "user" as const,
+        userId: result.userId,
+        label: result.label,
+        userName: user?.name ?? undefined,
+        userEmail: user?.email ?? undefined,
+        createdAt: result.createdAt,
+      };
+    }
+
+    return {
+      id: result.id,
+      systemId: result.systemId,
+      type: "mailbox" as const,
+      email: result.email ?? "",
+      label: result.label,
+      createdAt: result.createdAt,
+    };
+  });
+
+  const removeSystemContact = os.removeSystemContact.handler(
+    async ({ input }) => {
+      await entityService.removeContact(input);
+      return { success: true };
+    },
+  );
+
   /**
    * Notify all users subscribed to a system (and optionally its groups).
    * Delegates deduplication to notification-backend via notifyGroups RPC.
@@ -272,7 +366,7 @@ export const createCatalogRouter = ({
 
         // Spread to avoid mutation
         groupIds.push(
-          ...systemGroups.map(({ groupId }) => `${pluginId}.group.${groupId}`)
+          ...systemGroups.map(({ groupId }) => `${pluginId}.group.${groupId}`),
         );
       }
 
@@ -286,7 +380,7 @@ export const createCatalogRouter = ({
       });
 
       return { notifiedCount: result.notifiedCount };
-    }
+    },
   );
 
   // Build and return the router
@@ -298,6 +392,9 @@ export const createCatalogRouter = ({
     createSystem,
     updateSystem,
     deleteSystem,
+    getSystemContacts,
+    addSystemContact,
+    removeSystemContact,
     createGroup,
     updateGroup,
     deleteGroup,

package/src/schema.ts

@@ -1,22 +1,40 @@
 import {
   pgTable,
+  pgEnum,
   text,
   timestamp,
   json,
   primaryKey,
 } from "drizzle-orm/pg-core";
 
+// Enums
+export const contactTypeEnum = pgEnum("contact_type", ["user", "mailbox"]);
+
 // Tables use pgTable (schemaless) - runtime schema is set via search_path
 export const systems = pgTable("systems", {
   id: text("id").primaryKey(),
   name: text("name").notNull(),
   description: text("description"),
-  owner: text("owner"), // user_id or group_id reference? Keeping as text for now.
   metadata: json("metadata").default({}),
   createdAt: timestamp("created_at").defaultNow().notNull(),
   updatedAt: timestamp("updated_at").defaultNow().notNull(),
 });
 
+export const systemContacts = pgTable("system_contacts", {
+  id: text("id").primaryKey(),
+  systemId: text("system_id")
+    .notNull()
+    .references(() => systems.id, { onDelete: "cascade" }),
+  type: contactTypeEnum("type").notNull(),
+  // For type="user": userId references auth user
+  userId: text("user_id"),
+  // For type="mailbox": store email directly
+  email: text("email"),
+  // Optional label for display (e.g., "On-Call", "Team Lead")
+  label: text("label"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+});
+
 export const groups = pgTable("groups", {
   id: text("id").primaryKey(),
   name: text("name").notNull(),
@@ -38,7 +56,7 @@ export const systemsGroups = pgTable(
   },
   (t) => ({
     pk: primaryKey(t.systemId, t.groupId),
-  })
+  }),
 );
 
 export const views = pgTable("views", {

package/src/services/entity-service.test.ts

@@ -37,7 +37,6 @@ describe("EntityService", () => {
     const fullSystem = {
       ...data,
       description: null,
-      owner: null,
       status: "healthy" as "healthy" | "degraded" | "unhealthy",
       metadata: {},
       createdAt: new Date(),
@@ -60,7 +59,6 @@ describe("EntityService", () => {
       id: "test",
       name: "Updated",
       description: null,
-      owner: null,
       status: "healthy" as "healthy" | "degraded" | "unhealthy",
       metadata: {},
       createdAt: new Date(),

package/src/services/entity-service.ts

@@ -7,10 +7,17 @@ import { v4 as uuidv4 } from "uuid";
 type NewSystem = {
   name: string;
   description?: string;
-  owner?: string;
   metadata?: Record<string, unknown>;
 };
 
+type NewContact = {
+  systemId: string;
+  type: "user" | "mailbox";
+  userId?: string;
+  email?: string;
+  label?: string;
+};
+
 type NewGroup = {
   name: string;
   metadata?: Record<string, unknown>;
@@ -63,6 +70,34 @@ export class EntityService {
     await this.database.delete(schema.systems).where(eq(schema.systems.id, id));
   }
 
+  // System Contacts
+  async getContactsForSystem(systemId: string) {
+    return this.database
+      .select()
+      .from(schema.systemContacts)
+      .where(eq(schema.systemContacts.systemId, systemId));
+  }
+
+  async addContact(data: NewContact) {
+    const result = await this.database
+      .insert(schema.systemContacts)
+      .values({ id: uuidv4(), ...data })
+      .returning();
+    return result[0];
+  }
+
+  async removeContact(contactId: string) {
+    await this.database
+      .delete(schema.systemContacts)
+      .where(eq(schema.systemContacts.id, contactId));
+  }
+
+  async deleteContactsByUserId(userId: string) {
+    await this.database
+      .delete(schema.systemContacts)
+      .where(eq(schema.systemContacts.userId, userId));
+  }
+
   // Groups
   async getGroups() {
     // Fetch all groups
@@ -124,8 +159,8 @@ export class EntityService {
       .where(
         and(
           eq(schema.systemsGroups.groupId, groupId),
-          eq(schema.systemsGroups.systemId, systemId)
-        )
+          eq(schema.systemsGroups.systemId, systemId),
+        ),
       );
   }