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

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

@@ -0,0 +1,171 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Atom } from '@effect-atom/atom-react';
+import * as Option from 'effect/Option';
+
+import { type Space, SpaceState, isSpace } from '@dxos/client/echo';
+import { Filter, Obj, type Type } from '@dxos/echo';
+import { AtomObj, AtomQuery } from '@dxos/echo-atom';
+import { Migrations } from '@dxos/migrations';
+import { type Operation } from '@dxos/operation';
+import { type Node } from '@dxos/plugin-graph';
+import { type TreeData } from '@dxos/react-ui-list';
+import { ViewAnnotation, getTypenameFromQuery } from '@dxos/schema';
+import { type Label } from '@dxos/ui-types';
+
+import { meta } from '../../../meta';
+import { SPACE_TYPE } from '../../../types';
+
+export {
+  type MetadataResolver,
+  ACCEPT_ECHO_CLASS,
+  CACHEABLE_PROPS,
+  CAN_DROP_OBJECT,
+  blockInstructionCache,
+  buildCollectionPartials,
+  collectionPartialsCache,
+  createFactory,
+  createObjectNode,
+  getAcceptPersistenceKey,
+  getCollectionGraphNodePartials,
+  getDynamicLabel,
+  rearrangeCache,
+} from '@dxos/app-toolkit';
+
+//
+// Virtual Node Types
+//
+
+export const TYPES_SECTION_TYPE = `${meta.id}.types`;
+export const COLLECTIONS_SECTION_TYPE = `${meta.id}.collections`;
+export const TYPE_COLLECTION_TYPE = `${meta.id}.type-collection`;
+export const STATIC_SCHEMA_TYPE = `${meta.id}.static-schema`;
+
+//
+// Constants
+//
+
+/** Shared translation namespace descriptor. */
+export const META_NS: { ns: string } = { ns: meta.id };
+
+//
+// Stable Callbacks
+//
+
+export const BLOCK_REORDER_ABOVE = (_source: TreeData, instruction: any) => instruction.type === 'reorder-above';
+export const CAN_DROP_SPACE = (source: TreeData) => Obj.isObject(source.item.data) || isSpace(source.item.data);
+
+//
+// Matchers
+//
+
+/** Match space nodes and return the Space object. */
+export const whenSpace = (node: Node.Node): Option.Option<Space> =>
+  node.type === SPACE_TYPE && isSpace(node.data) ? Option.some(node.data) : Option.none();
+
+//
+// Caches (space-specific, not moved to app-toolkit)
+//
+
+export const spaceActionsCache = new Map<
+  string,
+  {
+    state: SpaceState;
+    hasPendingMigration: boolean;
+    migrating: boolean;
+    actions: Node.NodeArg<Node.ActionData<Operation.Service>>[];
+  }
+>();
+export const spaceRearrangeCache = new Map<string, (nextOrder: Space[]) => void>();
+
+//
+// Static Labels
+//
+
+export const ADD_VIEW_TO_SCHEMA_LABEL: Label = ['add view to schema label', META_NS];
+export const COPY_LINK_LABEL: Label = ['copy link label', META_NS];
+export const CREATE_OBJECT_IN_COLLECTION_LABEL: Label = ['create object in collection label', META_NS];
+export const CREATE_OBJECT_IN_SPACE_LABEL: Label = ['create object in space label', META_NS];
+export const EXPOSE_OBJECT_LABEL: Label = ['expose object label', META_NS];
+export const MIGRATE_SPACE_LABEL: Label = ['migrate space label', META_NS];
+export const NEW_TYPE_LABEL: Label = ['new type label', META_NS];
+export const REMOVE_FROM_COLLECTION_LABEL: Label = ['remove from collection label', META_NS];
+export const RENAME_SPACE_LABEL: Label = ['rename space label', META_NS];
+export const SETTINGS_PANEL_LABEL: Label = ['settings panel label', META_NS];
+export const SNAPSHOT_BY_SCHEMA_LABEL: Label = ['snapshot by schema label', META_NS];
+
+//
+// Helpers
+//
+
+export const checkPendingMigration = (space: Space) => {
+  return (
+    space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION ||
+    (space.state.get() === SpaceState.SPACE_READY &&
+      !!Migrations.versionProperty &&
+      space.properties[Migrations.versionProperty] !== Migrations.targetVersion)
+  );
+};
+
+export const downloadBlob = async (blob: Blob, filename: string) => {
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement('a');
+  anchor.href = url;
+  anchor.download = filename;
+
+  document.body.appendChild(anchor);
+  anchor.click();
+
+  document.body.removeChild(anchor);
+  URL.revokeObjectURL(url);
+};
+
+//
+// View Index
+//
+
+/**
+ * Index of view objects grouped by their target typename.
+ */
+export type ViewIndex = {
+  /** Typenames that have at least one straightforward view targeting them. */
+  typenamesWithViews: Set<string>;
+  /** View objects targeting a specific typename. */
+  getViewsForTypename: (typename: string) => Obj.Any[];
+};
+
+/**
+ * Builds an index of view objects by scanning view-annotated schemas and resolving the target
+ * typename from each view's query AST. Only straightforward views whose query resolves to a
+ * simple typename via getTypenameFromQuery are included.
+ */
+// TODO(wittjosiah): Make reactive to schema registry changes (currently only object/view mutations trigger updates).
+export const buildViewIndex = (get: Atom.Context, space: Space, schemas: Type.AnyEntity[]): ViewIndex => {
+  const viewSchemas = schemas.filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)));
+
+  const viewsByTypename = new Map<string, Obj.Any[]>();
+
+  if (viewSchemas.length > 0) {
+    const filter = Filter.or(...viewSchemas.map((schema) => Filter.type(schema)));
+    const viewObjects = get(AtomQuery.make(space.db, filter));
+
+    for (const viewObject of viewObjects) {
+      const viewSnapshot = get(AtomObj.make(viewObject));
+      const viewRef = viewSnapshot.view;
+      const viewTarget = viewRef ? get(AtomObj.make(viewRef)) : undefined;
+      const typename = getTypenameFromQuery(viewTarget?.query?.ast);
+      if (typename) {
+        const existing = viewsByTypename.get(typename) ?? [];
+        existing.push(viewObject);
+        viewsByTypename.set(typename, existing);
+      }
+    }
+  }
+
+  return {
+    typenamesWithViews: new Set(viewsByTypename.keys()),
+    getViewsForTypename: (typename) => viewsByTypename.get(typename) ?? [],
+  };
+};

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

