@dxos/plugin-space 0.8.2-main.f11618f → 0.8.2-main.fbd8ed0

package/src/types/types.ts

@@ -2,8 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Schema } from 'effect';
+
 import { type AnyIntentChain } from '@dxos/app-framework';
-import { S, type Expando, type BaseObject, type TypedObject } from '@dxos/echo-schema';
+import { type Expando, type BaseObject, type TypedObject } from '@dxos/echo-schema';
 import { type PublicKey } from '@dxos/react-client';
 // TODO(wittjosiah): This pulls in full client.
 import { EchoObjectSchema, ReactiveObjectSchema, type Space, SpaceSchema } from '@dxos/react-client/echo';
@@ -63,16 +65,16 @@ export type PluginState = {
   enabledEdgeReplication: boolean;
 };
 
-export const SpaceSettingsSchema = S.mutable(
-  S.Struct({
+export const SpaceSettingsSchema = Schema.mutable(
+  Schema.Struct({
     /**
      * Show closed spaces.
      */
-    showHidden: S.Boolean,
+    showHidden: Schema.Boolean,
   }),
 );
 
-export type SpaceSettingsProps = S.Schema.Type<typeof SpaceSettingsSchema>;
+export type SpaceSettingsProps = Schema.Schema.Type<typeof SpaceSettingsSchema>;
 
 // TODO(wittjosiah): Reconcile with graph export serializers.
 
@@ -93,18 +95,18 @@ export interface TypedObjectSerializer<T extends Expando = Expando> {
 export const IconAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Icon');
 export const HueAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Hue');
 
-export const SpaceForm = S.Struct({
-  name: S.optional(S.String.annotations({ title: 'Name' })),
-  icon: S.optional(S.String.annotations({ title: 'Icon', [IconAnnotationId]: true })),
-  hue: S.optional(S.String.annotations({ title: 'Color', [HueAnnotationId]: true })),
+export const SpaceForm = Schema.Struct({
+  name: Schema.optional(Schema.String.annotations({ title: 'Name' })),
+  icon: Schema.optional(Schema.String.annotations({ title: 'Icon', [IconAnnotationId]: true })),
+  hue: Schema.optional(Schema.String.annotations({ title: 'Color', [HueAnnotationId]: true })),
   // TODO(wittjosiah): Make optional with default value.
-  edgeReplication: S.Boolean.annotations({ title: 'Enable EDGE Replication' }),
+  edgeReplication: Schema.Boolean.annotations({ title: 'Enable EDGE Replication' }),
 });
 
 export type ObjectForm<T extends BaseObject = BaseObject> = {
-  // TODO(dmaretskyi): Change to S.Schema.AnyNoContext
+  // TODO(dmaretskyi): Change to Schema.Schema.AnyNoContext
   objectSchema: TypedObject;
-  formSchema?: S.Schema<T, any>;
+  formSchema?: Schema.Schema<T, any>;
   hidden?: boolean;
   getIntent: (props: T, options: { space: Space }) => AnyIntentChain;
 };
@@ -114,186 +116,176 @@ export const defineObjectForm = <T extends BaseObject>(form: ObjectForm<T>) => f
 export const SPACE_ACTION = `${SPACE_PLUGIN}/action`;
 
 export namespace SpaceAction {
-  export class OpenCreateSpace extends S.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
-    input: S.Void,
-    output: S.Void,
+  export class OpenCreateSpace extends Schema.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
+    input: Schema.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Create extends S.TaggedClass<Create>()(`${SPACE_ACTION}/create`, {
+  export class Create extends Schema.TaggedClass<Create>()(`${SPACE_ACTION}/create`, {
     input: SpaceForm,
-    output: S.Struct({
-      id: S.String,
-      subject: S.Array(S.String),
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
       space: SpaceSchema,
     }),
   }) {}
 
-  export class Join extends S.TaggedClass<Join>()(`${SPACE_ACTION}/join`, {
-    input: S.Struct({
-      invitationCode: S.optional(S.String),
-      onDone: S.optional(S.Any),
+  export class Join extends Schema.TaggedClass<Join>()(`${SPACE_ACTION}/join`, {
+    input: Schema.Struct({
+      invitationCode: Schema.optional(Schema.String),
+      onDone: Schema.optional(Schema.Any),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class OpenMembers extends S.TaggedClass<OpenMembers>()(`${SPACE_ACTION}/open-members`, {
-    input: S.Struct({
+  export class OpenMembers extends Schema.TaggedClass<OpenMembers>()(`${SPACE_ACTION}/open-members`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Share extends S.TaggedClass<Share>()(`${SPACE_ACTION}/share`, {
-    input: S.Struct({
+  export class Share extends Schema.TaggedClass<Share>()(`${SPACE_ACTION}/share`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      type: S.Enums(Invitation.Type),
-      authMethod: S.Enums(Invitation.AuthMethod),
-      multiUse: S.Boolean,
-      target: S.optional(S.String),
+      type: Schema.Enums(Invitation.Type),
+      authMethod: Schema.Enums(Invitation.AuthMethod),
+      multiUse: Schema.Boolean,
+      target: Schema.optional(Schema.String),
     }),
-    output: S.instanceOf(CancellableInvitationObservable),
+    output: Schema.instanceOf(CancellableInvitationObservable),
   }) {}
 
-  export class GetShareLink extends S.TaggedClass<GetShareLink>()(`${SPACE_ACTION}/get-share-link`, {
-    input: S.Struct({
+  export class GetShareLink extends Schema.TaggedClass<GetShareLink>()(`${SPACE_ACTION}/get-share-link`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      target: S.optional(S.String),
-      copyToClipboard: S.optional(S.Boolean),
+      target: Schema.optional(Schema.String),
+      copyToClipboard: Schema.optional(Schema.Boolean),
     }),
-    output: S.String,
+    output: Schema.String,
   }) {}
 
-  export class Lock extends S.TaggedClass<Lock>()(`${SPACE_ACTION}/lock`, {
-    input: S.Struct({
+  export class Lock extends Schema.TaggedClass<Lock>()(`${SPACE_ACTION}/lock`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Unlock extends S.TaggedClass<Unlock>()(`${SPACE_ACTION}/unlock`, {
-    input: S.Struct({
+  export class Unlock extends Schema.TaggedClass<Unlock>()(`${SPACE_ACTION}/unlock`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Rename extends S.TaggedClass<Rename>()(`${SPACE_ACTION}/rename`, {
-    input: S.Struct({
+  export class Rename extends Schema.TaggedClass<Rename>()(`${SPACE_ACTION}/rename`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      caller: S.optional(S.String),
+      caller: Schema.optional(Schema.String),
     }),
-    output: S.Void,
-  }) {}
-
-  export class AddSpace extends S.TaggedClass<AddSpace>()(`${SPACE_ACTION}/add-space`, {
-    input: S.Void,
-    output: S.Void,
-  }) {}
-
-  export class AddSpaceMenuGroup extends S.TaggedClass<AddSpaceMenuGroup>()(`${SPACE_ACTION}/add-space-menu-group`, {
-    input: S.Void,
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
   // TODO(wittjosiah): Handle scrolling to section.
   //   This maybe motivates making the space settings its own deck?
-  export class OpenSettings extends S.TaggedClass<OpenSettings>()(`${SPACE_ACTION}/open-settings`, {
-    input: S.Struct({ space: SpaceSchema }),
-    output: S.Void,
+  export class OpenSettings extends Schema.TaggedClass<OpenSettings>()(`${SPACE_ACTION}/open-settings`, {
+    input: Schema.Struct({ space: SpaceSchema }),
+    output: Schema.Void,
   }) {}
 
-  export class Open extends S.TaggedClass<Open>()(`${SPACE_ACTION}/open`, {
-    input: S.Struct({
+  export class Open extends Schema.TaggedClass<Open>()(`${SPACE_ACTION}/open`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Close extends S.TaggedClass<Close>()(`${SPACE_ACTION}/close`, {
-    input: S.Struct({
+  export class Close extends Schema.TaggedClass<Close>()(`${SPACE_ACTION}/close`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Migrate extends S.TaggedClass<Migrate>()(`${SPACE_ACTION}/migrate`, {
-    input: S.Struct({
+  export class Migrate extends Schema.TaggedClass<Migrate>()(`${SPACE_ACTION}/migrate`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      version: S.optional(S.String),
+      version: Schema.optional(Schema.String),
     }),
-    output: S.Boolean,
+    output: Schema.Boolean,
   }) {}
 
-  export class OpenCreateObject extends S.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
-    input: S.Struct({
-      target: S.Union(SpaceSchema, CollectionType),
-      navigable: S.optional(S.Boolean),
+  export class OpenCreateObject extends Schema.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
+    input: Schema.Struct({
+      target: Schema.Union(SpaceSchema, CollectionType),
+      navigable: Schema.optional(Schema.Boolean),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class AddObject extends S.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
-    input: S.Struct({
+  export class AddObject extends Schema.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
+    input: Schema.Struct({
       object: ReactiveObjectSchema,
-      target: S.Union(SpaceSchema, CollectionType),
-      hidden: S.optional(S.Boolean),
+      target: Schema.Union(SpaceSchema, CollectionType),
+      hidden: Schema.optional(Schema.Boolean),
     }),
-    output: S.Struct({
-      id: S.String,
-      subject: S.Array(S.String),
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
       object: EchoObjectSchema,
     }),
   }) {}
 
-  export const DeletionData = S.Struct({
-    objects: S.Array(EchoObjectSchema),
+  export const DeletionData = Schema.Struct({
+    objects: Schema.Array(EchoObjectSchema),
     parentCollection: CollectionType,
-    indices: S.Array(S.Number),
-    nestedObjectsList: S.Array(S.Array(EchoObjectSchema)),
-    wasActive: S.Array(S.String),
+    indices: Schema.Array(Schema.Number),
+    nestedObjectsList: Schema.Array(Schema.Array(EchoObjectSchema)),
+    wasActive: Schema.Array(Schema.String),
   });
 
-  export type DeletionData = S.Schema.Type<typeof DeletionData>;
+  export type DeletionData = Schema.Schema.Type<typeof DeletionData>;
 
-  export class RemoveObjects extends S.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
-    input: S.Struct({
-      objects: S.Array(EchoObjectSchema),
-      target: S.optional(CollectionType),
-      deletionData: S.optional(DeletionData),
+  export class RemoveObjects extends Schema.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
+    input: Schema.Struct({
+      objects: Schema.Array(EchoObjectSchema),
+      target: Schema.optional(CollectionType),
+      deletionData: Schema.optional(DeletionData),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class RenameObject extends S.TaggedClass<RenameObject>()(`${SPACE_ACTION}/rename-object`, {
-    input: S.Struct({
+  export class RenameObject extends Schema.TaggedClass<RenameObject>()(`${SPACE_ACTION}/rename-object`, {
+    input: Schema.Struct({
       object: EchoObjectSchema,
-      caller: S.optional(S.String),
+      caller: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class DuplicateObject extends S.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
-    input: S.Struct({
+  export class DuplicateObject extends Schema.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
+    input: Schema.Struct({
       object: EchoObjectSchema,
-      target: S.Union(SpaceSchema, CollectionType),
+      target: Schema.Union(SpaceSchema, CollectionType),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class WaitForObject extends S.TaggedClass<WaitForObject>()(`${SPACE_ACTION}/wait-for-object`, {
-    input: S.Struct({
-      id: S.optional(S.String),
+  export class WaitForObject extends Schema.TaggedClass<WaitForObject>()(`${SPACE_ACTION}/wait-for-object`, {
+    input: Schema.Struct({
+      id: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 }
 
 export namespace CollectionAction {
-  export class Create extends S.TaggedClass<Create>()('dxos.org/plugin/collection/action/create', {
-    input: S.Struct({
-      name: S.optional(S.String),
+  export class Create extends Schema.TaggedClass<Create>()('dxos.org/plugin/collection/action/create', {
+    input: Schema.Struct({
+      name: Schema.optional(Schema.String),
     }),
-    output: S.Struct({
+    output: Schema.Struct({
       object: CollectionType,
     }),
   }) {}

package/src/util.tsx

@@ -2,36 +2,30 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Rx } from '@effect-rx/rx-react';
+
 import { createIntent, LayoutAction, type PromiseIntentDispatcher } from '@dxos/app-framework';
-import { EXPANDO_TYPENAME, getTypeAnnotation, getTypename, type BaseObject, type Expando } from '@dxos/echo-schema';
+import { type BaseObject, EXPANDO_TYPENAME, getTypeAnnotation, getTypename, type Expando } from '@dxos/echo-schema';
 import { getSchema } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { isLiveObject, makeRef } from '@dxos/live-object';
+import { makeRef } from '@dxos/live-object';
 import { Migrations } from '@dxos/migrations';
 import {
   ACTION_GROUP_TYPE,
   ACTION_TYPE,
-  cleanup,
-  getGraph,
-  memoize,
+  type ReadableGraph,
   type ActionData,
-  type Graph,
   type InvokeParams,
   type Node,
   type NodeArg,
 } from '@dxos/plugin-graph';
 import {
-  Filter,
   fullyQualifiedId,
   getSpace,
   isEchoObject,
-  isSpace,
+  type QueryResult,
   SpaceState,
-  type Echo,
-  type FilterSource,
-  type Query,
-  type QueryOptions,
-  type ReactiveEchoObject,
+  type AnyLiveObject,
   type Space,
 } from '@dxos/react-client/echo';
 import { ATTENDABLE_PATH_SEPARATOR } from '@dxos/react-ui-attention';
@@ -44,36 +38,19 @@ export const COMPOSER_SPACE_LOCK = 'dxos.org/plugin/space/lock';
 // TODO(wittjosiah): Remove.
 export const SHARED = 'shared-spaces';
 
-const EMPTY_ARRAY: never[] = [];
-
 /**
- *
- * @param spaceOrEcho
- * @param filter
- * @param options
- * @returns
+ * Convert a query result to an Rx value of the objects.
  */
-export const memoizeQuery = <T extends BaseObject>(
-  spaceOrEcho?: Space | Echo,
-  filter?: FilterSource<T>,
-  options?: QueryOptions,
-): T[] => {
-  const key = JSON.stringify({
-    space: isSpace(spaceOrEcho) ? spaceOrEcho.id : undefined,
-    filter: Filter.from(filter).toProto(),
-  });
+export const rxFromQuery = <T extends BaseObject>(query: QueryResult<T>): Rx.Rx<T[]> => {
+  return Rx.make((get) => {
+    const unsubscribe = query.subscribe((result) => {
+      get.setSelf(result.objects);
+    });
 
-  const query = memoize(
-    () =>
-      isSpace(spaceOrEcho)
-        ? spaceOrEcho.db.query(filter, options)
-        : (spaceOrEcho?.query(filter, options) as Query<T> | undefined),
-    key,
-  );
-  const unsubscribe = memoize(() => query?.subscribe(), key);
-  cleanup(() => unsubscribe?.());
+    get.addFinalizer(() => unsubscribe());
 
-  return query?.objects ?? EMPTY_ARRAY;
+    return query.objects;
+  });
 };
 
 // TODO(wittjosiah): Factor out? Expose via capability?
@@ -109,7 +86,7 @@ const getCollectionGraphNodePartials = ({
       // Change on disk.
       collection.objects = nextOrder.filter(isEchoObject).map(makeRef);
     },
-    onTransferStart: (child: Node<ReactiveEchoObject<any>>, index?: number) => {
+    onTransferStart: (child: Node<AnyLiveObject<any>>, index?: number) => {
       // TODO(wittjosiah): Support transfer between spaces.
       // const childSpace = getSpace(child.data);
       // if (space && childSpace && !childSpace.key.equals(space.key)) {
@@ -138,7 +115,7 @@ const getCollectionGraphNodePartials = ({
 
       // }
     },
-    onTransferEnd: (child: Node<ReactiveEchoObject<any>>, destination: Node) => {
+    onTransferEnd: (child: Node<AnyLiveObject<any>>, destination: Node) => {
       // Remove child from origin collection.
       const index = collection.objects.findIndex((object) => object.target === child.data);
       if (index > -1) {
@@ -154,7 +131,7 @@ const getCollectionGraphNodePartials = ({
       //   childSpace.db.remove(child.data);
       // }
     },
-    onCopy: async (child: Node<ReactiveEchoObject<any>>, index?: number) => {
+    onCopy: async (child: Node<AnyLiveObject<any>>, index?: number) => {
       // Create clone of child and add to destination space.
       const newObject = await cloneObject(child.data, resolve, space);
       space.db.add(newObject);
@@ -309,8 +286,8 @@ export const constructSpaceActions = ({
       {
         id: getId(SpaceAction.Rename._tag),
         type: ACTION_TYPE,
-        data: async (params: InvokeParams) => {
-          await dispatch(createIntent(SpaceAction.Rename, { space, caller: params.caller }));
+        data: async (params?: InvokeParams) => {
+          await dispatch(createIntent(SpaceAction.Rename, { space, caller: params?.caller }));
         },
         properties: {
           label: ['rename space label', { ns: SPACE_PLUGIN }],
@@ -333,7 +310,7 @@ export const createObjectNode = ({
   navigable = false,
   resolve,
 }: {
-  object: ReactiveEchoObject<any>;
+  object: AnyLiveObject<any>;
   space: Space;
   navigable?: boolean;
   resolve: (typename: string) => Record<string, any>;
@@ -371,15 +348,16 @@ export const createObjectNode = ({
 };
 
 export const constructObjectActions = ({
-  node,
+  object,
+  graph,
   dispatch,
   navigable = false,
 }: {
-  node: Node<ReactiveEchoObject<any>>;
+  object: AnyLiveObject<any>;
+  graph: ReadableGraph;
   dispatch: PromiseIntentDispatcher;
   navigable?: boolean;
 }) => {
-  const object = node.data;
   const space = getSpace(object);
   invariant(space, 'Space not found');
   const getId = (id: string) => `${id}/${fullyQualifiedId(object)}`;
@@ -404,8 +382,8 @@ export const constructObjectActions = ({
     {
       id: getId(SpaceAction.RenameObject._tag),
       type: ACTION_TYPE,
-      data: async (params: InvokeParams) => {
-        await dispatch(createIntent(SpaceAction.RenameObject, { object, caller: params.caller }));
+      data: async (params?: InvokeParams) => {
+        await dispatch(createIntent(SpaceAction.RenameObject, { object, caller: params?.caller }));
       },
       properties: {
         label: [
@@ -413,8 +391,10 @@ export const constructObjectActions = ({
           { ns: SPACE_PLUGIN },
         ],
         icon: 'ph--pencil-simple-line--regular',
-        // TODO(wittjosiah): Doesn't work.
-        // keyBinding: 'shift+F6',
+        // TODO(wittjosiah): Need's focus.
+        keyBinding: {
+          macos: 'shift+F6',
+        },
         testId: 'spacePlugin.renameObject',
       },
     },
@@ -422,9 +402,8 @@ export const constructObjectActions = ({
       id: getId(SpaceAction.RemoveObjects._tag),
       type: ACTION_TYPE,
       data: async () => {
-        const graph = getGraph(node);
         const collection = graph
-          .nodes(node, { relation: 'inbound' })
+          .getConnections(fullyQualifiedId(object), 'inbound')
           .find(({ data }) => data instanceof CollectionType)?.data;
         await dispatch(createIntent(SpaceAction.RemoveObjects, { objects: [object], target: collection }));
       },
@@ -473,29 +452,13 @@ export const constructObjectActions = ({
   return actions;
 };
 
-/**
- * @deprecated
- */
-export const getActiveSpace = (graph: Graph, active?: string) => {
-  if (!active) {
-    return;
-  }
-
-  const node = graph.findNode(active);
-  if (!node || !isLiveObject(node.data)) {
-    return;
-  }
-
-  return getSpace(node.data);
-};
-
 /**
  * @deprecated This is a temporary solution.
  */
 export const getNestedObjects = async (
-  object: ReactiveEchoObject<any>,
+  object: AnyLiveObject<any>,
   resolve: (typename: string) => Record<string, any>,
-): Promise<ReactiveEchoObject<any>[]> => {
+): Promise<AnyLiveObject<any>[]> => {
   const type = getTypename(object);
   if (!type) {
     return [];
@@ -507,7 +470,7 @@ export const getNestedObjects = async (
     return [];
   }
 
-  const objects: ReactiveEchoObject<any>[] = await loadReferences(object);
+  const objects: AnyLiveObject<any>[] = await loadReferences(object);
   const nested = await Promise.all(objects.map((object) => getNestedObjects(object, resolve)));
   return [...objects, ...nested.flat()];
 };