@dxos/plugin-space 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

package/src/operations/delete.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Delete> = SpaceOperation.Delete.pipe(
+  Operation.withHandler((input) =>
+    Effect.promise(async () => {
+      await input.space.delete();
+    }),
+  ),
+);
+export default handler;

package/src/operations/duplicate-object.ts

@@ -0,0 +1,17 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+// TODO(wittjosiah): Implement object duplication without serializer.
+const handler: Operation.WithHandler<typeof SpaceOperation.DuplicateObject> = SpaceOperation.DuplicateObject.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      yield* Effect.fail(new Error('DuplicateObject is not yet implemented.'));
+    }),
+  ),
+);
+export default handler;

package/src/operations/export-space.ts

@@ -0,0 +1,30 @@
+// Copyright 2026 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.ExportSpace> = SpaceOperation.ExportSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ space, format }) {
+      yield* Effect.promise(() => space.waitUntilReady());
+      const archive = yield* Effect.promise(() => space.internal.export({ format }));
+      yield* Effect.sync(() => {
+        downloadArchive(new Blob([archive.contents as Uint8Array<ArrayBuffer>]), archive.filename);
+      });
+    }),
+  ),
+);
+export default handler;
+
+const downloadArchive = (data: Blob, filename: string): void => {
+  const url = URL.createObjectURL(data);
+  const element = document.createElement('a');
+  element.setAttribute('href', url);
+  element.setAttribute('download', filename);
+  element.setAttribute('target', 'download');
+  element.click();
+  URL.revokeObjectURL(url);
+};

package/src/operations/get-share-link.ts

@@ -0,0 +1,43 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+import { SpaceOperationConfig } from './helpers';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.GetShareLink> = SpaceOperation.GetShareLink.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const { Invitation, InvitationEncoder } = yield* Effect.promise(() => import('@dxos/react-client/invitations'));
+
+      const invitation = yield* Operation.invoke(SpaceOperation.Share, {
+        space: input.space,
+        type: Invitation.Type.DELEGATED,
+        authMethod: Invitation.AuthMethod.KNOWN_PUBLIC_KEY,
+        multiUse: true,
+        target: input.target,
+      });
+
+      const invitationCode = yield* Effect.tryPromise(
+        () =>
+          new Promise<string>((resolve) => {
+            invitation.subscribe((inv) => {
+              if (inv.state === Invitation.State.CONNECTING) {
+                resolve(InvitationEncoder.encode(inv));
+              }
+            });
+          }),
+      );
+      const { createInvitationUrl } = yield* Capability.get(SpaceOperationConfig);
+      const url = createInvitationUrl(invitationCode);
+      if (input.copyToClipboard) {
+        yield* Effect.tryPromise(() => navigator.clipboard.writeText(url));
+      }
+      return url;
+    }),
+  ),
+);
+export default handler;

package/src/operations/helpers.ts

@@ -0,0 +1,10 @@
+// Copyright 2025 DXOS.org
+
+import { Capability } from '@dxos/app-framework';
+
+export type SpaceOperationConfig = {
+  createInvitationUrl: (invitationCode: string) => string;
+  observability: boolean;
+};
+
+export const SpaceOperationConfig = Capability.make<SpaceOperationConfig>('org.dxos.plugin.space.operation-config');

package/src/operations/import-space.ts

@@ -0,0 +1,23 @@
+// Copyright 2026 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.ImportSpace> = SpaceOperation.ImportSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ archive, tags }) {
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      const space = yield* Effect.promise(() =>
+        client.spaces.import(archive, tags && tags.length > 0 ? { tags: [...tags] } : undefined),
+      );
+      yield* Effect.promise(() => space.waitUntilReady());
+      return { space };
+    }),
+  ),
+);
+export default handler;

package/src/operations/index.ts

@@ -0,0 +1,35 @@
+// Copyright 2025 DXOS.org
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export { SpaceOperation } from './definitions';
+
+export const SpaceOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./add-object'),
+  () => import('./add-relation'),
+  () => import('./add-type'),
+  () => import('./close'),
+  () => import('./create'),
+  () => import('./delete'),
+  () => import('./delete-field'),
+  () => import('./duplicate-object'),
+  () => import('./export-space'),
+  () => import('./get-share-link'),
+  () => import('./import-space'),
+  () => import('./join'),
+  () => import('./migrate'),
+  () => import('./open'),
+  () => import('./open-create-object'),
+  () => import('./open-create-space'),
+  () => import('./open-import-space'),
+  () => import('./open-members'),
+  () => import('./open-settings'),
+  () => import('./remove-objects'),
+  () => import('./rename'),
+  () => import('./rename-object'),
+  () => import('./restore-field'),
+  () => import('./restore-objects'),
+  () => import('./share'),
+  () => import('./snapshot'),
+  () => import('./wait-for-object'),
+);

package/src/operations/join.ts

