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

package/src/operations/add-object.ts

@@ -0,0 +1,82 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { getCollectionsPath, getObjectPath, getTypePath } from '@dxos/app-toolkit';
+import { Database, Obj, View } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+import { Collection } from '@dxos/echo';
+import { CollectionModel, ViewAnnotation, getTypenameFromQuery } from '@dxos/schema';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.AddObject> = SpaceOperation.AddObject.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const target = input.target as any;
+      const object = input.object as Obj.Unknown;
+      const db = Database.isDatabase(target) ? target : Obj.getDatabase(target);
+      invariant(db, 'Database not found.');
+
+      yield* CollectionModel.add({
+        object,
+        target: Database.isDatabase(target) ? undefined : target,
+        hidden: input.hidden,
+      }).pipe(Effect.provide(Database.layer(db)));
+
+      const typename = Obj.getTypename(object)!;
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'space.object.add',
+        properties: {
+          spaceId: db.spaceId,
+          objectId: object.id,
+          typename: Obj.getTypename(object),
+        },
+      });
+
+      const [schema] = db.schemaRegistry.query({ typename, location: ['runtime'] }).runSync();
+      const isViewSchema = schema !== undefined && ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false));
+      const view = isViewSchema
+        ? yield* Effect.promise(() => (object as Obj.Any).view.load() as Promise<View.View>)
+        : undefined;
+      const viewTargetTypename = view ? getTypenameFromQuery(view.query.ast) : undefined;
+      const subject = getSubjectPathForNewObject({
+        spaceId: db.spaceId,
+        objectId: object.id,
+        nodeId: input.targetNodeId,
+        typename,
+        viewTargetTypename,
+      });
+
+      return {
+        id: Obj.getDXN(object).toString(),
+        subject: [subject],
+        object,
+      };
+    }),
+  ),
+);
+export default handler;
+
+const getSubjectPathForNewObject = (props: {
+  spaceId: string;
+  objectId: string;
+  nodeId?: string;
+  typename: string;
+  viewTargetTypename?: string;
+}): string => {
+  const { nodeId, typename, viewTargetTypename, spaceId, objectId } = props;
+  if (typeof nodeId === 'string') {
+    return `${nodeId}/${objectId}`;
+  }
+  if (typename === Collection.Collection.typename) {
+    return getCollectionsPath(spaceId, objectId);
+  }
+  if (viewTargetTypename) {
+    return getTypePath(spaceId, viewTargetTypename, objectId);
+  }
+  return getObjectPath(spaceId, typename, objectId);
+};

package/src/operations/add-relation.ts

@@ -0,0 +1,25 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Database, Relation } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.AddRelation> = SpaceOperation.AddRelation.pipe(
+  Operation.withHandler((input) =>
+    Effect.sync(() => {
+      const db = input.db as Database.Database;
+      const relation = db.add(
+        Relation.make(input.schema, {
+          [Relation.Source]: input.source,
+          [Relation.Target]: input.target,
+          ...input.fields,
+        }),
+      );
+      return { relation };
+    }),
+  ),
+);
+export default handler;

package/src/operations/add-schema.ts

@@ -0,0 +1,52 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capability, Plugin } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+
+import { SpaceEvents, SpaceCapabilities } from '../types';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.AddSchema> = SpaceOperation.AddSchema.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const db = input.db;
+      const schemas = yield* Effect.promise(() => db.schemaRegistry.register([input.schema]));
+      const schema = schemas[0];
+      Obj.change(schema.persistentSchema, (obj) => {
+        if (input.name) {
+          obj.name = input.name;
+        }
+        if (input.typename) {
+          obj.typename = input.typename;
+        }
+        if (input.version) {
+          obj.version = input.version;
+        }
+      });
+
+      yield* Plugin.activate(SpaceEvents.SchemaAdded);
+      const onSchemaAdded = yield* Capability.getAll(SpaceCapabilities.OnSchemaAdded);
+      yield* Effect.all(
+        onSchemaAdded.map((callback) => callback({ db, schema, show: input.show })),
+        { concurrency: 'unbounded' },
+      );
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'space.schema.add',
+        properties: {
+          spaceId: db.spaceId,
+          objectId: schema.id,
+          typename: schema.typename,
+        },
+      });
+
+      return { id: schema.id, object: schema.persistentSchema, schema };
+    }),
+  ),
+);
+export default handler;

package/src/operations/close.ts

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

