@palantir/pack.state.foundry 0.8.0 → 0.10.0

package/src/__tests__/eventMappers.test.ts

@@ -0,0 +1,258 @@
+/*
+ * Copyright 2026 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { ActivityCollaborativeUpdate } from "@osdk/foundry.pack";
+import type { DocumentSchema, Model } from "@palantir/pack.document-schema.model-types";
+import { ActivityEventDataType, Metadata } from "@palantir/pack.document-schema.model-types";
+import { describe, expect, it } from "vitest";
+import { getActivityEvent } from "../eventMappers.js";
+
+const mockModel = {
+  __type: {} as { someField: string },
+  zodSchema: {} as Model["zodSchema"],
+  [Metadata]: { name: "TestModel" },
+} as unknown as Model;
+
+const emptySchema = {
+  [Metadata]: { name: "TestSchema", version: 0, models: {} },
+} as unknown as DocumentSchema;
+
+const schemaWithModel = {
+  ...emptySchema,
+  TestModel: mockModel,
+} as unknown as DocumentSchema;
+
+function makeActivityUpdate(
+  eventData: unknown,
+): ActivityCollaborativeUpdate {
+  return {
+    type: "activityCreated",
+    activityEvent: {
+      eventId: "event-1",
+      eventData,
+      isRead: false,
+      aggregationKey: "agg-1",
+      createdBy: "user-1",
+      createdTime: "2026-01-01T00:00:00Z",
+    },
+  } as ActivityCollaborativeUpdate;
+}
+
+describe("getActivityEvent", () => {
+  it("returns undefined for activityDeleted events", () => {
+    const update = {
+      type: "activityDeleted",
+      eventId: "event-1",
+      aggregationKey: "agg-1",
+    } as ActivityCollaborativeUpdate;
+
+    expect(getActivityEvent(emptySchema, update)).toBeUndefined();
+  });
+
+  it("maps documentCreate events", () => {
+    const result = getActivityEvent(
+      emptySchema,
+      makeActivityUpdate({
+        type: "documentCreate",
+        name: "My Document",
+        initialMandatorySecurity: {
+          classification: ["SECRET"],
+          markings: ["marking-1"],
+        },
+      }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.eventData).toEqual({
+      type: ActivityEventDataType.DOCUMENT_CREATE,
+      name: "My Document",
+      initialMandatorySecurity: {
+        classification: ["SECRET"],
+        markings: ["marking-1"],
+      },
+    });
+  });
+
+  it("maps documentCreate with missing fields to defaults", () => {
+    const result = getActivityEvent(
+      emptySchema,
+      makeActivityUpdate({
+        type: "documentCreate",
+        initialMandatorySecurity: undefined,
+      }),
+    );
+
+    expect(result!.eventData).toEqual({
+      type: ActivityEventDataType.DOCUMENT_CREATE,
+      name: "",
+      initialMandatorySecurity: {
+        classification: undefined,
+        markings: undefined,
+      },
+    });
+  });
+
+  it("maps documentRename events", () => {
+    const result = getActivityEvent(
+      emptySchema,
+      makeActivityUpdate({
+        type: "documentRename",
+        previousName: "Old Name",
+        newName: "New Name",
+      }),
+    );
+
+    expect(result!.eventData).toEqual({
+      type: ActivityEventDataType.DOCUMENT_RENAME,
+      previousName: "Old Name",
+      newName: "New Name",
+    });
+  });
+
+  it("maps documentDescriptionUpdate events", () => {
+    const result = getActivityEvent(
+      emptySchema,
+      makeActivityUpdate({
+        type: "documentDescriptionUpdate",
+        newDescription: "Updated description",
+        isInitial: false,
+      }),
+    );
+
+    expect(result!.eventData).toEqual({
+      type: ActivityEventDataType.DOCUMENT_DESCRIPTION_UPDATE,
+      newDescription: "Updated description",
+      isInitial: false,
+    });
+  });
+
+  it("maps documentMandatorySecurityUpdate events", () => {
+    const result = getActivityEvent(
+      emptySchema,
+      makeActivityUpdate({
+        type: "documentMandatorySecurityUpdate",
+        newClassification: ["test-classification"],
+        newMarkings: ["test-marking"],
+      }),
+    );
+
+    expect(result!.eventData).toEqual({
+      type: ActivityEventDataType.DOCUMENT_MANDATORY_SECURITY_UPDATE,
+      newClassification: ["test-classification"],
+      newMarkings: ["test-marking"],
+    });
+  });
+
+  it("maps documentDiscretionarySecurityUpdate events", () => {
+    const newSecurity = {
+      owners: [{ type: "all" as const }],
+      editors: [],
+      viewers: [],
+    };
+    const result = getActivityEvent(
+      emptySchema,
+      makeActivityUpdate({
+        type: "documentDiscretionarySecurityUpdate",
+        principalType: "ALL_PRINCIPAL",
+        previousDiscretionarySecurity: undefined,
+        newDiscretionarySecurity: newSecurity,
+      }),
+    );
+
+    expect(result!.eventData).toEqual({
+      type: ActivityEventDataType.DOCUMENT_DISCRETIONARY_SECURITY_UPDATE,
+      principalType: "ALL_PRINCIPAL",
+      previousDiscretionarySecurity: undefined,
+      newDiscretionarySecurity: newSecurity,
+    });
+  });
+
+  it("maps documentCustomEvent with known model to CUSTOM_EVENT", () => {
+    const customData = { eventType: "shapeAdd", nodeId: "node-1" };
+    const result = getActivityEvent(
+      schemaWithModel,
+      makeActivityUpdate({
+        type: "documentCustomEvent",
+        eventType: "TestModel",
+        data: customData,
+        version: 1,
+      }),
+    );
+
+    expect(result!.eventData).toEqual({
+      type: ActivityEventDataType.CUSTOM_EVENT,
+      model: mockModel,
+      eventType: "TestModel",
+      data: customData,
+    });
+  });
+
+  it("maps documentCustomEvent with unknown model to UNKNOWN", () => {
+    const customData = { eventType: "shapeAdd", nodeId: "node-1" };
+    const result = getActivityEvent(
+      emptySchema,
+      makeActivityUpdate({
+        type: "documentCustomEvent",
+        eventType: "NonExistentModel",
+        data: customData,
+        version: 1,
+      }),
+    );
+
+    expect(result!.eventData).toEqual({
+      type: ActivityEventDataType.UNKNOWN,
+      rawType: "NonExistentModel",
+      rawData: customData,
+    });
+  });
+
+  it("maps unrecognized event types to UNKNOWN", () => {
+    const result = getActivityEvent(
+      emptySchema,
+      makeActivityUpdate({
+        type: "someNewEventType",
+        someData: 123,
+      }),
+    );
+
+    expect(result!.eventData).toEqual({
+      type: ActivityEventDataType.UNKNOWN,
+      rawType: "someNewEventType",
+      rawData: { type: "someNewEventType", someData: 123 },
+    });
+  });
+
+  it("populates top-level event fields correctly", () => {
+    const result = getActivityEvent(
+      emptySchema,
+      makeActivityUpdate({
+        type: "documentCreate",
+        name: "Test",
+        initialMandatorySecurity: { classification: [], markings: [] },
+      }),
+    );
+
+    expect(result).toMatchObject({
+      eventId: "event-1",
+      aggregationKey: "agg-1",
+      createdBy: "user-1",
+      isRead: false,
+    });
+    expect(result!.createdInstant).toEqual(
+      new Date("2026-01-01T00:00:00Z").getTime(),
+    );
+  });
+});

package/src/eventMappers.ts

@@ -25,8 +25,9 @@ import type {
   ActivityEventData,
   ActivityEventDataDocumentCreate,
   ActivityEventDataDocumentDescriptionUpdate,
+  ActivityEventDataDocumentDiscretionarySecurityUpdate,
+  ActivityEventDataDocumentMandatorySecurityUpdate,
   ActivityEventDataDocumentRename,
-  ActivityEventDataDocumentSecurityUpdate,
   DocumentSchema,
   Model,
   ModelData,
@@ -62,119 +63,79 @@ export function getActivityEvent(
   };
 }
 
-/**
- * Platform event type names as sent by backpack.
- * Note: Only DOCUMENT_CREATE is currently emitted by the backend.
- * Remaining types are included for future use.
- */
-const PlatformEventType = {
-  DOCUMENT_CREATE: "DocumentCreateEvent",
-  DOCUMENT_DESCRIPTION_UPDATE: "DocumentDescriptionUpdateEvent",
-  DOCUMENT_RENAME: "DocumentRenameEvent",
-  DOCUMENT_SECURITY_UPDATE: "DocumentMandatorySecurityUpdateEvent",
-} as const;
-
-interface WireDocumentCreateEvent {
-  readonly name?: string;
-  readonly initialMandatorySecurity?: {
-    readonly classification?: readonly string[];
-    readonly markings?: readonly string[];
-  };
-}
-
-interface WireDocumentRenameEvent {
-  readonly previousName?: string;
-  readonly newName?: string;
-}
-
-interface WireDocumentDescriptionUpdateEvent {
-  readonly newDescription?: string;
-  readonly isInitial?: boolean;
-}
-
-interface WireDocumentSecurityUpdateEvent {
-  readonly newClassification?: readonly string[];
-  readonly newMarkings?: readonly string[];
-}
-
 function getActivityEventData(
   docSchema: DocumentSchema,
-  { eventData, eventType }: FoundryActivityEvent,
+  { eventData }: FoundryActivityEvent,
 ): ActivityEventData {
-  const platformEventData = getPlatformActivityEventData(
-    eventType,
-    eventData.data,
-  );
-  if (platformEventData != null) {
-    return platformEventData;
-  }
-
-  // Handle custom application-defined activity events
-  // TODO: validate model is valid for activity events
-  const model = docSchema[eventType];
-  if (model == null) {
-    return {
-      rawData: eventData.data,
-      rawType: eventType,
-      type: ActivityEventDataType.UNKNOWN,
-    };
-  }
-
-  // TODO: validate data against model schema
-
-  return {
-    eventData: eventData.data as ModelData<Model>,
-    model,
-    type: ActivityEventDataType.CUSTOM_EVENT,
-  };
-}
-
-function getPlatformActivityEventData(
-  eventType: string,
-  data: unknown,
-): ActivityEventData | undefined {
-  switch (eventType) {
-    case PlatformEventType.DOCUMENT_CREATE: {
-      const wireData = data as WireDocumentCreateEvent;
+  switch (eventData.type) {
+    case "documentCreate":
       return {
         initialMandatorySecurity: {
-          classification: wireData.initialMandatorySecurity?.classification,
-          markings: wireData.initialMandatorySecurity?.markings,
+          classification: eventData.initialMandatorySecurity?.classification,
+          markings: eventData.initialMandatorySecurity?.markings,
         },
-        name: wireData.name ?? "",
+        name: eventData.name ?? "",
         type: ActivityEventDataType.DOCUMENT_CREATE,
       } satisfies ActivityEventDataDocumentCreate;
-    }
 
-    case PlatformEventType.DOCUMENT_RENAME: {
-      const wireData = data as WireDocumentRenameEvent;
+    case "documentRename":
       return {
-        newName: wireData.newName ?? "",
-        previousName: wireData.previousName ?? "",
+        newName: eventData.newName ?? "",
+        previousName: eventData.previousName ?? "",
         type: ActivityEventDataType.DOCUMENT_RENAME,
       } satisfies ActivityEventDataDocumentRename;
-    }
 
-    case PlatformEventType.DOCUMENT_DESCRIPTION_UPDATE: {
-      const wireData = data as WireDocumentDescriptionUpdateEvent;
+    case "documentDescriptionUpdate":
       return {
-        isInitial: wireData.isInitial ?? false,
-        newDescription: wireData.newDescription ?? "",
+        isInitial: eventData.isInitial ?? false,
+        newDescription: eventData.newDescription ?? "",
         type: ActivityEventDataType.DOCUMENT_DESCRIPTION_UPDATE,
       } satisfies ActivityEventDataDocumentDescriptionUpdate;
-    }
 
-    case PlatformEventType.DOCUMENT_SECURITY_UPDATE: {
-      const wireData = data as WireDocumentSecurityUpdateEvent;
+    case "documentMandatorySecurityUpdate":
+      return {
+        newClassification: eventData.newClassification ?? [],
+        newMarkings: eventData.newMarkings ?? [],
+        type: ActivityEventDataType.DOCUMENT_MANDATORY_SECURITY_UPDATE,
+      } satisfies ActivityEventDataDocumentMandatorySecurityUpdate;
+
+    case "documentDiscretionarySecurityUpdate":
       return {
-        newClassification: wireData.newClassification ?? [],
-        newMarkings: wireData.newMarkings ?? [],
-        type: ActivityEventDataType.DOCUMENT_SECURITY_UPDATE,
-      } satisfies ActivityEventDataDocumentSecurityUpdate;
+        principalType: eventData.principalType ?? "",
+        previousDiscretionarySecurity: eventData.previousDiscretionarySecurity,
+        newDiscretionarySecurity: eventData.newDiscretionarySecurity ?? [],
+        type: ActivityEventDataType.DOCUMENT_DISCRETIONARY_SECURITY_UPDATE,
+      } satisfies ActivityEventDataDocumentDiscretionarySecurityUpdate;
+
+    case "documentCustomEvent": {
+      const { eventType, data } = eventData;
+      // TODO: validate model is valid for activity events
+      const model = docSchema[eventType];
+      if (model == null) {
+        return {
+          rawData: data,
+          rawType: eventType,
+          type: ActivityEventDataType.UNKNOWN,
+        };
+      }
+
+      // TODO: validate data against model schema
+      return {
+        data: data as ModelData<Model>,
+        eventType,
+        model,
+        type: ActivityEventDataType.CUSTOM_EVENT,
+      };
     }
 
-    default:
-      return undefined;
+    default: {
+      const unknownEventData = eventData as Record<string, unknown>;
+      return {
+        rawData: eventData,
+        rawType: typeof unknownEventData.type === "string" ? unknownEventData.type : "unknown",
+        type: ActivityEventDataType.UNKNOWN,
+      };
+    }
   }
 }