@supernova-studio/client 1.96.6 → 1.96.7

package/src/yjs/docs-editor/utils.ts

@@ -0,0 +1,115 @@
+import { PageBlockEditorModel } from "./model/block";
+import {
+  PageBlockDefinition,
+  PageBlockDefinitionPropertyType,
+  PageBlockItemEmbedValue,
+  PageBlockItemMultiRichTextValue,
+  PageBlockItemRichTextValue,
+  PageBlockItemTableValue,
+  PageBlockItemUntypedValue,
+  PageBlockItemV2,
+  PageBlockText,
+} from "@supernova-studio/model";
+
+export const BlockParsingUtils = {
+  singleBlockItem(block: PageBlockEditorModel) {
+    if (!block.data.items.length) throw new Error(`Block ${block.id} has no items`);
+    if (block.data.items.length > 1) throw new Error(`Block ${block.id} has more than 1 item`);
+
+    return block.data.items[0]!;
+  },
+
+  richTextPropertyValue(item: PageBlockItemV2, propertyKey: string): PageBlockItemRichTextValue {
+    const objectValue = this.objectPropertyValue(item, propertyKey);
+    const richText = PageBlockItemRichTextValue.parse(objectValue);
+
+    return richText;
+  },
+
+  multiRichTextPropertyValue(item: PageBlockItemV2, propertyKey: string): PageBlockItemMultiRichTextValue {
+    const objectValue = this.objectPropertyValue(item, propertyKey);
+    const richText = PageBlockItemMultiRichTextValue.parse(objectValue);
+
+    return richText;
+  },
+
+  tablePropertyValue(item: PageBlockItemV2, propertyKey: string): PageBlockItemTableValue {
+    const objectValue = this.objectPropertyValue(item, propertyKey);
+    const table = PageBlockItemTableValue.parse(objectValue);
+
+    return table;
+  },
+
+  embedPropertyValue(item: PageBlockItemV2, propertyKey: string): PageBlockItemEmbedValue {
+    const objectValue = this.objectPropertyValue(item, propertyKey);
+    const embed = PageBlockItemEmbedValue.parse(objectValue);
+
+    return embed;
+  },
+
+  objectPropertyValue(item: PageBlockItemV2, propertyKey: string) {
+    const value = this.propertyValueOrThrow(item, propertyKey);
+
+    if (typeof value !== "object") {
+      throw new Error(`Value for property ${propertyKey} is expected to be an object, but instead is ${typeof value}`);
+    }
+
+    return value;
+  },
+
+  propertyValueOrThrow(item: PageBlockItemV2, propertyKey: string): PageBlockItemUntypedValue {
+    const value = item.props[propertyKey];
+    if (!value) throw new Error(`Property ${propertyKey} is not defined on block item`);
+
+    return value;
+  },
+};
+
+export const BlockDefinitionUtils = {
+  firstRichTextProperty(definition: PageBlockDefinition) {
+    const property = definition.item.properties.find(p => p.type === "RichText");
+    if (property) return property;
+    return undefined;
+  },
+
+  firstMultiRichTextProperty(definition: PageBlockDefinition) {
+    const property = definition.item.properties.find(p => p.type === "MultiRichText");
+    if (property) return property;
+    return undefined;
+  },
+
+  firstTableProperty(definition: PageBlockDefinition) {
+    const property = definition.item.properties.find(p => p.type === "Table");
+    if (property) return property;
+    return undefined;
+  },
+
+  firstEmbedProperty(definition: PageBlockDefinition) {
+    const property = definition.item.properties.find(p => p.type === "EmbedURL");
+    if (property) return property;
+    return undefined;
+  },
+
+  richTextProperty(definition: PageBlockDefinition, propertyKey: string) {
+    return this.property(definition, propertyKey, "RichText");
+  },
+
+  property(
+    definition: PageBlockDefinition,
+    propertyKey: string,
+    expectedPropertyType?: PageBlockDefinitionPropertyType
+  ) {
+    const property = definition.item.properties.find(p => p.id === propertyKey);
+    if (!property) {
+      throw new Error(`Definition ${definition.id} doesn't contain property ${propertyKey}`);
+    }
+
+    if (expectedPropertyType && property.type !== expectedPropertyType) {
+      throw new Error(
+        `Property ${propertyKey} of definition ${definition.id} expected to be ${expectedPropertyType} but was ${property.type}`
+      );
+    }
+
+    return property;
+  },
+};

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

