@dxos/plugin-space 0.8.4-main.72ec0f3 → 0.8.4-main.7ace549

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

@@ -9,13 +9,13 @@ import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 
 import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { type QueryResult, type Space, SpaceState, getSpace, isSpace } from '@dxos/client/echo';
-import { DXN, Filter, Obj, Query, Type } from '@dxos/echo';
+import { type Space, SpaceState, getSpace, isSpace } from '@dxos/client/echo';
+import { DXN, type Database, type Entity, Filter, Obj, Type } from '@dxos/echo';
 import { log } from '@dxos/log';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { ATTENDABLE_PATH_SEPARATOR, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
 import { ROOT_ID, atomFromObservable, atomFromSignal, createExtension } from '@dxos/plugin-graph';
-import { Collection, StoredSchema, View, getTypenameFromQuery } from '@dxos/schema';
+import { Collection, View, ViewAnnotation, getTypenameFromQuery } from '@dxos/schema';
 import { isNonNullable } from '@dxos/util';
 
 import { getActiveSpace } from '../hooks';
@@ -168,14 +168,14 @@ export default (context: PluginContext) => {
             Option.getOrElse(() => []),
           ),
         ),
-      // resolver: ({ id }) => (id === SPACES ? spacesNode : undefined),
     }),
 
     // Create space nodes.
     createExtension({
       id: SPACES,
       connector: (node) => {
-        let query: QueryResult<Type.Expando> | undefined;
+        // TODO(wittjosiah): Find a simpler way to define this type.
+        let query: Database.QueryResult<Schema.Schema.Type<typeof Type.Expando>> | undefined;
         return Atom.make((get) =>
           Function.pipe(
             get(node),
@@ -235,46 +235,6 @@ export default (context: PluginContext) => {
           ),
         );
       },
-      // resolver: ({ id }) => {
-      //   if (id.length !== SPACE_ID_LENGTH) {
-      //     return;
-      //   }
-
-      //   const client = context.requestCapability(ClientCapabilities.Client);
-      //   const spaces = toSignal(
-      //     (onChange) => client.spaces.subscribe(() => onChange()).unsubscribe,
-      //     () => client.spaces.get(),
-      //   );
-
-      //   const isReady = toSignal(
-      //     (onChange) => client.spaces.isReady.subscribe(() => onChange()).unsubscribe,
-      //     () => client.spaces.isReady.get(),
-      //   );
-
-      //   if (!spaces || !isReady) {
-      //     return;
-      //   }
-
-      //   const space = spaces.find((space) => space.id === id);
-      //   if (!space) {
-      //     return;
-      //   }
-
-      //   if (space.state.get() === SpaceState.SPACE_INACTIVE) {
-      //     return false;
-      //   } else if (space.state.get() !== SpaceState.SPACE_READY) {
-      //     return undefined;
-      //   } else {
-      //     const state = context.requestCapability(SpaceCapabilities.State);
-      //     return constructSpaceNode({
-      //       space,
-      //       navigable: state.navigableCollections,
-      //       personal: space === client.spaces.default,
-      //       namesCache: state.spaceNames,
-      //       resolve,
-      //     });
-      //   }
-      // },
     }),
 
     // Create space actions.
@@ -359,7 +319,7 @@ export default (context: PluginContext) => {
         ),
     }),
 
