@palantir/pack.state.foundry 0.1.2 → 0.2.1

package/src/FoundryDocumentService.ts

@@ -16,24 +16,38 @@
 
 import type {
   CreateDocumentRequest,
-  DocumentSecurity,
+  DiscretionaryPrincipal,
+  DiscretionaryPrincipal as WireDiscretionaryPrincipal,
+  DocumentSecurity as WireDocumentSecurity,
   SearchDocumentsRequest,
 } from "@osdk/foundry.pack";
 import { Documents } from "@osdk/foundry.pack";
-import type { ModuleConfigTuple, PackAppInternal, Unsubscribe } from "@palantir/pack.core";
+import {
+  assertNever,
+  getOntologyRid,
+  type ModuleConfigTuple,
+  type PackAppInternal,
+  type Unsubscribe,
+} from "@palantir/pack.core";
 import type {
   ActivityEvent,
   DocumentId,
   DocumentMetadata,
   DocumentRef,
   DocumentSchema,
+  DocumentSecurity,
   Model,
   ModelData,
   PresenceEvent,
   PresenceSubscriptionOptions,
 } from "@palantir/pack.document-schema.model-types";
 import { getMetadata } from "@palantir/pack.document-schema.model-types";
-import type { DocumentService, InternalYjsDoc } from "@palantir/pack.state.core";
+import type {
+  CreateDocumentMetadata,
+  DocumentService,
+  InternalYjsDoc,
+  SearchDocumentsResult,
+} from "@palantir/pack.state.core";
 import {
   BaseYjsDocumentService,
   createDocumentServiceConfig,
@@ -44,6 +58,10 @@ import { createFoundryEventService } from "@palantir/pack.state.foundry-event";
 import { getActivityEvent, getPresenceEvent } from "./eventMappers.js";
 
 const DEFAULT_USE_PREVIEW_API = true;
+const EMPTY_DOCUMENT_SECURITY: DocumentSecurity = Object.freeze({
+  discretionary: {},
+  mandatory: {},
+});
 
 interface FoundryDocumentServiceConfig {
   readonly usePreviewApi?: boolean;
@@ -83,7 +101,10 @@ export class FoundryDocumentService extends BaseYjsDocumentService<FoundryIntern
   ) {
     super(
       app,
-      app.config.logger.child({}, { level: "debug", msgPrefix: "FoundryDocumentService" }),
+      app.config.logger.child(
+        {},
+        { level: "debug", msgPrefix: "FoundryDocumentService" },
+      ),
     );
   }
 
@@ -98,22 +119,23 @@ export class FoundryDocumentService extends BaseYjsDocumentService<FoundryIntern
   }
 
   get hasMetadataSubscriptions(): boolean {
-    return Array.from(this.documents.values()).some(doc =>
-      this.hasSubscriptions(doc) && doc.metadataSubscribers.size > 0
+    return Array.from(this.documents.values()).some(
+      doc => this.hasSubscriptions(doc) && doc.metadataSubscribers.size > 0,
     );
   }
 
   get hasStateSubscriptions(): boolean {
-    return Array.from(this.documents.values()).some(doc =>
-      this.hasSubscriptions(doc) && doc.docStateSubscribers.size > 0
+    return Array.from(this.documents.values()).some(
+      doc => this.hasSubscriptions(doc) && doc.docStateSubscribers.size > 0,
     );
   }
 
   readonly createDocument = async <T extends DocumentSchema>(
-    metadata: DocumentMetadata,
+    metadata: CreateDocumentMetadata,
     schema: T,
   ): Promise<DocumentRef<T>> => {
-    const { documentTypeName, name, ontologyRid, security } = metadata;
+    const { documentTypeName, name, security } = metadata;
+    const ontologyRid = await getOntologyRid(this.app);
 
     const request: CreateDocumentRequest = {
       documentTypeName: documentTypeName,
@@ -121,9 +143,13 @@ export class FoundryDocumentService extends BaseYjsDocumentService<FoundryIntern
       ontologyRid: ontologyRid,
       security: getWireSecurity(security),
     };
-    const createResponse = await Documents.create(this.app.config.osdkClient, request, {
-      preview: this.config.usePreviewApi ?? DEFAULT_USE_PREVIEW_API,
-    });
+    const createResponse = await Documents.create(
+      this.app.config.osdkClient,
+      request,
+      {
+        preview: this.config.usePreviewApi ?? DEFAULT_USE_PREVIEW_API,
+      },
+    );
 
     const documentId = createResponse.id as DocumentId;
     const docRef = this.createDocRef(documentId, schema);
@@ -135,26 +161,43 @@ export class FoundryDocumentService extends BaseYjsDocumentService<FoundryIntern
     schema: T,
     options?: {
       documentName?: string;
-      limit?: number;
+      pageSize?: number;
+      pageToken?: string;
     },
-  ): Promise<ReadonlyArray<DocumentMetadata & { readonly id: DocumentId }>> => {
+  ): Promise<SearchDocumentsResult> => {
     const request: SearchDocumentsRequest = {
       documentTypeName,
-      limit: options?.limit,
-      searchQuery: options?.documentName ? { documentName: options.documentName } : undefined,
+      searchQuery: options != null
+        ? {
+          documentName: options.documentName,
+          pageSize: options.pageSize,
+          pageToken: options.pageToken,
+        }
+        : undefined,
     };
 
-    const searchResponse = await Documents.search(this.app.config.osdkClient, request, {
-      preview: this.config.usePreviewApi ?? DEFAULT_USE_PREVIEW_API,
-    });
+    const searchResponse = await Documents.search(
+      this.app.config.osdkClient,
+      request,
+      {
+        preview: this.config.usePreviewApi ?? DEFAULT_USE_PREVIEW_API,
+      },
+    );
 
-    return searchResponse.map(doc => ({
-      documentTypeName: doc.documentTypeName,
-      id: doc.id as DocumentId,
-      name: doc.name,
-      ontologyRid: "unknown",
-      security: { discretionary: { owners: [] }, mandatory: {} },
-    }));
+    return {
+      data: searchResponse.data.map(doc => ({
+        createdBy: doc.createdBy,
+        createdTime: doc.createdTime,
+        documentTypeName: doc.documentTypeName,
+        id: doc.id as DocumentId,
+        name: doc.name,
+        ontologyRid: "unknown",
+        security: { discretionary: { owners: [] }, mandatory: {} },
+        updatedBy: doc.updatedBy,
+        updatedTime: doc.updatedTime,
+      })),
+      nextPageToken: searchResponse.nextPageToken,
+    };
   };
 
   protected onMetadataSubscriptionOpened(
@@ -189,7 +232,9 @@ export class FoundryDocumentService extends BaseYjsDocumentService<FoundryIntern
         });
       })
       .catch((e: unknown) => {
-        const error = new Error("Failed to load document metadata", { cause: e });
+        const error = new Error("Failed to load document metadata", {
+          cause: e,
+        });
         this.updateMetadataStatus(internalDoc, docRef, {
           error,
           load: DocumentLoadStatus.ERROR,
@@ -217,8 +262,7 @@ export class FoundryDocumentService extends BaseYjsDocumentService<FoundryIntern
   protected onMetadataSubscriptionClosed(
     _internalDoc: FoundryInternalDoc,
     _docRef: DocumentRef,
-  ): void {
-  }
+  ): void {}
 
   protected onDataSubscriptionClosed(
     internalDoc: FoundryInternalDoc,
@@ -239,21 +283,20 @@ export class FoundryDocumentService extends BaseYjsDocumentService<FoundryIntern
       unsubscribed = true;
     };
 
-    this.eventService.subscribeToActivityUpdates(
-      docRef.id,
-      foundryEvent => {
+    this.eventService
+      .subscribeToActivityUpdates(docRef.id, foundryEvent => {
         if (!unsubscribed) {
           const localEvent = getActivityEvent(docRef.schema, foundryEvent);
           if (localEvent != null) {
             callback(docRef, localEvent);
           }
         }
-      },
-    ).catch((e: unknown) => {
-      this.logger.error("Failed to subscribe to activity updates", e, {
-        docId: docRef.id,
+      })
+      .catch((e: unknown) => {
+        this.logger.error("Failed to subscribe to activity updates", e, {
+          docId: docRef.id,
+        });
       });
-    });
 
     return unsubscribeFn;
   }
@@ -268,20 +311,22 @@ export class FoundryDocumentService extends BaseYjsDocumentService<FoundryIntern
       unsubscribed = true;
     };
 
-    this.eventService.subscribeToPresenceUpdates(
-      docRef.id,
-      foundryUpdate => {
-        if (!unsubscribed) {
-          const localEvent = getPresenceEvent(docRef.schema, foundryUpdate);
-          callback(docRef, localEvent);
-        }
-      },
-      options,
-    ).catch((e: unknown) => {
-      this.logger.error("Failed to subscribe to presence updates", e, {
-        docId: docRef.id,
+    this.eventService
+      .subscribeToPresenceUpdates(
+        docRef.id,
+        foundryUpdate => {
+          if (!unsubscribed) {
+            const localEvent = getPresenceEvent(docRef.schema, foundryUpdate);
+            callback(docRef, localEvent);
+          }
+        },
+        options,
+      )
+      .catch((e: unknown) => {
+        this.logger.error("Failed to subscribe to presence updates", e, {
+          docId: docRef.id,
+        });
       });
-    });
 
     return unsubscribeFn;
   }
@@ -293,34 +338,46 @@ export class FoundryDocumentService extends BaseYjsDocumentService<FoundryIntern
   ): void {
     const eventType = getMetadata(model).name;
 
-    void this.eventService.publishCustomPresence(
-      docRef.id,
-      eventType,
-      eventData,
-    ).catch((e: unknown) => {
-      this.logger.error("Failed to publish custom presence", e, {
-        docId: docRef.id,
+    void this.eventService
+      .publishCustomPresence(docRef.id, eventType, eventData)
+      .catch((e: unknown) => {
+        this.logger.error("Failed to publish custom presence", e, {
+          docId: docRef.id,
+        });
       });
-    });
   }
 }
 
-function mutableArray<T>(array?: readonly T[]): T[] {
-  return array == null ? [] : (array as T[]);
-}
+function getWireSecurity({
+  discretionary,
+  mandatory,
+}: DocumentSecurity = EMPTY_DOCUMENT_SECURITY): WireDocumentSecurity {
+  const { editors = [], owners = [], viewers = [] } = discretionary;
 
-function getWireSecurity(
-  security: DocumentMetadata["security"],
-): DocumentSecurity {
   return {
     discretionary: {
-      editors: [...(security.discretionary.editors ?? [])],
-      owners: [...security.discretionary.owners],
-      viewers: [...(security.discretionary.viewers ?? [])],
+      editors: editors.map(getWirePrincipal),
+      owners: owners.map(getWirePrincipal),
+      viewers: viewers.map(getWirePrincipal),
     },
     mandatory: {
-      classification: mutableArray(security.mandatory.classification),
-      markings: mutableArray(security.mandatory.markings),
+      classification: mandatory.classification != null ? [...mandatory.classification] : [],
+      markings: mandatory.markings != null ? [...mandatory.markings] : [],
     },
   };
 }
+
+function getWirePrincipal(
+  principal: DiscretionaryPrincipal,
+): WireDiscretionaryPrincipal {
+  switch (principal.type) {
+    case "all":
+      return { type: "all" };
+    case "groupId":
+      return { type: "groupId", groupId: principal.groupId };
+    case "userId":
+      return { type: "userId", userId: principal.userId };
+    default:
+      assertNever(principal);
+  }
+}

package/src/eventMappers.ts

@@ -17,11 +17,16 @@
 import type {
   ActivityCollaborativeUpdate,
   ActivityEvent as FoundryActivityEvent,
+  PresenceCollaborativeUpdate,
 } from "@osdk/foundry.pack";
 import { invalidUserRef } from "@palantir/pack.auth";
 import type {
   ActivityEvent,
   ActivityEventData,
+  ActivityEventDataDocumentCreate,
+  ActivityEventDataDocumentDescriptionUpdate,
+  ActivityEventDataDocumentRename,
+  ActivityEventDataDocumentSecurityUpdate,
   DocumentSchema,
   Model,
   ModelData,
@@ -35,7 +40,6 @@ import {
   ActivityEventDataType,
   PresenceEventDataType,
 } from "@palantir/pack.document-schema.model-types";
-import type { PresenceCollaborativeUpdate } from "@palantir/pack.state.foundry-event";
 
 export function getActivityEvent(
   documentSchema: DocumentSchema,
@@ -58,11 +62,54 @@ 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,
 ): ActivityEventData {
-  // TODO: handle standard activity events
+  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) {
@@ -82,6 +129,55 @@ function getActivityEventData(
   };
 }
 
+function getPlatformActivityEventData(
+  eventType: string,
+  data: unknown,
+): ActivityEventData | undefined {
+  switch (eventType) {
+    case PlatformEventType.DOCUMENT_CREATE: {
+      const wireData = data as WireDocumentCreateEvent;
+      return {
+        initialMandatorySecurity: {
+          classification: wireData.initialMandatorySecurity?.classification,
+          markings: wireData.initialMandatorySecurity?.markings,
+        },
+        name: wireData.name ?? "",
+        type: ActivityEventDataType.DOCUMENT_CREATE,
+      } satisfies ActivityEventDataDocumentCreate;
+    }
+
+    case PlatformEventType.DOCUMENT_RENAME: {
+      const wireData = data as WireDocumentRenameEvent;
+      return {
+        newName: wireData.newName ?? "",
+        previousName: wireData.previousName ?? "",
+        type: ActivityEventDataType.DOCUMENT_RENAME,
+      } satisfies ActivityEventDataDocumentRename;
+    }
+
+    case PlatformEventType.DOCUMENT_DESCRIPTION_UPDATE: {
+      const wireData = data as WireDocumentDescriptionUpdateEvent;
+      return {
+        isInitial: wireData.isInitial ?? false,
+        newDescription: wireData.newDescription ?? "",
+        type: ActivityEventDataType.DOCUMENT_DESCRIPTION_UPDATE,
+      } satisfies ActivityEventDataDocumentDescriptionUpdate;
+    }
+
+    case PlatformEventType.DOCUMENT_SECURITY_UPDATE: {
+      const wireData = data as WireDocumentSecurityUpdateEvent;
+      return {
+        newClassification: wireData.newClassification ?? [],
+        newMarkings: wireData.newMarkings ?? [],
+        type: ActivityEventDataType.DOCUMENT_SECURITY_UPDATE,
+      } satisfies ActivityEventDataDocumentSecurityUpdate;
+    }
+
+    default:
+      return undefined;
+  }
+}
+
 const ARRIVED_DATA: PresenceEventDataArrived = {
   type: PresenceEventDataType.ARRIVED,
 } as const;
@@ -96,7 +192,7 @@ export function getPresenceEvent(
 ): PresenceEvent {
   switch (foundryUpdate.type) {
     case "presenceChangeEvent": {
-      const { userId, status } = foundryUpdate.presenceChangeEvent;
+      const { userId, status } = foundryUpdate;
       const eventData = status === "PRESENT" ? ARRIVED_DATA : DEPARTED_DATA;
       return {
         eventData,
@@ -105,7 +201,7 @@ export function getPresenceEvent(
     }
 
     case "customPresenceEvent": {
-      const { userId, eventData } = foundryUpdate.customPresenceEvent;
+      const { userId, eventData } = foundryUpdate;
       const presenceEventData = getPresenceEventData(documentSchema, eventData);
       return {
         eventData: presenceEventData,