@dxos/plugin-space 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

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

@@ -0,0 +1,346 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation, Segments, getObjectPathFromObject, toUrlPath } from '@dxos/app-toolkit';
+import { SpaceState, getSpace, isSpace } from '@dxos/client/echo';
+import { Collection, Obj, Type } from '@dxos/echo';
+import { AtomObj } from '@dxos/echo-atom';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+import { CreateAtom, Graph, GraphBuilder, Node } from '@dxos/plugin-graph';
+import { isNonNullable } from '@dxos/util';
+
+import { meta } from '#meta';
+import { SpaceCapabilities } from '#types';
+import { SpaceOperation } from '#operations';
+
+import {
+  COLLECTIONS_SECTION_TYPE,
+  COPY_LINK_LABEL,
+  CREATE_OBJECT_IN_COLLECTION_LABEL,
+  EXPOSE_OBJECT_LABEL,
+  type MetadataResolver,
+  REMOVE_FROM_COLLECTION_LABEL,
+  createObjectNode,
+  getCollectionGraphNodePartials,
+  getDynamicLabel,
+  whenSpace,
+} from './shared';
+
+//
+// Extension Factory
+//
+
+/** Creates collection-related extensions: collections section, collections, objects, and object actions. */
+export const createCollectionExtensions = Effect.fnUntraced(function* ({
+  shareableLinkOrigin,
+}: {
+  shareableLinkOrigin: string;
+}) {
+  const capabilities = yield* Capability.Service;
+
+  const resolve = (get: any) => (typename: string) =>
+    capabilities.getAll(AppCapabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
+
+  return yield* Effect.all([
+    // Collections section virtual node under each space.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.collections-section`,
+      match: whenSpace,
+      connector: (space, get) => {
+        const spaceState = get(CreateAtom.fromObservable(space.state));
+        if (spaceState !== SpaceState.SPACE_READY) {
+          return Effect.succeed([]);
+        }
+
+        const propertiesSnapshot = get(AtomObj.make(space.properties));
+        const collectionRef = propertiesSnapshot[Collection.Collection.typename] as any;
+        if (collectionRef) {
+          get(AtomObj.make(collectionRef));
+        }
+        const rootCollection = collectionRef?.target;
+        const collectionPartials = rootCollection
+          ? getCollectionGraphNodePartials({ collection: rootCollection, db: space.db, resolve: resolve(get) })
+          : undefined;
+
+        return Effect.succeed([
+          Node.make({
+            id: Segments.collections,
+            type: COLLECTIONS_SECTION_TYPE,
+            data: null,
+            properties: {
+              label: ['collections-section.label', { ns: meta.id }],
+              icon: 'ph--folder--regular',
+              iconHue: 'neutral',
+              role: 'branch',
+              position: 'hoist',
+              testId: 'spacePlugin.collectionsSection',
+              draggable: false,
+              droppable: false,
+              space,
+              ...collectionPartials,
+            },
+          }),
+        ]);
+      },
+    }),
+
+    // Root collection objects under the Collections virtual node.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.collections`,
+      match: (node) => {
+        const space = isSpace(node.properties.space) ? node.properties.space : undefined;
+        return node.type === COLLECTIONS_SECTION_TYPE && space ? Option.some(space) : Option.none();
+      },
+      connector: (space, get) => {
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+
+        const propertiesSnapshot = get(AtomObj.make(space.properties));
+        const collectionRef = propertiesSnapshot[Collection.Collection.typename] as any;
+        const collection = collectionRef ? get(AtomObj.make(collectionRef)) : undefined;
+        if (!collection) {
+          return Effect.succeed([]);
+        }
+
+        const rawRefs = collection.objects ?? [];
+
+        const objects = rawRefs
+          .map((ref: any) => {
+            get(AtomObj.make(ref));
+            return ref.target;
+          })
+          .filter(isNonNullable);
+
+        return Effect.succeed(
+          objects
+            .map((object: Obj.Unknown) =>
+              createObjectNode({
+                db: space.db,
+                object,
+                resolve: resolve(get),
+                navigable: ephemeralState.navigableCollections,
+                parentCollection: collectionRef?.target,
+              }),
+            )
+            .filter(isNonNullable),
+        );
+      },
+    }),
+
+    // Children of Collection.Collection nodes.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.objects`,
+      match: (node) => (Obj.instanceOf(Collection.Collection, node.data) ? Option.some(node.data) : Option.none()),
+      connector: (collection, get) => {
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        const space = getSpace(collection);
+
+        const collectionSnapshot = get(AtomObj.make(collection));
+        const refs = collectionSnapshot.objects ?? [];
+
+        const objects = refs
+          .map((ref: any) => {
+            get(AtomObj.make(ref));
+            return ref.target;
+          })
+          .filter(isNonNullable);
+
+        return Effect.succeed(
+          objects
+            .map(
+              (object: Obj.Unknown) =>
+                space &&
+                createObjectNode({
+                  object,
+                  db: space.db,
+                  resolve: resolve(get),
+                  navigable: ephemeralState.navigableCollections,
+                  parentCollection: collection,
+                }),
+            )
+            .filter(isNonNullable),
+        );
+      },
+      // TODO(graph-path-ids): Resolver temporarily disabled; redesign needed for path-based IDs.
+      // resolver: (id, get) => { ... },
+    }),
+
+    // Object actions.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.object-actions`,
+      match: (node) => {
+        const space = getSpace(node.data);
+        return space && Obj.isObject(node.data) && Obj.getTypename(node.data) === node.type
+          ? Option.some({ space, object: node.data, nodeId: node.id })
+          : Option.none();
+      },
+      actions: ({ space, object, nodeId }, get) => {
+        const deletable = !Obj.instanceOf(Type.PersistentType, object);
+
+        const [appGraph] = get(capabilities.atom(AppCapabilities.AppGraph));
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+
+        if (!appGraph) {
+          return Effect.succeed([]);
+        }
+
+        const parentId = nodeId.substring(0, nodeId.lastIndexOf('/'));
+        const parentNode = Option.getOrUndefined(Graph.getNode(appGraph.graph, parentId));
+        const parentCollection =
+          parentNode && Obj.instanceOf(Collection.Collection, parentNode.data) ? parentNode.data : undefined;
+
+        return Effect.succeed(
+          constructObjectActions({
+            object,
+            nodeId,
+            resolve: resolve(get),
+            deletable,
+            navigable: ephemeralState.navigableCollections,
+            shareableLinkOrigin,
+            parentCollection,
+          }),
+        );
+      },
+    }),
+  ]);
+});
+
+//
+// Helpers
+//
+
+/** Builds the action list for an ECHO object node. */
+const constructObjectActions = ({
+  object,
+  nodeId,
+  resolve,
+  deletable = true,
+  navigable = false,
+  shareableLinkOrigin,
+  parentCollection,
+}: {
+  object: Obj.Unknown;
+  nodeId: string;
+  resolve: MetadataResolver;
+  shareableLinkOrigin: string;
+  deletable?: boolean;
+  navigable?: boolean;
+  parentCollection?: Collection.Collection;
+}) => {
+  const db = Obj.getDatabase(object);
+  invariant(db, 'Database not found');
+  const typename = Obj.getTypename(object);
+  invariant(typename, 'Object has no typename');
+
+  const actions: Node.NodeArg<Node.ActionData<Operation.Service | Capability.Service>>[] = [
+    ...(Obj.instanceOf(Collection.Collection, object)
+      ? [
+          Node.makeAction({
+            id: SpaceOperation.OpenCreateObject.meta.key,
+            data: () => Operation.invoke(SpaceOperation.OpenCreateObject, { target: object, targetNodeId: nodeId }),
+            properties: {
+              label: CREATE_OBJECT_IN_COLLECTION_LABEL,
+              icon: 'ph--plus--regular',
+              disposition: 'list-item-primary',
+              testId: 'spacePlugin.createObject',
+            },
+          }),
+        ]
+      : []),
+    Node.makeAction({
+      id: SpaceOperation.RenameObject.meta.key,
+      data: (params?: Node.InvokeProps) =>
+        Operation.invoke(SpaceOperation.RenameObject, { object, caller: `${params?.caller}:${params?.parent?.id}` }),
+      properties: {
+        label: getDynamicLabel('rename object label', typename, { defaultValue: 'Rename' }),
+        icon: 'ph--pencil-simple-line--regular',
+        disposition: 'list-item',
+        testId: 'spacePlugin.renameObject',
+      },
+    }),
+    ...(parentCollection && !Obj.instanceOf(Collection.Collection, object)
+      ? [
+          Node.makeAction({
+            id: 'remove-from-collection',
+            data: () =>
+              Effect.gen(function* () {
+                const index = parentCollection.objects.findIndex((ref: any) => ref.target === object);
+                if (index !== -1) {
+                  const layout = yield* Capabilities.getAtomValue(AppCapabilities.Layout);
+                  const isActive = layout.active.includes(nodeId);
+
+                  Obj.change(parentCollection, (mutable) => {
+                    mutable.objects.splice(index, 1);
+                  });
+
+                  if (isActive) {
+                    yield* Operation.invoke(LayoutOperation.Open, {
+                      subject: [getObjectPathFromObject(object)],
+                    });
+                  }
+                }
+              }),
+            properties: {
+              label: REMOVE_FROM_COLLECTION_LABEL,
+              icon: 'ph--minus-circle--regular',
+              disposition: 'list-item',
+              testId: 'spacePlugin.removeFromCollection',
+            },
+          }),
+        ]
+      : []),
+    Node.makeAction({
+      id: SpaceOperation.RemoveObjects.meta.key,
+      data: () =>
+        Operation.invoke(SpaceOperation.RemoveObjects, {
+          objects: [object],
+          target: parentCollection,
+        }),
+      properties: {
+        label: getDynamicLabel('delete object label', typename, { defaultValue: 'Delete' }),
+        icon: 'ph--trash--regular',
+        disposition: 'list-item',
+        disabled: !deletable,
+        testId: 'spacePlugin.deleteObject',
+      },
+    }),
+    ...(navigable || !Obj.instanceOf(Collection.Collection, object)
+      ? [
+          Node.makeAction({
+            id: 'copy-link',
+            data: () =>
+              Effect.promise(async () => {
+                const url = new URL(toUrlPath(nodeId), shareableLinkOrigin);
+                await navigator.clipboard.writeText(url.toString());
+              }),
+            properties: {
+              label: COPY_LINK_LABEL,
+              icon: 'ph--link--regular',
+              disposition: 'list-item',
+              testId: 'spacePlugin.copyLink',
+            },
+          }),
+        ]
+      : []),
+    Node.makeAction({
+      id: LayoutOperation.Expose.meta.key,
+      data: () => Operation.invoke(LayoutOperation.Expose, { subject: getObjectPathFromObject(object) }),
+      properties: {
+        label: EXPOSE_OBJECT_LABEL,
+        icon: 'ph--eye--regular',
+        disposition: 'heading-list-item',
+        testId: 'spacePlugin.exposeObject',
+      },
+    }),
+  ];
+
+  return actions;
+};

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

