@dxos/plugin-space 0.8.4-main.fffef41 → 0.9.0

package/src/capabilities/app-graph-serializer.ts

@@ -2,75 +2,84 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, RootCollectionAnnotation } from '@dxos/app-toolkit';
 import { isSpace } from '@dxos/client/echo';
-import { Obj } from '@dxos/echo';
-import { Collection } from '@dxos/schema';
+import { Annotation, Collection, Obj, Type } from '@dxos/echo';
+
+import { meta } from '#meta';
+import { SpaceOperation } from '#operations';
+import { translations } from '#translations';
+import { SPACE_TYPE } from '#types';
 
-import { meta } from '../meta';
-import { translations } from '../translations';
-import { SPACE_TYPE, SpaceAction } from '../types';
 import { SPACES } from '../util';
 
-const COLLECTION_TYPE = Collection.Collection.typename;
+const COLLECTION_TYPE = Type.getTypename(Collection.Collection);
 
 // https://stackoverflow.com/a/19016910
 const DIRECTORY_TYPE = 'text/directory';
 
-export default (context: PluginContext) =>
-  contributes(Capabilities.AppGraphSerializer, [
-    {
-      inputType: SPACES,
-      outputType: DIRECTORY_TYPE,
-      serialize: (node) => ({
-        name: translations[0]['en-US'][meta.id]['spaces label'] ?? 'Spaces',
-        data: translations[0]['en-US'][meta.id]['spaces label'] ?? 'Spaces',
-        type: DIRECTORY_TYPE,
-      }),
-      deserialize: () => {
-        // No-op.
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // Get context for lazy capability access in callbacks.
+    const capabilities = yield* Capability.Service;
+
+    return Capability.contributes(AppCapabilities.AppGraphSerializer, [
+      {
+        inputType: SPACES,
+        outputType: DIRECTORY_TYPE,
+        serialize: (node) => ({
+          name: translations[0]['en-US'][meta.id]['spaces.label'] ?? 'Spaces',
+          data: translations[0]['en-US'][meta.id]['spaces.label'] ?? 'Spaces',
+          type: DIRECTORY_TYPE,
+        }),
+        deserialize: () => {
+          // No-op.
+        },
       },
-    },
-    {
-      inputType: SPACE_TYPE,
-      outputType: DIRECTORY_TYPE,
-      serialize: (node) => ({
-        name: node.data.properties.name ?? translations[0]['en-US'][meta.id]['unnamed space label'],
-        data: node.data.properties.name ?? translations[0]['en-US'][meta.id]['unnamed space label'],
-        type: DIRECTORY_TYPE,
-      }),
-      deserialize: async (data) => {
-        const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const result = await dispatch(createIntent(SpaceAction.Create, { name: data.name, edgeReplication: true }));
-        return result.data?.space;
+      {
+        inputType: SPACE_TYPE,
+        outputType: DIRECTORY_TYPE,
+        serialize: (node) => ({
+          name: node.data.properties.name ?? translations[0]['en-US'][meta.id]['unnamed-space.label'],
+          data: node.data.properties.name ?? translations[0]['en-US'][meta.id]['unnamed-space.label'],
+          type: DIRECTORY_TYPE,
+        }),
+        deserialize: async (data) => {
+          const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+          const result = await invokePromise(SpaceOperation.Create, { name: data.name, edgeReplication: true });
+          return result.data?.space;
+        },
       },
-    },
-    {
-      inputType: COLLECTION_TYPE,
-      outputType: DIRECTORY_TYPE,
-      serialize: (node) => ({
-        name: node.data.name ?? translations[0]['en-US'][meta.id]['object name placeholder'],
-        data: node.data.name ?? translations[0]['en-US'][meta.id]['object name placeholder'],
-        type: DIRECTORY_TYPE,
-      }),
-      deserialize: async (data, ancestors) => {
-        const space = ancestors.find(isSpace);
-        const collection =
-          ancestors.findLast((ancestor) => Obj.instanceOf(Collection.Collection, ancestor)) ??
-          space?.properties[COLLECTION_TYPE]?.target;
-        if (!space || !collection) {
-          return;
-        }
+      {
+        inputType: COLLECTION_TYPE,
+        outputType: DIRECTORY_TYPE,
+        serialize: (node) => ({
+          name: node.data.name ?? translations[0]['en-US'][meta.id]['object-name.placeholder'],
+          data: node.data.name ?? translations[0]['en-US'][meta.id]['object-name.placeholder'],
+          type: DIRECTORY_TYPE,
+        }),
+        deserialize: async (data, ancestors) => {
+          const space = ancestors.find(isSpace);
+          const collection =
+            ancestors.findLast((ancestor) => Obj.instanceOf(Collection.Collection, ancestor)) ??
+            (space && Annotation.get(space.properties, RootCollectionAnnotation).pipe(Option.getOrUndefined)?.target);
+          if (!space || !collection) {
+            return;
+          }
 
-        const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const result = await dispatch(
-          createIntent(SpaceAction.AddObject, {
+          const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+          const result = await invokePromise(SpaceOperation.AddObject, {
             target: collection,
             object: Obj.make(Collection.Collection, { name: data.name, objects: [] }),
-          }),
-        );
+          });
 
-        return result.data?.object;
+          return result.data?.object;
+        },
       },
-    },
-  ]);
+    ]);
+  }),
+);