@@ -0,0 +1,36 @@
+import * as Y from "yjs";
+import { DTOFeatureAgentResponseTracker } from "../../api/dto/forge/feature-messages";
+import { FeatureRoomBaseYDoc } from "./base";
+
+type FeatureRoomTransaction = {
+  agentResponseTrackers?: DTOFeatureAgentResponseTracker[];
+  agentResponseTrackerIdsToDelete?: string[];
+
+  executedTransactionIds?: string[];
+};
+
+export class BackendFeatureRoomYDoc {
+  private readonly yDoc: Y.Doc;
+
+  constructor(yDoc: Y.Doc) {
+    this.yDoc = yDoc;
+  }
+
+  updateFeatureRoom(transaction: FeatureRoomTransaction) {
+    this.yDoc.transact(trx => {
+      const yDoc = new FeatureRoomBaseYDoc(trx.doc);
+      // Agent Response Trackers
+      transaction.agentResponseTrackerIdsToDelete &&
+        yDoc.deleteAgentResponseTrackers(transaction.agentResponseTrackerIdsToDelete);
+      transaction.agentResponseTrackers && yDoc.updateAgentResponseTrackers(transaction.agentResponseTrackers);
+
+      // Executed transaction ids
+      transaction.executedTransactionIds && yDoc.updateExecutedTransactionIds(transaction.executedTransactionIds);
+    });
+  }
+
+  getState() {
+    const featureRoomDoc = new FeatureRoomBaseYDoc(this.yDoc);
+    return featureRoomDoc.getState();
+  }
+}

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

@@ -0,0 +1,109 @@
+import * as Y from "yjs";
+import { ZodSchema, ZodTypeDef } from "zod";
+import { DTOFeatureAgentResponseTracker } from "../../api/dto/forge/feature-messages";
+
+type YJSSerializable = { id: string };
+
+export interface FeatureRoomBaseYDocState {
+  isLoaded: boolean;
+  agentResponseTrackers: DTOFeatureAgentResponseTracker[];
+  executedTransactionIds: string[];
+}
+
+export interface FeatureRoomUpdate {
+  agentResponseTrackers?: DTOFeatureAgentResponseTracker[];
+  agentResponseTrackerIdsToDelete?: string[];
+
+  executedTransactionIds?: string[];
+}
+
+export class FeatureRoomBaseYDoc {
+  private readonly yDoc: Y.Doc;
+
+  constructor(yDoc: Y.Doc) {
+    this.yDoc = yDoc;
+  }
+
+  getState(): FeatureRoomBaseYDocState {
+    const agentResponseTrackers = this.getAgentResponseTrackers();
+    const executedTransactionIds = this.getExecutedTransactionIds();
+    const isLoaded = true; // For now, consider it loaded if we can access the data
+
+    return {
+      isLoaded,
+      agentResponseTrackers,
+      executedTransactionIds,
+    };
+  }
+
+  //
+  // Agent Response Trackers
+  //
+
+  getAgentResponseTrackers(): DTOFeatureAgentResponseTracker[] {
+    return this.getObjects(this.agentResponseTrackersYMap, DTOFeatureAgentResponseTracker);
+  }
+
+  updateAgentResponseTrackers(trackers: DTOFeatureAgentResponseTracker[]) {
+    this.setObjects(this.agentResponseTrackersYMap, trackers);
+  }
+
+  deleteAgentResponseTrackers(ids: string[]) {
+    this.deleteObjects(this.agentResponseTrackersYMap, ids);
+  }
+
+  private get agentResponseTrackersYMap() {
+    return this.yDoc.getMap<object>("forgeFeatureAgentResponseTrackers");
+  }
+
+  //
+  // 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");
+  }
+
+  //
+  // Utility methods
+  //
+
+  private getObjects<T extends YJSSerializable, I>(map: Y.Map<object>, schema: ZodSchema<T, ZodTypeDef, I>): T[] {
+    const objects: T[] = [];
+    map.forEach(value => objects.push(schema.parse(value)));
+    return objects;
+  }
+
+  private setObjects<T extends YJSSerializable>(map: Y.Map<object>, objects: T[]) {
+    objects.forEach(o => map.set(o.id, JSON.parse(JSON.stringify(o))));
+  }
+
+  private deleteObjects(map: Y.Map<object>, ids: string[]) {
+    ids.forEach(id => map.delete(id));
+  }
+}

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

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

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

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

