@dxos/plugin-space 0.8.3 → 0.8.4-main.1068cf700f

package/src/components/ObjectCardStack/ObjectForm.tsx

@@ -0,0 +1,97 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import React, { useCallback, useMemo } from 'react';
+
+import { DXN, Obj, type Ref, Tag, Type } from '@dxos/echo';
+import { type JsonPath, splitJsonPath } from '@dxos/echo/internal';
+import { invariant } from '@dxos/invariant';
+import { Form, omitId } from '@dxos/react-ui-form';
+import { isNonNullable } from '@dxos/util';
+
+import { meta as pluginMeta } from '../../meta';
+
+export type ObjectFormProps = {
+  schema: Schema.Schema.AnyNoContext;
+  object: Obj.Unknown;
+};
+
+export const ObjectForm = ({ object, schema }: ObjectFormProps) => {
+  const db = Obj.getDatabase(object);
+
+  const formSchema = useMemo(
+    () =>
+      Schema.Struct({
+        tags: Schema.Array(Type.Ref(Tag.Tag)).pipe(Schema.optional),
+      }).pipe(Schema.extend(omitId(schema))),
+    [schema],
+  );
+
+  const meta = Obj.getMeta(object);
+  const tags = (meta.tags ?? []).map((tag) => db?.makeRef(DXN.parse(tag))).filter(isNonNullable);
+  const values = useMemo(() => ({ tags, ...object }), [object, tags]);
+
+  const handleCreate = useCallback((schema: Type.Entity.Any, values: any) => {
+    invariant(db);
+    invariant(Type.isObjectSchema(schema));
+    const newObject = db.add(Obj.make(schema, values));
+    if (Obj.instanceOf(Tag.Tag, newObject)) {
+      Obj.change(object, (obj) => {
+        Obj.getMeta(obj).tags = [...(Obj.getMeta(obj).tags ?? []), Obj.getDXN(newObject).toString()];
+      });
+    }
+  }, []);
+
+  // TODO(wittjosiah): Use FormRootProps type.
+  const handleChange = useCallback(
+    ({ tags, ...values }: any, { isValid, changed }: { isValid: boolean; changed: Record<JsonPath, boolean> }) => {
+      if (!isValid) {
+        return;
+      }
+
+      const changedPaths = Object.keys(changed).filter((path) => changed[path as JsonPath]) as JsonPath[];
+
+      // Handle tags separately using Obj.change.
+      const hasTagsChange = changedPaths.some((path) => splitJsonPath(path)[0] === 'tags');
+      if (hasTagsChange) {
+        Obj.change(object, (obj) => {
+          Obj.getMeta(obj).tags = tags?.map((tag: Ref.Ref<Tag.Tag>) => tag.dxn.toString()) ?? [];
+        });
+      }
+
+      // Handle other property changes.
+      const nonTagPaths = changedPaths.filter((path) => splitJsonPath(path)[0] !== 'tags');
+      if (nonTagPaths.length > 0) {
+        Obj.change(object, () => {
+          for (const path of nonTagPaths) {
+            const parts = splitJsonPath(path);
+            const value = Obj.getValue(values, parts);
+            Obj.setValue(object, parts, value);
+          }
+        });
+      }
+    },
+    [object],
+  );
+
+  return (
+    <Form.Root
+      schema={omitId(formSchema)}
+      values={values}
+      createOptionIcon='ph--plus--regular'
+      createOptionLabel={['add tag label', { ns: pluginMeta.id }]}
+      createInitialValuePath='label'
+      db={db}
+      onValuesChanged={handleChange}
+      onCreate={handleCreate}
+    >
+      <Form.Viewport>
+        <Form.Content>
+          <Form.FieldSet />
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
+  );
+};

package/src/components/ObjectCardStack/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ObjectCardStack } from './ObjectCardStack';
+
+export default ObjectCardStack;

package/src/components/ObjectDetails/BaseObjectSettings.stories.tsx