package/src/capabilities/create-object.ts

@@ -0,0 +1,107 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Collection, Type } from '@dxos/echo';
+import { createDefaultSchema } from '@dxos/schema';
+import { Organization, Person, Project, Task } from '@dxos/types';
+
+import { SpaceOperation } from '#operations';
+import { SpaceCapabilities } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return [
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Collection.Collection),
+        inputSchema: Schema.Struct({ name: Schema.optional(Schema.String) }),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Collection.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: false,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Type.Type),
+        inputSchema: SpaceOperation.StoredSchemaForm,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const result = yield* Operation.invoke(SpaceOperation.AddType, {
+              db: options.db,
+              name: props.name,
+              type: createDefaultSchema(),
+            });
+            return {
+              id: result.id,
+              subject: [],
+              object: result.object,
+            };
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Organization.Organization),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Organization.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Person.Person),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Person.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Project.Project),
+        inputSchema: Type.getSchema(Project.Project),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Project.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Task.Task),
+        inputSchema: Type.getSchema(Task.Task),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Task.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+    ];
+  }),
+);

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 { Migrations } from '@dxos/migrations';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { Collection } from '@dxos/schema';
+import * as Effect from 'effect/Effect';
 
-export default async (context: PluginContext) => {
-  const client = context.getCapability(ClientCapabilities.Client);
-  await client.spaces.waitUntilReady();
+import { Capability } from '@dxos/app-framework';
+import { PERSONAL_SPACE_TAG, RootCollectionAnnotation } from '@dxos/app-toolkit';
+import { Annotation, Collection, Obj, Ref } from '@dxos/echo';
+import { MigrationVersionAnnotation, Migrations } from '@dxos/migrations';
+import { ClientCapabilities } from '@dxos/plugin-client';
+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[Collection.Collection.typename] = Ref.make(Obj.make(Collection.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) => {
+      Annotation.set(properties, RootCollectionAnnotation, Ref.make(Collection.make()));
+      if (Migrations.targetVersion) {
+        Annotation.set(properties, MigrationVersionAnnotation, 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 { makeCreateObjectEntryForDatabaseType } from '../util';
 
-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 { 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/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,101 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capability } from '@dxos/app-framework';
+import {
+  AppCapabilities,
+  getActiveSpace,
+  getObjectPath,
+  getSpaceIdFromPath,
+  getSpacePath,
+  type AppCapabilities as AppCaps,
+} from '@dxos/app-toolkit';
+import { Database, Entity, Key } from '@dxos/echo';
+import { EID } 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* () {
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const capabilities = yield* Capability.Service;
+
+    // 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 = EID.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;
+
+    // Parse object paths into EIDs (structure only; existence is checked by the caller).
+    // Handles canonical type paths (root/<spaceId>/types/<typename>/all/<objectId>)
+    // and collection paths (root/<spaceId>/collections/<collectionId>/<objectId>): the space id
+    // is the first segment and the object id the last.
+    const pathResolver: AppCaps.NavigationPathResolver = (qualifiedPath) => {
+      const segments = qualifiedPath.split('/');
+      const spaceId = getSpaceIdFromPath(qualifiedPath);
+      const objectId = segments[segments.length - 1];
+      if (!spaceId || !objectId || !Key.EntityId.isValid(objectId)) {
+        return Effect.succeed(Option.none());
+      }
+      return Effect.succeed(Option.some(EID.make({ spaceId, entityId: objectId as Key.EntityId })));
+    };
+
+    // Resolve a bare entity ID (no path separators) against the current space.
+    // Agents sometimes pass raw entity IDs from object creation results instead of full paths.
+    const bareEntityPathResolver: AppCaps.NavigationPathResolver = (path) => {
+      if (path.includes('/') || !Key.EntityId.isValid(path)) {
+        return Effect.succeed(Option.none());
+      }
+      const space = getActiveSpace(client, capabilities);
+      if (!space) {
+        return Effect.succeed(Option.none());
+      }
+      return Effect.succeed(Option.some(EID.make({ spaceId: space.id, entityId: path as Key.EntityId })));
+    };
+
+    return [
+      Capability.contributes(AppCapabilities.NavigationTargetResolver, resolver),
+      Capability.contributes(AppCapabilities.NavigationPathResolver, pathResolver),
+      Capability.contributes(AppCapabilities.NavigationPathResolver, bareEntityPathResolver),
+    ];
+  }),
+);

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,21 +2,24 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { useCapability } from '@dxos/app-framework/react';
+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;
+      },
+    }),
+  ),
+);