-    // Create nodes for objects in a collection or by its fully qualified id.
+    // Create nodes for objects in a collection or by its DXN.
     createExtension({
       id: `${meta.id}/objects`,
       connector: (node) =>
@@ -397,95 +357,68 @@ export default (context: PluginContext) => {
             Option.getOrElse(() => []),
           ),
         ),
-      // resolver: ({ id }) => {
-      //   if (id.length !== FQ_ID_LENGTH) {
-      //     return;
-      //   }
-
-      //   const [spaceId, objectId] = id.split(':');
-      //   if (spaceId.length !== SPACE_ID_LENGTH && objectId.length !== OBJECT_ID_LENGTH) {
-      //     return;
-      //   }
-
-      //   const client = context.requestCapability(ClientCapabilities.Client);
-      //   const space = client.spaces.get().find((space) => space.id === spaceId);
-      //   if (!space) {
-      //     return;
-      //   }
-
-      //   const spaceState = toSignal(
-      //     (onChange) => space.state.subscribe(() => onChange()).unsubscribe,
-      //     () => space.state.get(),
-      //     space.id,
-      //   );
-      //   if (spaceState !== SpaceState.SPACE_READY) {
-      //     return;
-      //   }
-
-      //   const [object] = memoizeQuery(space, Query.select(Filter.ids(objectId)));
-      //   if (!object) {
-      //     return;
-      //   }
-
-      //   if (isDeleted(object)) {
-      //     return false;
-      //   } else {
-      //     const state = context.requestCapability(SpaceCapabilities.State);
-      //     return createObjectNode({ object, space, resolve, navigable: state.navigableCollections });
-      //   }
-      // },
+      resolver: (id) => {
+        let query: Database.QueryResult<Entity.Unknown> | undefined;
+        return Atom.make((get) => {
+          const client = context.getCapability(ClientCapabilities.Client);
+          const dxn = DXN.tryParse(id)?.asEchoDXN();
+          if (!dxn || !dxn.spaceId) {
+            return null;
+          }
+
+          const space = client.spaces.get(dxn.spaceId);
+          if (!space) {
+            return null;
+          }
+
+          if (!query) {
+            query = space.db.query(Filter.ids(dxn.echoId));
+          }
+
+          const object = get(atomFromQuery(query)).at(0);
+          if (!Obj.isObject(object)) {
+            return null;
+          }
+
+          return createObjectNode({ object, space, resolve: resolve(get), disposition: 'hidden' });
+        });
+      },
     }),
 