@@ -0,0 +1,63 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useEffect, useState } from 'react';
+
+import { type Obj, Tag } from '@dxos/echo';
+import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
+import { withTheme } from '@dxos/react-ui/testing';
+import { render } from '@dxos/storybook-utils';
+import { Pipeline } from '@dxos/types';
+
+import { translations } from '../../translations';
+
+import { BaseObjectSettings } from './BaseObjectSettings';
+
+const DefaultStory = () => {
+  const { space } = useClientStory();
+  const [object, setObject] = useState<Obj.Unknown>();
+
+  useEffect(() => {
+    if (space && !object) {
+      const object = space.db.add(Pipeline.make());
+      setObject(object);
+    }
+  }, [space, object]);
+
+  if (!object) {
+    return null;
+  }
+
+  return <BaseObjectSettings object={object} classNames='is-[20rem]' />;
+};
+
+const meta = {
+  title: 'plugins/plugin-space/BaseObjectSettings',
+  component: BaseObjectSettings as any,
+  render: render(DefaultStory),
+  decorators: [
+    withTheme(),
+    withClientProvider({
+      createIdentity: true,
+      createSpace: true,
+      types: [Pipeline.Pipeline, Tag.Tag],
+      onCreateSpace: async ({ space }) => {
+        space.db.add(Tag.make({ label: 'Tag 1' }));
+        space.db.add(Tag.make({ label: 'Tag 2' }));
+        space.db.add(Tag.make({ label: 'Tag 3' }));
+      },
+    }),
+  ],
+  parameters: {
+    layout: 'centered',
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/components/ObjectDetails/BaseObjectSettings.tsx

@@ -0,0 +1,122 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import React, { type PropsWithChildren, useCallback, useMemo } from 'react';
+
+import { DXN, Obj, type Ref, Tag, Type } from '@dxos/echo';
+import { type JsonPath, splitJsonPath } from '@dxos/echo/internal';
+import { invariant } from '@dxos/invariant';
+import { type ThemedClassName } from '@dxos/react-ui';
+import { Form, omitId } from '@dxos/react-ui-form';
+import { isNonNullable } from '@dxos/util';
+
+import { meta as pluginMeta } from '../../meta';
+
+// TODO(wittjosiah): Would be nice to control order when extending so this isn't always first/last.
+const BaseSchema = Schema.Struct({
+  tags: Schema.Array(Type.Ref(Tag.Tag)).pipe(Schema.optional),
+});
+
+export type BaseObjectSettingsProps = ThemedClassName<
+  PropsWithChildren<{
+    object: Obj.Unknown;
+  }>
+>;
+
+// TODO(wittjosiah): Reconcile w/ ObjectDetailsPanel.
+export const BaseObjectSettings = ({ classNames, children, object }: BaseObjectSettingsProps) => {
+  const db = Obj.getDatabase(object);
+
+  const formSchema = useMemo(() => {
+    return Function.pipe(
+      Obj.getSchema(object),
+      Option.fromNullable,
+      Option.map((schema) => BaseSchema.pipe(Schema.extend(schema))),
+      Option.getOrUndefined,
+    );
+  }, [object]);
+
+  const meta = Obj.getMeta(object);
+  const tags = (meta.tags ?? []).map((tag) => db?.makeRef(DXN.parse(tag))).filter(isNonNullable);
+  const values = useMemo(
+    () => ({
+      tags,
+      ...object,
+    }),
+    [object, tags],
+  );
+
+  const handleCreate = useCallback((schema: Type.Entity.Any, values: any) => {
+    invariant(db);
+    invariant(Type.isObjectSchema(schema));
+    const newObject = db.add(Obj.make(schema, values));
+    if (Obj.instanceOf(Tag.Tag, newObject)) {
+      Obj.change(object, (obj) => {
+        Obj.getMeta(obj).tags = [...(Obj.getMeta(obj).tags ?? []), Obj.getDXN(newObject).toString()];
+      });
+    }
+  }, []);
+
+  // TODO(wittjosiah): Use FormRootProps type.
+  const handleChange = useCallback(
+    (
+      { tags, ...values }: Schema.Schema.Type<typeof formSchema>,
+      { isValid, changed }: { isValid: boolean; changed: Record<JsonPath, boolean> },
+    ) => {
+      if (!isValid) {
+        return;
+      }
+
+      const changedPaths = Object.keys(changed).filter((path) => changed[path as JsonPath]) as JsonPath[];
+
+      // Handle tags separately using Obj.change.
+      const hasTagsChange = changedPaths.some((path) => splitJsonPath(path)[0] === 'tags');
+      if (hasTagsChange) {
+        Obj.change(object, (obj) => {
+          Obj.getMeta(obj).tags = tags?.map((tag: Ref.Ref<Tag.Tag>) => tag.dxn.toString()) ?? [];
+        });
+      }
+
+      // Handle other property changes.
+      const nonTagPaths = changedPaths.filter((path) => splitJsonPath(path)[0] !== 'tags');
+      if (nonTagPaths.length > 0) {
+        Obj.change(object, () => {
+          for (const path of nonTagPaths) {
+            const parts = splitJsonPath(path);
+            const value = Obj.getValue(values, parts);
+            Obj.setValue(object, parts, value);
+          }
+        });
+      }
+    },
+    [object],
+  );
+
+  if (!formSchema) {
+    return null;
+  }
+
+  return (
+    <Form.Root
+      schema={omitId(formSchema)}
+      values={values}
+      createOptionIcon='ph--plus--regular'
+      createOptionLabel={['add tag label', { ns: pluginMeta.id }]}
+      createInitialValuePath='label'
+      db={db}
+      onValuesChanged={handleChange}
+      onCreate={handleCreate}
+    >
+      <Form.Viewport>
+        <Form.Content classNames={classNames}>
+          <Form.FieldSet />
+          {children}
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
+  );
+};

package/src/components/{ObjectSettings → ObjectDetails}/ForeignKeys.tsx

@@ -4,14 +4,14 @@
 
 import React, { useCallback } from 'react';
 
-import { type ForeignKey } from '@dxos/echo-schema';
+import { type Key } from '@dxos/echo';
 import { IconButton, List, ListItem, useTranslation } from '@dxos/react-ui';
 
-import { SPACE_PLUGIN } from '../../meta';
+import { meta } from '../../meta';
 
 export type ForeignKeysProps = {
-  keys: ForeignKey[];
-  onDelete?: (key: ForeignKey) => void;
+  keys: Key.ForeignKey[];
+  onDelete?: (key: Key.ForeignKey) => void;
 };
 
 // TODO(wittjosiah): This is a clone of `TokenManager`. Consider a form variant for arrays of read-only objects.
@@ -26,19 +26,19 @@ export const ForeignKeys = ({ keys, onDelete }: ForeignKeysProps) => {
 };
 
 type KeyItemProps = {
-  forignKey: ForeignKey;
-  onDelete?: (key: ForeignKey) => void;
+  forignKey: Key.ForeignKey;
+  onDelete?: (key: Key.ForeignKey) => void;
 };
 
 const KeyItem = ({ forignKey, onDelete }: KeyItemProps) => {
-  const { t } = useTranslation(SPACE_PLUGIN);
+  const { t } = useTranslation(meta.id);
 
   const handleDelete = useCallback(() => {
     onDelete?.(forignKey);
   }, [forignKey, onDelete]);
 
   return (
-    <ListItem.Root classNames='px-2'>
+    <ListItem.Root classNames='pli-2'>
       <ListItem.Heading classNames='flex flex-col grow truncate'>
         <div>{forignKey.source}</div>
         <div className='text-description text-sm truncate'>{forignKey.id}</div>

package/src/components/ObjectDetails/ObjectDetails.tsx

@@ -0,0 +1,33 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, useMemo } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { type Obj } from '@dxos/echo';
+import { Toolbar } from '@dxos/react-ui';
+import { Layout } from '@dxos/react-ui';
+
+import { BaseObjectSettings } from './BaseObjectSettings';
+
+export type ObjectDetailsProps = SurfaceComponentProps<Obj.Unknown>;
+
+export const ObjectDetails = forwardRef<HTMLDivElement, ObjectDetailsProps>(
+  ({ role, subject: object }, forwardedRef) => {
+    const data = useMemo(() => ({ subject: object }), [object]);
+
+    return (
+      <Layout.Main toolbar role={role} ref={forwardedRef}>
+        <Toolbar.Root />
+        <BaseObjectSettings object={object}>
+          <Surface.Surface role='base-object-settings' data={data} />
+          <Surface.Surface role='object-settings' data={data} />
+          {/* TODO(wittjosiah): Remove (or add as surface)? */}
+          {/* <AdvancedObjectSettings object={object} /> */}
+        </BaseObjectSettings>
+      </Layout.Main>
+    );
+  },
+);

package/src/components/ObjectDetails/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ObjectDetails } from './ObjectDetails';
+
+export default ObjectDetails;

package/src/components/ObjectRenamePopover/ObjectRenamePopover.tsx

@@ -0,0 +1,52 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React, { useCallback, useRef, useState } from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { Button, Input, useTranslation } from '@dxos/react-ui';
+import { osTranslations } from '@dxos/ui-theme';
+
+import { meta } from '../../meta';
+
+export const OBJECT_RENAME_POPOVER = `${meta.id}/ObjectRenamePopover`;
+
+export const ObjectRenamePopover = ({ object }: { object: Obj.Unknown }) => {
+  const { t } = useTranslation(meta.id);
+  const doneButton = useRef<HTMLButtonElement>(null);
+  const [name, setName] = useState(Obj.getLabel(object));
+  const { invokePromise } = useOperationInvoker();
+
+  const handleDone = useCallback(() => {
+    try {
+      name && Obj.change(object, () => Obj.setLabel(object, name));
+    } catch (err) {
+      log.error('Failed to rename object', { err });
+    }
+    void invokePromise(LayoutOperation.UpdatePopover, { anchorId: '', state: false });
+  }, [object, name, invokePromise]);
+
+  return (
+    <div role='none' className='p-2 flex gap-2'>
+      <div role='none' className='flex-1'>
+        <Input.Root>
+          <Input.Label srOnly>{t('object name label')}</Input.Label>
+          <Input.TextInput
+            placeholder={t('object placeholder')}
+            value={name}
+            data-testid='spacePlugin.renameObject.input'
+            onChange={({ target: { value } }) => setName(value)}
+            onKeyDown={({ key }) => key === 'Enter' && doneButton.current?.click()}
+          />
+        </Input.Root>
+      </div>
+      <Button ref={doneButton} classNames='self-stretch' onClick={handleDone}>
+        {t('done label', { ns: osTranslations })}
+      </Button>
+    </div>
+  );
+};

package/src/components/ObjectRenamePopover/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './ObjectRenamePopover';

package/src/components/RecordArticle.stories.tsx

@@ -0,0 +1,116 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Surface } from '@dxos/app-framework/ui';
+import { Filter, Obj, Ref, Relation, type Type } from '@dxos/echo';
+import { faker } from '@dxos/random';
+import { useQuery } from '@dxos/react-client/echo';
+import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
+import { withTheme } from '@dxos/react-ui/testing';
+import { Card } from '@dxos/react-ui-mosaic';
+import { Json } from '@dxos/react-ui-syntax-highlighter';
+import { type ValueGenerator, createAsyncGenerator } from '@dxos/schema/testing';
+import { translations as shellTranslations } from '@dxos/shell/react';
+import { render } from '@dxos/storybook-utils';
+import { HasSubject, Organization, Person, Task } from '@dxos/types';
+
+import { translations } from '../translations';
+
+import { RecordArticle } from './RecordArticle';
+
+faker.seed(1);
+const generator: ValueGenerator = faker as any;
+
+const DefaultStory = () => {
+  const { space } = useClientStory();
+  const [object] = useQuery(space?.db, Filter.type(Organization.Organization));
+  if (!object) {
+    return null;
+  }
+
+  return <RecordArticle subject={object} />;
+};
+
+const meta = {
+  title: 'plugins/plugin-space/RecordArticle',
+  component: RecordArticle as any,
+  render: render(DefaultStory),
+  decorators: [
+    withTheme(),
+    // TODO(wittjosiah): Try to write story which does not depend on plugin manager.
+    withPluginManager({
+      capabilities: [
+        Capability.contributes(Capabilities.ReactSurface, [
+          Surface.create({
+            id: 'section',
+            role: 'section',
+            component: ({ data }) => (
+              <Card.Root>
+                <Json classNames='text-sm' data={data} />
+              </Card.Root>
+            ),
+          }),
+          Surface.create({
+            id: 'card',
+            role: 'card',
+            component: ({ data }) => (
+              <Card.Root>
+                <Json classNames='text-sm' data={data} />
+              </Card.Root>
+            ),
+          }),
+        ]),
+      ],
+    }),
+    // TODO(burdon): Use plugin.
+    withClientProvider({
+      createIdentity: true,
+      createSpace: true,
+      types: [Organization.Organization, Person.Person, Task.Task, HasSubject.HasSubject],
+      onCreateSpace: async ({ space }) => {
+        const org = space.db.add(
+          Obj.make(Organization.Organization, {
+            name: 'DXOS',
+          }),
+        );
+        const task = space.db.add(
+          Obj.make(Task.Task, {
+            title: 'Task',
+          }),
+        );
+        space.db.add(
+          Relation.make(HasSubject.HasSubject, {
+            [Relation.Source]: task,
+            [Relation.Target]: org,
+            completedAt: new Date().toISOString(),
+          }),
+        );
+        const objectGenerator = createAsyncGenerator(generator, Person.Person as Type.Obj.Any, {
+          db: space?.db,
+          force: true,
+        });
+        await objectGenerator.createObjects(3).then((objects) => {
+          objects.forEach((object) => {
+            object.organization = Ref.make(org);
+          });
+        });
+      },
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations: [...translations, ...shellTranslations],
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/components/RecordArticle.tsx

@@ -0,0 +1,124 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { type Database, Entity, Filter, Obj, Ref, Relation } from '@dxos/echo';
+import { useQuery } from '@dxos/react-client/echo';
+import { Layout, ScrollArea, useTranslation } from '@dxos/react-ui';
+import { Masonry } from '@dxos/react-ui-masonry';
+import { Card as MosaicCard } from '@dxos/react-ui-mosaic';
+import { mx } from '@dxos/ui-theme';
+import { isNonNullable } from '@dxos/util';
+
+import { meta } from '../meta';
+
+export const RecordArticle = ({ role, subject }: SurfaceComponentProps) => {
+  const { t } = useTranslation(meta.id);
+  const db = Obj.getDatabase(subject);
+  const data = useMemo(() => ({ subject }), [subject]);
+  const related = useRelatedObjects(db, subject, {
+    references: true,
+    relations: true,
+  });
+  const singleColumn = related.length === 1;
+
+  return (
+    <Layout.Main role={role}>
+      <ScrollArea.Root orientation='vertical'>
+        <ScrollArea.Viewport classNames={mx('p-4 gap-4')}>
+          <div role='none' className={mx('flex is-full card-max-width')}>
+            <Surface.Surface role='section' data={data} limit={1} />
+          </div>
+
+          {related.length > 0 && (
+            <div role='none' className={mx('flex flex-col gap-1', singleColumn ? 'card-max-width' : 'is-full')}>
+              <label className='mbs-2 text-sm text-description'>{t('related objects label')}</label>
+              <Masonry.Root<Entity.Unknown>
+                items={related}
+                render={Card}
+                columnCount={singleColumn ? 1 : undefined}
+                intrinsicHeight
+              />
+            </div>
+          )}
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
+    </Layout.Main>
+  );
+};
+
+const Card = ({ data: subject }: { data: Entity.Unknown }) => {
+  const data = useMemo(() => ({ subject }), [subject]);
+  return (
+    <MosaicCard.Root>
+      <MosaicCard.Toolbar>
+        <span />
+        <MosaicCard.Title>{Entity.getLabel(subject)}</MosaicCard.Title>
+      </MosaicCard.Toolbar>
+      <Surface.Surface role='card--content' data={data} limit={1} />
+    </MosaicCard.Root>
+  );
+};
+
+// TODO(wittjosiah): This is a hack. ECHO needs to have a back reference index to easily query for related objects.
+const useRelatedObjects = (
+  db?: Database.Database,
+  record?: Obj.Unknown,
+  options: { references?: boolean; relations?: boolean } = {},
+) => {
+  const objects = useQuery(db, Filter.everything());
+  return useMemo(() => {
+    if (!record) {
+      return [];
+    }
+
+    const related: Entity.Unknown[] = [];
+
+    // TODO(burdon): Change Person => Organization to relations.
+    if (options.references) {
+      const getReferences = (obj: Entity.Unknown): Ref.Unknown[] => {
+        return Object.getOwnPropertyNames(obj)
+          .map((name) => obj[name as keyof Obj.Unknown])
+          .filter((value) => Ref.isRef(value)) as Ref.Unknown[];
+      };
+
+      const references = getReferences(record);
+      const referenceTargets = references.map((ref) => ref.target).filter(isNonNullable);
+      const referenceSources = objects.filter((obj) => {
+        const refs = getReferences(obj);
+        return refs.some((ref) => ref.target === record);
+      });
+
+      related.push(...referenceTargets, ...referenceSources);
+    }
+
+    if (options.relations) {
+      // TODO(dmaretskyi): Workaround until https://github.com/dxos/dxos/pull/10100 lands.
+      const isValidRelation = (obj: Relation.Unknown) => {
+        try {
+          return Relation.isRelation(obj) && Relation.getSource(obj) && Relation.getTarget(obj);
+        } catch {
+          return false;
+        }
+      };
+
+      const relations = objects.filter(Relation.isRelation).filter((obj) => isValidRelation(obj));
+      const targetObjects = relations
+        .filter((relation) => Relation.getTarget(relation) === record)
+        .map((relation) => Relation.getSource(relation));
+      const sourceObjects = relations
+        .filter((relation) => Relation.getSource(relation) === record)
+        .map((relation) => Relation.getTarget(relation));
+
+      related.push(...targetObjects, ...sourceObjects);
+    }
+
+    return related;
+  }, [record, objects]);
+};
+
+export default RecordArticle;