package/src/yjs/forge-project-room/backend.ts

@@ -0,0 +1,59 @@
+import { ForgeProjectArtifact, ForgeSection, ProjectFeature, ForgeRelation } from "@supernova-studio/model";
+import * as Y from "yjs";
+import { ForgeProjectRoomBaseYDoc } from "./base";
+
+type ForgeProjectRoomTransaction = {
+  artifacts?: ForgeProjectArtifact[];
+  artifactIdsToDelete?: string[];
+  features?: ProjectFeature[];
+  featureIdsToDelete?: string[];
+  artifactSections?: ForgeSection[];
+  artifactSectionIdsToDelete?: string[];
+  featureSections?: ForgeSection[];
+  featureSectionIdsToDelete?: string[];
+  relations?: ForgeRelation[];
+  executedTransactionIds?: string[];
+};
+
+export class BackendForgeProjectRoomYDoc {
+  private readonly yDoc: Y.Doc;
+
+  constructor(yDoc: Y.Doc) {
+    this.yDoc = yDoc;
+  }
+
+  updateWithLists(transaction: ForgeProjectRoomTransaction) {
+    this.yDoc.transact(trx => {
+      const yDoc = new ForgeProjectRoomBaseYDoc(trx.doc);
+
+      // Delete artifacts first
+      transaction.artifactIdsToDelete && yDoc.deleteArtifacts(transaction.artifactIdsToDelete);
+
+      // Then update/add artifacts
+      transaction.artifacts && yDoc.updateArtifacts(transaction.artifacts);
+
+      // Delete features
+      transaction.featureIdsToDelete && yDoc.deleteFeatures(transaction.featureIdsToDelete);
+
+      // Then update/add features
+      transaction.features && yDoc.updateFeatures(transaction.features);
+
+      // Delete artifact sections
+      transaction.artifactSectionIdsToDelete && yDoc.deleteArtifactSections(transaction.artifactSectionIdsToDelete);
+
+      // Then update/add artifact sections
+      transaction.artifactSections && yDoc.updateArtifactSections(transaction.artifactSections);
+
+      // Delete feature sections
+      transaction.featureSectionIdsToDelete && yDoc.deleteFeatureSections(transaction.featureSectionIdsToDelete);
+
+      // Then update/add feature sections
+      transaction.featureSections && yDoc.updateFeatureSections(transaction.featureSections);
+
+      // Then update/add relations
+      transaction.relations && yDoc.updateRelations(transaction.relations);
+
+      transaction.executedTransactionIds && yDoc.updateExecutedTransactionIds(transaction.executedTransactionIds);
+    });
+  }
+}

package/src/yjs/forge-project-room/base.ts