@@ -0,0 +1,72 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { AppNode } from '@dxos/app-toolkit';
+import { linkedSegment } from '@dxos/react-ui-attention';
+import { Obj } from '@dxos/echo';
+import { GraphBuilder, NodeMatcher } from '@dxos/plugin-graph';
+// TODO(wittjosiah): This is currently necessary for type portability.
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Node } from '@dxos/plugin-graph';
+import { ViewAnnotation } from '@dxos/schema';
+
+import { meta } from '#meta';
+
+//
+// Extension Factory
+//
+
+/** Creates companion panel extensions: object settings and selected-objects. */
+export const createCompanionExtensions = Effect.fnUntraced(function* () {
+  return yield* Effect.all([
+    // Object settings plank companion.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.settings`,
+      match: NodeMatcher.whenEchoObjectMatches,
+      connector: (node) =>
+        Effect.succeed([
+          AppNode.makeCompanion({
+            id: linkedSegment('settings'),
+            label: ['object-settings.label', { ns: meta.id }],
+            icon: 'ph--sliders--regular',
+            data: 'settings',
+            position: 'fallback',
+          }),
+        ]),
+    }),
+
+    // View selected objects companion.
+    GraphBuilder.createExtension({
+      id: `${meta.id}.selected-objects`,
+      match: (node) => {
+        if (!Obj.isObject(node.data)) {
+          return Option.none();
+        }
+
+        const schema = Obj.getSchema(node.data);
+        const isView = Option.fromNullable(schema).pipe(
+          Option.flatMap((candidate) => ViewAnnotation.get(candidate)),
+          Option.getOrElse(() => false),
+        );
+        if (!isView) {
+          return Option.none();
+        }
+
+        return Option.some(node);
+      },
+      connector: (node) =>
+        Effect.succeed([
+          AppNode.makeCompanion({
+            id: linkedSegment('selected-objects'),
+            label: ['companion-selected-objects.label', { ns: meta.id }],
+            icon: 'ph--tree-view--regular',
+            data: 'selected-objects',
+          }),
+        ]),
+    }),
+  ]);
+});

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

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { createSpaceExtensions } from './spaces';
+export { createTypeExtensions } from './types';
+export { createCollectionExtensions } from './collections';
+export { createCompanionExtensions } from './companions';
+export { createSettingsExtensions } from './settings';

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

