@dxos/plugin-space 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/src/capabilities/migrations.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { LegacySpaceProperties, SpaceProperties } from '@dxos/client-protocol';
+import { defineObjectMigration } from '@dxos/client/echo';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { AccessToken, AnchoredTo, HasConnection, HasRelationship, HasSubject } from '@dxos/types';
+
+const identityTransform = async (from: any) => ({ ...from });
+const noopCallback = async () => {};
+
+const migrations = [
+  defineObjectMigration({
+    from: LegacySpaceProperties,
+    to: SpaceProperties,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  defineObjectMigration({
+    from: AccessToken.LegacyAccessToken,
+    to: AccessToken.AccessToken,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  defineObjectMigration({
+    from: AnchoredTo.LegacyAnchoredTo,
+    to: AnchoredTo.AnchoredTo,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  defineObjectMigration({
+    from: HasConnection.LegacyHasConnection,
+    to: HasConnection.HasConnection,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  defineObjectMigration({
+    from: HasRelationship.LegacyHasRelationship,
+    to: HasRelationship.HasRelationship,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  defineObjectMigration({
+    from: HasSubject.LegacyHasSubject,
+    to: HasSubject.HasSubject,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+];
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(ClientCapabilities.Migration, migrations);
+  }),
+);

package/src/capabilities/navigation-handler/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export type { NavigationHandlerOptions } from './navigation-handler';
+
+export const NavigationHandler = Capability.lazy('NavigationHandler', () => import('./navigation-handler'));

package/src/capabilities/navigation-handler/navigation-handler.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
+
+import { SpaceOperation } from '../../operations';
+
+export type NavigationHandlerOptions = {
+  invitationProp?: string;
+};
+
+/**
+ * NavigationHandler for space invitation URL params.
+ * Handles ?spaceInvitationCode=X → join space via invitation.
+ */
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({ invitationProp = 'spaceInvitationCode' }: NavigationHandlerOptions = {}) {
+    const capabilities = yield* Capability.Service;
+    const operationService = yield* Capability.get(Capabilities.OperationInvoker);
+
+    const handler: AppCapabilities.NavigationHandler = (url: URL) =>
+      Effect.gen(function* () {
+        const invitationCode = url.searchParams.get(invitationProp);
+        if (invitationCode) {
+          log('space invitation received via navigation');
+          removeQueryParam(invitationProp);
+          yield* Operation.invoke(SpaceOperation.Join, { invitationCode });
+        }
+      }).pipe(
+        Effect.provideService(Capability.Service, capabilities),
+        Effect.provideService(Operation.Service, operationService),
+        Effect.orDie,
+      );
+
+    return Capability.contributes(AppCapabilities.NavigationHandler, handler);
+  }),
+);
+
+/** Remove a query param from the current browser URL. */
+const removeQueryParam = (key: string) => {
+  const current = new URL(window.location.href);
+  current.searchParams.delete(key);
+  history.replaceState(null, '', current.pathname + current.search);
+};

package/src/capabilities/navigation-resolver.ts

@@ -0,0 +1,94 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capability } from '@dxos/app-framework';
+import {
+  AppCapabilities,
+  getObjectPath,
+  getSpaceIdFromPath,
+  getSpacePath,
+  type AppCapabilities as AppCaps,
+} from '@dxos/app-toolkit';
+import { Database, Entity, Key } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { SETTINGS_ID, SETTINGS_KEY } from '@dxos/plugin-settings/types';
+
+import { meta } from '#meta';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // TODO(wittjosiah): Remove cast once NavigationTargetResolver type includes Database.Service.
+    const resolver: AppCaps.NavigationTargetResolver = ((query) =>
+      Effect.gen(function* () {
+        if (!query?.dxn) {
+          return [
+            {
+              path: `${getSpacePath(SETTINGS_ID)}/${SETTINGS_KEY}:${meta.id.replaceAll('/', ':')}`,
+              label: 'Spaces settings',
+              type: 'settings',
+            },
+          ];
+        }
+
+        const dxn = DXN.tryParse(query.dxn.startsWith('@dxn:') ? query.dxn.slice(1) : query.dxn);
+        if (!dxn) {
+          return [];
+        }
+
+        const { db } = yield* Database.Service;
+        const ref = db.makeRef(dxn);
+        const object = yield* Database.load(ref).pipe(Effect.catchAll(() => Effect.succeed(null)));
+        if (!object) {
+          return [];
+        }
+
+        const typename = Entity.getTypename(object);
+        if (!typename) {
+          return [];
+        }
+
+        return [
+          {
+            path: getObjectPath(db.spaceId, typename, object.id),
+            label: Entity.getLabel(object) ?? '',
+            type: typename,
+          },
+        ];
+      })) as AppCaps.NavigationTargetResolver;
+
+    // Resolve object paths to DXNs.
+    // Handles canonical type paths (root/<spaceId>/types/<typename>/all/<objectId>)
+    // and collection paths (root/<spaceId>/collections/<collectionId>/<objectId>).
+    // Validates that the object actually exists in the space before returning a DXN.
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const pathResolver: AppCaps.NavigationPathResolver = (qualifiedPath) => {
+      const segments = qualifiedPath.split('/');
+      const spaceId = getSpaceIdFromPath(qualifiedPath);
+      const objectId = segments[segments.length - 1];
+      if (!spaceId || !objectId || !Key.ObjectId.isValid(objectId)) {
+        return Effect.succeed(Option.none());
+      }
+
+      const space = client.spaces.get(spaceId);
+      if (!space) {
+        return Effect.succeed(Option.none());
+      }
+
+      const dxn = DXN.fromSpaceAndObjectId(spaceId, objectId as Key.ObjectId);
+      const ref = space.db.makeRef(dxn);
+      return Database.loadOption(ref).pipe(
+        Effect.map((option) => (Option.isSome(option) ? Option.some(dxn) : Option.none<DXN>())),
+      );
+    };
+
+    return [
+      Capability.contributes(AppCapabilities.NavigationTargetResolver, resolver),
+      Capability.contributes(AppCapabilities.NavigationPathResolver, pathResolver),
+    ];
+  }),
+);

package/src/capabilities/node.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/operation';
+
+export const IdentityCreated = Capability.lazy('IdentityCreated', () => import('./identity-created'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const UndoMappings = Capability.lazy('UndoMappings', () => import('./undo-mappings'));

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,14 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/operation';
+
+import { SpaceOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, SpaceOperationHandlerSet);
+  }),
+);

package/src/capabilities/react-root.tsx

@@ -2,19 +2,24 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capabilities, contributes, useCapability } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { useAtomCapability } from '@dxos/app-framework/ui';
 
-import { SpaceCapabilities } from './capabilities';
-import { AwaitingObject } from '../components';
-import { SPACE_PLUGIN } from '../meta';
+import { AwaitingObject } from '#components';
+import { meta } from '#meta';
+import { SpaceCapabilities } from '#types';
 
-export default () =>
-  contributes(Capabilities.ReactRoot, {
-    id: SPACE_PLUGIN,
-    root: () => {
-      const state = useCapability(SpaceCapabilities.State);
-      return state.awaiting ? <AwaitingObject id={state.awaiting} /> : null;
-    },
-  });
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactRoot, {
+      id: meta.id,
+      root: () => {
+        const ephemeral = useAtomCapability(SpaceCapabilities.EphemeralState);
+        return ephemeral.awaiting ? <AwaitingObject id={ephemeral.awaiting} /> : null;
+      },
+    }),
+  ),
+);