@dxos/plugin-space 0.8.4-main.422d1c7879 → 0.8.4-main.4f23b4e393

package/src/capabilities/app-graph-builder/extensions/types.ts

@@ -8,25 +8,25 @@ import * as Match from 'effect/Match';
 import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 
-import { Capability } from '@dxos/app-framework';
-import { AppCapabilities, AppNode, LayoutOperation, Segments } from '@dxos/app-toolkit';
+import { Capability, type CapabilityManager } from '@dxos/app-framework';
+import { AppNode, AppNodeMatcher, LayoutOperation, Segments } from '@dxos/app-toolkit';
 import { type Space, SpaceState, isSpace } from '@dxos/client/echo';
-import { Collection, Filter, Obj, Query, Type } from '@dxos/echo';
+import { Operation } from '@dxos/compute';
+import { Annotation, Collection, Filter, Obj, Query, Type } from '@dxos/echo';
 import { AtomObj, AtomQuery } from '@dxos/echo-atom';
 import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
-import { Operation } from '@dxos/operation';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { CreateAtom, GraphBuilder, Node } from '@dxos/plugin-graph';
 import { ViewAnnotation } from '@dxos/schema';
 import { createFilename, isNonNullable } from '@dxos/util';
 
 import { meta } from '#meta';
 import { SpaceOperation } from '#operations';
+import { SpaceCapabilities } from '#types';
 
 import {
   ADD_VIEW_TO_SCHEMA_LABEL,
   BLOCK_REORDER_ABOVE,
-  type MetadataResolver,
   SNAPSHOT_BY_SCHEMA_LABEL,
   STATIC_SCHEMA_TYPE,
   TYPES_SECTION_TYPE,
@@ -35,7 +35,6 @@ import {
   createObjectNode,
   downloadBlob,
   getDynamicLabel,
-  whenSpace,
 } from './shared';
 
 //
@@ -46,14 +45,11 @@ import {
 export const createTypeExtensions = Effect.fnUntraced(function* () {
   const capabilities = yield* Capability.Service;
 
-  const resolve = (_get: any) => (typename: string) =>
-    capabilities.getAll(AppCapabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
-
   return yield* Effect.all([
     // Types section virtual node under each space.
     GraphBuilder.createExtension({
       id: 'types-section',
-      match: whenSpace,
+      match: AppNodeMatcher.whenSpace,
       connector: (space, get) => {
         const spaceState = get(CreateAtom.fromObservable(space.state));
         if (spaceState !== SpaceState.SPACE_READY) {
@@ -65,8 +61,9 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
             id: Segments.types,
             type: TYPES_SECTION_TYPE,
             label: ['types-section.label', { ns: meta.id }],
-            icon: 'ph--shapes--regular',
+            icon: 'ph--database--regular',
             space,
+            position: 'fallback',
             testId: 'spacePlugin.typesSection',
           }),
         ]);
@@ -92,9 +89,6 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
           if (SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false))) {
             return false;
           }
-          if (ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false))) {
-            return false;
-          }
           if (Type.getTypename(schema) === Collection.Collection.typename) {
             return false;
           }
@@ -109,12 +103,13 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
           }
           const typename = Type.getTypename(schema);
           const objects = get(AtomQuery.make(space.db, Filter.typename(typename)));
+          if (ViewAnnotation.has(schema)) {
+            return objects.some((obj) => !viewIndex.isView(obj));
+          }
           return objects.length > 0 || viewIndex.typenamesWithViews.has(typename);
         });
 
-        return Effect.succeed(
-          visibleSchemas.map((schema) => createSchemaNode({ schema, space, resolve: resolve(get), get })),
-        );
+        return Effect.succeed(visibleSchemas.map((schema) => createSchemaNode({ schema, space, get })));
       },
     }),
 
@@ -162,7 +157,6 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
             createObjectNode({
               db: space.db,
               object,
-              resolve: resolve(get),
               droppable: false,
             }),
           )
@@ -182,7 +176,14 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
         return Option.some({ space: node.data.space as Space, typename: node.data.typename as string });
       },
       connector: ({ space, typename }, get) => {
-        const objects = get(AtomQuery.make(space.db, Filter.typename(typename)));
+        const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
+        const schemas = client
+          ? get(AtomQuery.fromQuery(client.graph.schemaRegistry.query({ location: ['runtime'] })))
+          : [];
+        const viewIndex = buildViewIndex(get, space, schemas);
+        const objects = get(AtomQuery.make(space.db, Filter.typename(typename))).filter(
+          (object: Obj.Unknown) => !viewIndex.isView(object),
+        );
 
         return Effect.succeed(
           objects
@@ -191,7 +192,6 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
               return createObjectNode({
                 db: space.db,
                 object,
-                resolve: resolve(get),
                 droppable: false,
               });
             })
@@ -228,7 +228,7 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
             schema: schema as Type.AnyObj,
             space,
             deletable,
-            resolve: resolve(get),
+            capabilities,
           }),
         );
       },
