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

package/src/containers/ViewEditor/ViewEditor.tsx

@@ -2,33 +2,31 @@
 // Copyright 2023 DXOS.org
 //
 
-import * as Schema from 'effect/Schema';
 import React, { useCallback, useState } from 'react';
 
 import { useOperationInvoker } from '@dxos/app-framework/ui';
-import { DXN, Filter, JsonSchema, Obj, Query, type QueryAST, Tag, Type } from '@dxos/echo';
-import { type View } from '@dxos/echo';
+import { resolveSchemaWithRegistry } from '@dxos/app-toolkit/query';
+import { useTypeOptions } from '@dxos/app-toolkit/ui';
+import { EID, Filter, Obj, Query, type QueryAST, Scope, Tag, Type, type View } from '@dxos/echo';
 import { type Mutable } from '@dxos/echo/internal';
 import { useClient } from '@dxos/react-client';
-import { getSpace, useQuery } from '@dxos/react-client/echo';
+import { useQuery } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 import { ViewEditor as NaturalViewEditor } from '@dxos/react-ui-form';
 import { ViewModel } from '@dxos/schema';
 
-import { resolveSchemaWithRegistry } from '../../helpers';
-import { useTypeOptions } from '../../hooks';
-import { SpaceOperation } from '../../types';
+import { SpaceOperation } from '#operations';
 
 export type ViewEditorProps = { view: View.View };
 
 export const ViewEditor = ({ view }: ViewEditorProps) => {
   const { invokePromise } = useOperationInvoker();
   const client = useClient();
-  const space = getSpace(view);
-  const [schema, setSchema] = useState<Schema.Schema.AnyNoContext>(() => Schema.Struct({}));
-  const tags = useQuery(space?.db, Filter.type(Tag.Tag));
+  const db = Obj.getDatabase(view);
+  const [type, setType] = useState<Type.AnyEntity>();
+  const tags = useQuery(db, Filter.type(Tag.Tag));
   const types = useTypeOptions({
-    space,
+    db,
     annotation: {
       location: ['database', 'runtime'],
       kind: ['user'],
@@ -36,43 +34,47 @@ export const ViewEditor = ({ view }: ViewEditorProps) => {
   });
 
   useAsyncEffect(async () => {
-    if (!view?.query || !space) {
+    if (!view?.query || !db) {
       return;
     }
 
-    const foundSchema = await resolveSchemaWithRegistry(space.db.schemaRegistry, view.query.ast);
-    if (foundSchema && foundSchema !== schema) {
-      setSchema(() => foundSchema);
+    const foundType = await resolveSchemaWithRegistry(db, view.query.ast);
+    if (foundType && foundType !== type) {
+      setType(() => foundType);
     }
-  }, [client, space, view, schema]);
+  }, [client, db, view, type]);
 
   const handleQueryChanged = useCallback(
-    async (newQuery: QueryAST.Query, target?: string) => {
-      if (!view || !space) {
+    async (newQuery: QueryAST.Query, target?: EID.EID) => {
+      if (!view || !db) {
         return;
       }
 
-      const queue = target && DXN.tryParse(target) ? target : undefined;
-      const query = queue ? Query.fromAst(newQuery).from({ queues: [queue] }) : Query.fromAst(newQuery);
-      Obj.change(view, (v) => {
-        v.query.ast = query.ast as Mutable<typeof query.ast>;
+      const queue = target;
+      const query = queue
+        ? Query.fromAst(newQuery).from([
+            Scope.feed(`dxn:queue:data:${EID.getSpaceId(queue)}:${EID.getEntityId(queue)}`),
+          ])
+        : Query.fromAst(newQuery);
+      Obj.update(view, (view) => {
+        view.query.ast = query.ast as Mutable<typeof query.ast>;
       });
-      const newSchema = await resolveSchemaWithRegistry(space.db.schemaRegistry, query.ast);
-      if (!newSchema) {
+      const newType = await resolveSchemaWithRegistry(db, query.ast);
+      if (!newType) {
         return;
       }
 
       const newView = ViewModel.make({
         query,
-        jsonSchema: JsonSchema.toJsonSchema(newSchema),
+        jsonSchema: newType.jsonSchema,
       });
-      Obj.change(view, (v) => {
-        v.projection = Obj.getSnapshot(newView).projection as Mutable<typeof v.projection>;
+      Obj.update(view, (view) => {
+        view.projection = Obj.getSnapshot(newView).projection as Mutable<typeof view.projection>;
       });
 
-      setSchema(() => newSchema);
+      setType(() => newType);
     },
-    [view, schema],
+    [view, type],
   );
 
   const handleDelete = useCallback(
@@ -82,21 +84,21 @@ export const ViewEditor = ({ view }: ViewEditorProps) => {
     [invokePromise, view],
   );
 
-  if (!space || !schema) {
+  if (!db || !type) {
     return null;
   }
 
   return (
     <NaturalViewEditor
-      registry={space.db.schemaRegistry}
-      schema={schema}
+      registry={db.graph.registry}
+      type={type}
       view={view}
       mode='tag'
-      db={space.db}
+      db={db}
       tags={tags}
       types={types}
       onQueryChanged={handleQueryChanged}
-      onDelete={Type.isMutable(schema) ? handleDelete : undefined}
+      onDelete={Type.getDatabase(type) != null ? handleDelete : undefined}
     />
   );
 };

package/src/containers/ViewEditor/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2023 DXOS.org
 //
 
-import { ViewEditor } from './ViewEditor';
-
-export default ViewEditor;
+export { ViewEditor as default } from './ViewEditor';

package/src/containers/index.ts

@@ -10,17 +10,18 @@ export const CollectionArticle: ComponentType<any> = lazy(() => import('./Collec
 export const CollectionSection: ComponentType<any> = lazy(() => import('./CollectionSection'));
 export const CreateObjectDialog: ComponentType<any> = lazy(() => import('./CreateObjectDialog'));
 export const CreateSpaceDialog: ComponentType<any> = lazy(() => import('./CreateSpaceDialog'));
+export const ImportSpaceDialog: ComponentType<any> = lazy(() => import('./ImportSpaceDialog'));
 export const InlineSyncStatus: ComponentType<any> = lazy(() => import('./InlineSyncStatus'));
 export const JoinDialog: ComponentType<any> = lazy(() => import('./JoinDialog'));
 export const MembersContainer: ComponentType<any> = lazy(() => import('./MembersContainer'));
 export const MenuFooter: ComponentType<any> = lazy(() => import('./MenuFooter'));
 export const ObjectCardStack: ComponentType<any> = lazy(() => import('./ObjectCardStack'));
-export const ObjectDetails: ComponentType<any> = lazy(() => import('./ObjectDetails'));
-export const ObjectRenamePopover: ComponentType<any> = lazy(() => import('./ObjectRenamePopover'));
+export const ObjectProperties: ComponentType<any> = lazy(() => import('./ObjectProperties'));
+export const EntityRenamePopover: ComponentType<any> = lazy(() => import('./EntityRenamePopover'));
 export const RecordArticle: ComponentType<any> = lazy(() => import('./RecordArticle'));
+export const RelatedArticle: ComponentType<any> = lazy(() => import('./RelatedArticle'));
 export const SchemaContainer: ComponentType<any> = lazy(() => import('./SchemaContainer'));
 export const SmallPresenceLive: ComponentType<any> = lazy(() => import('./SmallPresenceLive'));
-export const SpacePluginSettings: ComponentType<any> = lazy(() => import('./SpacePluginSettings'));
 export const SpacePresence: ComponentType<any> = lazy(() => import('./SpacePresence'));
 export const SpaceRenamePopover: ComponentType<any> = lazy(() => import('./SpaceRenamePopover'));
 export const SpaceSettingsContainer: ComponentType<any> = lazy(() => import('./SpaceSettingsContainer'));

package/src/hooks/index.ts

@@ -2,7 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './useActiveSpace';
 export * from './useInputSurfaceLookup';
 export * from './usePath';
-export * from './useTypeOptions';
+export * from './useRelatedObjects';

package/src/hooks/useInputSurfaceLookup.tsx

@@ -17,9 +17,16 @@ export const useInputSurfaceLookup = (baseData?: Record<string, any>): FormField
   const pluginManager = usePluginManager();
   return useCallback<FormFieldProvider>(
     ({ schema, prop, fieldProps }) => {
-      const data = { prop, schema, ...baseData };
+      const data = {
+        prop,
+        schema,
+        /** Property Schema AST (`fieldProps.type`). Not spread as React prop `type` — Surface peels `type` for role tokens. */
+        fieldPropertyAst: fieldProps.type,
+        ...baseData,
+      };
+      const { type: _fieldPropertyAstExcluded, ...surfaceFieldProps } = fieldProps as Record<string, any>;
       if (Surface.isAvailable(pluginManager.capabilities, { role: 'form-input', data })) {
-        return <Surface.Surface role='form-input' data={data} {...fieldProps} />;
+        return <Surface.Surface role='form-input' data={data} {...surfaceFieldProps} />;
       }
     },
     [pluginManager, baseData],

package/src/hooks/useRelatedObjects.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { type Database, Entity, Filter, Obj, Ref, Relation } from '@dxos/echo';
+import { useQuery } from '@dxos/react-client/echo';
+import { isNonNullable } from '@dxos/util';
+
+/**
+ * Returns objects related to `subject` via direct references and/or relations.
+ * Returns an empty array when `subject` is undefined.
+ */
+// TODO(burdon): Factor out (make more generally useful -- e.g., in cards).
+// TODO(wittjosiah): This is a hack. ECHO needs to have a back reference index to easily query for related objects.
+export const useRelatedObjects = (
+  db?: Database.Database,
+  subject?: Obj.Unknown,
+  options: {
+    references?: boolean;
+    relations?: boolean;
+  } = {},
+) => {
+  const objects = useQuery(db, Filter.everything());
+  return useMemo(() => {
+    if (!subject) {
+      return [];
+    }
+
+    const related: Entity.Unknown[] = [];
+
+    // TODO(burdon): Change Person => Organization to relations.
+    if (options.references) {
+      const getReferences = (obj: Entity.Unknown): Ref.Unknown[] => {
+        return Object.getOwnPropertyNames(obj)
+          .map((name) => obj[name as keyof Obj.Unknown])
+          .filter((value) => Ref.isRef(value)) as Ref.Unknown[];
+      };
+
+      const references = getReferences(subject);
+      const referenceTargets = references.map((ref) => ref.target).filter(isNonNullable);
+      const referenceSources = objects.filter((obj) => {
+        const refs = getReferences(obj);
+        return refs.some((ref) => ref.target === subject);
+      });
+
+      related.push(...referenceTargets, ...referenceSources);
+    }
+
+    if (options.relations) {
+      // TODO(dmaretskyi): Workaround until https://github.com/dxos/dxos/pull/10100 lands.
+      const isValidRelation = (obj: Relation.Unknown) => {
+        try {
+          return Relation.isRelation(obj) && Relation.getSource(obj) && Relation.getTarget(obj);
+        } catch {
+          return false;
+        }
+      };
+
+      const relations = objects.filter(Relation.isRelation).filter((obj) => isValidRelation(obj));
+      const targetObjects = relations
+        .filter((relation) => Relation.getTarget(relation) === subject)
+        .map((relation) => Relation.getSource(relation));
+      const sourceObjects = relations
+        .filter((relation) => Relation.getSource(relation) === subject)
+        .map((relation) => Relation.getTarget(relation));
+
+      related.push(...targetObjects, ...sourceObjects);
+    }
+
+    return (
+      Array.from(new Set(related))
+        // TODO(burdon): Configure.
+        .filter((obj) => Entity.getTypename(obj) !== 'org.dxos.type.text')
+        .filter((obj) => Entity.getTypename(obj) !== 'org.dxos.type.assistant.chat')
+    );
+  }, [subject, objects, options.references, options.relations]);
+};

package/src/index.ts

@@ -2,12 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
-export { SpaceCapabilities, SpaceEvents } from './types';
-
-export * from './components';
-export * from './helpers';
-export * from './hooks';
 export * from './meta';
+export * from './types';
 export * from './util';
 
-export * from './SpacePlugin';
+export { CollectionOperation, SpaceOperation } from './operations/definitions';

package/src/meta.ts

@@ -2,15 +2,33 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Plugin } from '@dxos/app-framework';
+import { Plugin } from '@dxos/app-framework';
+import { DXN } from '@dxos/keys';
 import { trim } from '@dxos/util';
 
-export const meta: Plugin.Meta = {
-  id: 'org.dxos.plugin.space',
+export const meta = Plugin.makeMeta({
+  key: DXN.make('org.dxos.plugin.space'),
   name: 'Spaces',
+  author: 'DXOS',
+  spec: 'PLUGIN.mdl',
   description: trim`
-    Core workspace container system for organizing and sharing collaborative environments.
-    Create, manage, and share spaces with granular access control and invitation management.
+    SpacePlugin is the core workspace container for DXOS Composer. It owns the full lifecycle of
+    collaborative spaces — creating, joining, opening, closing, and resetting them — and manages
+    the membership and invitation system that controls who can access each space.
+
+    The plugin maintains an ordered app-graph of every space and its collections, wires navigation
+    so that opening a space or object updates the layout, and tracks real-time peer presence so
+    that the UI can show which collaborators are viewing each object.
+
+    Object and schema management sit at the heart of SpacePlugin: it registers the canonical DXOS
+    schema types (Person, Task, Project, Event, …), provides the create-object dialog that all
+    other plugins populate with their own types, and exposes operations for adding, removing,
+    restoring, duplicating, and serialising objects. Import/export of space archives and schema
+    migrations are also handled here.
+
+    A full set of undo-aware operations (RemoveObjects/RestoreObjects, DeleteField/RestoreField)
+    integrates with the process manager so that destructive edits can be reversed in one step.
   `,
   icon: 'ph--planet--regular',
-};
+  tags: ['system'],
+});

package/src/operations/add-object.ts

@@ -0,0 +1,85 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { CollectionModel, getCollectionsPath, getObjectPath, getTypePath } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Collection, Database, Filter, Obj, Query, Scope, Type } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { ObservabilityOperation } from '@dxos/plugin-observability';
+import { 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 types = yield* Effect.promise(() =>
+        db.query(Query.select(Filter.type(Type.Type)).from(Scope.registry())).run(),
+      );
+      const [runtimeSchema] = types.filter((t) => !Type.isTypeKind(t) && Type.getTypename(t) === typename);
+      const echoViewPath =
+        runtimeSchema !== undefined
+          ? ViewAnnotation.get(Type.getSchema(runtimeSchema)).pipe(Option.getOrElse(() => []))
+          : [];
+      const view = echoViewPath.length > 0 ? yield* ViewAnnotation.tryLoadAtPath(object, echoViewPath) : 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.getURI(object),
+        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 === Type.getTypename(Collection.Collection)) {
+    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 { Operation } from '@dxos/compute';
+import { Database, Relation } from '@dxos/echo';
+
+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-type.ts

@@ -0,0 +1,51 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capability, Plugin } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Type } from '@dxos/echo';
+import { ObservabilityOperation } from '@dxos/plugin-observability';
+
+import { SpaceEvents, SpaceCapabilities } from '../types';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.AddType> = SpaceOperation.AddType.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const db = input.db;
+      const type = yield* Effect.promise(() => db.addType(input.type));
+      Type.update(type, (draft) => {
+        if (input.name) {
+          draft.name = input.name;
+        }
+        const meta = Type.getMeta(draft);
+        if (input.typename) {
+          meta.key = input.typename;
+        }
+        if (input.version) {
+          meta.version = input.version;
+        }
+      });
+
+      yield* Plugin.activate(SpaceEvents.TypeAdded);
+      const onTypeAdded = yield* Capability.getAll(SpaceCapabilities.OnTypeAdded);
+      yield* Effect.all(
+        onTypeAdded.map((callback) => callback({ db, type, show: input.show })),
+        { concurrency: 'unbounded' },
+      );
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'space.type.add',
+        properties: {
+          spaceId: db.spaceId,
+          objectId: type.id,
+          typename: Type.getTypename(type),
+        },
+      });
+
+      return { id: type.id, object: type };
+    }),
+  ),
+);
+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/compute';
+
+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,66 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capability, Plugin } from '@dxos/app-framework';
+import { RootCollectionAnnotation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Annotation, Collection, Obj, Ref } from '@dxos/echo';
+import { MigrationVersionAnnotation, Migrations } from '@dxos/migrations';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { ObservabilityOperation } from '@dxos/plugin-observability';
+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.update(space.properties, (properties) => {
+        Annotation.set(properties, RootCollectionAnnotation, Ref.make(collection));
+        if (Migrations.targetVersion) {
+          Annotation.set(properties, MigrationVersionAnnotation, 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;