@dxos/plugin-space 0.8.4-main.72ec0f3 → 0.8.4-main.8360d9e660

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -0,0 +1,763 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capabilities, Capability, Plugin, UndoMapping } from '@dxos/app-framework';
+import {
+  AppCapabilities,
+  LayoutOperation,
+  getCollectionsPath,
+  getObjectPath,
+  getObjectPathFromObject,
+  getTypePath,
+} from '@dxos/app-toolkit';
+import { SpaceState, getSpace } from '@dxos/client/echo';
+import { Database, Obj, Query, Ref, Relation, Type, View } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { EchoDatabaseImpl, Serializer } from '@dxos/echo-db';
+import { invariant } from '@dxos/invariant';
+import { Migrations } from '@dxos/migrations';
+import { OperationResolver } from '@dxos/operation';
+import { Operation } from '@dxos/operation';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { ObservabilityOperation } from '@dxos/plugin-observability/types';
+import { ViewAnnotation } from '@dxos/schema';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { getSpacePath } from '@dxos/app-toolkit';
+import { iconValues } from '@dxos/react-ui-pickers/icons';
+import { CollectionModel, ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from '@dxos/schema';
+import { hues } from '@dxos/ui-theme';
+
+import {
+  CREATE_OBJECT_DIALOG,
+  CREATE_SPACE_DIALOG,
+  JOIN_DIALOG,
+  OBJECT_RENAME_POPOVER,
+  SPACE_RENAME_POPOVER,
+} from '../../constants';
+import { type JoinDialogProps } from '../../containers/JoinDialog';
+import { meta } from '../../meta';
+import { SpaceEvents } from '../../types';
+import { SpaceCapabilities, SpaceOperation } from '../../types';
+import { COMPOSER_SPACE_LOCK, cloneObject, getNestedObjects } from '../../util';
+import { isNonNullable } from '@dxos/util';
+
+type OperationResolverOptions = {
+  createInvitationUrl: (invitationCode: string) => string;
+  observability?: boolean;
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({ createInvitationUrl, observability }: OperationResolverOptions) {
+    const capabilityManager = yield* Capability.Service;
+
+    const resolve = (typename: string) =>
+      capabilityManager.getAll(AppCapabilities.Metadata).find(({ id }: { id: string }) => id === typename)?.metadata ??
+      {};
+
+    return [
+      Capability.contributes(Capabilities.UndoMapping, [
+        UndoMapping.make({
+          operation: SpaceOperation.DeleteField,
+          inverse: SpaceOperation.RestoreField,
+          deriveContext: (input, output) => ({
+            view: input.view,
+            field: output.field,
+            props: output.props,
+            index: output.index,
+          }),
+          message: ['field deleted label', { ns: meta.id }],
+        }),
+        UndoMapping.make({
+          operation: SpaceOperation.RemoveObjects,
+          inverse: SpaceOperation.RestoreObjects,
+          deriveContext: (_input, output) => ({
+            objects: output.objects,
+            parentCollection: output.parentCollection,
+            indices: output.indices,
+            nestedObjectsList: output.nestedObjectsList,
+            wasActive: output.wasActive,
+          }),
+          message: (input, _output) => {
+            const ns = Obj.getTypename(input.objects[0]);
+            return ns && input.objects.length === 1
+              ? ['object deleted label', { ns }]
+              : ['objects deleted label', { ns: meta.id }];
+          },
+        }),
+      ]),
+      Capability.contributes(Capabilities.OperationResolver, [
+        //
+        // Open
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Open,
+          handler: (input) =>
+            Effect.promise(async () => {
+              await input.space.open();
+            }),
+        }),
+
+        //
+        // Close
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Close,
+          handler: (input) =>
+            Effect.promise(async () => {
+              await input.space.close();
+            }),
+        }),
+
+        //
+        // Join
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Join,
+          handler: Effect.fnUntraced(function* (input) {
+            yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+              subject: JOIN_DIALOG,
+              blockAlign: 'start',
+              props: {
+                initialInvitationCode: input.invitationCode,
+                onDone: input.onDone,
+              } satisfies Partial<JoinDialogProps>,
+            });
+          }),
+        }),
+
+        //
+        // WaitForObject
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.WaitForObject,
+          handler: Effect.fnUntraced(function* (input) {
+            yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+              ...current,
+              awaiting: input.id,
+            }));
+          }),
+        }),
+
+        //
+        // OpenSettings
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.OpenSettings,
+          handler: Effect.fnUntraced(function* (input) {
+            yield* Operation.invoke(LayoutOperation.Open, {
+              subject: [`${getSpacePath(input.space.id)}/settings`],
+              workspace: getSpacePath(input.space.id),
+            });
+          }),
+        }),
+
+        //
+        // RemoveObjects
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.RemoveObjects,
+          handler: Effect.fnUntraced(function* (input) {
+            const layout = yield* Capabilities.getAtomValue(AppCapabilities.Layout);
+            const objects = input.objects as Obj.Unknown[];
+
+            // All objects must be a member of the same space.
+            const space = getSpace(objects[0]);
+            invariant(space && objects.every((obj) => Obj.isObject(obj) && getSpace(obj) === space));
+
+            const parentCollection: Collection.Collection =
+              input.target ?? space.properties[Collection.Collection.typename]?.target;
+
+            const nestedObjectsList = yield* Effect.promise(() =>
+              Promise.all(objects.map((obj) => getNestedObjects(obj, resolve))),
+            );
+
+            // Capture indices before removal.
+            const indices = objects.map((obj) =>
+              Obj.instanceOf(Collection.Collection, parentCollection)
+                ? parentCollection.objects.findIndex((ref) => ref.target === obj)
+                : -1,
+            );
+
+            // Close objects that were open.
+            const wasActive = objects
+              .flatMap((obj, i) => [obj, ...nestedObjectsList[i]])
+              .filter(Obj.isObject)
+              .map((object) => layout.active.find((graphId) => graphId.endsWith(object.id)))
+              .filter(isNonNullable);
+
+            for (let i = 0; i < objects.length; i++) {
+              const obj = objects[i];
+              const nestedObjects = nestedObjectsList[i];
+
+              // Remove from parent collection.
+              const index = parentCollection.objects.findIndex((ref) => ref.target === obj);
+              if (index !== -1) {
+                Obj.change(parentCollection, (c) => {
+                  c.objects.splice(index, 1);
+                });
+              }
+
+              // Delete nested objects.
+              for (const nestedObject of nestedObjects) {
+                if (Obj.isObject(nestedObject)) {
+                  Obj.getDatabase(nestedObject)?.remove(nestedObject);
+                } else if (Relation.isRelation(nestedObject)) {
+                  const db = Obj.getDatabase(Relation.getSource(nestedObject));
+                  db?.remove(nestedObject);
+                }
+              }
+
+              // Delete the object.
+              const db = Obj.getDatabase(obj);
+              db?.remove(obj);
+            }
+
+            if (wasActive.length > 0) {
+              yield* Operation.invoke(LayoutOperation.Close, { subject: wasActive });
+            }
+
+            // Return data needed for undo.
+            return {
+              objects,
+              parentCollection,
+              indices,
+              nestedObjectsList,
+              wasActive,
+            };
+          }),
+        }),
+
+        //
+        // DeleteField
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.DeleteField,
+          handler: Effect.fnUntraced(function* (input) {
+            const registry = yield* Capability.get(Capabilities.AtomRegistry);
+            const view = input.view as any;
+            const db = Obj.getDatabase(view);
+            invariant(db);
+            const typename = getTypenameFromQuery(view.query.ast);
+            invariant(typename);
+            const schema = yield* Effect.promise(() => db.schemaRegistry.query({ typename }).firstOrUndefined());
+            invariant(schema);
+
+            // Create projection with change callbacks that wrap in Obj.change().
+            const projection = new ProjectionModel({
+              registry,
+              view,
+              baseSchema: schema.jsonSchema,
+              change: createEchoChangeCallback(view, schema),
+            });
+
+            const result = projection.deleteFieldProjection(input.fieldId);
+
+            // Return data needed for undo.
+            return {
+              field: result.deleted.field,
+              props: result.deleted.props,
+              index: result.index,
+            };
+          }),
+        }),
+
+        //
+        // OpenCreateObject
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.OpenCreateObject,
+          handler: Effect.fnUntraced(function* (input) {
+            const ephemeralState = yield* Capabilities.getAtomValue(SpaceCapabilities.EphemeralState);
+            const navigable = input.navigable ?? true;
+            yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+              subject: CREATE_OBJECT_DIALOG,
+              blockAlign: 'start',
+              props: {
+                target: input.target,
+                views: input.views,
+                typename: input.typename,
+                initialFormValues: input.initialFormValues,
+                onCreateObject: input.onCreateObject,
+                targetNodeId: input.targetNodeId,
+                shouldNavigate: navigable
+                  ? (object: Obj.Unknown) => {
+                      const isCollection = Obj.instanceOf(Collection.Collection, object);
+                      return !isCollection || ephemeralState.navigableCollections;
+                    }
+                  : () => false,
+              },
+            });
+          }),
+        }),
+
+        //
+        // AddObject
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.AddObject,
+          handler: Effect.fnUntraced(function* (input) {
+            const target = input.target as any;
+            const object = input.object as Obj.Unknown;
+            const db = Database.isDatabase(target) ? target : Obj.getDatabase(target);
+            invariant(db, 'Database not found.');
+
+            yield* CollectionModel.add({
+              object,
+              target: Database.isDatabase(target) ? undefined : target,
+              hidden: input.hidden,
+            }).pipe(Effect.provide(Database.layer(db)));
+
+            const typename = Obj.getTypename(object)!;
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'space.object.add',
+              properties: {
+                spaceId: db.spaceId,
+                objectId: object.id,
+                typename: Obj.getTypename(object),
+              },
+            });
+
+            const [schema] = db.schemaRegistry.query({ typename, location: ['runtime'] }).runSync();
+            const isViewSchema = schema !== undefined && ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false));
+            const view = isViewSchema
+              ? yield* Effect.promise(() => (object as Obj.Any).view.load() as Promise<View.View>)
+              : undefined;
+            const viewTargetTypename = view ? getTypenameFromQuery(view.query.ast) : undefined;
+            const subject = getSubjectPathForNewObject({
+              spaceId: db.spaceId,
+              objectId: object.id,
+              nodeId: input.targetNodeId,
+              typename,
+              viewTargetTypename,
+            });
+
+            return {
+              id: Obj.getDXN(object).toString(),
+              subject: [subject],
+              object,
+            };
+          }),
+        }),
+
+        //
+        // Share
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Share,
+          handler: Effect.fnUntraced(function* (input) {
+            const { space, type, authMethod, multiUse, target } = input;
+            const invitation = space.share({ type, authMethod, multiUse, target });
+
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'space.share',
+              properties: {
+                spaceId: space.id,
+              },
+            });
+
+            return invitation;
+          }),
+        }),
+
+        //
+        // Lock
+        // TODO(wittjosiah): This appears to be unused.
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Lock,
+          handler: Effect.fnUntraced(function* ({ space }) {
+            Obj.change(space.properties, (p) => {
+              p[COMPOSER_SPACE_LOCK] = true;
+            });
+
+            if (observability) {
+              yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+                name: 'space.lock',
+                properties: { spaceId: space.id },
+              });
+            }
+          }),
+        }),
+
+        //
+        // Unlock
+        // TODO(wittjosiah): This appears to be unused.
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Unlock,
+          handler: Effect.fnUntraced(function* ({ space }) {
+            Obj.change(space.properties, (p) => {
+              p[COMPOSER_SPACE_LOCK] = false;
+            });
+
+            if (observability) {
+              yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+                name: 'space.unlock',
+                properties: { spaceId: space.id },
+              });
+            }
+          }),
+        }),
+
+        //
+        // OpenCreateSpace
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.OpenCreateSpace,
+          handler: Effect.fnUntraced(function* () {
+            yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+              subject: CREATE_SPACE_DIALOG,
+              blockAlign: 'start',
+            });
+          }),
+        }),
+
+        //
+        // Create
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Create,
+          handler: Effect.fnUntraced(function* ({ name, hue: hue_, icon: icon_, edgeReplication }) {
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const hue = hue_ ?? hues[Math.floor(Math.random() * hues.length)];
+            const icon = icon_ ?? iconValues[Math.floor(Math.random() * iconValues.length)];
+            const space = yield* Effect.promise(() => client.spaces.create({ name, hue, icon }));
+            if (edgeReplication) {
+              yield* Effect.promise(() => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
+            }
+            yield* Effect.promise(() => space.waitUntilReady());
+
+            // Create root collection.
+            const collection = Obj.make(Collection.Collection, { objects: [] });
+            Obj.change(space.properties, (p) => {
+              p[Collection.Collection.typename] = Ref.make(collection);
+              // Set current migration version.
+              if (Migrations.versionProperty) {
+                p[Migrations.versionProperty] = Migrations.targetVersion;
+              }
+            });
+
+            // Allow other plugins to add default content.
+            yield* Plugin.activate(SpaceEvents.SpaceCreated);
+            const onCreateSpaceCallbacks = yield* Capability.getAll(SpaceCapabilities.OnCreateSpace);
+            yield* Effect.all(
+              onCreateSpaceCallbacks.map((onCreateSpace) =>
+                onCreateSpace({ space, isDefault: false, rootCollection: collection }),
+              ),
+            );
+
+            if (observability) {
+              yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+                name: 'space.create',
+                properties: { spaceId: space.id },
+              });
+            }
+
+            return { id: space.id, subject: [space.id], space };
+          }),
+        }),
+
+        //
+        // Migrate
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Migrate,
+          handler: Effect.fnUntraced(function* (input) {
+            const { space, version: targetVersion } = input;
+
+            if (space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
+              yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+                ...current,
+                sdkMigrationRunning: { ...current.sdkMigrationRunning, [space.id]: true },
+              }));
+              yield* Effect.promise(() => space.internal.migrate());
+              yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+                ...current,
+                sdkMigrationRunning: { ...current.sdkMigrationRunning, [space.id]: false },
+              }));
+            }
+            const result = yield* Effect.promise(() => Migrations.migrate(space, targetVersion));
+
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'space.migrate',
+              properties: {
+                spaceId: space.id,
+                targetVersion,
+                version: Migrations.versionProperty ? space.properties[Migrations.versionProperty] : undefined,
+              },
+            });
+
+            return result;
+          }),
+        }),
+
+        //
+        // Snapshot
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Snapshot,
+          handler: (input) =>
+            Effect.promise(async () => {
+              const db = input.db as any;
+              invariant(db instanceof EchoDatabaseImpl, 'Database must be an instance of EchoDatabaseImpl');
+              const backup = await new Serializer().export(db, input.query && Query.fromAst(input.query));
+              return {
+                snapshot: new Blob([JSON.stringify(backup, null, 2)], { type: 'application/json' }),
+              };
+            }),
+        }),
+
+        //
+        // Rename
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.Rename,
+          handler: Effect.fnUntraced(function* (input) {
+            yield* Operation.invoke(LayoutOperation.UpdatePopover, {
+              subject: SPACE_RENAME_POPOVER,
+              anchorId: input.caller ?? '',
+              props: input.space,
+            });
+          }),
+        }),
+
+        //
+        // RenameObject
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.RenameObject,
+          handler: Effect.fnUntraced(function* (input) {
+            const object = input.object as Obj.Unknown;
+            yield* Operation.invoke(LayoutOperation.UpdatePopover, {
+              subject: OBJECT_RENAME_POPOVER,
+              anchorId: input.caller ?? '',
+              props: object,
+            });
+          }),
+        }),
+
+        //
+        // OpenMembers
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.OpenMembers,
+          handler: Effect.fnUntraced(function* (input) {
+            yield* Operation.invoke(LayoutOperation.Open, {
+              subject: [`${getSpacePath(input.space.id)}/settings`],
+              workspace: getSpacePath(input.space.id),
+            });
+          }),
+        }),
+
+        //
+        // GetShareLink
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.GetShareLink,
+          handler: Effect.fnUntraced(function* (input) {
+            const { Invitation, InvitationEncoder } = yield* Effect.promise(
+              () => import('@dxos/react-client/invitations'),
+            );
+
+            const invitation = yield* Operation.invoke(SpaceOperation.Share, {
+              space: input.space,
+              type: Invitation.Type.DELEGATED,
+              authMethod: Invitation.AuthMethod.KNOWN_PUBLIC_KEY,
+              multiUse: true,
+              target: input.target,
+            });
+
+            // NOTE: Delegated invitations are invalid until the connecting state when keys are filled in.
+            const invitationCode = yield* Effect.tryPromise(
+              () =>
+                new Promise<string>((resolve) => {
+                  invitation.subscribe((inv) => {
+                    if (inv.state === Invitation.State.CONNECTING) {
+                      resolve(InvitationEncoder.encode(inv));
+                    }
+                  });
+                }),
+            );
+            const url = createInvitationUrl(invitationCode);
+            if (input.copyToClipboard) {
+              yield* Effect.tryPromise(() => navigator.clipboard.writeText(url));
+            }
+            return url;
+          }),
+        }),
+
+        //
+        // AddSchema
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.AddSchema,
+          handler: Effect.fnUntraced(function* (input) {
+            const db = input.db;
+            const schemas = yield* Effect.promise(() => db.schemaRegistry.register([input.schema]));
+            const schema = schemas[0];
+            Obj.change(schema.persistentSchema, (s) => {
+              if (input.name) {
+                s.name = input.name;
+              }
+              if (input.typename) {
+                s.typename = input.typename;
+              }
+              if (input.version) {
+                s.version = input.version;
+              }
+            });
+
+            yield* Plugin.activate(SpaceEvents.SchemaAdded);
+            const onSchemaAdded = yield* Capability.getAll(SpaceCapabilities.OnSchemaAdded);
+            yield* Effect.all(
+              onSchemaAdded.map((callback) => callback({ db, schema, show: input.show })),
+              { concurrency: 'unbounded' },
+            );
+
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'space.schema.add',
+              properties: {
+                spaceId: db.spaceId,
+                objectId: schema.id,
+                typename: schema.typename,
+              },
+            });
+
+            return { id: schema.id, object: schema.persistentSchema, schema };
+          }),
+        }),
+
+        //
+        // AddRelation
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.AddRelation,
+          handler: (input) =>
+            Effect.sync(() => {
+              const db = input.db as Database.Database;
+              const relation = db.add(
+                Relation.make(input.schema, {
+                  [Relation.Source]: input.source,
+                  [Relation.Target]: input.target,
+                  ...input.fields,
+                }),
+              );
+              return { relation };
+            }),
+        }),
+
+        //
+        // DuplicateObject
+        // TODO(wittjosiah): This appears to be unused.
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.DuplicateObject,
+          handler: Effect.fnUntraced(function* (input) {
+            const object = input.object as Obj.Unknown;
+            const db = Obj.getDatabase(object);
+            invariant(db, 'Database not found.');
+            const newObject = yield* Effect.promise(() => cloneObject(object, resolve, db));
+            yield* Operation.invoke(SpaceOperation.AddObject, { object: newObject, target: db });
+          }),
+        }),
+
+        //
+        // RestoreField (inverse of DeleteField)
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.RestoreField,
+          handler: Effect.fnUntraced(function* (input) {
+            const registry = yield* Capability.get(Capabilities.AtomRegistry);
+            const view = input.view as any;
+            const db = Obj.getDatabase(view);
+            invariant(db);
+            const typename = getTypenameFromQuery(view.query.ast);
+            invariant(typename);
+            const schema = yield* Effect.promise(() => db.schemaRegistry.query({ typename }).firstOrUndefined());
+            invariant(schema);
+
+            // Create projection with change callbacks that wrap in Obj.change().
+            const projection = new ProjectionModel({
+              registry,
+              view,
+              baseSchema: schema.jsonSchema,
+              change: createEchoChangeCallback(view, schema),
+            });
+
+            projection.setFieldProjection({ field: input.field, props: input.props }, input.index);
+          }),
+        }),
+
+        //
+        // RestoreObjects (inverse of RemoveObjects)
+        //
+        OperationResolver.make({
+          operation: SpaceOperation.RestoreObjects,
+          handler: Effect.fnUntraced(function* (input) {
+            const objects = input.objects as Obj.Unknown[];
+            const parentCollection = input.parentCollection as Collection.Collection;
+            const indices = input.indices as number[];
+            const nestedObjectsList = input.nestedObjectsList as Obj.Unknown[][];
+            const wasActive = input.wasActive as string[];
+
+            // Get the space from the first object.
+            const space = getSpace(objects[0]);
+            invariant(space);
+
+            // Restore objects to the space.
+            const restoredObjects = objects.map((obj: Obj.Unknown) => space.db.add(obj));
+
+            // Restore nested objects to the space.
+            nestedObjectsList.flat().forEach((obj: Obj.Unknown) => {
+              if (Obj.isObject(obj)) {
+                space.db.add(obj);
+              } else if (Relation.isRelation(obj)) {
+                space.db.add(obj);
+              }
+            });
+
+            // Restore objects to the parent collection at their original indices.
+            Obj.change(parentCollection, (c) => {
+              indices.forEach((index: number, i: number) => {
+                if (index !== -1) {
+                  c.objects.splice(index, 0, Ref.make(restoredObjects[i] as Obj.Unknown));
+                }
+              });
+            });
+
+            // Re-open objects that were active.
+            if (wasActive.length > 0) {
+              yield* Operation.invoke(LayoutOperation.Open, { subject: wasActive });
+            }
+          }),
+        }),
+      ]),
+    ];
+  }),
+);
+
+/** Resolves the subject path where a newly added object should be opened in the graph. */
+const getSubjectPathForNewObject = (props: {
+  spaceId: string;
+  objectId: string;
+  nodeId?: string;
+  typename: string;
+  /** When set, the object is a view (e.g. Table) and should open under the type its query targets. */
+  viewTargetTypename?: string;
+}): string => {
+  const { nodeId, typename, viewTargetTypename, spaceId, objectId } = props;
+  if (typeof nodeId === 'string') {
+    return `${nodeId}/${objectId}`;
+  }
+  if (typename === Collection.Collection.typename) {
+    return getCollectionsPath(spaceId, objectId);
+  }
+  if (viewTargetTypename) {
+    return getTypePath(spaceId, viewTargetTypename, objectId);
+  }
+  return getObjectPath(spaceId, typename, objectId);
+};