@dxos/plugin-space 0.8.4-main.c85a9c8dae → 0.8.4-main.d05673bc65

package/src/capabilities/app-graph-builder/extensions/types.ts

@@ -0,0 +1,421 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Atom } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Match from 'effect/Match';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation, Segments } from '@dxos/app-toolkit';
+import { type Space, SpaceState, isSpace } from '@dxos/client/echo';
+import { Collection, Filter, Obj, Query, Type } from '@dxos/echo';
+import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
+import { AtomObj, AtomQuery } from '@dxos/echo-atom';
+import { Operation } from '@dxos/operation';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { CreateAtom, GraphBuilder, Node } from '@dxos/plugin-graph';
+import { ViewAnnotation } from '@dxos/schema';
+import { createFilename, isNonNullable } from '@dxos/util';
+
+import { meta } from '../../../meta';
+import { SpaceOperation } from '../../../types';
+
+import {
+  ADD_VIEW_TO_SCHEMA_LABEL,
+  BLOCK_REORDER_ABOVE,
+  type MetadataResolver,
+  SNAPSHOT_BY_SCHEMA_LABEL,
+  STATIC_SCHEMA_TYPE,
+  TYPES_SECTION_TYPE,
+  TYPE_COLLECTION_TYPE,
+  buildViewIndex,
+  createObjectNode,
+  downloadBlob,
+  getDynamicLabel,
+  whenSpace,
+} from './shared';
+
+//
+// Extension Factory
+//
+
+/** Creates type-related extensions: types section, schema nodes, schema children, and schema actions. */
+export const createTypeExtensions = Effect.fnUntraced(function* () {
+  const capabilities = yield* Capability.Service;
+
+  const resolve = (_get: any) => (typename: string) =>
+    capabilities.getAll(AppCapabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
+
+  return yield* Effect.all([
+    // Types section virtual node under each space.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.types-section`,
+      match: whenSpace,
+      connector: (space, get) => {
+        const spaceState = get(CreateAtom.fromObservable(space.state));
+        if (spaceState !== SpaceState.SPACE_READY) {
+          return Effect.succeed([]);
+        }
+
+        return Effect.succeed([
+          {
+            id: Segments.types,
+            type: TYPES_SECTION_TYPE,
+            data: null,
+            properties: {
+              label: ['types section label', { ns: meta.id }],
+              icon: 'ph--shapes--regular',
+              iconHue: 'neutral',
+              role: 'branch',
+              testId: 'spacePlugin.typesSection',
+              draggable: false,
+              droppable: false,
+              space,
+            },
+          },
+        ]);
+      },
+    }),
+
+    // Schema nodes under the Types virtual node.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.types`,
+      match: (node) => {
+        const space = isSpace(node.properties.space) ? node.properties.space : undefined;
+        return node.type === TYPES_SECTION_TYPE && space ? Option.some(space) : Option.none();
+      },
+      connector: (space, get) => {
+        // TODO(wittjosiah): Make schema queries reactive to simplify this.
+        // Reactive subscription to database schema objects so the connector re-runs on schema changes.
+        get(AtomQuery.make(space.db, Filter.type(Type.PersistentType)));
+        // Reactive subscription to client/plugin-contributed schemas so the connector re-runs when new schemas or static schemas are added.
+        get(capabilities.atom(AppCapabilities.Schema));
+        const allSchemas = space.db.schemaRegistry.query({ location: ['runtime', 'database'] }).runSync();
+
+        const userSchemas = allSchemas.filter((schema) => {
+          if (getTypeAnnotation(schema)?.kind === EntityKind.Relation) {
+            return false;
+          }
+          if (SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false))) {
+            return false;
+          }
+          if (ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false))) {
+            return false;
+          }
+          if (Type.getTypename(schema) === Collection.Collection.typename) {
+            return false;
+          }
+          return true;
+        });
+
+        const viewIndex = buildViewIndex(get, space, allSchemas);
+
+        const visibleSchemas = userSchemas.filter((schema) => {
+          if (Type.isMutable(schema)) {
+            return true;
+          }
+          const typename = Type.getTypename(schema);
+          const objects = get(AtomQuery.make(space.db, Filter.typename(typename)));
+          return objects.length > 0 || viewIndex.typenamesWithViews.has(typename);
+        });
+
+        return Effect.succeed(
+          visibleSchemas.map((schema) => createSchemaNode({ schema, space, resolve: resolve(get), get })),
+        );
+      },
+    }),
+
+    // {All} virtual node + view objects under each schema node.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.schema-children`,
+      match: (node) => {
+        const space = isSpace(node.properties.space) ? node.properties.space : undefined;
+        return space && (Obj.instanceOf(Type.PersistentType, node.data) || Schema.isSchema(node.data))
+          ? Option.some({ space, schema: node.data })
+          : Option.none();
+      },
+      connector: ({ space, schema }, get) => {
+        const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
+        const schemas = client?.graph.schemaRegistry.query({ location: ['runtime'] }).runSync() ?? [];
+
+        const typename = Schema.isSchema(schema) ? Type.getTypename(schema as Type.AnyObj) : schema.typename;
+
+        // {All} virtual node.
+        const allNode = {
+          id: 'all',
+          type: TYPE_COLLECTION_TYPE,
+          data: { space, typename },
+          properties: {
+            label: ['type collection all label', { ns: meta.id }],
+            icon: 'ph--list--regular',
+            iconHue: 'neutral',
+            role: 'branch',
+            testId: `spacePlugin.typeCollectionAll.${typename}`,
+            selectable: false,
+            draggable: false,
+            droppable: false,
+            childrenDroppable: false,
+            blockInstruction: BLOCK_REORDER_ABOVE,
+          },
+        };
+
+        // View objects for this schema.
+        const viewIndex = buildViewIndex(get, space, schemas);
+        const viewNodes = viewIndex
+          .getViewsForTypename(typename)
+          .map((object: Obj.Unknown) =>
+            createObjectNode({
+              db: space.db,
+              object,
+              resolve: resolve(get),
+              droppable: false,
+            }),
+          )
+          .filter(isNonNullable);
+
+        return Effect.succeed([allNode, ...viewNodes]);
+      },
+    }),
+
+    // Objects of the schema type under the {All} node.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.type-collection-objects`,
+      match: (node) => {
+        if (node.type !== TYPE_COLLECTION_TYPE || !node.data?.space || !node.data?.typename) {
+          return Option.none();
+        }
+        return Option.some({ space: node.data.space as Space, typename: node.data.typename as string });
+      },
+      connector: ({ space, typename }, get) => {
+        const objects = get(AtomQuery.make(space.db, Filter.typename(typename)));
+
+        return Effect.succeed(
+          objects
+            .map((object: Obj.Unknown) => {
+              get(AtomObj.make(object));
+              return createObjectNode({
+                db: space.db,
+                object,
+                resolve: resolve(get),
+                droppable: false,
+              });
+            })
+            .filter(isNonNullable),
+        );
+      },
+    }),
+
+    // Actions for schema nodes.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.schema-actions`,
+      match: (node) => {
+        const space = isSpace(node.properties.space) ? node.properties.space : undefined;
+        return space && Schema.isSchema(node.data) ? Option.some({ space, schema: node.data }) : Option.none();
+      },
+      actions: ({ space, schema }, get) => {
+        const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
+        const schemas = client?.graph.schemaRegistry.query({ location: ['runtime'] }).runSync() ?? [];
+
+        const targetTypename = Type.getTypename(schema as Type.AnyObj);
+        const viewIndex = buildViewIndex(get, space, schemas);
+        const deletable =
+          Type.isMutable(schema as Type.AnyObj) && viewIndex.getViewsForTypename(targetTypename).length === 0;
+
+        return Effect.succeed(
+          createSchemaActions({
+            schema: schema as Type.AnyObj,
+            space,
+            deletable,
+            resolve: resolve(get),
+          }),
+        );
+      },
+    }),
+  ]);
+});
+
+//
+// Helpers
+//
+
+/** Builds a graph node for a schema in the Types subtree. */
+const createSchemaNode = ({
+  schema,
+  space,
+  resolve,
+  get,
+}: {
+  schema: Type.AnyEntity;
+  space: Space;
+  resolve: MetadataResolver;
+  get: Atom.Context;
+}): Node.Node => {
+  const typename = Type.getTypename(schema);
+  const metadata = resolve(typename);
+  const { label, nodeId } = Match.value(schema).pipe(
+    Match.when(Type.isMutable, (mutableSchema) => {
+      const persistentSchema = mutableSchema.persistentSchema;
+      const snapshot = get(AtomObj.make(persistentSchema));
+      return {
+        label: snapshot.name || ['object name placeholder', { ns: Type.PersistentType.typename }],
+        nodeId: typename,
+      };
+    }),
+    Match.orElse(() => ({
+      label: getDynamicLabel('typename label', typename, { count: 2, default: typename }),
+      nodeId: typename,
+    })),
+  );
+  const icon = Type.isMutable(schema) ? 'ph--cube--regular' : (metadata.icon ?? 'ph--placeholder--regular');
+  const iconHue = Type.isMutable(schema) ? 'neutral' : metadata.iconHue;
+  return {
+    id: nodeId,
+    type: STATIC_SCHEMA_TYPE,
+    data: schema,
+    properties: {
+      label,
+      icon,
+      iconHue,
+      role: 'branch',
+      testId: `spacePlugin.schemaNode.${typename}`,
+      selectable: false,
+      draggable: false,
+      droppable: false,
+      childrenDroppable: false,
+      space,
+    },
+  };
+};
+
+/** Builds schema actions (add view, rename, delete, snapshot). */
+const createSchemaActions = ({
+  schema,
+  space,
+  deletable,
+  resolve,
+}: {
+  schema: Type.AnyObj;
+  space: Space;
+  deletable: boolean;
+  resolve: MetadataResolver;
+}) => {
+  const typename = Type.getTypename(schema);
+  const metadata = resolve(typename);
+  const createObjectFn = metadata.createObject;
+  const inputSchema = metadata.inputSchema;
+
+  const actions: Node.NodeArg<Node.ActionData<Operation.Service>>[] = [
+    ...(createObjectFn
+      ? [
+          {
+            id: SpaceOperation.OpenCreateObject.meta.key,
+            type: Node.ActionType,
+            data: Effect.fnUntraced(function* () {
+              if (inputSchema) {
+                yield* Operation.invoke(SpaceOperation.OpenCreateObject, {
+                  target: space.db,
+                  typename,
+                });
+              } else {
+                const createdObject = yield* createObjectFn({}, { db: space.db }) as Effect.Effect<
+                  Obj.Unknown,
+                  Error,
+                  never
+                >;
+                const addResult = yield* Operation.invoke(SpaceOperation.AddObject, {
+                  target: space.db,
+                  hidden: true,
+                  object: createdObject,
+                });
+                if (addResult.subject) {
+                  yield* Operation.invoke(LayoutOperation.Open, { subject: addResult.subject });
+                }
+              }
+            }),
+            properties: {
+              label: getDynamicLabel('add object label', typename),
+              icon: 'ph--plus--regular',
+              disposition: 'list-item-primary',
+              testId: 'spacePlugin.createObject',
+            },
+          },
+        ]
+      : []),
+    {
+      id: `${SpaceOperation.AddObject.meta.key}-view`,
+      type: Node.ActionType,
+      data: () =>
+        Operation.invoke(SpaceOperation.OpenCreateObject, {
+          target: space.db,
+          views: true,
+          initialFormValues: { typename: Type.getTypename(schema) },
+        }),
+      properties: {
+        label: ADD_VIEW_TO_SCHEMA_LABEL,
+        icon: 'ph--circles-three-plus--regular',
+        disposition: 'list-item',
+        testId: 'spacePlugin.addViewToSchema',
+      },
+    },
+    {
+      id: SpaceOperation.RenameObject.meta.key,
+      type: Node.ActionType,
+      data: (params?: Node.InvokeProps) =>
+        Type.isMutable(schema)
+          ? Operation.invoke(SpaceOperation.RenameObject, {
+              object: (schema as Type.RuntimeType).persistentSchema as any,
+              caller: `${params?.caller}:${params?.parent?.id}`,
+            })
+          : Effect.fail(new Error('Cannot rename immutable schema')),
+      properties: {
+        label: getDynamicLabel('rename object label', Type.getTypename(Type.PersistentType)),
+        icon: 'ph--pencil-simple-line--regular',
+        disabled: !Type.isMutable(schema),
+        disposition: 'list-item',
+        testId: 'spacePlugin.renameObject',
+      },
+    },
+    {
+      id: SpaceOperation.RemoveObjects.meta.key,
+      type: Node.ActionType,
+      data: () =>
+        Type.isMutable(schema)
+          ? Operation.invoke(SpaceOperation.RemoveObjects, {
+              objects: [(schema as Type.RuntimeType).persistentSchema as Obj.Unknown],
+            })
+          : Effect.succeed(undefined),
+      properties: {
+        label: getDynamicLabel('delete object label', Type.getTypename(Type.PersistentType)),
+        icon: 'ph--trash--regular',
+        disposition: 'list-item',
+        disabled: !deletable,
+        testId: 'spacePlugin.deleteObject',
+      },
+    },
+    {
+      id: SpaceOperation.Snapshot.meta.key,
+      type: Node.ActionType,
+      data: Effect.fnUntraced(function* () {
+        const result = yield* Operation.invoke(SpaceOperation.Snapshot, {
+          db: space.db,
+          query: Query.select(Filter.type(schema)).ast,
+        });
+        if (result.snapshot) {
+          yield* Effect.tryPromise(() =>
+            downloadBlob(result.snapshot, createFilename({ parts: [space.id, Type.getTypename(schema)], ext: 'json' })),
+          );
+        }
+      }),
+      properties: {
+        label: SNAPSHOT_BY_SCHEMA_LABEL,
+        icon: 'ph--camera--regular',
+        disposition: 'list-item',
+      },
+    },
+  ];
+
+  return actions;
+};

