@supernova-studio/client 1.96.6 → 1.96.7

package/src/yjs/thread-room/frontend.ts

@@ -0,0 +1,39 @@
+import * as Y from "yjs";
+import { DTOFeatureAgentResponseTracker } from "../../api/dto/forge/feature-messages";
+import { ThreadRoomBaseYDoc, ThreadRoomBaseYDocState } from "./base";
+
+export class FrontendThreadRoomYDoc {
+  private readonly yDoc: Y.Doc;
+
+  constructor(yDoc: Y.Doc, private readonly debug = false) {
+    this.yDoc = yDoc;
+  }
+
+  //
+  // State Access
+  //
+
+  getState(): ThreadRoomBaseYDocState {
+    const doc = new ThreadRoomBaseYDoc(this.yDoc);
+    return doc.getState();
+  }
+
+  //
+  // Agent Response Trackers
+  //
+
+  getAgentResponseTrackers(): DTOFeatureAgentResponseTracker[] {
+    const doc = new ThreadRoomBaseYDoc(this.yDoc);
+    return doc.getAgentResponseTrackers();
+  }
+
+  updateAgentResponseTracker(tracker: DTOFeatureAgentResponseTracker) {
+    const doc = new ThreadRoomBaseYDoc(this.yDoc);
+    return doc.updateAgentResponseTrackers([tracker]);
+  }
+
+  deleteAgentResponseTrackers(id: string) {
+    const doc = new ThreadRoomBaseYDoc(this.yDoc);
+    return doc.deleteAgentResponseTrackers([id]);
+  }
+}

package/src/yjs/thread-room/index.ts

@@ -0,0 +1,3 @@
+export * from "./backend";
+export * from "./base";
+export * from "./frontend";

package/src/yjs/utils/index.ts

@@ -0,0 +1 @@
+export * from "./key-value-storage";

package/src/yjs/utils/key-value-storage.ts

@@ -0,0 +1,57 @@
+import { YKeyValue } from "y-utility/y-keyvalue";
+import * as Y from "yjs";
+
+export interface YJSKeyValueStorage<T> {
+  forEach(fn: (item: T, key: string) => void): void;
+  get(key: string): T | undefined;
+  set(key: string, value: T): void;
+  delete(key: string): void;
+}
+
+export class YJSKeyValueStorageV1<T> implements YJSKeyValueStorage<T> {
+  private readonly map: Y.Map<T>;
+
+  constructor(yDoc: Y.Doc, key: string) {
+    this.map = yDoc.getMap(key);
+  }
+
+  forEach(fn: (item: T, key: string) => void): void {
+    this.map.forEach((value, key) => fn(value, key));
+  }
+
+  get(key: string): T | undefined {
+    return this.map.get(key);
+  }
+
+  set(key: string, value: T): void {
+    this.map.set(key, value);
+  }
+
+  delete(key: string): void {
+    this.map.delete(key);
+  }
+}
+
+export class YJSKeyValueStorageV2<T> implements YJSKeyValueStorage<T> {
+  private readonly kv: YKeyValue<T>;
+
+  constructor(yDoc: Y.Doc, key: string) {
+    this.kv = new YKeyValue(yDoc.getArray(key));
+  }
+
+  forEach(fn: (item: T, key: string) => void): void {
+    this.kv.yarray.forEach(({ key, val }) => fn(val, key));
+  }
+
+  get(key: string): T | undefined {
+    return this.kv.get(key);
+  }
+
+  set(key: string, value: T): void {
+    this.kv.set(key, value);
+  }
+
+  delete(key: string): void {
+    this.kv.delete(key);
+  }
+}

package/src/yjs/version-room/backend.ts