@@ -0,0 +1,67 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { isPersonalSpace } from '@dxos/app-toolkit';
+import { GraphBuilder, NodeMatcher } from '@dxos/plugin-graph';
+// TODO(wittjosiah): This is currently necessary for type portability.
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Node } from '@dxos/plugin-graph';
+
+import { meta } from '#meta';
+
+//
+// Extension Factory
+//
+
+/** Creates the settings-sections extension for space settings panel. */
+export const createSettingsExtensions = Effect.fnUntraced(function* () {
+  const extension = yield* GraphBuilder.createExtension({
+    id: `${meta.id}.settings-sections`,
+    match: NodeMatcher.whenNodeType(`${meta.id}.settings`),
+    connector: (node) => {
+      const personal = node.properties.space && isPersonalSpace(node.properties.space);
+      return Effect.succeed([
+        {
+          id: `${meta.id}.general`,
+          type: `${meta.id}.general`,
+          data: `${meta.id}.general`,
+          properties: {
+            label: ['space-settings-properties.label', { ns: meta.id }],
+            icon: 'ph--sliders--regular',
+            position: 'hoist',
+            testId: 'spacePlugin.general',
+          },
+        },
+        ...(!personal
+          ? [
+              {
+                id: `${meta.id}.members`,
+                type: `${meta.id}.members`,
+                data: `${meta.id}.members`,
+                properties: {
+                  label: ['members-panel.label', { ns: meta.id }],
+                  icon: 'ph--users--regular',
+                  position: 'hoist',
+                  testId: 'spacePlugin.members',
+                },
+              },
+            ]
+          : []),
+        {
+          id: `${meta.id}.schema`,
+          type: `${meta.id}.schema`,
+          data: `${meta.id}.schema`,
+          properties: {
+            label: ['space-settings-schema.label', { ns: meta.id }],
+            icon: 'ph--shapes--regular',
+            testId: 'spacePlugin.schema',
+          },
+        },
+      ]);
+    },
+  });
+  return [extension];
+});

