@dxos/plugin-space 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/src/capabilities/identity-created.ts

@@ -2,24 +2,32 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
-import { Obj, Ref } from '@dxos/echo';
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { PERSONAL_SPACE_TAG } from '@dxos/app-toolkit';
+import { Collection, Obj, Ref } from '@dxos/echo';
 import { Migrations } from '@dxos/migrations';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { DataType } from '@dxos/schema';
-
-export default async (context: PluginContext) => {
-  const client = context.getCapability(ClientCapabilities.Client);
-  await client.spaces.waitUntilReady();
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { MembershipPolicy } from '@dxos/protocols/proto/dxos/halo/credentials';
 
-  const defaultSpace = client.spaces.default;
-  await defaultSpace.waitUntilReady();
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const client = yield* Capability.get(ClientCapabilities.Client);
 
-  // Create root collection structure.
-  defaultSpace.properties[DataType.Collection.typename] = Ref.make(Obj.make(DataType.Collection, { objects: [] }));
-  if (Migrations.versionProperty) {
-    defaultSpace.properties[Migrations.versionProperty] = Migrations.targetVersion;
-  }
+    const personalSpace = yield* Effect.tryPromise(() =>
+      client.spaces.create({}, { tags: [PERSONAL_SPACE_TAG], membershipPolicy: MembershipPolicy.LOCKED }),
+    );
+    yield* Effect.tryPromise(() => personalSpace.waitUntilReady());
 
-  return contributes(Capabilities.Null, null);
-};
+    // Create root collection structure.
+    yield* Effect.tryPromise(() => personalSpace.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
+    Obj.update(personalSpace.properties, (properties) => {
+      properties[Collection.Collection.typename] = Ref.make(Collection.make());
+      if (Migrations.versionProperty) {
+        properties[Migrations.versionProperty] = Migrations.targetVersion;
+      }
+    });
+  }),
+);

package/src/capabilities/index.ts

@@ -2,17 +2,26 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
 
-export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
-export const AppGraphSerializer = lazy(() => import('./app-graph-serializer'));
-export const IdentityCreated = lazy(() => import('./identity-created'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const ReactRoot = lazy(() => import('./react-root'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const SchemaDefs = lazy(() => import('./schema-defs'));
-export const SpaceSettings = lazy(() => import('./settings'));
-export const SpaceState = lazy(() => import('./state'));
-export const SpacesReady = lazy(() => import('./spaces-ready'));
+export * from './app-graph-builder';
 
-export * from './capabilities';
+export const AppGraphSerializer = Capability.lazy('AppGraphSerializer', () => import('./app-graph-serializer'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+export const IdentityCreated = Capability.lazy('IdentityCreated', () => import('./identity-created'));
+export const Migrations = Capability.lazy('SpaceMigrations', () => import('./migrations'));
+export { NavigationHandler } from './navigation-handler';
+export type { NavigationHandlerOptions } from './navigation-handler';
+export const NavigationResolver = Capability.lazy('NavigationResolver', () => import('./navigation-resolver'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactRoot = Capability.lazy('ReactRoot', () => import('./react-root'));
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const Repair = Capability.lazy('Repair', () => import('./repair'));
+export const SpaceSettings = Capability.lazy('SpaceSettings', () => import('./settings'));
+export const SpacesReady = Capability.lazy('SpacesReady', () => import('./spaces-ready'));
+export const SpaceState = Capability.lazy('SpaceState', () => import('./state'));
+export const UndoMappings = Capability.lazy('UndoMappings', () => import('./undo-mappings'));

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 { Migration } from '@dxos/echo';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { AccessToken, AnchoredTo, HasConnection, HasRelationship, HasSubject } from '@dxos/types';
+
+const identityTransform = async (from: any) => ({ ...from });
+const noopCallback = async () => {};
+
+const migrations = [
+  Migration.define({
+    from: LegacySpaceProperties,
+    to: SpaceProperties,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  Migration.define({
+    from: AccessToken.LegacyAccessToken,
+    to: AccessToken.AccessToken,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  Migration.define({
+    from: AnchoredTo.LegacyAnchoredTo,
+    to: AnchoredTo.AnchoredTo,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  Migration.define({
+    from: HasConnection.LegacyHasConnection,
+    to: HasConnection.HasConnection,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  Migration.define({
+    from: HasRelationship.LegacyHasRelationship,
+    to: HasRelationship.HasRelationship,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  Migration.define({
+    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 { Operation } from '@dxos/compute';
+import { log } from '@dxos/log';
+
+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';
+import { SETTINGS_ID, SETTINGS_KEY } from '@dxos/plugin-settings';
+
+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,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+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/compute';
+
+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,20 +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 { AwaitingObject } from '../components';
-import { meta } from '../meta';
+import { AwaitingObject } from '#components';
+import { meta } from '#meta';
+import { SpaceCapabilities } from '#types';
 
-import { SpaceCapabilities } from './capabilities';
-
-export default () =>
-  contributes(Capabilities.ReactRoot, {
-    id: meta.id,
-    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;
+      },
+    }),
+  ),
+);