package/src/capabilities/identity-created/identity-created.ts

@@ -19,10 +19,10 @@ export default Capability.makeModule(
     yield* Effect.tryPromise(() => defaultSpace.waitUntilReady());
 
     // Create root collection structure.
-    Obj.change(defaultSpace.properties, (p) => {
-      p[Collection.Collection.typename] = Ref.make(Collection.make());
+    Obj.change(defaultSpace.properties, (properties) => {
+      properties[Collection.Collection.typename] = Ref.make(Collection.make());
       if (Migrations.versionProperty) {
-        p[Migrations.versionProperty] = Migrations.targetVersion;
+        properties[Migrations.versionProperty] = Migrations.targetVersion;
       }
     });
   }),

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

@@ -3,11 +3,19 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 
 import { Capabilities, Capability, Plugin, UndoMapping } from '@dxos/app-framework';
-import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+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 } from '@dxos/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';
@@ -16,16 +24,11 @@ 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 { ATTENDABLE_PATH_SEPARATOR } from '@dxos/react-ui-attention/types';
+import { getSpacePath } from '@dxos/app-toolkit';
 import { iconValues } from '@dxos/react-ui-pickers/icons';
-import {
-  CollectionModel,
-  ManagedCollection,
-  ProjectionModel,
-  createEchoChangeCallback,
-  getTypenameFromQuery,
-} from '@dxos/schema';
+import { CollectionModel, ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from '@dxos/schema';
 import { hues } from '@dxos/ui-theme';
 
 import {
@@ -35,11 +38,12 @@ import {
   OBJECT_RENAME_POPOVER,
   SPACE_RENAME_POPOVER,
 } from '../../constants';
-import { type JoinDialogProps } from '../../containers/JoinDialog/JoinDialog';
+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;
@@ -80,7 +84,7 @@ export default Capability.makeModule(
           message: (input, _output) => {
             const ns = Obj.getTypename(input.objects[0]);
             return ns && input.objects.length === 1
-              ? ['object deleted label', { ns: meta.id }]
+              ? ['object deleted label', { ns }]
               : ['objects deleted label', { ns: meta.id }];
           },
         }),
@@ -145,8 +149,8 @@ export default Capability.makeModule(
           operation: SpaceOperation.OpenSettings,
           handler: Effect.fnUntraced(function* (input) {
             yield* Operation.invoke(LayoutOperation.Open, {
-              subject: [`properties-settings${ATTENDABLE_PATH_SEPARATOR}${input.space.id}`],
-              workspace: input.space.id,
+              subject: [`${getSpacePath(input.space.id)}/settings`],
+              workspace: getSpacePath(input.space.id),
             });
           }),
         }),