@@ -0,0 +1,101 @@
+import {
+  DocumentationPageApproval,
+  DocumentationPageSnapshot,
+  DocumentationPageV2,
+  ElementGroup,
+  ElementGroupSnapshot,
+} from "@supernova-studio/model";
+import * as Y from "yjs";
+import { DocumentationHierarchySettings } from "../design-system-content";
+import { VersionRoomBaseYDoc } from "./base";
+
+type DocumentationHierarchyTransaction = {
+  pages?: DocumentationPageV2[];
+  pageIdsToDelete?: string[];
+
+  groups?: ElementGroup[];
+  groupIdsToDelete?: string[];
+
+  pageSnapshots?: DocumentationPageSnapshot[];
+  pageSnapshotIdsToDelete?: string[];
+
+  groupSnapshots?: ElementGroupSnapshot[];
+  groupSnapshotIdsToDelete?: string[];
+
+  internalSettings?: Partial<DocumentationHierarchySettings>;
+
+  pageHashesToUpdate?: Record<string, string>;
+
+  pageApprovals?: DocumentationPageApproval[];
+  pageApprovalIdsToDelete?: string[];
+
+  executedTransactionIds?: string[];
+
+  roomMetadata?: {
+    storageVersion?: 1 | 2;
+  };
+};
+
+export class BackendVersionRoomYDoc {
+  private readonly yDoc: Y.Doc;
+
+  constructor(yDoc: Y.Doc) {
+    this.yDoc = yDoc;
+  }
+
+  getDocumentationHierarchy() {
+    const yDoc = new VersionRoomBaseYDoc(this.yDoc);
+
+    return {
+      pages: yDoc.getPages(),
+      pageSnapshots: yDoc.getPageSnapshots(),
+      groups: yDoc.getGroups(),
+      groupSnapshots: yDoc.getGroupSnapshots(),
+    };
+  }
+
+  updateDocumentationHierarchy(transaction: DocumentationHierarchyTransaction) {
+    this.yDoc.transact(trx => {
+      const yDoc = new VersionRoomBaseYDoc(trx.doc);
+
+      // Room metadata (needs to come first as it can define underlying mechanics of the room)
+      transaction.roomMetadata?.storageVersion && yDoc.setStorageVersion(transaction.roomMetadata.storageVersion);
+
+      // Pages
+      transaction.pageIdsToDelete && yDoc.deletePages(transaction.pageIdsToDelete);
+      transaction.pages && yDoc.updatePages(transaction.pages);
+
+      // Groups
+      transaction.groupIdsToDelete && yDoc.deleteGroups(transaction.groupIdsToDelete);
+      transaction.groups && yDoc.updateGroups(transaction.groups);
+
+      // Page snapshots
+      transaction.pageSnapshotIdsToDelete && yDoc.deletePageSnapshots(transaction.pageSnapshotIdsToDelete);
+      transaction.pageSnapshots && yDoc.updatePageSnapshots(transaction.pageSnapshots);
+
+      // Snapshots - published groups
+      transaction.groupSnapshotIdsToDelete && yDoc.deleteGroupSnapshots(transaction.groupSnapshotIdsToDelete);
+      transaction.groupSnapshots && yDoc.updateGroupSnapshots(transaction.groupSnapshots);
+
+      // Settings
+      transaction.internalSettings && yDoc.updateDocumentationInternalSettings(transaction.internalSettings);
+      transaction.pageHashesToUpdate && yDoc.updateDocumentationPageContentHashes(transaction.pageHashesToUpdate);
+      transaction.pageApprovals && yDoc.updateApprovalStates(transaction.pageApprovals);
+      transaction.pageApprovalIdsToDelete && yDoc.removeApprovalStates(transaction.pageApprovalIdsToDelete);
+
+      // Executed transaction ids
+      transaction.executedTransactionIds && yDoc.updateExecutedTransactionIds(transaction.executedTransactionIds);
+    });
+  }
+
+  getDocumentationPageContentHashes() {
+    const versionDoc = new VersionRoomBaseYDoc(this.yDoc);
+
+    // Limit each hash string by 100 characters
+    const validHashes = Object.entries(versionDoc.getDocumentationPageContentHashes()).filter(e => {
+      return e[1].length < 100;
+    });
+
+    return Object.fromEntries(validHashes);
+  }
+}

package/src/yjs/version-room/base.ts