package/src/operations/create.ts

@@ -0,0 +1,60 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capability, Plugin } from '@dxos/app-framework';
+import { Collection, Obj, Ref } from '@dxos/echo';
+import { Migrations } from '@dxos/migrations';
+import { Operation } from '@dxos/operation';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { iconValues } from '@dxos/react-ui-pickers/icons';
+import { hues } from '@dxos/ui-theme';
+
+import { SpaceEvents, SpaceCapabilities } from '../types';
+
+import { SpaceOperation } from './definitions';
+import { SpaceOperationConfig } from './helpers';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Create> = SpaceOperation.Create.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ name, hue: hue_, icon: icon_, edgeReplication }) {
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      const hue = hue_ ?? hues[Math.floor(Math.random() * hues.length)];
+      const icon = icon_ ?? iconValues[Math.floor(Math.random() * iconValues.length)];
+      const space = yield* Effect.promise(() => client.spaces.create({ name, hue, icon }));
+      if (edgeReplication) {
+        yield* Effect.promise(() => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
+      }
+      yield* Effect.promise(() => space.waitUntilReady());
+
+      const collection = Obj.make(Collection.Collection, { objects: [] });
+      Obj.change(space.properties, (obj) => {
+        obj[Collection.Collection.typename] = Ref.make(collection);
+        if (Migrations.versionProperty) {
+          obj[Migrations.versionProperty] = Migrations.targetVersion;
+        }
+      });
+
+      yield* Plugin.activate(SpaceEvents.SpaceCreated);
+      const onCreateSpaceCallbacks = yield* Capability.getAll(SpaceCapabilities.OnCreateSpace);
+      yield* Effect.all(
+        onCreateSpaceCallbacks.map((onCreateSpace) =>
+          onCreateSpace({ space, isDefault: false, rootCollection: collection }),
+        ),
+      );
+
+      const { observability } = yield* Capability.get(SpaceOperationConfig);
+      if (observability) {
+        yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+          name: 'space.create',
+          properties: { spaceId: space.id },
+        });
+      }
+
+      return { id: space.id, subject: [space.id], space };
+    }),
+  ),
+);
+export default handler;

package/src/operations/definitions.ts