package/src/capabilities/app-graph-builder/extensions/shared.test.ts

@@ -0,0 +1,112 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Registry from '@effect-atom/atom/Registry';
+import * as Schema from 'effect/Schema';
+import { afterEach, beforeEach, describe, test } from 'vitest';
+
+import { Filter, Obj, Query, Ref, Type, View } from '@dxos/echo';
+import { type EchoDatabase } from '@dxos/echo-db';
+import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { ViewAnnotation } from '@dxos/schema';
+
+import { buildViewIndex } from './shared';
+
+const TestContact = Schema.Struct({
+  name: Schema.String,
+}).pipe(
+  Type.object({
+    typename: 'test/Contact',
+    version: '0.1.0',
+  }),
+);
+
+const TestViewWrapper = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  view: Ref.Ref(View.View),
+}).pipe(
+  Type.object({
+    typename: 'test/ViewWrapper',
+    version: '0.1.0',
+  }),
+  ViewAnnotation.set(true),
+);
+
+describe('buildViewIndex', () => {
+  let testBuilder: EchoTestBuilder;
+  let db: EchoDatabase;
+  let registry: Registry.Registry;
+
+  beforeEach(async () => {
+    testBuilder = await new EchoTestBuilder().open();
+    const result = await testBuilder.createDatabase({ types: [TestContact, TestViewWrapper, View.View] });
+    db = result.db;
+    registry = Registry.make();
+  });
+
+  afterEach(async () => {
+    await testBuilder.close();
+  });
+
+  test('includes typename when a straightforward view targets it', async ({ expect }) => {
+    const viewObj = db.add(
+      View.make({
+        query: { ast: Query.select(Filter.type(TestContact)).ast },
+      }),
+    );
+    db.add(Obj.make(TestViewWrapper, { view: Ref.make(viewObj) }));
+    await db.flush();
+
+    const allSchemas = db.schemaRegistry.query({ location: ['runtime'] }).runSync();
+    const viewIndex = buildViewIndex(registry.get.bind(registry) as any, { db } as any, allSchemas);
+
+    expect(viewIndex.typenamesWithViews.has(Type.getTypename(TestContact))).toBe(true);
+  });
+
+  test('excludes typename when no straightforward view targets it', async ({ expect }) => {
+    const viewObj = db.add(
+      View.make({
+        query: { ast: Query.select(Filter.nothing()).ast },
+      }),
+    );
+    db.add(Obj.make(TestViewWrapper, { view: Ref.make(viewObj) }));
+    await db.flush();
+
+    const allSchemas = db.schemaRegistry.query({ location: ['runtime'] }).runSync();
+    const viewIndex = buildViewIndex(registry.get.bind(registry) as any, { db } as any, allSchemas);
+
+    expect(viewIndex.typenamesWithViews.has(Type.getTypename(TestContact))).toBe(false);
+    expect(viewIndex.typenamesWithViews.size).toBe(0);
+  });
+
+  test('getViewsForTypename returns matching view objects', async ({ expect }) => {
+    const viewObj = db.add(
+      View.make({
+        query: { ast: Query.select(Filter.type(TestContact)).ast },
+      }),
+    );
+    const tableView = db.add(Obj.make(TestViewWrapper, { view: Ref.make(viewObj) }));
+    await db.flush();
+
+    const allSchemas = db.schemaRegistry.query({ location: ['runtime'] }).runSync();
+    const viewIndex = buildViewIndex(registry.get.bind(registry) as any, { db } as any, allSchemas);
+
+    const views = viewIndex.getViewsForTypename(Type.getTypename(TestContact));
+    expect(views).toHaveLength(1);
+    expect(views[0].id).toBe(tableView.id);
+  });
+
+  test('returns empty index when no view schemas exist', async ({ expect }) => {
+    await db.flush();
+
+    const userSchemas = db.schemaRegistry
+      .query({ location: ['runtime'] })
+      .runSync()
+      .filter((schema) => !ViewAnnotation.get(schema).pipe((opt) => opt._tag === 'Some' && opt.value));
+    const viewIndex = buildViewIndex(registry.get.bind(registry) as any, { db } as any, userSchemas);
+
+    expect(viewIndex.typenamesWithViews.size).toBe(0);
+    expect(viewIndex.getViewsForTypename(Type.getTypename(TestContact))).toHaveLength(0);
+  });
+});