@@ -163,7 +167,6 @@ export default Capability.makeModule(
             // 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 openObjectIds = new Set<string>(layout.active);
 
             const parentCollection: Collection.Collection =
               input.target ?? space.properties[Collection.Collection.typename]?.target;
@@ -182,8 +185,9 @@ export default Capability.makeModule(
             // Close objects that were open.
             const wasActive = objects
               .flatMap((obj, i) => [obj, ...nestedObjectsList[i]])
-              .filter((obj) => Obj.isObject(obj) && openObjectIds.has(Obj.getDXN(obj).toString()))
-              .map((obj) => Obj.getDXN(obj).toString());
+              .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];
@@ -278,11 +282,11 @@ export default Capability.makeModule(
                 typename: input.typename,
                 initialFormValues: input.initialFormValues,
                 onCreateObject: input.onCreateObject,
+                targetNodeId: input.targetNodeId,
                 shouldNavigate: navigable
                   ? (object: Obj.Unknown) => {
                       const isCollection = Obj.instanceOf(Collection.Collection, object);
-                      const isSystemCollection = Obj.instanceOf(ManagedCollection.ManagedCollection, object);
-                      return (!isCollection && !isSystemCollection) || ephemeralState.navigableCollections;
+                      return !isCollection || ephemeralState.navigableCollections;
                     }
                   : () => false,
               },
@@ -307,6 +311,7 @@ export default Capability.makeModule(
               hidden: input.hidden,
             }).pipe(Effect.provide(Database.layer(db)));
 