@@ -0,0 +1,190 @@
+import { ForgeProjectArtifact, ForgeSection, ProjectFeature, ForgeRelation } from "@supernova-studio/model";
+import * as Y from "yjs";
+import { ZodSchema, ZodTypeDef } from "zod";
+
+type YJSSerializable = { id: string };
+
+export interface ForgeProjectRoomBaseYDocState {
+  isLoaded: boolean;
+  artifacts: ForgeProjectArtifact[];
+  features: ProjectFeature[];
+  artifactSections: ForgeSection[];
+  featureSections: ForgeSection[];
+  relations: ForgeRelation[];
+  executedTransactionIds: string[];
+}
+
+export class ForgeProjectRoomBaseYDoc {
+  private readonly yDoc: Y.Doc;
+
+  constructor(yDoc: Y.Doc) {
+    this.yDoc = yDoc;
+  }
+
+  getState(): ForgeProjectRoomBaseYDocState {
+    const artifacts = this.getArtifacts();
+    const features = this.getFeatures();
+    const artifactSections = this.getArtifactSections();
+    const featureSections = this.getFeatureSections();
+    const relations = this.getRelations();
+    const executedTransactionIds = this.getExecutedTransactionIds();
+    const isLoaded = true; // For now, consider it loaded if we can access artifacts
+
+    return {
+      isLoaded,
+      artifacts,
+      features,
+      artifactSections,
+      featureSections,
+      relations,
+      executedTransactionIds,
+    };
+  }
+
+  //
+  // Artifacts
+  //
+
+  getArtifacts(): ForgeProjectArtifact[] {
+    return this.getObjects(this.artifactsYMap, ForgeProjectArtifact);
+  }
+
+  updateArtifacts(artifacts: ForgeProjectArtifact[]) {
+    this.setObjects(this.artifactsYMap, artifacts);
+  }
+
+  deleteArtifacts(ids: string[]) {
+    this.deleteObjects(this.artifactsYMap, ids);
+  }
+
+  private get artifactsYMap() {
+    return this.yDoc.getMap<object>("forgeProjectArtifacts");
+  }
+
+  //
+  // Features
+  //
+
+  getFeatures(): ProjectFeature[] {
+    return this.getObjects(this.featuresYMap, ProjectFeature);
+  }
+
+  updateFeatures(features: ProjectFeature[]) {
+    this.setObjects(this.featuresYMap, features);
+  }
+
+  deleteFeatures(ids: string[]) {
+    this.deleteObjects(this.featuresYMap, ids);
+  }
+
+  private get featuresYMap() {
+    return this.yDoc.getMap<object>("forgeProjectFeatures");
+  }
+
+  //
+  // Sections
+  //
+
+  getArtifactSections(): ForgeSection[] {
+    return this.getObjects(this.artifactSectionsYMap, ForgeSection);
+  }
+
+  updateArtifactSections(sections: ForgeSection[]) {
+    this.setObjects(this.artifactSectionsYMap, sections);
+  }
+
+  deleteArtifactSections(ids: string[]) {
+    this.deleteObjects(this.artifactSectionsYMap, ids);
+  }
+
+  private get artifactSectionsYMap() {
+    return this.yDoc.getMap<object>("forgeProjectArtifactSections");
+  }
+
+  //
+  // Feature Sections
+  //
+
+  getFeatureSections(): ForgeSection[] {
+    return this.getObjects(this.featureSectionsYMap, ForgeSection);
+  }
+
+  updateFeatureSections(sections: ForgeSection[]) {
+    this.setObjects(this.featureSectionsYMap, sections);
+  }
+
+  deleteFeatureSections(ids: string[]) {
+    this.deleteObjects(this.featureSectionsYMap, ids);
+  }
+
+  private get featureSectionsYMap() {
+    return this.yDoc.getMap<object>("forgeProjectFeatureSections");
+  }
+
+  //
+  // Relations
+  //
+
+  getRelations(): ForgeRelation[] {
+    return this.getObjects(this.relationsYMap, ForgeRelation);
+  }
+
+  updateRelations(relations: ForgeRelation[]) {
+    this.setObjects(this.relationsYMap, relations);
+  }
+
+  private get relationsYMap() {
+    return this.yDoc.getMap<object>("forgeRelations");
+  }
+
+  //
+  // 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");
+  }
+
+  //
+  // Utility methods
+  //
+
+  private getObjects<T extends YJSSerializable, I>(map: Y.Map<object>, schema: ZodSchema<T, ZodTypeDef, I>): T[] {
+    const objects: T[] = [];
+    map.forEach(value => objects.push(schema.parse(value)));
+    return objects;
+  }
+
+  private setObjects<T extends YJSSerializable>(map: Y.Map<object>, objects: T[]) {
+    objects.forEach(o => map.set(o.id, JSON.parse(JSON.stringify(o))));
+  }
+
+  private deleteObjects(map: Y.Map<object>, ids: string[]) {
+    ids.forEach(id => map.delete(id));
+  }
+}

package/src/yjs/forge-project-room/index.ts

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

package/src/yjs/index.ts