@@ -0,0 +1,26 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { JOIN_DIALOG } from '../constants';
+import { type JoinDialogProps } from '../containers/JoinDialog';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Join> = SpaceOperation.Join.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: JOIN_DIALOG,
+        blockAlign: 'start',
+        props: {
+          initialInvitationCode: input.invitationCode,
+          onDone: input.onDone,
+        } satisfies Partial<JoinDialogProps>,
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/migrate.ts

@@ -0,0 +1,47 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capabilities } from '@dxos/app-framework';
+import { SpaceState } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Annotation } from '@dxos/echo';
+import { MigrationVersionAnnotation, Migrations } from '@dxos/migrations';
+import { ObservabilityOperation } from '@dxos/plugin-observability';
+
+import { SpaceCapabilities } from '../types';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Migrate> = SpaceOperation.Migrate.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const { space, version: targetVersion } = input;
+
+      if (space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
+        yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+          ...current,
+          sdkMigrationRunning: { ...current.sdkMigrationRunning, [space.id]: true },
+        }));
+        yield* Effect.promise(() => space.internal.migrate());
+        yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+          ...current,
+          sdkMigrationRunning: { ...current.sdkMigrationRunning, [space.id]: false },
+        }));
+      }
+      const result = yield* Effect.promise(() => Migrations.migrate(space, targetVersion));
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'space.migrate',
+        properties: {
+          spaceId: space.id,
+          targetVersion,
+          version: Annotation.get(space.properties, MigrationVersionAnnotation).pipe(Option.getOrUndefined),
+        },
+      });
+
+      return result;
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-create-object.ts

@@ -0,0 +1,40 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Collection, Obj } from '@dxos/echo';
+
+import { CREATE_OBJECT_DIALOG } from '../constants';
+import { SpaceCapabilities } from '../types';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenCreateObject> = SpaceOperation.OpenCreateObject.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const ephemeralState = yield* Capabilities.getAtomValue(SpaceCapabilities.EphemeralState);
+      const navigable = input.navigable ?? true;
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: CREATE_OBJECT_DIALOG,
+        blockAlign: 'start',
+        props: {
+          target: input.target,
+          views: input.views,
+          typename: input.typename,
+          initialFormValues: input.initialFormValues,
+          onCreateObject: input.onCreateObject,
+          targetNodeId: input.targetNodeId,
+          shouldNavigate: navigable
+            ? (object: Obj.Unknown) => {
+                const isCollection = Obj.instanceOf(Collection.Collection, object);
+                return !isCollection || ephemeralState.navigableCollections;
+              }
+            : () => false,
+        },
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-create-space.ts

@@ -0,0 +1,21 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { CREATE_SPACE_DIALOG } from '../constants';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenCreateSpace> = SpaceOperation.OpenCreateSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: CREATE_SPACE_DIALOG,
+        blockAlign: 'start',
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-import-space.ts

@@ -0,0 +1,21 @@
+// Copyright 2026 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { IMPORT_SPACE_DIALOG } from '../constants';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenImportSpace> = SpaceOperation.OpenImportSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: IMPORT_SPACE_DIALOG,
+        blockAlign: 'start',
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-members.ts

@@ -0,0 +1,20 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenMembers> = SpaceOperation.OpenMembers.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Operation.invoke(LayoutOperation.Open, {
+        subject: [`${getSpacePath(input.space.id)}/settings`],
+        workspace: getSpacePath(input.space.id),
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-settings.ts

@@ -0,0 +1,20 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenSettings> = SpaceOperation.OpenSettings.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Operation.invoke(LayoutOperation.Open, {
+        subject: [`${getSpacePath(input.space.id)}/general`],
+        workspace: getSpacePath(input.space.id),
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open.ts

@@ -0,0 +1,16 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Open> = SpaceOperation.Open.pipe(
+  Operation.withHandler((input) =>
+    Effect.promise(async () => {
+      await input.space.open();
+    }),
+  ),
+);
+export default handler;

package/src/operations/remove-objects.ts

@@ -0,0 +1,70 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capabilities } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation, RootCollectionAnnotation } from '@dxos/app-toolkit';
+import { getSpace } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Annotation, Collection, Entity, Obj } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { isNonNullable } from '@dxos/util';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.RemoveObjects> = SpaceOperation.RemoveObjects.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const layout = yield* Capabilities.getAtomValue(AppCapabilities.Layout);
+      const entities = input.objects;
+
+      const space = getSpace(entities[0] as Obj.Unknown);
+      invariant(
+        space && entities.every((entity) => Entity.isEntity(entity) && getSpace(entity as Obj.Unknown) === space),
+      );
+
+      const parentCollection =
+        input.target ?? Annotation.get(space.properties, RootCollectionAnnotation).pipe(Option.getOrUndefined)?.target;
+      invariant(parentCollection, 'No parent collection found for space — cannot remove objects.');
+
+      // Type entities (persisted schemas) live outside collections — `findIndex` will
+      // return -1 for them and the splice/active-tracking branches are skipped.
+      const indices = entities.map((entity) =>
+        Obj.instanceOf(Collection.Collection, parentCollection)
+          ? parentCollection.objects.findIndex((ref) => ref.target === entity)
+          : -1,
+      );
+
+      const wasActive = entities
+        .map((entity) => layout.active.find((graphId) => graphId.endsWith(entity.id)))
+        .filter(isNonNullable);
+
+      for (const entity of entities) {
+        if (Obj.instanceOf(Collection.Collection, parentCollection)) {
+          const index = parentCollection.objects.findIndex((ref) => ref.target === entity);
+          if (index !== -1) {
+            Obj.update(parentCollection, (parentCollection) => {
+              parentCollection.objects.splice(index, 1);
+            });
+          }
+        }
+
+        const db = Entity.getDatabase(entity);
+        db?.remove(entity);
+      }
+
+      if (wasActive.length > 0) {
+        yield* Operation.invoke(LayoutOperation.Close, { subject: wasActive });
+      }
+
+      return {
+        objects: entities,
+        parentCollection,
+        indices,
+        wasActive,
+      };
+    }),
+  ),
+);
+export default handler;