@@ -0,0 +1,343 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { type Space, SpaceState } from '@dxos/client/echo';
+import { Filter, Obj } from '@dxos/echo';
+import { AtomObj, AtomQuery } from '@dxos/echo-atom';
+import { Migrations } from '@dxos/migrations';
+import { Operation } from '@dxos/operation';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { CreateAtom, Graph, GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
+import { Expando } from '@dxos/schema';
+
+import { getActiveSpace } from '../../../hooks';
+import { meta } from '../../../meta';
+import { SPACE_TYPE, SpaceCapabilities } from '../../../types';
+import { SpaceOperation } from '../../../operations';
+import { getPersonalSpace, isPersonalSpace } from '@dxos/app-toolkit';
+
+import { SHARED, getSpaceDisplayName } from '../../../util';
+
+import {
+  CACHEABLE_PROPS,
+  CAN_DROP_SPACE,
+  CREATE_OBJECT_IN_SPACE_LABEL,
+  MIGRATE_SPACE_LABEL,
+  RENAME_SPACE_LABEL,
+  SETTINGS_PANEL_LABEL,
+  checkPendingMigration,
+  spaceActionsCache,
+  spaceRearrangeCache,
+  whenSpace,
+} from './shared';
+
+//
+// Extension Factory
+//
+
+/** Creates space-related extensions: primary actions, space nodes, and space actions. */
+export const createSpaceExtensions = Effect.fnUntraced(function* () {
+  const capabilities = yield* Capability.Service;
+
+  return yield* Effect.all([
+    GraphBuilder.createExtension({
+      id: `${meta.id}.primary-actions`,
+      position: 'hoist',
+      match: NodeMatcher.whenRoot,
+      actions: () =>
+        Effect.succeed([
+          {
+            id: SpaceOperation.OpenCreateSpace.meta.key,
+            data: () => Operation.invoke(SpaceOperation.OpenCreateSpace),
+            properties: {
+              label: ['create space label', { ns: meta.id }],
+              icon: 'ph--plus--regular',
+              testId: 'spacePlugin.createSpace',
+              disposition: 'menu',
+            },
+          },
+          {
+            id: SpaceOperation.Join.meta.key,
+            data: () => Operation.invoke(SpaceOperation.Join, {}),
+            properties: {
+              label: ['join space label', { ns: meta.id }],
+              icon: 'ph--sign-in--regular',
+              testId: 'spacePlugin.joinSpace',
+              disposition: 'menu',
+            },
+          },
+          {
+            id: SpaceOperation.OpenMembers.meta.key,
+            data: Effect.fnUntraced(function* () {
+              const client = yield* Capability.get(ClientCapabilities.Client);
+              const space = getActiveSpace(capabilities) ?? getPersonalSpace(client);
+              if (space) {
+                yield* Operation.invoke(SpaceOperation.OpenMembers, { space });
+              }
+            }),
+            properties: {
+              label: ['share space label', { ns: meta.id }],
+              icon: 'ph--users--regular',
+              testId: 'spacePlugin.shareSpace',
+              keyBinding: {
+                macos: 'meta+.',
+                windows: 'alt+.',
+              },
+            },
+          },
+          {
+            id: SpaceOperation.OpenSettings.meta.key,
+            data: Effect.fnUntraced(function* () {
+              const client = yield* Capability.get(ClientCapabilities.Client);
+              const space = getActiveSpace(capabilities) ?? getPersonalSpace(client);
+              if (space) {
+                yield* Operation.invoke(SpaceOperation.OpenSettings, { space });
+              }
+            }),
+            properties: {
+              label: ['open current space settings label', { ns: meta.id }],
+              icon: 'ph--faders--regular',
+              keyBinding: {
+                macos: 'meta+shift+,',
+                windows: 'ctrl+shift+,',
+              },
+            },
+          },
+        ]),
+    }),
+
+    GraphBuilder.createExtension({
+      id: `${meta.id}.spaces`,
+      match: NodeMatcher.whenRoot,
+      connector: (_node, get) => {
+        const client = capabilities.get(ClientCapabilities.Client);
+        const stateAtom = capabilities.get(SpaceCapabilities.State);
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const spacesAtom = CreateAtom.fromObservable(client.spaces);
+
+        const spaces = get(spacesAtom);
+        const personalSpace = getPersonalSpace(client);
+
+        if (!spaces || !personalSpace) {
+          return Effect.succeed([]);
+        }
+
+        const settingsAtom = capabilities.get(SpaceCapabilities.Settings);
+        const settings = get(settingsAtom);
+        const state = get(stateAtom);
+        const ephemeralState = get(ephemeralAtom);
+
+        try {
+          const [spacesOrder] = get(AtomQuery.make(personalSpace.db, Filter.type(Expando.Expando, { key: SHARED })));
+          const { graph } = capabilities.get(AppCapabilities.AppGraph);
+
+          const spacesOrderSnapshot = spacesOrder ? get(AtomObj.make(spacesOrder)) : undefined;
+          const order: string[] = (spacesOrderSnapshot as any)?.order ?? [];
+          const orderMap = new Map(order.map((id, index) => [id, index]));
+
+          const spaceStates = spaces.map((space) => get(CreateAtom.fromObservable(space.state)));
+
+          spaces.forEach((space) => {
+            if (space.state.get() === SpaceState.SPACE_READY) {
+              get(AtomObj.make(space.properties));
+            }
+          });
+
+          return Effect.succeed(
+            [
+              ...spaces
+                .filter((space) => orderMap.has(space.id))
+                .sort((sortA, sortB) => orderMap.get(sortA.id)! - orderMap.get(sortB.id)!),
+              ...spaces.filter((space) => !orderMap.has(space.id)),
+            ]
+              .filter((space, idx) => (settings?.showHidden ? true : spaceStates[idx] !== SpaceState.SPACE_INACTIVE))
+              .map((space) =>
+                constructSpaceNode({
+                  space,
+                  navigable: ephemeralState.navigableCollections,
+                  personal: isPersonalSpace(space),
+                  namesCache: state.spaceNames,
+                  graph,
+                  spacesOrder,
+                }),
+              ),
+          );
+        } catch {
+          return Effect.succeed([]);
+        }
+      },
+      // TODO(graph-path-ids): Resolver temporarily disabled; redesign needed for path-based IDs.
+      // resolver: (id, get) => { ... },
+    }),
+
+    GraphBuilder.createExtension({
+      id: `${meta.id}.actions`,
+      match: whenSpace,
+      actions: (space, get) => {
+        const [client] = get(capabilities.atom(ClientCapabilities.Client));
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+
+        if (!client) {
+          return Effect.succeed([]);
+        }
+
+        return Effect.succeed(
+          constructSpaceActions({
+            space,
+            migrating: ephemeralState.sdkMigrationRunning[space.id],
+          }),
+        );
+      },
+    }),
+  ]);
+});
+
+//
+// Helpers
+//
+
+/** Builds an app-graph node for a space, including settings children and optional rearrange handler. */
+const constructSpaceNode = ({
+  space,
+  navigable = false,
+  personal,
+  namesCache,
+  graph,
+  spacesOrder,
+}: {
+  space: Space;
+  navigable?: boolean;
+  personal?: boolean;
+  namesCache?: Record<string, string>;
+  graph?: Graph.ExpandableGraph;
+  spacesOrder?: Obj.Any;
+}) => {
+  const hasPendingMigration = checkPendingMigration(space);
+
+  let onRearrange: ((nextOrder: Space[]) => void) | undefined;
+  if (graph && spacesOrder) {
+    onRearrange = spaceRearrangeCache.get(space.id);
+    if (!onRearrange) {
+      onRearrange = (nextOrder: Space[]) => {
+        Graph.sortEdges(
+          graph,
+          Node.RootId,
+          'outbound',
+          nextOrder.map(({ id }) => id),
+        );
+
+        Obj.change(spacesOrder, (mutableOrder: any) => {
+          mutableOrder.order = nextOrder.map(({ id }) => id);
+        });
+      };
+      spaceRearrangeCache.set(space.id, onRearrange);
+    }
+  }
+
+  return {
+    id: space.id,
+    type: SPACE_TYPE,
+    cacheable: CACHEABLE_PROPS,
+    data: space,
+    properties: {
+      label: getSpaceDisplayName(space, { personal, namesCache }),
+      description: space.state.get() === SpaceState.SPACE_READY && space.properties.description,
+      hue: space.state.get() === SpaceState.SPACE_READY && space.properties.hue,
+      icon:
+        space.state.get() === SpaceState.SPACE_READY && space.properties.icon
+          ? `ph--${space.properties.icon}--regular`
+          : undefined,
+      iconHue: space.state.get() === SpaceState.SPACE_READY && space.properties.iconHue,
+      disabled: !navigable || space.state.get() !== SpaceState.SPACE_READY || hasPendingMigration,
+      disposition: 'workspace',
+      testId: 'spacePlugin.space',
+      onRearrange,
+      canDrop: CAN_DROP_SPACE,
+    },
+    nodes: [
+      {
+        id: 'settings',
+        type: `${meta.id}.settings`,
+        data: null,
+        properties: {
+          label: SETTINGS_PANEL_LABEL,
+          icon: 'ph--faders--regular',
+          disposition: 'alternate-tree',
+          space,
+        },
+      },
+    ],
+  };
+};
+
+/** Builds the action list for a space node (migrate, create object, rename). */
+const constructSpaceActions = ({ space, migrating }: { space: Space; migrating?: boolean }) => {
+  const state = space.state.get();
+  const hasPendingMigration = checkPendingMigration(space);
+  const isMigrating = migrating || Migrations.running(space);
+
+  const cached = spaceActionsCache.get(space.id);
+  if (
+    cached &&
+    cached.state === state &&
+    cached.hasPendingMigration === hasPendingMigration &&
+    cached.migrating === isMigrating
+  ) {
+    return cached.actions;
+  }
+
+  const actions: Node.NodeArg<Node.ActionData<Operation.Service>>[] = [];
+
+  if (hasPendingMigration) {
+    actions.push({
+      id: SpaceOperation.Migrate.meta.key,
+      type: Node.ActionGroupType,
+      data: () => Operation.invoke(SpaceOperation.Migrate, { space }),
+      properties: {
+        label: MIGRATE_SPACE_LABEL,
+        icon: 'ph--database--regular',
+        disposition: 'list-item-primary',
+        disabled: isMigrating,
+      },
+    });
+  }
+
+  if (state === SpaceState.SPACE_READY && !hasPendingMigration) {
+    actions.push(
+      {
+        id: SpaceOperation.OpenCreateObject.meta.key,
+        type: Node.ActionType,
+        data: () => Operation.invoke(SpaceOperation.OpenCreateObject, { target: space.db }),
+        properties: {
+          label: CREATE_OBJECT_IN_SPACE_LABEL,
+          icon: 'ph--plus--regular',
+          disposition: 'list-item-primary',
+          testId: 'spacePlugin.createObject',
+        },
+      },
+      {
+        id: SpaceOperation.Rename.meta.key,
+        type: Node.ActionType,
+        data: (params?: Node.InvokeProps) =>
+          Operation.invoke(SpaceOperation.Rename, { space, caller: `${params?.caller}:${params?.parent?.id}` }),
+        properties: {
+          label: RENAME_SPACE_LABEL,
+          icon: 'ph--pencil-simple-line--regular',
+          keyBinding: {
+            macos: 'shift+F6',
+            windows: 'shift+F6',
+          },
+        },
+      },
+    );
+  }
+
+  spaceActionsCache.set(space.id, { state, hasPendingMigration, migrating: isMigrating, actions });
+  return actions;
+};