@@ -0,0 +1,7 @@
+export * from "./design-system-content";
+export * from "./docs-editor";
+export * from "./feature-room";
+export * from "./forge-project-room";
+export * from "./thread-room";
+export * from "./utils";
+export * from "./version-room";

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

@@ -0,0 +1,32 @@
+import * as Y from "yjs";
+import { DTOFeatureAgentResponseTracker } from "../../api/dto/forge/feature-messages";
+import { ThreadRoomBaseYDoc } from "./base";
+
+type ThreadRoomTransaction = {
+  agentResponseTrackers?: DTOFeatureAgentResponseTracker[];
+  agentResponseTrackerIdsToDelete?: string[];
+};
+
+export class BackendThreadRoomYDoc {
+  private readonly yDoc: Y.Doc;
+
+  constructor(yDoc: Y.Doc) {
+    this.yDoc = yDoc;
+  }
+
+  updateState(transaction: ThreadRoomTransaction) {
+    this.yDoc.transact(trx => {
+      const yDoc = new ThreadRoomBaseYDoc(trx.doc);
+
+      // Agent Response Trackers
+      transaction.agentResponseTrackerIdsToDelete &&
+        yDoc.deleteAgentResponseTrackers(transaction.agentResponseTrackerIdsToDelete);
+      transaction.agentResponseTrackers && yDoc.updateAgentResponseTrackers(transaction.agentResponseTrackers);
+    });
+  }
+
+  getState() {
+    const featureRoomDoc = new ThreadRoomBaseYDoc(this.yDoc);
+    return featureRoomDoc.getState();
+  }
+}

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

@@ -0,0 +1,71 @@
+import * as Y from "yjs";
+import { ZodSchema, ZodTypeDef } from "zod";
+import { DTOFeatureAgentResponseTracker } from "../../api/dto/forge/feature-messages";
+
+type YJSSerializable = { id: string };
+
+export interface ThreadRoomBaseYDocState {
+  isLoaded: boolean;
+  agentResponseTrackers: DTOFeatureAgentResponseTracker[];
+}
+
+export interface ThreadRoomUpdate {
+  agentResponseTrackers?: DTOFeatureAgentResponseTracker[];
+  agentResponseTrackerIdsToDelete?: string[];
+}
+
+export class ThreadRoomBaseYDoc {
+  private readonly yDoc: Y.Doc;
+
+  constructor(yDoc: Y.Doc) {
+    this.yDoc = yDoc;
+  }
+
+  getState(): ThreadRoomBaseYDocState {
+    const agentResponseTrackers = this.getAgentResponseTrackers();
+    const isLoaded = true; // For now, consider it loaded if we can access the data
+
+    return {
+      isLoaded,
+      agentResponseTrackers,
+    };
+  }
+
+  //
+  // Agent Response Trackers
+  //
+
+  getAgentResponseTrackers(): DTOFeatureAgentResponseTracker[] {
+    return this.getObjects(this.agentResponseTrackersYMap, DTOFeatureAgentResponseTracker);
+  }
+
+  updateAgentResponseTrackers(trackers: DTOFeatureAgentResponseTracker[]) {
+    this.setObjects(this.agentResponseTrackersYMap, trackers);
+  }
+
+  deleteAgentResponseTrackers(ids: string[]) {
+    this.deleteObjects(this.agentResponseTrackersYMap, ids);
+  }
+
+  private get agentResponseTrackersYMap() {
+    return this.yDoc.getMap<object>("forgeFeatureAgentResponseTrackers");
+  }
+
+  //
+  // Utility methods
+  //
+
+  private getObjects<T extends YJSSerializable, I>(map: Y.Map<object>, schema: ZodSchema<T, ZodTypeDef, I>): T[] {
+    const objects: T[] = [];
+    map.forEach(value => objects.push(schema.parse(value)));
+    return objects;
+  }
+
+  private setObjects<T extends YJSSerializable>(map: Y.Map<object>, objects: T[]) {
+    objects.forEach(o => map.set(o.id, JSON.parse(JSON.stringify(o))));
+  }
+
+  private deleteObjects(map: Y.Map<object>, ids: string[]) {
+    ids.forEach(id => map.delete(id));
+  }
+}