@@ -254,16 +254,16 @@ const uniqueSchemasByTypename = <TSchema extends Type.AnyEntity>(schemas: TSchem
 const createSchemaNode = ({
   schema,
   space,
-  resolve,
   get,
 }: {
   schema: Type.AnyEntity;
   space: Space;
-  resolve: MetadataResolver;
   get: Atom.Context;
 }): Node.NodeArg<Type.AnyEntity> => {
   const typename = Type.getTypename(schema);
-  const metadata = resolve(typename);
+  const iconAnnotation = !Type.isMutable(schema)
+    ? Option.getOrUndefined(Annotation.IconAnnotation.get(schema))
+    : undefined;
   const { label, nodeId } = Match.value(schema).pipe(
     Match.when(Type.isMutable, (mutableSchema) => {
       const persistentSchema = mutableSchema.persistentSchema;
@@ -274,12 +274,12 @@ const createSchemaNode = ({
       };
     }),
     Match.orElse(() => ({
-      label: getDynamicLabel('typename.label', typename, { count: 2, default: typename }),
+      label: getDynamicLabel('typename.label', typename, { count: 2, defaultValue: typename }),
       nodeId: typename,
     })),
   );
-  const icon = Type.isMutable(schema) ? 'ph--cube--regular' : (metadata.icon ?? 'ph--placeholder--regular');
-  const iconHue = Type.isMutable(schema) ? 'neutral' : metadata.iconHue;
+  const icon = Type.isMutable(schema) ? 'ph--cube--regular' : (iconAnnotation?.icon ?? 'ph--placeholder--regular');
+  const iconHue = Type.isMutable(schema) ? 'neutral' : iconAnnotation?.hue;
   return Node.make({
     id: nodeId,
     type: STATIC_SCHEMA_TYPE,
@@ -304,17 +304,19 @@ const createSchemaActions = ({
   schema,
   space,
   deletable,
-  resolve,
+  capabilities,
 }: {
   schema: Type.AnyObj;
   space: Space;
   deletable: boolean;
-  resolve: MetadataResolver;
+  capabilities: CapabilityManager.CapabilityManager;
 }) => {
   const typename = Type.getTypename(schema);
-  const metadata = resolve(typename);
-  const createObjectFn = metadata.createObject;
-  const inputSchema = metadata.inputSchema;
+  const createEntry = capabilities
+    .getAll(SpaceCapabilities.CreateObjectEntry)
+    .find((entry: SpaceCapabilities.CreateObjectEntry) => entry.id === typename);
+  const createObjectFn = createEntry?.createObject;
+  const inputSchema = createEntry?.inputSchema;
 
   const actions: Node.NodeArg<Node.ActionData<Operation.Service>>[] = [
     ...(createObjectFn
@@ -328,11 +330,9 @@ const createSchemaActions = ({
                   typename,
                 });
               } else {
-                const result = yield* createObjectFn({}, { db: space.db, target: space.db }) as Effect.Effect<
-                  { subject: readonly string[] },
-                  Error,
-                  never
-                >;
+                const result = yield* createObjectFn({}, { db: space.db, target: space.db }).pipe(
+                  Effect.provideService(Capability.Service, capabilities),
+                );
                 if (result.subject.length > 0) {
                   yield* Operation.invoke(LayoutOperation.Open, {
                     subject: [...result.subject],
@@ -375,7 +375,7 @@ const createSchemaActions = ({
             })
           : Effect.fail(new Error('Cannot rename immutable schema')),
       properties: {
-        label: getDynamicLabel('rename object label', Type.getTypename(Type.PersistentType)),
+        label: getDynamicLabel('rename-object.label', Type.getTypename(Type.PersistentType)),
         icon: 'ph--pencil-simple-line--regular',
         disabled: !Type.isMutable(schema),
         disposition: 'list-item',

package/src/capabilities/app-graph-serializer.ts

@@ -7,14 +7,13 @@ import * as Effect from 'effect/Effect';
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
 import { isSpace } from '@dxos/client/echo';
-import { Obj } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
+import { Collection, Obj } from '@dxos/echo';
 
 import { meta } from '#meta';
 import { SpaceOperation } from '#operations';
+import { translations } from '#translations';
 import { SPACE_TYPE } from '#types';
 
-import { translations } from '../translations';
 import { SPACES } from '../util';
 
 const COLLECTION_TYPE = Collection.Collection.typename;

package/src/capabilities/create-object.ts

@@ -0,0 +1,107 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Collection, Type } from '@dxos/echo';
+import { createDefaultSchema } from '@dxos/schema';
+import { Organization, Person, Project, Task } from '@dxos/types';
+
+import { SpaceOperation } from '#operations';
+import { SpaceCapabilities } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return [
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Collection.Collection.typename,
+        inputSchema: Schema.Struct({ name: Schema.optional(Schema.String) }),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Collection.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: false,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Type.PersistentType),
+        inputSchema: SpaceOperation.StoredSchemaForm,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const result = yield* Operation.invoke(SpaceOperation.AddSchema, {
+              db: options.db,
+              name: props.name,
+              schema: createDefaultSchema(),
+            });
+            return {
+              id: result.id,
+              subject: [],
+              object: result.object,
+            };
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Organization.Organization.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Organization.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Person.Person.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Person.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Project.Project.typename,
+        inputSchema: Project.Project,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Project.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Task.Task.typename,
+        inputSchema: Task.Task,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Task.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+    ];
+  }),
+);

package/src/capabilities/identity-created.ts

@@ -6,10 +6,9 @@ import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
 import { PERSONAL_SPACE_TAG } from '@dxos/app-toolkit';
-import { Obj, Ref } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
+import { Collection, Obj, Ref } from '@dxos/echo';
 import { Migrations } from '@dxos/migrations';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { MembershipPolicy } from '@dxos/protocols/proto/dxos/halo/credentials';
 
@@ -24,7 +23,7 @@ export default Capability.makeModule(
 
     // Create root collection structure.
     yield* Effect.tryPromise(() => personalSpace.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
-    Obj.change(personalSpace.properties, (properties) => {
+    Obj.update(personalSpace.properties, (properties) => {
       properties[Collection.Collection.typename] = Ref.make(Collection.make());
       if (Migrations.versionProperty) {
         properties[Migrations.versionProperty] = Migrations.targetVersion;

package/src/capabilities/index.ts

@@ -3,11 +3,12 @@
 //
 
 import { Capability } from '@dxos/app-framework';
-import { OperationHandlerSet } from '@dxos/operation';
+import { OperationHandlerSet } from '@dxos/compute';
 
 export * from './app-graph-builder';
 
 export const AppGraphSerializer = Capability.lazy('AppGraphSerializer', () => import('./app-graph-serializer'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
 export const IdentityCreated = Capability.lazy('IdentityCreated', () => import('./identity-created'));
 export const Migrations = Capability.lazy('SpaceMigrations', () => import('./migrations'));
 export { NavigationHandler } from './navigation-handler';

package/src/capabilities/migrations.ts

@@ -6,45 +6,45 @@ import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
 import { LegacySpaceProperties, SpaceProperties } from '@dxos/client-protocol';
-import { defineObjectMigration } from '@dxos/client/echo';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { Migration } from '@dxos/echo';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { AccessToken, AnchoredTo, HasConnection, HasRelationship, HasSubject } from '@dxos/types';
 
 const identityTransform = async (from: any) => ({ ...from });
 const noopCallback = async () => {};
 
 const migrations = [
-  defineObjectMigration({
+  Migration.define({
     from: LegacySpaceProperties,
     to: SpaceProperties,
     transform: identityTransform,
     onMigration: noopCallback,
   }),
-  defineObjectMigration({
+  Migration.define({
     from: AccessToken.LegacyAccessToken,
     to: AccessToken.AccessToken,
     transform: identityTransform,
     onMigration: noopCallback,
   }),
-  defineObjectMigration({
+  Migration.define({
     from: AnchoredTo.LegacyAnchoredTo,
     to: AnchoredTo.AnchoredTo,
     transform: identityTransform,
     onMigration: noopCallback,
   }),
-  defineObjectMigration({
+  Migration.define({
     from: HasConnection.LegacyHasConnection,
     to: HasConnection.HasConnection,
     transform: identityTransform,
     onMigration: noopCallback,
   }),
-  defineObjectMigration({
+  Migration.define({
     from: HasRelationship.LegacyHasRelationship,
     to: HasRelationship.HasRelationship,
     transform: identityTransform,
     onMigration: noopCallback,
   }),
-  defineObjectMigration({
+  Migration.define({
     from: HasSubject.LegacyHasSubject,
     to: HasSubject.HasSubject,
     transform: identityTransform,

package/src/capabilities/navigation-handler/navigation-handler.ts

@@ -6,8 +6,8 @@ import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
 
 import { SpaceOperation } from '../../operations';
 

package/src/capabilities/navigation-resolver.ts

@@ -15,8 +15,8 @@ import {
 } from '@dxos/app-toolkit';
 import { Database, Entity, Key } from '@dxos/echo';
 import { DXN } from '@dxos/keys';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
-import { SETTINGS_ID, SETTINGS_KEY } from '@dxos/plugin-settings/types';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { SETTINGS_ID, SETTINGS_KEY } from '@dxos/plugin-settings';
 
 import { meta } from '#meta';
 

package/src/capabilities/node.ts

@@ -3,8 +3,9 @@
 //
 
 import { Capability } from '@dxos/app-framework';
-import { OperationHandlerSet } from '@dxos/operation';
+import { OperationHandlerSet } from '@dxos/compute';
 
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
 export const IdentityCreated = Capability.lazy('IdentityCreated', () => import('./identity-created'));
 export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
   'OperationHandler',

package/src/capabilities/operation-handler.ts

@@ -3,7 +3,7 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import type { OperationHandlerSet } from '@dxos/operation';
+import type { OperationHandlerSet } from '@dxos/compute';
 
 import { SpaceOperationHandlerSet } from '#operations';