@dxos/plugin-space 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/dist/lib/node-esm/app-graph-builder-N37ED6UI.mjs

@@ -0,0 +1,594 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  getActiveSpace
+} from "./chunk-OSFH2XKO.mjs";
+import {
+  SHARED,
+  constructObjectActions,
+  constructSpaceActions,
+  constructSpaceNode,
+  createObjectNode,
+  createStaticSchemaActions,
+  createStaticSchemaNode
+} from "./chunk-WW6YYBRG.mjs";
+import {
+  SPACE_TYPE,
+  SpaceCapabilities,
+  SpaceOperation
+} from "./chunk-3DWZCVVQ.mjs";
+import {
+  meta
+} from "./chunk-SL4BJSUG.mjs";
+
+// src/capabilities/app-graph-builder/app-graph-builder.ts
+import * as Effect from "effect/Effect";
+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 } from "@dxos/app-toolkit";
+import { SpaceState, getSpace, isSpace, parseId } from "@dxos/client/echo";
+import { DXN, Feed, Filter, Obj, Type } from "@dxos/echo";
+import { Collection } from "@dxos/echo";
+import { AtomObj, AtomQuery } from "@dxos/echo-atom";
+import { Operation } from "@dxos/operation";
+import { ClientCapabilities } from "@dxos/plugin-client";
+import { ATTENDABLE_PATH_SEPARATOR, PLANK_COMPANION_TYPE } from "@dxos/plugin-deck/types";
+import { CreateAtom, GraphBuilder, NodeMatcher } from "@dxos/plugin-graph";
+import { Expando, ManagedCollection, ViewAnnotation, getTypenameFromQuery } from "@dxos/schema";
+import { isNonNullable } from "@dxos/util";
+var whenSpace = (node) => node.type === SPACE_TYPE && isSpace(node.data) ? Option.some(node.data) : Option.none();
+var app_graph_builder_default = Capability.makeModule(Effect.fnUntraced(function* ({ shareableLinkOrigin = window.location.origin } = {}) {
+  const capabilities = yield* Capability.Service;
+  const resolve = (get) => (typename) => capabilities.getAll(AppCapabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
+  const extensions = yield* Effect.all([
+    // Primary actions.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/primary-actions`,
+      position: "hoist",
+      match: NodeMatcher.whenRoot,
+      actions: () => Effect.succeed([
+        {
+          id: SpaceOperation.OpenCreateSpace.meta.key,
+          data: () => Operation.invoke(SpaceOperation.OpenCreateSpace),
+          properties: {
+            label: [
+              "create space label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--plus--regular",
+            testId: "spacePlugin.createSpace",
+            disposition: "menu"
+          }
+        },
+        {
+          id: SpaceOperation.Join.meta.key,
+          data: () => Operation.invoke(SpaceOperation.Join, {}),
+          properties: {
+            label: [
+              "join space label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--sign-in--regular",
+            testId: "spacePlugin.joinSpace",
+            disposition: "menu"
+          }
+        },
+        {
+          id: SpaceOperation.OpenMembers.meta.key,
+          data: Effect.fnUntraced(function* () {
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = getActiveSpace(capabilities) ?? client.spaces.default;
+            yield* Operation.invoke(SpaceOperation.OpenMembers, {
+              space
+            });
+          }),
+          properties: {
+            label: [
+              "share space label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--users--regular",
+            testId: "spacePlugin.shareSpace",
+            keyBinding: {
+              macos: "meta+.",
+              windows: "alt+."
+            }
+          }
+        },
+        {
+          id: SpaceOperation.OpenSettings.meta.key,
+          data: Effect.fnUntraced(function* () {
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = getActiveSpace(capabilities) ?? client.spaces.default;
+            yield* Operation.invoke(SpaceOperation.OpenSettings, {
+              space
+            });
+          }),
+          properties: {
+            label: [
+              "open current space settings label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--faders--regular",
+            keyBinding: {
+              macos: "meta+shift+,",
+              windows: "ctrl+shift+,"
+            }
+          }
+        }
+      ])
+    }),
+    // Create space nodes.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/spaces`,
+      match: NodeMatcher.whenRoot,
+      connector: (node, get) => {
+        const client = capabilities.get(ClientCapabilities.Client);
+        const stateAtom = capabilities.get(SpaceCapabilities.State);
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const spacesAtom = CreateAtom.fromObservable(client.spaces);
+        const isReadyAtom = CreateAtom.fromObservable(client.spaces.isReady);
+        const spaces = get(spacesAtom);
+        const isReady = get(isReadyAtom);
+        if (!spaces || !isReady) {
+          return Effect.succeed([]);
+        }
+        const settingsAtom = capabilities.get(SpaceCapabilities.Settings);
+        const settings = get(settingsAtom);
+        const state = get(stateAtom);
+        const ephemeralState = get(ephemeralAtom);
+        try {
+          const [spacesOrder] = get(AtomQuery.make(client.spaces.default.db, Filter.type(Expando.Expando, {
+            key: SHARED
+          })));
+          const { graph } = capabilities.get(AppCapabilities.AppGraph);
+          const spacesOrderSnapshot = spacesOrder ? get(AtomObj.make(spacesOrder)) : void 0;
+          const order = spacesOrderSnapshot?.order ?? [];
+          const orderMap = new Map(order.map((id, index) => [
+            id,
+            index
+          ]));
+          const spaceStates = spaces.map((space) => get(CreateAtom.fromObservable(space.state)));
+          spaces.forEach((space) => {
+            if (space.state.get() === SpaceState.SPACE_READY) {
+              get(AtomObj.make(space.properties));
+            }
+          });
+          return Effect.succeed([
+            ...spaces.filter((space) => orderMap.has(space.id)).sort((a, b) => orderMap.get(a.id) - orderMap.get(b.id)),
+            ...spaces.filter((space) => !orderMap.has(space.id))
+          ].filter((space, i) => settings?.showHidden ? true : spaceStates[i] !== SpaceState.SPACE_INACTIVE).map((space) => constructSpaceNode({
+            space,
+            navigable: ephemeralState.navigableCollections,
+            personal: space === client.spaces.default,
+            namesCache: state.spaceNames,
+            resolve: resolve(get),
+            graph,
+            spacesOrder
+          })));
+        } catch {
+          return Effect.succeed([]);
+        }
+      },
+      resolver: (id, get) => {
+        const { spaceId } = parseId(id);
+        if (!spaceId) {
+          return Effect.succeed(null);
+        }
+        const client = capabilities.get(ClientCapabilities.Client);
+        const spaces = get(CreateAtom.fromObservable(client.spaces));
+        const space = spaces?.find((s) => s.id === spaceId);
+        if (!space) {
+          return Effect.succeed(null);
+        }
+        const state = get(capabilities.get(SpaceCapabilities.State));
+        const ephemeralState = get(capabilities.get(SpaceCapabilities.EphemeralState));
+        const { graph } = capabilities.get(AppCapabilities.AppGraph);
+        const [spacesOrder] = get(AtomQuery.make(client.spaces.default.db, Filter.type(Expando.Expando, {
+          key: SHARED
+        })));
+        return Effect.succeed(constructSpaceNode({
+          space,
+          navigable: ephemeralState.navigableCollections,
+          personal: space === client.spaces.default,
+          namesCache: state.spaceNames,
+          resolve: resolve(get),
+          graph,
+          spacesOrder
+        }));
+      }
+    }),
+    // Create space actions.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/actions`,
+      match: whenSpace,
+      actions: (space, get) => {
+        const [client] = get(capabilities.atom(ClientCapabilities.Client));
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        if (!client) {
+          return Effect.succeed([]);
+        }
+        return Effect.succeed(constructSpaceActions({
+          space,
+          migrating: ephemeralState.sdkMigrationRunning[space.id]
+        }));
+      }
+    }),
+    // Create nodes for objects in the root collection of a space.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/root-collection`,
+      match: whenSpace,
+      connector: (space, get) => {
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        const spaceState = get(CreateAtom.fromObservable(space.state));
+        if (spaceState !== SpaceState.SPACE_READY) {
+          return Effect.succeed([]);
+        }
+        const propertiesSnapshot = get(AtomObj.make(space.properties));
+        const collectionRef = propertiesSnapshot[Collection.Collection.typename];
+        const collection = collectionRef ? get(AtomObj.make(collectionRef)) : void 0;
+        if (!collection) {
+          return Effect.succeed([]);
+        }
+        const rawRefs = collection.objects ?? [];
+        const objects = rawRefs.map((ref) => {
+          get(AtomObj.make(ref));
+          return ref.target;
+        }).filter(isNonNullable);
+        return Effect.succeed(objects.map((object) => createObjectNode({
+          db: space.db,
+          object,
+          resolve: resolve(get),
+          navigable: ephemeralState.navigableCollections,
+          parentCollection: collectionRef?.target
+        })).filter(isNonNullable));
+      }
+    }),
+    // Create nodes for objects in a collection or by its DXN.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/objects`,
+      match: (node) => Obj.instanceOf(Collection.Collection, node.data) ? Option.some(node.data) : Option.none(),
+      connector: (collection, get) => {
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        const space = getSpace(collection);
+        const collectionSnapshot = get(AtomObj.make(collection));
+        const refs = collectionSnapshot.objects ?? [];
+        const objects = refs.map((ref) => {
+          get(AtomObj.make(ref));
+          return ref.target;
+        }).filter(isNonNullable);
+        return Effect.succeed(objects.map((object) => space && createObjectNode({
+          object,
+          db: space.db,
+          resolve: resolve(get),
+          navigable: ephemeralState.navigableCollections,
+          parentCollection: collection
+        })).filter(isNonNullable));
+      },
+      resolver: (id, get) => {
+        const client = capabilities.get(ClientCapabilities.Client);
+        const dxn = DXN.tryParse(id)?.asEchoDXN();
+        if (!dxn || !dxn.spaceId) {
+          return Effect.succeed(null);
+        }
+        const space = client.spaces.get(dxn.spaceId);
+        if (!space) {
+          return Effect.succeed(null);
+        }
+        const object = get(AtomQuery.make(space.db, Filter.id(dxn.echoId))).at(0);
+        if (!Obj.isObject(object)) {
+          return Effect.succeed(null);
+        }
+        return Effect.succeed(createObjectNode({
+          object,
+          db: space.db,
+          resolve: resolve(get),
+          disposition: "hidden"
+        }));
+      }
+    }),
+    // Create object nodes for schema-based system collections.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/system-collections`,
+      match: (node) => Obj.instanceOf(ManagedCollection.ManagedCollection, node.data) ? Option.some(node.data) : Option.none(),
+      connector: (collection, get) => {
+        const [typename, feedKind] = collection.key.split("~");
+        const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
+        const space = getSpace(collection);
+        if (!space || !client) {
+          return Effect.succeed([]);
+        }
+        const filter = Match.value(typename).pipe(Match.when(Feed.Feed.typename, () => Filter.type(Feed.Feed, {
+          kind: feedKind
+        })), Match.orElse((typename2) => {
+          const schema = client.graph.schemaRegistry.query({
+            typename: typename2,
+            location: [
+              "runtime"
+            ],
+            includeSystem: true
+          }).runSync()[0];
+          return schema ? Filter.type(schema) : void 0;
+        }));
+        if (!filter) {
+          return Effect.succeed([]);
+        }
+        return Effect.succeed(get(AtomQuery.make(space.db, filter)).map((object) => {
+          get(AtomObj.make(object));
+          return createObjectNode({
+            object,
+            db: space.db,
+            managedCollectionChild: true,
+            resolve: resolve(get)
+          });
+        }).filter(isNonNullable));
+      }
+    }),
+    // Create branch nodes for static schema record types.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/static-schemas`,
+      match: (node) => Obj.instanceOf(ManagedCollection.ManagedCollection, node.data) && node.data.key === Type.getTypename(Type.PersistentType) ? Option.some(node.data) : Option.none(),
+      connector: (collection, get) => {
+        const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
+        const space = getSpace(collection);
+        if (!space) {
+          return Effect.succeed([]);
+        }
+        const propertiesSnapshot = get(AtomObj.make(space.properties));
+        const staticRecords = propertiesSnapshot.staticRecords ?? [];
+        return Effect.succeed(staticRecords.map((typename) => client?.graph.schemaRegistry.query({
+          typename,
+          location: [
+            "runtime"
+          ]
+        }).runSync()[0]).filter(isNonNullable).map((schema) => createStaticSchemaNode({
+          schema,
+          space
+        })));
+      }
+    }),
+    // Create actions for static schema record types.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/static-schema-actions`,
+      match: (node) => {
+        const space = isSpace(node.properties.space) ? node.properties.space : void 0;
+        return space && Schema.isSchema(node.data) ? Option.some({
+          space,
+          schema: node.data
+        }) : Option.none();
+      },
+      actions: ({ space, schema }, get) => {
+        const schemas = get(capabilities.atom(ClientCapabilities.Client)).at(0)?.graph.schemaRegistry.query({
+          location: [
+            "runtime"
+          ]
+        }).runSync() ?? [];
+        const filter = Filter.or(...schemas.filter((schema2) => ViewAnnotation.get(schema2).pipe(Option.getOrElse(() => false))).map((schema2) => Filter.type(schema2)));
+        const objects = get(AtomQuery.make(space.db, filter));
+        const targetTypename = Type.getTypename(schema);
+        const filteredViews = objects.filter((viewObject) => {
+          const viewSnapshot = get(AtomObj.make(viewObject));
+          const viewRef = viewSnapshot.view;
+          const viewTarget = viewRef ? get(AtomObj.make(viewRef)) : void 0;
+          return getTypenameFromQuery(viewTarget?.query?.ast) === targetTypename;
+        });
+        const deletable = filteredViews.length === 0;
+        return Effect.succeed(createStaticSchemaActions({
+          schema,
+          space,
+          deletable
+        }));
+      }
+    }),
+    // Create nodes for views of record types.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/schema-views`,
+      match: (node) => {
+        const space = getSpace(node.data) ?? (isSpace(node.properties.space) ? node.properties.space : void 0);
+        return space && (Obj.instanceOf(Type.PersistentType, node.data) || Schema.isSchema(node.data)) ? Option.some({
+          space,
+          schema: node.data
+        }) : Option.none();
+      },
+      connector: ({ space, schema }, get) => {
+        const schemas = get(capabilities.atom(ClientCapabilities.Client)).at(0)?.graph.schemaRegistry.query({
+          location: [
+            "runtime"
+          ]
+        }).runSync() ?? [];
+        const filter = Filter.or(...schemas.filter((schema2) => ViewAnnotation.get(schema2).pipe(Option.getOrElse(() => false))).map((schema2) => Filter.type(schema2)));
+        const typename = Schema.isSchema(schema) ? Type.getTypename(schema) : schema.typename;
+        const objects = get(AtomQuery.make(space.db, filter));
+        return Effect.succeed(objects.filter((object) => {
+          const objectSnapshot = get(AtomObj.make(object));
+          const viewRef = objectSnapshot.view;
+          const viewTarget = viewRef ? get(AtomObj.make(viewRef)) : void 0;
+          return getTypenameFromQuery(viewTarget?.query?.ast) === typename;
+        }).map((object) => createObjectNode({
+          object,
+          db: space.db,
+          resolve: resolve(get),
+          droppable: false
+        })).filter(isNonNullable));
+      }
+    }),
+    // Create collection actions and action groups.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/object-actions`,
+      match: (node) => {
+        const space = getSpace(node.data);
+        return space && Obj.isObject(node.data) && Obj.getTypename(node.data) === node.type ? Option.some({
+          space,
+          object: node.data
+        }) : Option.none();
+      },
+      actions: ({ space, object }, get) => {
+        const schemas = get(capabilities.atom(ClientCapabilities.Client)).at(0)?.graph.schemaRegistry.query({
+          location: [
+            "runtime"
+          ]
+        }).runSync() ?? [];
+        const filter = Filter.or(...schemas.filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false))).map((schema) => Filter.type(schema)));
+        const isSchema2 = Obj.instanceOf(Type.PersistentType, object);
+        let deletable = !isSchema2 && !Obj.instanceOf(ManagedCollection.ManagedCollection, object);
+        if (isSchema2) {
+          const objects = get(AtomQuery.make(space.db, filter));
+          const filteredViews = objects.filter((viewObject) => {
+            const viewSnapshot = get(AtomObj.make(viewObject));
+            const viewRef = viewSnapshot.view;
+            const viewTarget = viewRef ? get(AtomObj.make(viewRef)) : void 0;
+            return getTypenameFromQuery(viewTarget?.query?.ast) === object.typename;
+          });
+          deletable = filteredViews.length === 0;
+        }
+        const [appGraph] = get(capabilities.atom(AppCapabilities.AppGraph));
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        if (!appGraph) {
+          return Effect.succeed([]);
+        }
+        return Effect.succeed(constructObjectActions({
+          object,
+          graph: appGraph.graph,
+          resolve: resolve(get),
+          capabilities,
+          deletable,
+          navigable: ephemeralState.navigableCollections,
+          shareableLinkOrigin
+        }));
+      }
+    }),
+    // View selected objects.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/selected-objects`,
+      match: (node) => {
+        if (!Obj.isObject(node.data)) {
+          return Option.none();
+        }
+        const schema = Obj.getSchema(node.data);
+        const isView = Option.fromNullable(schema).pipe(Option.flatMap((schema2) => ViewAnnotation.get(schema2)), Option.getOrElse(() => false));
+        if (!isView) {
+          return Option.none();
+        }
+        return Option.some(node);
+      },
+      connector: (node) => Effect.succeed([
+        {
+          id: [
+            node.id,
+            "selected-objects"
+          ].join(ATTENDABLE_PATH_SEPARATOR),
+          type: PLANK_COMPANION_TYPE,
+          data: "selected-objects",
+          properties: {
+            label: [
+              "companion selected objects label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--tree-view--regular",
+            disposition: "hidden"
+          }
+        }
+      ])
+    }),
+    // Space settings panel children (General settings, Members, Types).
+    GraphBuilder.createExtension({
+      id: `${meta.id}/settings-sections`,
+      match: NodeMatcher.whenNodeType(`${meta.id}/settings`),
+      connector: (node) => Effect.succeed([
+        {
+          id: `properties-${node.id}`,
+          type: `${meta.id}/properties`,
+          data: `${meta.id}/properties`,
+          properties: {
+            label: [
+              "space settings properties label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--sliders--regular",
+            position: "hoist",
+            testId: "spacePlugin.general"
+          }
+        },
+        {
+          id: `members-${node.id}`,
+          type: `${meta.id}/members`,
+          data: `${meta.id}/members`,
+          properties: {
+            label: [
+              "members panel label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--users--regular",
+            position: "hoist",
+            testId: "spacePlugin.members"
+          }
+        },
+        {
+          id: `schema-${node.id}`,
+          type: `${meta.id}/schema`,
+          data: `${meta.id}/schema`,
+          properties: {
+            label: [
+              "space settings schema label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--shapes--regular",
+            testId: "spacePlugin.schema"
+          }
+        }
+      ])
+    }),
+    // Object settings plank companion.
+    GraphBuilder.createExtension({
+      id: `${meta.id}/settings`,
+      match: NodeMatcher.whenEchoObjectMatches,
+      connector: (node) => Effect.succeed([
+        {
+          id: [
+            node.id,
+            "settings"
+          ].join(ATTENDABLE_PATH_SEPARATOR),
+          type: PLANK_COMPANION_TYPE,
+          data: "settings",
+          properties: {
+            label: [
+              "object settings label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--sliders--regular",
+            disposition: "hidden",
+            position: "fallback"
+          }
+        }
+      ])
+    })
+  ]);
+  return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+}));
+export {
+  app_graph_builder_default as default
+};
+//# sourceMappingURL=app-graph-builder-N37ED6UI.mjs.map