-    // Create nodes for objects in a query collection.
+    // Create object nodes for schema-based system collections.
     createExtension({
-      id: `${meta.id}/query-collection-objects`,
+      id: `${meta.id}/system-collections`,
       connector: (node) => {
-        let query: QueryResult<Type.Expando> | undefined;
+        const client = context.getCapability(ClientCapabilities.Client);
+        // TODO(wittjosiah): Find a simpler way to define this type.
+        let query: Database.QueryResult<Schema.Schema.Type<typeof Type.Expando>> | undefined;
         return Atom.make((get) =>
           Function.pipe(
             get(node),
             Option.flatMap((node) =>
-              Obj.instanceOf(Collection.QueryCollection, node.data) ? Option.some(node.data) : Option.none(),
+              Obj.instanceOf(Collection.Managed, node.data) ? Option.some(node.data) : Option.none(),
             ),
             Option.flatMap((collection) => {
               const space = getSpace(collection);
-              const typename = getTypenameFromQuery(collection.query);
-              return typename && space ? Option.some({ typename, space }) : Option.none();
+              const schema = client.graph.schemaRegistry.schemas.find(
+                (schema) => Type.getTypename(schema) === collection.key,
+              );
+              return space && schema ? Option.some({ space, schema }) : Option.none();
             }),
-            Option.map(({ typename, space }) => {
-              const state = context.getCapability(SpaceCapabilities.State);
+            Option.map(({ space, schema }) => {
               if (!query) {
-                query = space.db.query(
-                  Query.without(
-                    Query.select(Filter.typename(typename)),
-                    // TODO(wittjosiah): This query is broader than it should be.
-                    //   It will return all objects in the collection, not just the ones of the given type.
-                    //   However this works fine for now because this query is only used for exclusions.
-                    Query.select(Filter.typename(typename))
-                      .referencedBy(Collection.Collection, 'objects')
-                      .reference('objects'),
-                  ),
-                );
+                query = space.db.query(Filter.type(schema));
               }
-              return (
-                get(atomFromQuery(query))
-                  // TODO(wittjosiah): This should be the default sort order.
-                  .toSorted((a, b) => a.id.localeCompare(b.id))
-                  .map((object) =>
-                    get(
-                      atomFromSignal(() =>
-                        createObjectNode({
-                          object,
-                          space,
-                          resolve: resolve(get),
-                          droppable: false, // Cannot rearrange query collections.
-                          navigable: state.navigableCollections,
-                        }),
-                      ),
-                    ),
-                  )
-                  .filter(isNonNullable)
-              );
+              return get(atomFromQuery(query))
+                .map((object) =>
+                  createObjectNode({
+                    object,
+                    space,
+                    managedCollectionChild: true,
+                    resolve: resolve(get),
+                  }),
+                )
+                .filter(isNonNullable);
             }),
             Option.getOrElse(() => []),
           ),
@@ -493,7 +426,7 @@ export default (context: PluginContext) => {
       },
     }),
 
-    // Static schema records.
+    // Create branch nodes for static schema record types.
     createExtension({
       id: `${meta.id}/static-schemas`,
       connector: (node) => {
@@ -502,8 +435,7 @@ export default (context: PluginContext) => {
           Function.pipe(
             get(node),
             Option.flatMap((node) =>
-              Obj.instanceOf(Collection.QueryCollection, node.data) &&
-              getTypenameFromQuery(node.data.query) === StoredSchema.typename
+              Obj.instanceOf(Collection.Managed, node.data) && node.data.key === Type.getTypename(Type.PersistentType)
                 ? Option.some(node.data)
                 : Option.none(),
             ),
@@ -525,13 +457,19 @@ export default (context: PluginContext) => {
       },
     }),
 
-    // Create static schema actions.
+    // Create actions for static schema record types.
     createExtension({
       id: `${meta.id}/static-schema-actions`,
       actions: (node) => {
-        let query: QueryResult<View.View> | undefined;
-        return Atom.make((get) =>
-          Function.pipe(
+        let query: Database.QueryResult<Obj.Any> | undefined;
+        return Atom.make((get) => {
+          // TODO(wittjosiah): Use schemaRegistry query once it support atom reactivity.
+          const schemas = get(context.capabilities(ClientCapabilities.Schema))
+            .flat()
+            .filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)));
+          const filter = Filter.or(...schemas.map((schema) => Filter.type(schema)));
+
+          return Function.pipe(
             get(node),
             Option.flatMap((node) => {
               const space = isSpace(node.properties.space) ? node.properties.space : undefined;
@@ -539,16 +477,18 @@ export default (context: PluginContext) => {
             }),
             Option.map(({ space, schema }) => {
               if (!query) {
-                // TODO(wittjosiah): Support filtering by nested properties (e.g. `query.typename`).
-                query = space.db.query(Filter.type(View.View));
+                // TODO(wittjosiah): Ideally this query would traverse the view reference & filter by the query ast.
+                // TODO(wittjosiah): Remove cast.
+                query = space.db.query(filter) as unknown as Database.QueryResult<Obj.Any>;
               }
 
-              const views = get(atomFromQuery(query));
+              const objects = get(atomFromQuery(query));
               const filteredViews = get(
                 atomFromSignal(() =>
-                  // TODO(wittjosiah): Remove cast.
-                  views.filter(
-                    (view) => getTypenameFromQuery(view.query.ast) === Type.getTypename(schema as Type.Obj.Any),
+                  objects.filter(
+                    (viewObject) =>
+                      getTypenameFromQuery((viewObject as any).view.target?.query.ast) ===
+                      Type.getTypename(schema as Type.Obj.Any),
                   ),
                 ),
               );
@@ -568,103 +508,60 @@ export default (context: PluginContext) => {
               });
             }),
             Option.getOrElse(() => []),
-          ),
-        );
+          );
+        });
       },
     }),
 
-    // Create nodes for schema views.
+    // Create nodes for views of record types.
     createExtension({
       id: `${meta.id}/schema-views`,
       connector: (node) => {
-        let query: QueryResult<View.View> | undefined;
-        return Atom.make((get) =>
-          Function.pipe(
+        let query: Database.QueryResult<Obj.Any> | undefined;
+        return Atom.make((get) => {
+          // TODO(wittjosiah): Use schemaRegistry query once it support atom reactivity.
+          const schemas = get(context.capabilities(ClientCapabilities.Schema))
+            .flat()
+            .filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)));
+          const filter = Filter.or(...schemas.map((schema) => Filter.type(schema)));
+
+          return Function.pipe(
             get(node),
             Option.flatMap((node) => {
               const space = getSpace(node.data) ?? (isSpace(node.properties.space) ? node.properties.space : undefined);
-              return space && (Obj.instanceOf(StoredSchema, node.data) || Schema.isSchema(node.data))
+              return space && (Obj.instanceOf(Type.PersistentType, node.data) || Schema.isSchema(node.data))
                 ? Option.some({ space, schema: node.data })
                 : Option.none();
             }),
             Option.map(({ space, schema }) => {
               if (!query) {
-                // TODO(wittjosiah): Support filtering by nested properties (e.g. `query.typename`).
-                query = space.db.query(Filter.type(View.View));
+                // TODO(wittjosiah): Ideally this query would traverse the view reference & filter by the query ast.
+                // TODO(wittjosiah): Remove cast.
+                query = space.db.query(filter) as unknown as Database.QueryResult<Obj.Any>;
               }
 
-              // TODO(wittjosiah): Remove cast.
+              // TODO(wittjosiah): Remove casts.
               const typename = Schema.isSchema(schema) ? Type.getTypename(schema as Type.Obj.Any) : schema.typename;
-              return (
-                get(atomFromQuery(query))
-                  .filter((view) => getTypenameFromQuery(view.query.ast) === typename)
-                  // Filter out Collection views from Projects.
-                  .filter((view) =>
-                    get(
-                      atomFromSignal(() => {
-                        const presentation = view.presentation.target;
-                        if (presentation) {
-                          const typename = Obj.getTypename(presentation);
-                          return typename !== Collection.Collection.typename;
-                        } else {
-                          return false;
-                        }
+              return get(atomFromQuery(query))
+                .filter((object) =>
+                  get(atomFromSignal(() => getTypenameFromQuery((object as any).view.target?.query.ast) === typename)),
+                )
+                .map((object) =>
+                  get(
+                    atomFromSignal(() =>
+                      createObjectNode({
+                        object,
+                        space,
+                        resolve: resolve(get),
+                        droppable: false,
                       }),
                     ),
-                  )
-                  .map((view) =>
-                    get(
-                      atomFromSignal(() =>
-                        createObjectNode({
-                          object: view,
-                          space,
-                          resolve: resolve(get),
-                          droppable: false,
-                        }),
-                      ),
-                    ),
-                  )
-                  .filter(isNonNullable)
-              );
+                  ),
+                )
+                .filter(isNonNullable);
             }),
             Option.getOrElse(() => []),
-          ),
-        );
-      },
-    }),
-
-    // Create record nodes.
-    createExtension({
-      id: `${meta.id}/records`,
-      resolver: (id) => {
-        let query: QueryResult<Type.Expando> | undefined;
-        return Atom.make((get) => {
-          const client = context.getCapability(ClientCapabilities.Client);
-          const dxn = DXN.tryParse(id)?.asEchoDXN();
-          if (!dxn || !dxn.spaceId) {
-            return null;
-          }
-
-          const space = client.spaces.get(dxn.spaceId);
-          if (!space) {
-            return null;
-          }
-
-          if (!query) {
-            query = space.db.query(Filter.ids(dxn.echoId));
-          }
-
-          const object = get(atomFromQuery(query)).at(0);
-          if (!object) {
-            return null;
-          }
-
-          return createObjectNode({
-            object,
-            space,
-            resolve: resolve(get),
-            disposition: 'hidden',
-          });
+          );
         });
       },
     }),
@@ -673,9 +570,15 @@ export default (context: PluginContext) => {
     createExtension({
       id: `${meta.id}/object-actions`,
       actions: (node) => {
-        let query: QueryResult<View.View> | undefined;
-        return Atom.make((get) =>
-          Function.pipe(
+        let query: Database.QueryResult<Obj.Any> | undefined;
+        return Atom.make((get) => {
+          // TODO(wittjosiah): Use schemaRegistry query once it support atom reactivity.
+          const schemas = get(context.capabilities(ClientCapabilities.Schema))
+            .flat()
+            .filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)));
+          const filter = Filter.or(...schemas.map((schema) => Filter.type(schema)));
+
+          return Function.pipe(
             get(node),
             Option.flatMap((node) => {
               const space = getSpace(node.data);
@@ -684,24 +587,25 @@ export default (context: PluginContext) => {
                 : Option.none();
             }),
             Option.flatMap(({ space, object }) => {
-              const isSchema = Obj.instanceOf(StoredSchema, object);
+              const isSchema = Obj.instanceOf(Type.PersistentType, object);
               if (!query && isSchema) {
-                // TODO(wittjosiah): Support filtering by nested properties (e.g. `query.typename`).
-                query = space.db.query(Filter.type(View.View));
+                // TODO(wittjosiah): Ideally this query would traverse the view reference & filter by the query ast.
+                // TODO(wittjosiah): Remove cast.
+                query = space.db.query(filter) as unknown as Database.QueryResult<Obj.Any>;
               }
 
               let deletable =
                 !isSchema &&
-                // Don't allow the Records smart collection to be deleted.
-                !(
-                  Obj.instanceOf(Collection.QueryCollection, object) &&
-                  getTypenameFromQuery(object.query) === StoredSchema.typename
-                );
+                // Don't allow system collections to be deleted.
+                !Obj.instanceOf(Collection.Managed, object);
               if (isSchema && query) {
-                const views = get(atomFromQuery(query));
+                const objects = get(atomFromQuery(query));
                 const filteredViews = get(
                   atomFromSignal(() =>
-                    views.filter((view) => getTypenameFromQuery(view.query.ast) === object.typename),
+                    objects.filter(
+                      (viewObject) =>
+                        getTypenameFromQuery((viewObject as any).view.target?.query.ast) === object.typename,
+                    ),
                   ),
                 );
                 deletable = filteredViews.length === 0;
@@ -710,7 +614,6 @@ export default (context: PluginContext) => {
               const [dispatcher] = get(context.capabilities(Capabilities.IntentDispatcher));
               const [appGraph] = get(context.capabilities(Capabilities.AppGraph));
               const [state] = get(context.capabilities(SpaceCapabilities.State));
-              const objectForms = get(context.capabilities(SpaceCapabilities.ObjectForm));
 
               if (!dispatcher || !appGraph || !state) {
                 return Option.none();
@@ -719,7 +622,7 @@ export default (context: PluginContext) => {
                   object,
                   graph: appGraph.graph,
                   dispatch: dispatcher.dispatchPromise,
-                  objectForms,
+                  resolve: resolve(get),
                   deletable,
                   navigable: get(atomFromSignal(() => state.navigableCollections)),
                 });
@@ -727,8 +630,8 @@ export default (context: PluginContext) => {
             }),
             Option.map((params) => constructObjectActions(params)),
             Option.getOrElse(() => []),
-          ),
-        );
+          );
+        });
       },
     }),
 

package/src/capabilities/capabilities.ts

@@ -10,7 +10,7 @@ import { type Collection } from '@dxos/schema';
 import { type DeepReadonly, type Position } from '@dxos/util';
 
 import { meta } from '../meta';
-import { type ObjectForm, type PluginState } from '../types';
+import { type PluginState } from '../types';
 
 export namespace SpaceCapabilities {
   export const State = defineCapability<DeepReadonly<PluginState>>(`${meta.id}/capability/state`);
@@ -19,8 +19,12 @@ export namespace SpaceCapabilities {
   export type SettingsSection = { id: string; label: Label; position?: Position };
   export const SettingsSection = defineCapability<SettingsSection>(`${meta.id}/capability/settings-section`);
 
-  export type onCreateSpace = (params: { space: Space; rootCollection: Collection.Collection }) => AnyIntentChain;
-  export const onCreateSpace = defineCapability<onCreateSpace>(`${meta.id}/capability/on-space-created`);
+  export type OnCreateSpace = (params: {
+    space: Space;
+    isDefault: boolean;
+    rootCollection: Collection.Collection;
+  }) => AnyIntentChain;
+  export const OnCreateSpace = defineCapability<OnCreateSpace>(`${meta.id}/capability/on-space-created`);
 
   export type OnSchemaAdded = (params: {
     space: Space;
@@ -30,6 +34,7 @@ export namespace SpaceCapabilities {
   }) => AnyIntentChain;
   export const OnSchemaAdded = defineCapability<OnSchemaAdded>(`${meta.id}/capability/on-schema-added`);
 
-  // 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`);
+  // TODO(wittjosiah): Replace with migrations, this is not a sustainable solution.
+  export type HandleRepair = (params: { space: Space; isDefault: boolean }) => Promise<void>;
+  export const Repair = defineCapability<HandleRepair>(`${meta.id}/capability/repair`);
 }

package/src/capabilities/index.ts

@@ -10,7 +10,7 @@ export const IdentityCreated = lazy(() => import('./identity-created'));
 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 Repair = lazy(() => import('./repair'));
 export const SpaceSettings = lazy(() => import('./settings'));
 export const SpaceState = lazy(() => import('./state'));
 export const SpacesReady = lazy(() => import('./spaces-ready'));