package/src/operations/rename-object.ts

@@ -0,0 +1,22 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { ENTITY_RENAME_POPOVER } from '../constants';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.RenameObject> = SpaceOperation.RenameObject.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Operation.invoke(LayoutOperation.UpdatePopover, {
+        subject: ENTITY_RENAME_POPOVER,
+        anchorId: input.caller ?? '',
+        props: input.object,
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/rename.ts

@@ -0,0 +1,22 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { SPACE_RENAME_POPOVER } from '../constants';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Rename> = SpaceOperation.Rename.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Operation.invoke(LayoutOperation.UpdatePopover, {
+        subject: SPACE_RENAME_POPOVER,
+        anchorId: input.caller ?? '',
+        props: input.space,
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/restore-field.ts

@@ -0,0 +1,37 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Filter, JsonSchema, Obj, Type } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from '@dxos/schema';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.RestoreField> = SpaceOperation.RestoreField.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const registry = yield* Capability.get(Capabilities.AtomRegistry);
+      const view = input.view as any;
+      const db = Obj.getDatabase(view);
+      invariant(db);
+      const typename = getTypenameFromQuery(view.query.ast);
+      invariant(typename);
+      const types = yield* Effect.promise(() => db.query(Filter.type(Type.Type)).run());
+      const schema = types.find((t) => Type.getTypename(t) === typename);
+      invariant(schema);
+
+      const projection = new ProjectionModel({
+        registry,
+        view,
+        baseSchema: JsonSchema.toJsonSchema(schema),
+        change: createEchoChangeCallback(view, schema),
+      });
+
+      projection.setFieldProjection({ field: input.field, props: input.props }, input.index);
+    }),
+  ),
+);
+export default handler;

package/src/operations/restore-objects.ts

@@ -0,0 +1,39 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Collection, type Entity, Obj, Ref } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.RestoreObjects> = SpaceOperation.RestoreObjects.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const entities = input.objects;
+      const parentCollection = input.parentCollection as Collection.Collection;
+      const indices = input.indices as number[];
+      const wasActive = input.wasActive as string[];
+
+      const db = Obj.getDatabase(entities[0] as Obj.Unknown);
+      invariant(db);
+
+      const restored = entities.map((entity: Entity.Unknown) => db.add(entity));
+
+      Obj.update(parentCollection, (parentCollection) => {
+        indices.forEach((index: number, i: number) => {
+          if (index !== -1) {
+            parentCollection.objects.splice(index, 0, Ref.make(restored[i] as Obj.Unknown));
+          }
+        });
+      });
+
+      if (wasActive.length > 0) {
+        yield* Operation.invoke(LayoutOperation.Open, { subject: wasActive });
+      }
+    }),
+  ),
+);
+export default handler;

package/src/operations/share.ts

@@ -0,0 +1,27 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { ObservabilityOperation } from '@dxos/plugin-observability';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Share> = SpaceOperation.Share.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const { space, type, authMethod, multiUse, target } = input;
+      const invitation = space.share({ type, authMethod, multiUse, target });
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'space.share',
+        properties: {
+          spaceId: space.id,
+        },
+      });
+
+      return invitation;
+    }),
+  ),
+);
+export default handler;

package/src/operations/snapshot.ts

@@ -0,0 +1,24 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Query } from '@dxos/echo';
+import { EchoDatabaseImpl, Serializer } from '@dxos/echo-db';
+import { invariant } from '@dxos/invariant';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Snapshot> = SpaceOperation.Snapshot.pipe(
+  Operation.withHandler((input) =>
+    Effect.promise(async () => {
+      const db = input.db as any;
+      invariant(db instanceof EchoDatabaseImpl, 'Database must be an instance of EchoDatabaseImpl');
+      const backup = await new Serializer().export(db, input.query && Query.fromAst(input.query));
+      return {
+        snapshot: new Blob([JSON.stringify(backup, null, 2)], { type: 'application/json' }),
+      };
+    }),
+  ),
+);
+export default handler;