@@ -0,0 +1,437 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Capability, Plugin } from '@dxos/app-framework';
+import { SpaceSchema } from '@dxos/client/echo';
+import { CancellableInvitationObservable, Invitation } from '@dxos/client/invitations';
+import { Collection, Database, Obj, QueryAST, Type, View } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { SpaceForm } from '../types';
+import { meta } from '#meta';
+
+const COLLECTION_OPERATION = 'org.dxos.plugin.collection.operation';
+
+export namespace CollectionOperation {
+  export const Create = Operation.make({
+    meta: { key: `${COLLECTION_OPERATION}.create`, name: 'Create Collection' },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      name: Schema.optional(Schema.String),
+    }),
+    output: Schema.Struct({
+      object: Collection.Collection,
+    }),
+  });
+}
+
+const SPACE_OPERATION = `${meta.id}.operation`;
+
+/**
+ * Operations for the Space plugin.
+ */
+export namespace SpaceOperation {
+  export const Create = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.create`,
+      name: 'Create Space',
+      description: 'Create a new space.',
+    },
+    services: [Capability.Service, Plugin.Service],
+    input: SpaceForm,
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
+      space: SpaceSchema,
+    }),
+  });
+
+  export const Join = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.join`,
+      name: 'Join Space',
+      description: 'Join a space via invitation.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      invitationCode: Schema.optional(Schema.String),
+      onDone: Schema.optional(Schema.Any),
+    }),
+    output: Schema.Void,
+  });
+
+  export const Open = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open`,
+      name: 'Open Space',
+      description: 'Open a space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+    }),
+    output: Schema.Void,
+  });
+
+  export const Close = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.close`,
+      name: 'Close Space',
+      description: 'Close a space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+    }),
+    output: Schema.Void,
+  });
+
+  export const Share = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.share`,
+      name: 'Share Space',
+      description: 'Share a space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+      type: Schema.Enums(Invitation.Type),
+      authMethod: Schema.Enums(Invitation.AuthMethod),
+      multiUse: Schema.Boolean,
+      target: Schema.optional(Schema.String),
+    }),
+    output: Schema.instanceOf(CancellableInvitationObservable),
+  });
+
+  export const OpenSettings = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open-settings`,
+      name: 'Open Space Settings',
+      description: 'Open space settings.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+    }),
+    output: Schema.Void,
+  });
+
+  export const WaitForObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.wait-for-object`,
+      name: 'Wait For Object',
+      description: 'Wait for an object to be available.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      id: Schema.optional(Schema.String),
+    }),
+    output: Schema.Void,
+  });
+
+  export const AddObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.add-object`,
+      name: 'Add Object',
+      description: 'Add an object to a space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      object: Obj.Unknown.annotations({ description: 'The object to add.' }),
+      target: Schema.Union(Database.Database, Collection.Collection).annotations({
+        description: 'The database or collection to add to.',
+      }),
+      hidden: Schema.optional(Schema.Boolean),
+      targetNodeId: Schema.optional(
+        Schema.String.annotations({ description: 'Qualified graph node ID of the target collection.' }),
+      ),
+    }),
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
+      object: Obj.Unknown,
+    }),
+  });
+
+  export const RemoveObjectsOutput = Schema.Struct({
+    objects: Schema.Array(Obj.Unknown).annotations({ description: 'The removed objects.' }),
+    parentCollection: Collection.Collection.annotations({ description: 'The collection removed from.' }),
+    indices: Schema.Array(Schema.Number).annotations({ description: 'The indices the objects were at.' }),
+    nestedObjectsList: Schema.Array(Schema.Array(Obj.Unknown)).annotations({
+      description: 'Nested objects that were removed.',
+    }),
+    wasActive: Schema.Array(Schema.String).annotations({
+      description: 'IDs of objects that were active before removal.',
+    }),
+  });
+
+  export type RemoveObjectsOutput = Schema.Schema.Type<typeof RemoveObjectsOutput>;
+
+  export const RemoveObjects = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.remove-objects`,
+      name: 'Remove Objects',
+      description: 'Remove objects from a space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      objects: Schema.Array(Obj.Unknown).annotations({ description: 'The objects to remove.' }),
+      target: Schema.optional(Collection.Collection).annotations({ description: 'The collection to remove from.' }),
+    }),
+    output: RemoveObjectsOutput,
+  });
+
+  export const DeleteFieldOutput = Schema.Struct({
+    field: View.FieldSchema.annotations({ description: 'The deleted field schema.' }),
+    // TODO(wittjosiah): This creates a type error with PropertySchema.
+    props: Schema.Any.annotations({ description: 'The deleted field properties.' }),
+    index: Schema.Number.annotations({ description: 'The index the field was at.' }),
+  });
+
+  export type DeleteFieldOutput = Schema.Schema.Type<typeof DeleteFieldOutput>;
+
+  export const DeleteField = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.delete-field`,
+      name: 'Delete Field',
+      description: 'Delete a field from a view.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      view: View.View.annotations({ description: 'The view to delete the field from.' }),
+      fieldId: Schema.String,
+    }),
+    output: DeleteFieldOutput,
+  });
+
+  export const OpenCreateObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open-create-object`,
+      name: 'Open Create Object Dialog',
+      description: 'Open the create object dialog.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      target: Schema.Union(Database.Database, Collection.Collection).annotations({
+        description: 'The database or collection to create in.',
+      }),
+      views: Schema.optional(Schema.Boolean),
+      typename: Schema.optional(Schema.String),
+      initialFormValues: Schema.optional(Schema.Any),
+      navigable: Schema.optional(Schema.Boolean),
+      targetNodeId: Schema.optional(
+        Schema.String.annotations({ description: 'Qualified graph node ID of the target collection.' }),
+      ),
+      // TODO(wittjosiah): This is a function, is there a better way to handle this?
+      onCreateObject: Schema.optional(Schema.Any),
+    }),
+    output: Schema.Void,
+  });
+
+  export const OpenCreateSpace = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open-create-space`,
+      name: 'Open Create Space Dialog',
+      description: 'Open the create space dialog.',
+    },
+    services: [Capability.Service],
+    input: Schema.Void,
+    output: Schema.Void,
+  });
+
+  export const Migrate = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.migrate`,
+      name: 'Migrate Space',
+      description: 'Migrate a space to a new version.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+      version: Schema.optional(Schema.String),
+    }),
+    output: Schema.Boolean,
+  });
+
+  export const Snapshot = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.snapshot`,
+      name: 'Create Snapshot',
+      description: 'Create a snapshot of the space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      db: Database.Database,
+      query: QueryAST.Query.pipe(Schema.optional),
+    }),
+    output: Schema.Struct({
+      snapshot: Schema.instanceOf(Blob),
+    }),
+  });
+
+  export const Rename = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.rename`,
+      name: 'Rename Space',
+      description: 'Rename a space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+      caller: Schema.optional(Schema.String),
+    }),
+    output: Schema.Void,
+  });
+
+  export const RenameObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.rename-object`,
+      name: 'Rename Object',
+      description: 'Rename an object.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      object: Obj.Unknown,
+      caller: Schema.optional(Schema.String),
+    }),
+    output: Schema.Void,
+  });
+
+  export const OpenMembers = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open-members`,
+      name: 'Open Members',
+      description: 'Open the members panel for a space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+    }),
+    output: Schema.Void,
+  });
+
+  export const GetShareLink = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.get-share-link`,
+      name: 'Get Share Link',
+      description: 'Get a shareable link for a space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+      target: Schema.optional(Schema.String),
+      copyToClipboard: Schema.optional(Schema.Boolean),
+    }),
+    output: Schema.String,
+  });
+
+  export const StoredSchemaForm = Schema.Struct({
+    name: Schema.optional(Schema.String),
+  });
+
+  export const AddSchema = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.add-schema`,
+      name: 'Add Schema',
+      description: 'Add a schema to the space.',
+    },
+    services: [Capability.Service, Plugin.Service],
+    input: Schema.Struct({
+      db: Database.Database,
+      name: Schema.optional(Schema.String),
+      typename: Schema.optional(Schema.String),
+      version: Schema.optional(Schema.String),
+      // TODO(wittjosiah): Schema for schema?
+      schema: Schema.Any,
+      show: Schema.optional(Schema.Boolean),
+    }),
+    output: Schema.Struct({
+      id: Schema.String,
+      object: Type.PersistentType,
+      schema: Schema.instanceOf(Type.RuntimeType),
+    }),
+  });
+
+  export const AddRelation = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.add-relation`,
+      name: 'Add Relation',
+      description: 'Add a relation between objects.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      db: Database.Database,
+      // TODO(wittjosiah): Relation schema.
+      schema: Schema.Any,
+      source: Obj.Unknown,
+      target: Obj.Unknown,
+      // TODO(wittjosiah): Type based on relation schema.
+      fields: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+    }),
+    output: Schema.Struct({
+      relation: Schema.Any,
+    }),
+  });
+
+  // TODO(wittjosiah): This appears to be unused.
+  export const DuplicateObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.duplicate-object`,
+      name: 'Duplicate Object',
+      description: 'Duplicate an object.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      object: Obj.Unknown,
+      target: Schema.Union(Database.Database, Collection.Collection),
+    }),
+    output: Schema.Void,
+  });
+
+  /**
+   * Restore a deleted field to a view (inverse of DeleteField).
+   */
+  export const RestoreField = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.restore-field`,
+      name: 'Restore Field',
+      description: 'Restore a deleted field to a view.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      view: View.View.annotations({ description: 'The view to restore the field to.' }),
+      field: View.FieldSchema.annotations({ description: 'The field schema to restore.' }),
+      // TODO(wittjosiah): This creates a type error with PropertySchema.
+      props: Schema.Any.annotations({ description: 'The field properties to restore.' }),
+      index: Schema.Number.annotations({ description: 'The index to restore the field at.' }),
+    }),
+    output: Schema.Void,
+  });
+
+  /**
+   * Restore deleted objects to a space (inverse of RemoveObjects).
+   */
+  export const RestoreObjects = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.restore-objects`,
+      name: 'Restore Objects',
+      description: 'Restore deleted objects to a space.',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      objects: Schema.Array(Obj.Unknown).annotations({ description: 'The objects to restore.' }),
+      parentCollection: Collection.Collection.annotations({ description: 'The collection to restore to.' }),
+      indices: Schema.Array(Schema.Number).annotations({ description: 'The indices to restore at.' }),
+      nestedObjectsList: Schema.Array(Schema.Array(Obj.Unknown)).annotations({
+        description: 'Nested objects to restore.',
+      }),
+      wasActive: Schema.Array(Schema.String).annotations({
+        description: 'IDs of objects that were active before deletion.',
+      }),
+    }),
+    output: Schema.Void,
+  });
+}