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

package/src/capabilities/{spaces-ready/spaces-ready.ts → spaces-ready.ts}

@@ -5,21 +5,23 @@
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation, getPersonalSpace, getSpacePath, setPersonalSpace } from '@dxos/app-toolkit';
 import { SubscriptionList } from '@dxos/async';
 import { Filter, Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
-import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { ClientCapabilities } from '@dxos/plugin-client';
+import { AttentionCapabilities } from '@dxos/plugin-attention/types';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
 import { Graph } from '@dxos/plugin-graph';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { PublicKey } from '@dxos/react-client';
-import { SPACE_ID_LENGTH, SpaceState, parseId } from '@dxos/react-client/echo';
+import { type Space, SPACE_ID_LENGTH, SpaceState, parseId } from '@dxos/react-client/echo';
 import { Expando } from '@dxos/schema';
 import { ComplexMap, reduceGroupBy } from '@dxos/util';
 
-import { SpaceCapabilities, SpaceOperation } from '../../types';
-import { COMPOSER_SPACE_LOCK, SHARED } from '../../util';
+import { SpaceCapabilities } from '#types';
+import { SpaceOperation } from '#operations';
+import { SHARED } from '../util';
 
 const ACTIVE_NODE_BROADCAST_INTERVAL = 30_000;
 const WAIT_FOR_OBJECT_TIMEOUT = 5_000;
@@ -27,46 +29,104 @@ const WAIT_FOR_OBJECT_TIMEOUT = 5_000;
 // E.g., dxn:echo:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
 const ECHO_DXN_LENGTH = 3 + 1 + 4 + 1 + 33 + 1 + 26;
 
+/**
+ * Resolve the personal space, migrating from legacy DefaultSpace credential if needed.
+ * Returns undefined for new users who haven't created an identity yet.
+ */
+const resolvePersonalSpace = (client: {
+  spaces: { get(): Space[]; get(id: any): Space | undefined };
+  halo: { queryCredentials(options: { type: string }): any[] };
+}): { space: Space; fromCredential: boolean } | undefined => {
+  // Check for personal space via tags or __DEFAULT__ property.
+  const found = getPersonalSpace(client);
+  if (found) {
+    return { space: found, fromCredential: false };
+  }
+
+  // Migration: read the legacy DefaultSpace credential from HALO.
+  const defaultSpaceCredential = client.halo.queryCredentials({
+    type: 'dxos.halo.credentials.DefaultSpace',
+  })[0];
+  if (!defaultSpaceCredential) {
+    // New user — no credential, no personal space yet.
+    return undefined;
+  }
+
+  const defaultSpaceId = defaultSpaceCredential.subject.assertion.spaceId;
+  const space = client.spaces.get(defaultSpaceId);
+  return space ? { space, fromCredential: true } : undefined;
+};
+
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
     const subscriptions = new SubscriptionList();
     const spaceSubscriptions = new SubscriptionList();
 
-    const { invoke, invokePromise } = yield* Capability.get(Common.Capability.OperationInvoker);
-    const { graph } = yield* Capability.get(Common.Capability.AppGraph);
-    const registry = yield* Capability.get(Common.Capability.AtomRegistry);
-    const layoutAtom = yield* Capability.get(Common.Capability.Layout);
+    const { invoke, invokePromise } = yield* Capability.get(Capabilities.OperationInvoker);
+    const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
+    const layoutAtom = yield* Capability.get(AppCapabilities.Layout);
     const attention = yield* Capability.get(AttentionCapabilities.Attention);
     const stateAtom = yield* Capability.get(SpaceCapabilities.State);
     const ephemeralAtom = yield* Capability.get(SpaceCapabilities.EphemeralState);
     const client = yield* Capability.get(ClientCapabilities.Client);
 
-    const defaultSpace = client.spaces.default;
-    yield* Effect.tryPromise(() => defaultSpace.waitUntilReady());
+    //
+    // Personal space initialization — deferred until found.
+    //
 
-    // Check if deck state indicates we should switch to default space.
-    const layout = registry.get(layoutAtom);
-    if (layout.workspace === 'default') {
-      yield* invoke(Common.LayoutOperation.SwitchWorkspace, { subject: defaultSpace.id });
-    }
+    let personalSpaceInitialized = false;
+    const initializePersonalSpace = async (personalSpace: Space, { fromCredential }: { fromCredential: boolean }) => {
+      if (personalSpaceInitialized) {
+        return;
+      }
 
-    // Initialize space sharing lock in default space.
-    if (typeof defaultSpace.properties[COMPOSER_SPACE_LOCK] !== 'boolean') {
-      Obj.change(defaultSpace.properties, (p) => {
-        p[COMPOSER_SPACE_LOCK] = true;
-      });
-    }
+      await personalSpace.waitUntilReady();
+      personalSpaceInitialized = true;
 
-    const queryResults = yield* Effect.tryPromise(() =>
-      defaultSpace.db.query(Filter.type(Expando.Expando, { key: SHARED })).run(),
-    );
-    const spacesOrder = queryResults[0];
-    if (!spacesOrder) {
-      // TODO(wittjosiah): Cannot be a Folder because Spaces are not TypedObjects so can't be saved in the database.
-      //  Instead, we store order as an array of space ids.
-      defaultSpace.db.add(Obj.make(Expando.Expando, { key: SHARED, order: [] }));
+      // Only set the __DEFAULT__ property when migrating from the legacy credential.
+      // Spaces created with the personal tag don't need it.
+      if (fromCredential) {
+        setPersonalSpace(personalSpace);
+      }
+
+      // Check if deck state indicates we should switch to default space.
+      const layout = registry.get(layoutAtom);
+      if (layout.workspace === 'default') {
+        await invoke(LayoutOperation.SwitchWorkspace, { subject: getSpacePath(personalSpace.id) }).pipe(
+          Effect.runPromise,
+        );
+      }
+
+      const queryResults = await personalSpace.db.query(Filter.type(Expando.Expando, { key: SHARED })).run();
+      const spacesOrder = queryResults[0];
+      if (!spacesOrder) {
+        // TODO(wittjosiah): Cannot be a Folder because Spaces are not TypedObjects so can't be saved in the database.
+        //  Instead, we store order as an array of space ids.
+        personalSpace.db.add(Obj.make(Expando.Expando, { key: SHARED, order: [] }));
+      }
+    };
+
+    // Try to find the personal space now, or subscribe to find it later.
+    // Initialization is async (non-blocking) so subscriptions wire immediately.
+    const resolved = resolvePersonalSpace(client);
+    if (resolved) {
+      void initializePersonalSpace(resolved.space, resolved);
+    } else {
+      subscriptions.add(
+        client.spaces.subscribe(() => {
+          const resolved = resolvePersonalSpace(client);
+          if (resolved) {
+            void initializePersonalSpace(resolved.space, resolved);
+          }
+        }).unsubscribe,
+      );
     }
 
+    //
+    // Space subscriptions — set up immediately, do not depend on personal space.
+    //
+
     // Await missing objects - subscribe to layout atom changes.
     // NOTE: Use immediate: true to check initial state (URL handler may have already set active).
     let lastActiveCleanup: (() => void) | undefined;
@@ -106,9 +166,11 @@ export default Capability.makeModule(
     // Cache space names.
     subscriptions.add(
       client.spaces.subscribe(async (spaces) => {
-        // TODO(wittjosiah): Remove. This is a hack to be able to migrate the default space properties.
-        if (defaultSpace.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
-          await defaultSpace.internal.migrate();
+        // TODO(wittjosiah): Remove. This is a hack to be able to migrate the personal space properties.
+        const resolved = resolvePersonalSpace(client);
+        if (resolved?.space && resolved.space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
+          const personalSpace = resolved.space;
+          await personalSpace.internal.migrate();
         }
 
         spaces
@@ -279,7 +341,7 @@ export default Capability.makeModule(
       log.catch(err);
     }
 
-    return Capability.contributes(Common.Capability.Null, null, () =>
+    return Capability.contributes(Capabilities.Null, null, () =>
       Effect.sync(() => {
         spaceSubscriptions.clear();
         subscriptions.clear();

package/src/capabilities/{state/state.ts → state.ts}

@@ -5,13 +5,13 @@
 import { Atom } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
 import { createKvsStore } from '@dxos/effect';
 import { PublicKey } from '@dxos/keys';
 import { ComplexMap } from '@dxos/util';
 
-import { meta } from '../../meta';
-import { SpaceCapabilities } from '../../types';
+import { meta } from '#meta';
+import { SpaceCapabilities } from '#types';
 
 /** Default persisted state. */
 const defaultSpaceState: SpaceCapabilities.SpaceState = {
@@ -21,11 +21,11 @@ const defaultSpaceState: SpaceCapabilities.SpaceState = {
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    const registry = yield* Capability.get(Common.Capability.AtomRegistry);
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
 
     // Persisted state using KVS store.
     const stateAtom = createKvsStore({
-      key: `${meta.id}/state`,
+      key: `${meta.id}.state`,
       schema: SpaceCapabilities.StateSchema,
       defaultValue: () => ({ ...defaultSpaceState }),
     });
@@ -39,10 +39,12 @@ export default Capability.makeModule(
       viewersByIdentity: new ComplexMap<PublicKey, Set<string>>(PublicKey.hash),
     }).pipe(Atom.keepAlive);
 
-    const manager = yield* Capability.get(Common.Capability.PluginManager);
+    const manager = yield* Capability.get(Capabilities.PluginManager);
     // Update navigableCollections based on plugin state.
     const updateNavigableCollections = () => {
-      const enabled = manager.getEnabled().includes('dxos.org/plugin/stack');
+      const enabled =
+        manager.getEnabled().includes('org.dxos.plugin.stack') ||
+        manager.getEnabled().includes('org.dxos.plugin.simple-layout');
       const current = registry.get(ephemeralAtom);
       if (enabled !== current.navigableCollections) {
         registry.update(ephemeralAtom, (c) => ({ ...c, navigableCollections: enabled }));

package/src/capabilities/undo-mappings.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+
+import { meta } from '#meta';
+import { SpaceOperation } from '#operations';
+import { SpaceOperationConfig } from '../operations/helpers';
+
+type UndoMappingsOptions = {
+  createInvitationUrl: (invitationCode: string) => string;
+  observability?: boolean;
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({ createInvitationUrl, observability }: UndoMappingsOptions) {
+    return [
+      Capability.contributes(Capabilities.UndoMapping, [
+        UndoMapping.make({
+          operation: SpaceOperation.DeleteField,
+          inverse: SpaceOperation.RestoreField,
+          deriveContext: (input, output) => ({
+            view: input.view,
+            field: output.field,
+            props: output.props,
+            index: output.index,
+          }),
+          message: ['field-deleted.label', { ns: meta.id }],
+        }),
+        UndoMapping.make({
+          operation: SpaceOperation.RemoveObjects,
+          inverse: SpaceOperation.RestoreObjects,
+          deriveContext: (_input, output) => ({
+            objects: output.objects,
+            parentCollection: output.parentCollection,
+            indices: output.indices,
+            nestedObjectsList: output.nestedObjectsList,
+            wasActive: output.wasActive,
+          }),
+          message: (input, _output) => {
+            const ns = Obj.getTypename(input.objects[0]);
+            return ns && input.objects.length === 1
+              ? ['object-deleted.label', { ns }]
+              : ['objects-deleted.label', { ns: meta.id }];
+          },
+        }),
+      ]),
+      Capability.contributes(SpaceOperationConfig, {
+        createInvitationUrl,
+        observability: observability ?? false,
+      }),
+    ];
+  }),
+);

package/src/cli/commands/database/add.ts

@@ -11,23 +11,23 @@ import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
 
 // eslint-disable-next-line unused-imports/no-unused-imports
-import { Common as AppFrameworkCommon, type Capability, Plugin } from '@dxos/app-framework';
+import { type Capability, Plugin } from '@dxos/app-framework';
+import { AppActivationEvents, AppCapabilities } from '@dxos/app-toolkit';
 import { CommandConfig, Common, flushAndSync, print, spaceLayer } from '@dxos/cli-util';
 import { SpaceProperties } from '@dxos/client/echo';
-import { Database, Filter, Obj, Ref, Type } from '@dxos/echo';
+import { Database, Filter, Obj, Type } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
 import { EntityKind, getTypeAnnotation } from '@dxos/echo/internal';
 // eslint-disable-next-line unused-imports/no-unused-imports
 import type { Operation } from '@dxos/operation';
-import { Collection } from '@dxos/schema';
 
-import { type CreateObject } from '../../../types';
+import { type CreateObject } from '#types';
 
 import { printObject } from './util';
 
 export type Metadata = {
   createObject: CreateObject;
   inputSchema?: Schema.Schema.AnyNoContext;
-  addToCollectionOnCreate?: boolean;
 };
 
 export const add = Command.make(
@@ -42,19 +42,17 @@ export const add = Command.make(
       const manager = yield* Plugin.Service;
       const { db } = yield* Database.Service;
 
-      yield* manager.activate(AppFrameworkCommon.ActivationEvent.SetupMetadata);
+      yield* manager.activate(AppActivationEvents.SetupMetadata);
 
       const resolve = (typename: string) => {
         const metadata = manager.capabilities
-          .getAll(AppFrameworkCommon.Capability.Metadata)
+          .getAll(AppCapabilities.Metadata)
           .find(({ id }) => id === typename)?.metadata;
         return metadata?.createObject ? (metadata as Metadata) : undefined;
       };
 
-      const [properties] = yield* Database.Service.runQuery(Filter.type(SpaceProperties));
-      const collection = yield* Database.Service.load<Collection.Collection>(
-        properties[Collection.Collection.typename],
-      );
+      const [properties] = yield* Database.runQuery(Filter.type(SpaceProperties));
+      const collection = yield* Database.load<Collection.Collection>(properties[Collection.Collection.typename]);
 
       const selectedTypename = yield* Option.match(typename, {
         onNone: () => selectTypename(resolve),
@@ -65,16 +63,12 @@ export const add = Command.make(
         return yield* Effect.fail(new Error(`Unknown typename: ${selectedTypename}`));
       }
 
-      const object = yield* metadata.createObject({}, { db });
+      const result = yield* metadata.createObject({}, { db, target: collection });
+      const object = result.object;
       if (!Obj.isObject(object)) {
         return yield* Effect.fail(new Error(`Invalid object: ${object}`));
       }
 
-      const objectRef = Ref.make(object);
-      Obj.change(collection, (c) => {
-        c.objects.push(objectRef);
-      });
-
       if (json) {
         yield* Console.log(JSON.stringify(object, null, 2));
       } else {
@@ -92,7 +86,7 @@ export const add = Command.make(
  * Prompts for typename selection if not provided.
  */
 const selectTypename = Effect.fn(function* (resolve: (typename: string) => Metadata | undefined) {
-  const schemas = yield* Database.Service.runSchemaQuery({
+  const schemas = yield* Database.runSchemaQuery({
     location: ['database', 'runtime'],
     includeSystem: false,
   }).pipe(

package/src/cli/commands/database/query/query.test.ts

@@ -21,9 +21,8 @@ describe('spaces query', () => {
       // TODO(wittjosiah): Create test runtime so that client service can be shared with `beforeEach`.
       const client = yield* ClientService;
       yield* Effect.tryPromise(() => client.halo.createIdentity());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-      yield* Effect.tryPromise(() => client.spaces.default.waitUntilReady());
-      const space = client.spaces.default;
+      const space = yield* Effect.tryPromise(() => client.spaces.create());
+      yield* Effect.tryPromise(() => space.waitUntilReady());
       yield* handler({ typename: Option.some(Task.Task.typename) }).pipe(
         Effect.provide(spaceLayer(Option.some(space.id))),
       );
@@ -38,8 +37,7 @@ describe('spaces query', () => {
       const client = yield* ClientService;
       yield* Effect.tryPromise(() => client.addTypes([Task.Task]));
       yield* Effect.tryPromise(() => client.halo.createIdentity());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-      const space = client.spaces.default;
+      const space = yield* Effect.tryPromise(() => client.spaces.create());
       yield* Effect.tryPromise(() => space.waitUntilReady());
       space.db.add(Obj.make(Task.Task, { title: 'Task 1' }));
       space.db.add(Obj.make(Task.Task, { title: 'Task 2' }));

package/src/cli/commands/database/query/query.ts

@@ -20,7 +20,7 @@ export const handler = ({ typename }: { typename: Option.Option<string> }) =>
       onNone: () => Filter.everything(),
       onSome: (typename) => Filter.typename(typename),
     });
-    const objects = yield* Database.Service.runQuery(filter);
+    const objects = yield* Database.runQuery(filter);
 
     if (json) {
       yield* Console.log(JSON.stringify(objects, null, 2));

package/src/cli/commands/database/remove.ts

@@ -34,9 +34,9 @@ export const remove = Command.make(
       } else {
         throw new Error('Must specify typename or id');
       }
-      const objects = yield* Database.Service.runQuery(query);
+      const objects = yield* Database.runQuery(query);
       for (const object of objects) {
-        yield* Database.Service.remove(object);
+        yield* Database.remove(object);
       }
 
       if (json) {

package/src/cli/commands/database/stats.ts

@@ -24,7 +24,7 @@ export const stats = Command.make(
   () =>
     Effect.gen(function* () {
       const { json } = yield* CommandConfig;
-      const objects = yield* Database.Service.runQuery(Query.select(Filter.everything()));
+      const objects = yield* Database.runQuery(Query.select(Filter.everything()));
       const stats = Function.pipe(
         objects,
         Array.groupBy((obj) => Obj.getTypename(obj) ?? '<empty>'),

package/src/cli/commands/space/close/close.ts

@@ -19,7 +19,7 @@ export const handler = ({ spaceId }: { spaceId: Key.SpaceId }) =>
     const space = yield* getSpace(spaceId);
 
     // Flush and sync before closing
-    yield* Effect.tryPromise(() => space.db.flush({ indexes: true }));
+    yield* Effect.tryPromise(() => space.db.flush());
     yield* waitForSync(space);
 
     yield* Effect.tryPromise(() => space.close());

package/src/cli/commands/space/create/create.ts

@@ -22,8 +22,8 @@ export const handler = Effect.fn(function* ({ name }: { name: Option.Option<stri
   yield* Effect.tryPromise(() => space.waitUntilReady());
 
   if (Option.isSome(name)) {
-    Obj.change(space.properties, (p) => {
-      p.name = Option.getOrUndefined(name);
+    Obj.change(space.properties, (obj) => {
+      obj.name = Option.getOrUndefined(name);
     });
   }
 
@@ -48,7 +48,7 @@ export const handler = Effect.fn(function* ({ name }: { name: Option.Option<stri
   }
 
   // Flush and sync before completion
-  yield* Effect.tryPromise(() => space.db.flush({ indexes: true }));
+  yield* Effect.tryPromise(() => space.db.flush());
   yield* waitForSync(space);
 });
 

package/src/cli/commands/space/info/info.test.ts

@@ -29,19 +29,4 @@ describe('space info', () => {
       expect(parsed).toHaveProperty('key');
       expect(parsed.id).toBe(space.id);
     }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
-
-  it('should show default space info when spaceId is not provided', () =>
-    Effect.gen(function* () {
-      const client = yield* ClientService;
-      yield* Effect.tryPromise(() => client.halo.createIdentity());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-      yield* handler({ spaceId: Option.none() });
-      const logger = yield* TestConsole.TestConsole;
-      const logs = logger.logs;
-      expect(logs).toHaveLength(1);
-      const parsed = TestConsole.parseJson<{ id: string; state: string; key: string }>(logs[0]);
-      expect(parsed).toHaveProperty('id');
-      expect(parsed).toHaveProperty('state');
-      expect(parsed).toHaveProperty('key');
-    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
 });

package/src/cli/commands/space/join/join.ts

@@ -88,7 +88,7 @@ export const handler = Effect.fn(function* ({
   }
 
   // Flush and sync after joining
-  yield* Effect.tryPromise(() => space.db.flush({ indexes: true }));
+  yield* Effect.tryPromise(() => space.db.flush());
   yield* waitForSync(space);
 
   if (json) {

package/src/cli/commands/space/members/members.test.ts

@@ -30,17 +30,4 @@ describe('space members', () => {
       expect(parsed[0]).toHaveProperty('presence');
       // name might be undefined if identity has no displayName
     }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
-
-  it('should list default space members when spaceId is not provided', () =>
-    Effect.gen(function* () {
-      const client = yield* ClientService;
-      yield* Effect.tryPromise(() => client.halo.createIdentity());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-      yield* handler({ spaceId: Option.none() });
-      const logger = yield* TestConsole.TestConsole;
-      const logs = logger.logs;
-      expect(logs).toHaveLength(1);
-      const parsed = TestConsole.parseJson<Array<{ key: string; presence: string }>>(logs[0]);
-      expect(Array.isArray(parsed)).toBe(true);
-    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
 });

package/src/cli/commands/space/open/open.ts

@@ -20,7 +20,7 @@ export const handler = ({ spaceId }: { spaceId: Key.SpaceId }) =>
     yield* Effect.tryPromise(() => space.open());
 
     // Flush and sync after opening
-    yield* Effect.tryPromise(() => space.db.flush({ indexes: true }));
+    yield* Effect.tryPromise(() => space.db.flush());
     yield* waitForSync(space);
 
     if (json) {

package/src/cli/commands/space/schema/list/list.test.ts

@@ -26,17 +26,4 @@ describe('space schema list', () => {
       const parsed = TestConsole.parseJson(logs[0]);
       expect(Array.isArray(parsed)).toBe(true);
     }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
-
-  it('should list default space schemas when spaceId is not provided', () =>
-    Effect.gen(function* () {
-      const client = yield* ClientService;
-      yield* Effect.tryPromise(() => client.halo.createIdentity());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-      yield* handler({ spaceId: Option.none(), typename: Option.none() });
-      const logger = yield* TestConsole.TestConsole;
-      const logs = logger.logs;
-      expect(logs).toHaveLength(1);
-      const parsed = TestConsole.parseJson(logs[0]);
-      expect(Array.isArray(parsed)).toBe(true);
-    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
 });

package/src/cli/plugin.ts

@@ -4,10 +4,13 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common, Plugin } from '@dxos/app-framework';
+import { ActivationEvents, Capability, Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
 import { Tag } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
 import { ClientEvents } from '@dxos/plugin-client/types';
-import { Collection, DataTypes } from '@dxos/schema';
+import { DataTypes } from '@dxos/schema';
 import {
   AnchoredTo,
   Employer,
@@ -17,24 +20,43 @@ import {
   HasSubject,
   Organization,
   Person,
-  Project,
+  Pipeline,
   Task,
 } from '@dxos/types';
 
-import { IdentityCreated } from '../capabilities/identity-created';
-import { OperationResolver } from '../capabilities/operation-resolver';
-import { meta } from '../meta';
-import { SpaceEvents } from '../types';
-import { type CreateObject, type SpacePluginOptions } from '../types';
+import { IdentityCreated, OperationHandler, UndoMappings } from '#capabilities';
+
+import { meta } from '#meta';
+import { SpaceEvents } from '#types';
+import { type CreateObject, type SpacePluginOptions } from '#types';
+import { SpaceOperation } from '#operations';
 
 import { database, queue, space } from './commands';
 
 export const SpacePlugin = Plugin.define<SpacePluginOptions>(meta).pipe(
   // TODO(wittjosiah): Could some of these commands make use of operations?
-  Common.Plugin.addCommandModule({
+  AppPlugin.addCommandModule({
     commands: [database, queue, space],
   }),
-  Common.Plugin.addSchemaModule({
+  AppPlugin.addMetadataModule({
+    metadata: {
+      id: Collection.Collection.typename,
+      metadata: {
+        createObject: ((props, options) =>
+          Effect.gen(function* () {
+            const object = Collection.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          })) satisfies CreateObject,
+      },
+    },
+  }),
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({
     schema: [
       ...DataTypes,
       AnchoredTo.AnchoredTo,
@@ -45,36 +67,33 @@ export const SpacePlugin = Plugin.define<SpacePluginOptions>(meta).pipe(
       HasSubject.HasSubject,
       Organization.Organization,
       Person.Person,
-      Project.Project,
+      Pipeline.Pipeline,
       Tag.Tag,
       Task.Task,
     ],
   }),
-  Common.Plugin.addMetadataModule({
-    metadata: {
-      id: Collection.Collection.typename,
-      metadata: {
-        createObject: ((props) => Effect.sync(() => Collection.make(props))) satisfies CreateObject,
-        addToCollectionOnCreate: true,
-      },
-    },
-  }),
-  Plugin.addModule(({ invitationUrl = 'http://localhost:5173', invitationProp = 'spaceInvitationCode' }) => {
-    const createInvitationUrl = (invitationCode: string) => {
-      const baseUrl = new URL(invitationUrl);
-      baseUrl.searchParams.set(invitationProp, invitationCode);
-      return baseUrl.toString();
-    };
+  Plugin.addModule(
+    ({
+      shareableLinkOrigin = 'http://localhost:5173',
+      invitationPath = '/',
+      invitationProp = 'spaceInvitationCode',
+    }) => {
+      const createInvitationUrl = (invitationCode: string) => {
+        const baseUrl = new URL(invitationPath || '/', shareableLinkOrigin);
+        baseUrl.searchParams.set(invitationProp, invitationCode);
+        return baseUrl.toString();
+      };
 
-    return {
-      id: Capability.getModuleTag(OperationResolver),
-      activatesOn: Common.ActivationEvent.SetupOperationResolver,
-      activate: () => OperationResolver({ createInvitationUrl, observability: false }),
-    };
-  }),
+      return {
+        id: Capability.getModuleTag(UndoMappings),
+        activatesOn: ActivationEvents.SetupOperationHandler,
+        activate: () => UndoMappings({ createInvitationUrl, observability: false }),
+      };
+    },
+  ),
   Plugin.addModule({
     activatesOn: ClientEvents.IdentityCreated,
-    activatesAfter: [SpaceEvents.DefaultSpaceReady],
+    activatesAfter: [SpaceEvents.PersonalSpaceReady],
     activate: IdentityCreated,
   }),
   Plugin.make,