@dxos/plugin-space 0.8.4-main.f5c0578 → 0.8.4-main.fcc0d83b33

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-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,87 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+import { getSpace } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Collection, Obj, Relation } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { isNonNullable } from '@dxos/util';
+
+import { getNestedObjects } from '../util';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.RemoveObjects> = SpaceOperation.RemoveObjects.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const capabilityManager = yield* Capability.Service;
+      const resolve = (typename: string) =>
+        capabilityManager.getAll(AppCapabilities.Metadata).find(({ id }: { id: string }) => id === typename)
+          ?.metadata ?? {};
+
+      const layout = yield* Capabilities.getAtomValue(AppCapabilities.Layout);
+      const objects = input.objects as Obj.Unknown[];
+
+      const space = getSpace(objects[0]);
+      invariant(space && objects.every((obj) => Obj.isObject(obj) && getSpace(obj) === space));
+
+      const parentCollection: Collection.Collection =
+        input.target ?? space.properties[Collection.Collection.typename]?.target;
+
+      const nestedObjectsList = yield* Effect.promise(() =>
+        Promise.all(objects.map((obj) => getNestedObjects(obj, resolve))),
+      );
+
+      const indices = objects.map((obj) =>
+        Obj.instanceOf(Collection.Collection, parentCollection)
+          ? parentCollection.objects.findIndex((ref) => ref.target === obj)
+          : -1,
+      );
+
+      const wasActive = objects
+        .flatMap((obj, i) => [obj, ...nestedObjectsList[i]])
+        .filter(Obj.isObject)
+        .map((object) => layout.active.find((graphId) => graphId.endsWith(object.id)))
+        .filter(isNonNullable);
+
+      for (let i = 0; i < objects.length; i++) {
+        const obj = objects[i];
+        const nestedObjects = nestedObjectsList[i];
+
+        const index = parentCollection.objects.findIndex((ref) => ref.target === obj);
+        if (index !== -1) {
+          Obj.update(parentCollection, (parentCollection) => {
+            parentCollection.objects.splice(index, 1);
+          });
+        }
+
+        for (const nestedObject of nestedObjects) {
+          if (Obj.isObject(nestedObject)) {
+            Obj.getDatabase(nestedObject)?.remove(nestedObject);
+          } else if (Relation.isRelation(nestedObject)) {
+            const db = Obj.getDatabase(Relation.getSource(nestedObject));
+            db?.remove(nestedObject);
+          }
+        }
+
+        const db = Obj.getDatabase(obj);
+        db?.remove(obj);
+      }
+
+      if (wasActive.length > 0) {
+        yield* Operation.invoke(LayoutOperation.Close, { subject: wasActive });
+      }
+
+      return {
+        objects,
+        parentCollection,
+        indices,
+        nestedObjectsList,
+        wasActive,
+      };
+    }),
+  ),
+);
+export default handler;

package/src/operations/rename-object.ts

@@ -0,0 +1,24 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+
+import { OBJECT_RENAME_POPOVER } from '../constants';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.RenameObject> = SpaceOperation.RenameObject.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const object = input.object as Obj.Unknown;
+      yield* Operation.invoke(LayoutOperation.UpdatePopover, {
+        subject: OBJECT_RENAME_POPOVER,
+        anchorId: input.caller ?? '',
+        props: 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,36 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Obj } 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 schema = yield* Effect.promise(() => db.schemaRegistry.query({ typename }).firstOrUndefined());
+      invariant(schema);
+
+      const projection = new ProjectionModel({
+        registry,
+        view,
+        baseSchema: schema.jsonSchema,
+        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,49 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { getSpace } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Collection, Obj, Ref, Relation } 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 objects = input.objects as Obj.Unknown[];
+      const parentCollection = input.parentCollection as Collection.Collection;
+      const indices = input.indices as number[];
+      const nestedObjectsList = input.nestedObjectsList as Obj.Unknown[][];
+      const wasActive = input.wasActive as string[];
+
+      const space = getSpace(objects[0]);
+      invariant(space);
+
+      const restoredObjects = objects.map((obj: Obj.Unknown) => space.db.add(obj));
+
+      nestedObjectsList.flat().forEach((obj: Obj.Unknown) => {
+        if (Obj.isObject(obj)) {
+          space.db.add(obj);
+        } else if (Relation.isRelation(obj)) {
+          space.db.add(obj);
+        }
+      });
+
+      Obj.update(parentCollection, (parentCollection) => {
+        indices.forEach((index: number, i: number) => {
+          if (index !== -1) {
+            parentCollection.objects.splice(index, 0, Ref.make(restoredObjects[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/operations';
+
+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;

package/src/operations/wait-for-object.ts

@@ -0,0 +1,21 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+
+import { SpaceCapabilities } from '../types';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.WaitForObject> = SpaceOperation.WaitForObject.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+        ...current,
+        awaiting: input.id,
+      }));
+    }),
+  ),
+);
+export default handler;