@dxos/plugin-space 0.8.4-main.3f58842 → 0.8.4-main.548089c

package/src/capabilities/capabilities.ts

@@ -2,28 +2,34 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
+import type * as Schema from 'effect/Schema';
 
-import { type AnyIntentChain, defineCapability, type Label } from '@dxos/app-framework';
+import { type AnyIntentChain, type Label, defineCapability } from '@dxos/app-framework';
 import { type Space } from '@dxos/react-client/echo';
-import { type DataType } from '@dxos/schema';
-import { type Position, type DeepReadonly } from '@dxos/util';
+import { type Collection } from '@dxos/schema';
+import { type DeepReadonly, type Position } from '@dxos/util';
 
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { type ObjectForm, type PluginState } from '../types';
 
 export namespace SpaceCapabilities {
-  export const State = defineCapability<DeepReadonly<PluginState>>(`${SPACE_PLUGIN}/capability/state`);
-  export const MutableState = defineCapability<PluginState>(`${SPACE_PLUGIN}/capability/state`);
+  export const State = defineCapability<DeepReadonly<PluginState>>(`${meta.id}/capability/state`);
+  export const MutableState = defineCapability<PluginState>(`${meta.id}/capability/state`);
 
   export type SettingsSection = { id: string; label: Label; position?: Position };
-  export const SettingsSection = defineCapability<SettingsSection>(`${SPACE_PLUGIN}/capability/settings-section`);
+  export const SettingsSection = defineCapability<SettingsSection>(`${meta.id}/capability/settings-section`);
 
-  export type OnSpaceCreated = (params: { space: Space; rootCollection: DataType.Collection }) => AnyIntentChain;
-  export const OnSpaceCreated = defineCapability<OnSpaceCreated>(`${SPACE_PLUGIN}/capability/on-space-created`);
+  export type onCreateSpace = (params: { space: Space; rootCollection: Collection.Collection }) => AnyIntentChain;
+  export const onCreateSpace = defineCapability<onCreateSpace>(`${meta.id}/capability/on-space-created`);
 
-  export type OnSchemaAdded = (params: { space: Space; schema: Schema.Schema.AnyNoContext }) => AnyIntentChain;
-  export const OnSchemaAdded = defineCapability<OnSchemaAdded>(`${SPACE_PLUGIN}/capability/on-schema-added`);
+  export type OnSchemaAdded = (params: {
+    space: Space;
+    schema: Schema.Schema.AnyNoContext;
+    // TODO(wittjosiah): This is leaky.
+    show?: boolean;
+  }) => AnyIntentChain;
+  export const OnSchemaAdded = defineCapability<OnSchemaAdded>(`${meta.id}/capability/on-schema-added`);
 
-  export const ObjectForm = defineCapability<ObjectForm<any>>(`${SPACE_PLUGIN}/capability/object-form`);
+  // TODO(burdon): Should this be view? Forms are UI concepts? (associated with a View/schema).
+  export const ObjectForm = defineCapability<ObjectForm<any>>(`${meta.id}/capability/object-form`);
 }

package/src/capabilities/identity-created.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { contributes, type PluginContext, Capabilities } from '@dxos/app-framework';
+import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
 import { Obj, Ref } from '@dxos/echo';
 import { Migrations } from '@dxos/migrations';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { DataType } from '@dxos/schema';