+            const typename = Obj.getTypename(object)!;
             yield* Operation.schedule(ObservabilityOperation.SendEvent, {
               name: 'space.object.add',
               properties: {
@@ -316,9 +321,23 @@ export default Capability.makeModule(
               },
             });
 
+            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: [Obj.getDXN(object).toString()],
+              subject: [subject],
               object,
             };
           }),
@@ -422,13 +441,6 @@ export default Capability.makeModule(
               }
             });
 
-            // Create records smart collection.
-            Obj.change(collection, (c) => {
-              c.objects.push(
-                Ref.make(ManagedCollection.makeManagedCollection({ key: Type.getTypename(Type.PersistentType) })),
-              );
-            });
-
             // Allow other plugins to add default content.
             yield* Plugin.activate(SpaceEvents.SpaceCreated);
             const onCreateSpaceCallbacks = yield* Capability.getAll(SpaceCapabilities.OnCreateSpace);
@@ -507,7 +519,7 @@ export default Capability.makeModule(
           handler: Effect.fnUntraced(function* (input) {
             yield* Operation.invoke(LayoutOperation.UpdatePopover, {
               subject: SPACE_RENAME_POPOVER,
-              anchorId: `dxos.org/ui/${input.caller}/${input.space.id}`,
+              anchorId: input.caller ?? '',
               props: input.space,
             });
           }),
@@ -522,7 +534,7 @@ export default Capability.makeModule(
             const object = input.object as Obj.Unknown;
             yield* Operation.invoke(LayoutOperation.UpdatePopover, {
               subject: OBJECT_RENAME_POPOVER,
-              anchorId: `dxos.org/ui/${input.caller}/${Obj.getDXN(object).toString()}`,
+              anchorId: input.caller ?? '',
               props: object,
             });
           }),