@@ -0,0 +1,323 @@
+import {
+  DocumentationPageApproval,
+  DocumentationPageSnapshot,
+  DocumentationPageV2,
+  ElementGroup,
+  ElementGroupSnapshot,
+} from "@supernova-studio/model";
+import * as Y from "yjs";
+import { ZodSchema, ZodTypeDef } from "zod";
+import { DocumentationHierarchySettings } from "../design-system-content";
+import { YJSKeyValueStorage, YJSKeyValueStorageV1, YJSKeyValueStorageV2 } from "../utils/key-value-storage";
+import { VersionRoomBaseYDocState } from "./types";
+
+type YJSSerializable = { id: string };
+
+export class VersionRoomBaseYDoc {
+  private readonly yDoc: Y.Doc;
+
+  constructor(yDoc: Y.Doc) {
+    this.yDoc = yDoc;
+  }
+
+  getState(): VersionRoomBaseYDocState {
+    // For backward compatibility we are using groups array to determine if Y doc content
+    // was loaded: if the content was loaded there has to be at least one (root) group in
+    // the doc. To be improved later if needed.
+
+    const groups = this.getGroups();
+    const isLoaded = !!groups.length;
+
+    return {
+      isLoaded,
+      groups,
+      pages: this.getPages(),
+      approvals: this.getApprovals(),
+      groupSnapshots: this.getGroupSnapshots(),
+      pageContentHashes: this.getDocumentationPageContentHashes(),
+      pageSnapshots: this.getPageSnapshots(),
+      settings: this.getDocumentationInternalSettings(),
+      pageLiveblockRoomIds: this.getDocumentationPageLiveblocksRoomIds(),
+      executedTransactionIds: this.getExecutedTransactionIds(),
+      storageVersion: this.getStorageVersion(),
+    };
+  }
+
+  //
+  // Pages
+  //
+
+  getPages(): DocumentationPageV2[] {
+    return this.getObjects(this.pagesYMap, DocumentationPageV2);
+  }
+
+  updatePages(pages: DocumentationPageV2[]) {
+    pages = pages.map(page => {
+      // We remove blocks from the payload here because it will not get parsed anyway
+      return {
+        ...page,
+        data: {
+          configuration: page.data.configuration,
+        },
+      };
+    });
+
+    this.setObjects(this.pagesYMap, pages);
+  }
+
+  deletePages(ids: string[]) {
+    this.deleteObjects(this.pagesYMap, ids);
+  }
+
+  private get pagesYMap(): YJSKeyValueStorage<object> {
+    return this.getKeyValueStorage<object>("documentationPages");
+  }
+
+  //
+  // Groups
+  //
+
+  getGroups(): ElementGroup[] {
+    return this.getObjects(this.groupsYMap, ElementGroup);
+  }
+
+  updateGroups(groups: ElementGroup[]) {
+    this.setObjects(this.groupsYMap, groups);
+  }
+
+  deleteGroups(ids: string[]) {
+    this.deleteObjects(this.groupsYMap, ids);
+  }
+
+  private get groupsYMap(): YJSKeyValueStorage<object> {
+    return this.getKeyValueStorage<object>("documentationGroups");
+  }
+
+  //
+  // Documentation internal settings
+  //
+
+  getDocumentationInternalSettings(): DocumentationHierarchySettings {
+    const map = this.internalSettingsYMap;
+
+    const rawSettings: Record<keyof DocumentationHierarchySettings, any> = {
+      routingVersion: map.get("routingVersion"),
+      isDraftFeatureAdopted: map.get("isDraftFeatureAdopted") ?? false,
+      isApprovalFeatureEnabled: map.get("isApprovalFeatureEnabled") ?? false,
+      approvalRequiredForPublishing: map.get("approvalRequiredForPublishing") ?? false,
+    };
+
+    const settingsParseResult = DocumentationHierarchySettings.safeParse(rawSettings);
+    if (!settingsParseResult.success) {
+      return {
+        routingVersion: "2",
+        isDraftFeatureAdopted: false,
+        isApprovalFeatureEnabled: false,
+        approvalRequiredForPublishing: false,
+      };
+    }
+
+    return settingsParseResult.data;
+  }
+
+  updateDocumentationInternalSettings(settings: Partial<DocumentationHierarchySettings>) {
+    const map = this.internalSettingsYMap;
+    map.set("routingVersion", settings.routingVersion ?? map.get("routingVersion"));
+    map.set("isDraftFeatureAdopted", settings.isDraftFeatureAdopted ?? map.get("isDraftFeatureAdopted"));
+    map.set("isApprovalFeatureEnabled", settings.isApprovalFeatureEnabled ?? map.get("isApprovalFeatureEnabled"));
+    map.set(
+      "approvalRequiredForPublishing",
+      settings.approvalRequiredForPublishing ?? map.get("approvalRequiredForPublishing")
+    );
+  }
+
+  private get internalSettingsYMap(): YJSKeyValueStorage<unknown> {
+    return this.getKeyValueStorage<unknown>("documentationInternalSettings");
+  }
+
+  //
+  // Documentation page snapshot
+  //
+
+  getPageSnapshots(): DocumentationPageSnapshot[] {
+    return this.getObjects(this.documentationPagePublishedStatesYMap, DocumentationPageSnapshot);
+  }
+
+  updatePageSnapshots(snapshots: DocumentationPageSnapshot[]) {
+    this.setObjects(this.documentationPagePublishedStatesYMap, snapshots);
+  }
+
+  deletePageSnapshots(ids: string[]) {
+    this.deleteObjects(this.documentationPagePublishedStatesYMap, ids);
+  }
+
+  private get documentationPagePublishedStatesYMap(): YJSKeyValueStorage<object> {
+    return this.getKeyValueStorage<object>("documentationPageSnapshots");
+  }
+
+  //
+  // Documentation group snapshots
+  //
+
+  getGroupSnapshots(): ElementGroupSnapshot[] {
+    return this.getObjects(this.documentationGroupPublishedStatesYMap, ElementGroupSnapshot);
+  }
+
+  updateGroupSnapshots(snapshots: ElementGroupSnapshot[]) {
+    this.setObjects(this.documentationGroupPublishedStatesYMap, snapshots);
+  }
+
+  deleteGroupSnapshots(ids: string[]) {
+    this.deleteObjects(this.documentationGroupPublishedStatesYMap, ids);
+  }
+
+  private get documentationGroupPublishedStatesYMap(): YJSKeyValueStorage<object> {
+    return this.getKeyValueStorage<object>("documentationGroupSnapshots");
+  }
+
+  //
+  // Utils
+  //
+
+  private getObjects<T extends YJSSerializable, I>(
+    map: YJSKeyValueStorage<object>,
+    schema: ZodSchema<T, ZodTypeDef, I>
+  ): T[] {
+    const results: T[] = [];
+    map.forEach(object => results.push(schema.parse(object)));
+    return results;
+  }
+
+  private setObjects<T extends YJSSerializable>(map: YJSKeyValueStorage<object>, objects: T[]) {
+    objects.forEach(o => map.set(o.id, JSON.parse(JSON.stringify(o))));
+  }
+
+  private deleteObjects(map: YJSKeyValueStorage<object>, ids: string[]) {
+    ids.forEach(id => map.delete(id));
+  }
+
+  //
+  // Documentation page content hashes
+  //
+
+  getDocumentationPageContentHashes(): Record<string, string> {
+    const map = this.documentationPageContentHashesYMap;
+
+    const result: Record<string, string> = {};
+    map.forEach((hash, key) => {
+      if (typeof hash === "string") result[key] = hash;
+    });
+
+    return result;
+  }
+
+  getDocumentationPageLiveblocksRoomIds(): Record<string, string> {
+    const map = this.documentationPageLiveblocksRoomIdsYMap;
+
+    const result: Record<string, string> = {};
+    map.forEach((hash, key) => {
+      if (typeof hash === "string") result[key] = hash;
+    });
+
+    return result;
+  }
+
+  private get documentationPageLiveblocksRoomIdsYMap(): YJSKeyValueStorage<string> {
+    return this.getKeyValueStorage<string>("documentationPageLiveblocksRoomIds");
+  }
+
+  updateDocumentationPageContentHashes(hashes: Record<string, string>) {
+    const map = this.documentationPageContentHashesYMap;
+    Object.entries(hashes).forEach(([key, hash]) => map.set(key, hash));
+  }
+
+  private get documentationPageContentHashesYMap(): YJSKeyValueStorage<string> {
+    return this.getKeyValueStorage<string>("documentationPageHashes");
+  }
+
+  //
+  // Approval states
+  //
+
+  updateApprovalStates(updates: DocumentationPageApproval[]) {
+    this.setObjects(this.documentationPageApprovalsMap, updates);
+  }
+
+  removeApprovalStates(ids: string[]) {
+    this.deleteObjects(this.documentationPageApprovalsMap, ids);
+  }
+
+  getApprovals() {
+    return this.getObjects(this.documentationPageApprovalsMap, DocumentationPageApproval);
+  }
+
+  private get documentationPageApprovalsMap(): YJSKeyValueStorage<object> {
+    return this.getKeyValueStorage<object>("documentationPageApprovals");
+  }
+
+  //
+  // Executed transactions
+  //
+
+  updateExecutedTransactionIds(transactionIds: string[]) {
+    transactionIds = Array.from(new Set(transactionIds));
+    if (!transactionIds.length) return;
+
+    const array = this.executedTransactionIdsArray;
+
+    // Append transactions at the end
+    array.push(transactionIds);
+
+    // Trim from the beginning in case it contains more than 100
+    if (array.length > 100) {
+      array.delete(0, array.length - 100);
+    }
+  }
+
+  getExecutedTransactionIds(): string[] {
+    const array = this.executedTransactionIdsArray;
+
+    // Y.Array doesn't support filtering
+    const transactionIds: string[] = [];
+    array.forEach(e => typeof e === "string" && transactionIds.push(e));
+
+    return transactionIds;
+  }
+
+  private get executedTransactionIdsArray() {
+    return this.yDoc.getArray<unknown>("executedTransactionIds");
+  }
+
+  //
+  // Room metadata
+  //
+
+  setStorageVersion(version: 1 | 2) {
+    this.roomMetadataMap.set("storageVersion", version.toString());
+  }
+
+  getStorageVersion(): 1 | 2 {
+    const storageVersion = this.roomMetadataMap.get("storageVersion");
+    if (storageVersion === "2") return 2;
+    else return 1;
+  }
+
+  private get roomMetadataMap() {
+    return this.yDoc.getMap<string>("roomMetadata");
+  }
+
+  //
+  // Utils
+  //
+
+  private getKeyValueStorage<T>(key: string): YJSKeyValueStorage<T> {
+    const version = this.getStorageVersion();
+    switch (version) {
+      case 2:
+        key += "V2";
+        return new YJSKeyValueStorageV2(this.yDoc, key);
+      default:
+        return new YJSKeyValueStorageV1(this.yDoc, key);
+    }
+  }
+}