+import { Collection } from '@dxos/schema';
 
 export default async (context: PluginContext) => {
   const client = context.getCapability(ClientCapabilities.Client);
@@ -16,7 +16,7 @@ export default async (context: PluginContext) => {
   await defaultSpace.waitUntilReady();
 
   // Create root collection structure.
-  defaultSpace.properties[DataType.Collection.typename] = Ref.make(Obj.make(DataType.Collection, { objects: [] }));
+  defaultSpace.properties[Collection.Collection.typename] = Ref.make(Obj.make(Collection.Collection, { objects: [] }));
   if (Migrations.versionProperty) {
     defaultSpace.properties[Migrations.versionProperty] = Migrations.targetVersion;
   }

package/src/capabilities/index.ts

@@ -11,7 +11,6 @@ export const IntentResolver = lazy(() => import('./intent-resolver'));
 export const ReactRoot = lazy(() => import('./react-root'));
 export const ReactSurface = lazy(() => import('./react-surface'));
 export const SchemaDefs = lazy(() => import('./schema-defs'));
-export const SchemaTools = lazy(() => import('./schema-tools'));
 export const SpaceSettings = lazy(() => import('./settings'));
 export const SpaceState = lazy(() => import('./state'));
 export const SpacesReady = lazy(() => import('./spaces-ready'));

package/src/capabilities/intent-resolver.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
 import {
   Capabilities,
@@ -12,31 +12,35 @@ import {
   createIntent,
   createResolver,
 } from '@dxos/app-framework';
-import { Obj, Ref, Relation, Type } from '@dxos/echo';
+import { Filter, Obj, Query, Ref, Relation, Type } from '@dxos/echo';
+import { DatabaseService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { Migrations } from '@dxos/migrations';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
-import { isSpace, getSpace, SpaceState, fullyQualifiedId } from '@dxos/react-client/echo';
+import { SpaceState, getSpace, isSpace } from '@dxos/react-client/echo';
 import { Invitation, InvitationEncoder } from '@dxos/react-client/invitations';
 import { ATTENDABLE_PATH_SEPARATOR } from '@dxos/react-ui-attention';
-import { DataType, ProjectionModel } from '@dxos/schema';
+import { iconValues } from '@dxos/react-ui-pickers';
+import { hues } from '@dxos/react-ui-theme';
+import { Collection, ProjectionModel, StoredSchema, getTypenameFromQuery } from '@dxos/schema';
 
-import { SpaceCapabilities } from './capabilities';
 import {
   CREATE_OBJECT_DIALOG,
   CREATE_SPACE_DIALOG,
-  JOIN_DIALOG,
-  POPOVER_RENAME_OBJECT,
-  POPOVER_RENAME_SPACE,
   type CreateObjectDialogProps,
+  JOIN_DIALOG,
   type JoinDialogProps,
+  OBJECT_RENAME_POPOVER,
+  SPACE_RENAME_POPOVER,
 } from '../components';
 import { SpaceEvents } from '../events';
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { CollectionAction, SpaceAction } from '../types';
-import { cloneObject, COMPOSER_SPACE_LOCK, getNestedObjects } from '../util';
+import { COMPOSER_SPACE_LOCK, cloneObject, getNestedObjects } from '../util';
+
+import { SpaceCapabilities } from './capabilities';
 
 // TODO(wittjosiah): Remove.
 const SPACE_MAX_OBJECTS = 500;
@@ -68,8 +72,10 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
     }),
     createResolver({
       intent: SpaceAction.Create,
-      resolve: async ({ name, hue, icon, edgeReplication }) => {
+      resolve: async ({ name, hue: hue_, icon: icon_, edgeReplication }) => {
         const client = context.getCapability(ClientCapabilities.Client);
+        const hue = hue_ ?? hues[Math.floor(Math.random() * hues.length)];
+        const icon = icon_ ?? iconValues[Math.floor(Math.random() * iconValues.length)];
         const space = await client.spaces.create({ name, hue, icon });
         if (edgeReplication) {
           await space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED);
@@ -77,8 +83,8 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         await space.waitUntilReady();
 
         // Create root collection.
-        const collection = Obj.make(DataType.Collection, { objects: [] });
-        space.properties[DataType.Collection.typename] = Ref.make(collection);
+        const collection = Obj.make(Collection.Collection, { objects: [] });
+        space.properties[Collection.Collection.typename] = Ref.make(collection);
 
         // Set current migration version.
         if (Migrations.versionProperty) {
@@ -86,16 +92,20 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         }
 
         // Create records smart collection.
-        const records = Obj.make(DataType.QueryCollection, {
-          query: { typename: DataType.StoredSchema.typename },
-        });
-        collection.objects.push(Ref.make(records));
+        collection.objects.push(
+          Ref.make(
+            Obj.make(Collection.QueryCollection, {
+              // NOTE: This is specifically Filter.typename due to current limitations in query collection parsing.
+              query: Query.select(Filter.typename(StoredSchema.typename)).ast,
+            }),
+          ),
+        );
 
         // Allow other plugins to add default content.
         await context.activatePromise(SpaceEvents.SpaceCreated);
-        const onSpaceCreatedCallbacks = context.getCapabilities(SpaceCapabilities.OnSpaceCreated);
-        const spaceCreatedIntents = onSpaceCreatedCallbacks.map((onSpaceCreated) =>
-          onSpaceCreated({ space, rootCollection: collection }),
+        const onCreateSpaceCallbacks = context.getCapabilities(SpaceCapabilities.onCreateSpace);
+        const spaceCreatedIntents = onCreateSpaceCallbacks.map((onCreateSpace) =>
+          onCreateSpace({ space, rootCollection: collection }),
         );
 
         return {
@@ -253,7 +263,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           intents: [
             createIntent(LayoutAction.UpdatePopover, {
               part: 'popover',
-              subject: POPOVER_RENAME_SPACE,
+              subject: SPACE_RENAME_POPOVER,
               options: {
                 anchorId: `dxos.org/ui/${caller}/${space.id}`,
                 props: space,
@@ -322,7 +332,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
     }),
     createResolver({
       intent: SpaceAction.UseStaticSchema,
-      resolve: async ({ space, typename }) => {
+      resolve: async ({ space, typename, show }) => {
         const client = context.getCapability(ClientCapabilities.Client);
         const schema = client.graph.schemaRegistry.schemas.find((schema) => Type.getTypename(schema) === typename);
         invariant(schema, `Schema not found: ${typename}`);
@@ -337,7 +347,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
 
         await context.activatePromise(SpaceEvents.SchemaAdded);
         const onSchemaAdded = context.getCapabilities(SpaceCapabilities.OnSchemaAdded);
-        const schemaAddedIntents = onSchemaAdded.map((onSchemaAdded) => onSchemaAdded({ space, schema }));
+        const schemaAddedIntents = onSchemaAdded.map((onSchemaAdded) => onSchemaAdded({ space, schema, show }));
 
         return {
           data: {},
@@ -360,15 +370,21 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
     }),
     createResolver({
       intent: SpaceAction.AddSchema,
-      resolve: async ({ space, name, schema: schemaInput }) => {
+      resolve: async ({ space, name, typename, version, schema: schemaInput, show }) => {
         const [schema] = await space.db.schemaRegistry.register([schemaInput]);
         if (name) {
           schema.storedSchema.name = name;
         }
+        if (typename) {
+          schema.storedSchema.typename = typename;
+        }
+        if (version) {
+          schema.storedSchema.version = version;
+        }
 
         await context.activatePromise(SpaceEvents.SchemaAdded);
         const onSchemaAdded = context.getCapabilities(SpaceCapabilities.OnSchemaAdded);
-        const schemaAddedIntents = onSchemaAdded.map((onSchemaAdded) => onSchemaAdded({ space, schema }));
+        const schemaAddedIntents = onSchemaAdded.map((onSchemaAdded) => onSchemaAdded({ space, schema, show }));
 
         return {
           data: {
@@ -399,15 +415,16 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
       resolve: async ({ view, fieldId, deletionData }, undo) => {
         const space = getSpace(view);
         invariant(space);
-        invariant(view.query.typename);
-        const schema = await space.db.schemaRegistry.query({ typename: view.query.typename }).firstOrUndefined();
+        const typename = getTypenameFromQuery(view.query.ast);
+        invariant(typename);
+        const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();
         invariant(schema);
         const projection = new ProjectionModel(schema.jsonSchema, view.projection);
         if (!undo) {
           const { deleted, index } = projection.deleteFieldProjection(fieldId);
           return {
             undoable: {
-              message: ['field deleted label', { ns: SPACE_PLUGIN }],
+              message: ['field deleted label', { ns: meta.id }],
               data: { deletionData: { ...deleted, index } },
             },
           };
@@ -419,7 +436,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
     }),
     createResolver({
       intent: SpaceAction.OpenCreateObject,
-      resolve: ({ target, typename, navigable = true, onCreateObject }) => {
+      resolve: ({ target, views, typename, initialFormValues, navigable = true, onCreateObject }) => {
         const state = context.getCapability(SpaceCapabilities.State);
 
         return {
@@ -431,12 +448,14 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
                 blockAlign: 'start',
                 props: {
                   target,
+                  views,
                   typename,
+                  initialFormValues,
                   onCreateObject,
                   shouldNavigate: navigable
                     ? (object: Obj.Any) => {
-                        const isCollection = Obj.instanceOf(DataType.Collection, object);
-                        const isQueryCollection = Obj.instanceOf(DataType.QueryCollection, object);
+                        const isCollection = Obj.instanceOf(Collection.Collection, object);
+                        const isQueryCollection = Obj.instanceOf(Collection.QueryCollection, object);
                         return (!isCollection && !isQueryCollection) || state.navigableCollections;
                       }
                     : () => false,
@@ -460,13 +479,13 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
               createIntent(LayoutAction.AddToast, {
                 part: 'toast',
                 subject: {
-                  id: `${SPACE_PLUGIN}/space-limit`,
-                  title: ['space limit label', { ns: SPACE_PLUGIN }],
-                  description: ['space limit description', { ns: SPACE_PLUGIN }],
+                  id: `${meta.id}/space-limit`,
+                  title: ['space limit label', { ns: meta.id }],
+                  description: ['space limit description', { ns: meta.id }],
                   duration: 5_000,
                   icon: 'ph--warning--regular',
-                  actionLabel: ['remove deleted objects label', { ns: SPACE_PLUGIN }],
-                  actionAlt: ['remove deleted objects alt', { ns: SPACE_PLUGIN }],
+                  actionLabel: ['remove deleted objects label', { ns: meta.id }],
+                  actionAlt: ['remove deleted objects alt', { ns: meta.id }],
                   closeLabel: ['close label', { ns: 'os' }],
                   onAction: () => space.db.coreDatabase.unlinkDeletedObjects(),
                 },
@@ -485,25 +504,18 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           };
         }
 
-        if (Obj.instanceOf(DataType.Collection, target)) {
-          target.objects.push(Ref.make(object));
-        } else if (isSpace(target) && hidden) {
-          space.db.add(object);
-        } else if (isSpace(target)) {
-          const collection = space.properties[DataType.Collection.typename]?.target;
-          if (Obj.instanceOf(DataType.Collection, collection)) {
-            collection.objects.push(Ref.make(object));
-          } else {
-            // TODO(wittjosiah): Can't add non-echo objects by including in a collection because of types.
-            const collection = Obj.make(DataType.Collection, { objects: [Ref.make(object)] });
-            space.properties[DataType.Collection.typename] = Ref.make(collection);
-          }
-        }
+        await Effect.gen(function* () {
+          yield* Collection.add({
+            object,
+            target: isSpace(target) ? undefined : target,
+            hidden,
+          });
+        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.runPromise);
 
         return {
           data: {
-            id: fullyQualifiedId(object),
-            subject: [fullyQualifiedId(object)],
+            id: Obj.getDXN(object).toString(),
+            subject: [Obj.getDXN(object).toString()],
             object,
           },
           intents: [
@@ -552,26 +564,26 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         const openObjectIds = new Set<string>(layout.active);
 
         if (!undo) {
-          const parentCollection: DataType.Collection =
-            target ?? space.properties[DataType.Collection.typename]?.target;
+          const parentCollection: Collection.Collection =
+            target ?? space.properties[Collection.Collection.typename]?.target;
           const nestedObjectsList = await Promise.all(objects.map((obj) => getNestedObjects(obj, resolve)));
 
           const deletionData = {
             objects,
             parentCollection,
             indices: objects.map((obj) =>
-              Obj.instanceOf(DataType.Collection, parentCollection)
+              Obj.instanceOf(Collection.Collection, parentCollection)
                 ? parentCollection.objects.findIndex((object) => object.target === obj)
                 : -1,
             ),
             nestedObjectsList,
             wasActive: objects
               .flatMap((obj, i) => [obj, ...nestedObjectsList[i]])
-              .map((obj) => fullyQualifiedId(obj))
+              .map((obj) => Obj.getDXN(obj).toString())
               .filter((id) => openObjectIds.has(id)),
           } satisfies SpaceAction.DeletionData;
 
-          if (Obj.instanceOf(DataType.Collection, deletionData.parentCollection)) {
+          if (Obj.instanceOf(Collection.Collection, deletionData.parentCollection)) {
             [...deletionData.indices]
               .sort((a, b) => b - a)
               .forEach((index: number) => {
@@ -586,7 +598,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           });
           objects.forEach((obj) => space.db.remove(obj));
 
-          const undoMessageKey = objects.some((obj) => Obj.instanceOf(DataType.Collection, obj))
+          const undoMessageKey = objects.some((obj) => Obj.instanceOf(Collection.Collection, obj))
             ? 'collection deleted label'
             : objects.length > 1
               ? 'objects deleted label'
@@ -595,7 +607,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           return {
             undoable: {
               // TODO(ZaymonFC): Pluralize if more than one object.
-              message: [undoMessageKey, { ns: SPACE_PLUGIN }],
+              message: [undoMessageKey, { ns: meta.id }],
               data: { deletionData },
             },
             intents:
@@ -613,7 +625,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           if (
             deletionData?.objects?.length &&
             deletionData.objects.every(Obj.isObject) &&
-            Obj.instanceOf(DataType.Collection, deletionData.parentCollection)
+            Obj.instanceOf(Collection.Collection, deletionData.parentCollection)
           ) {
             // Restore the object to the space.
             const restoredObjects = deletionData.objects.map((obj: Type.Expando) => space.db.add(obj));
@@ -650,9 +662,9 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         intents: [
           createIntent(LayoutAction.UpdatePopover, {
             part: 'popover',
-            subject: POPOVER_RENAME_OBJECT,
+            subject: OBJECT_RENAME_POPOVER,
             options: {
-              anchorId: `dxos.org/ui/${caller}/${fullyQualifiedId(object)}`,
+              anchorId: `dxos.org/ui/${caller}/${Obj.getDXN(object).toString()}`,
               props: object,
             },
           }),
@@ -681,13 +693,18 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
     createResolver({
       intent: CollectionAction.Create,
       resolve: async ({ name }) => ({
-        data: { object: Obj.make(DataType.Collection, { name, objects: [] }) },
+        data: { object: Obj.make(Collection.Collection, { name, objects: [] }) },
       }),
     }),
     createResolver({
       intent: CollectionAction.CreateQueryCollection,
       resolve: async ({ name, typename }) => ({
-        data: { object: Obj.make(DataType.QueryCollection, { name, query: { typename } }) },
+        data: {
+          object: Obj.make(Collection.QueryCollection, {
+            name,
+            query: Query.select(Filter.typename(typename)).ast,
+          }),
+        },
       }),
     }),
   ]);

package/src/capabilities/react-root.tsx

@@ -4,15 +4,17 @@
 
 import React from 'react';
 
-import { Capabilities, contributes, useCapability } from '@dxos/app-framework';
+import { Capabilities, contributes } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/react';
 
-import { SpaceCapabilities } from './capabilities';
 import { AwaitingObject } from '../components';
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
+
+import { SpaceCapabilities } from './capabilities';
 
 export default () =>
   contributes(Capabilities.ReactRoot, {
-    id: SPACE_PLUGIN,
+    id: meta.id,
     root: () => {
       const state = useCapability(SpaceCapabilities.State);
       return state.awaiting ? <AwaitingObject id={state.awaiting} /> : null;