@@ -535,8 +547,8 @@ export default Capability.makeModule(
           operation: SpaceOperation.OpenMembers,
           handler: Effect.fnUntraced(function* (input) {
             yield* Operation.invoke(LayoutOperation.Open, {
-              subject: [`members-settings${ATTENDABLE_PATH_SEPARATOR}${input.space.id}`],
-              workspace: input.space.id,
+              subject: [`${getSpacePath(input.space.id)}/settings`],
+              workspace: getSpacePath(input.space.id),
             });
           }),
         }),
@@ -578,48 +590,6 @@ export default Capability.makeModule(
           }),
         }),
 
-        //
-        // UseStaticSchema
-        //
-        OperationResolver.make({
-          operation: SpaceOperation.UseStaticSchema,
-          handler: Effect.fnUntraced(function* (input) {
-            const db = input.db as Database.Database;
-            const client = yield* Capability.get(ClientCapabilities.Client);
-            const schema: any = yield* Effect.promise(() =>
-              (client as any).graph.schemaRegistry.query({ typename: input.typename, location: ['runtime'] }).first(),
-            );
-            const space = client.spaces.get(db.spaceId);
-            invariant(space, 'Space not found');
-
-            Obj.change(space.properties, (p) => {
-              if (!p.staticRecords) {
-                p.staticRecords = [];
-              }
-              if (!p.staticRecords.includes(input.typename)) {
-                p.staticRecords.push(input.typename);
-              }
-            });
-
-            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.use',
-              properties: {
-                spaceId: space.id,
-                typename: Type.getTypename(schema),
-              },
-            });
-
-            return {};
-          }),
-        }),
-
         //
         // AddSchema
         //
@@ -769,3 +739,25 @@ export default Capability.makeModule(
     ];
   }),
 );
+
+/** 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);
+};