@dxos/plugin-pipeline 0.8.4-main.2244d791bb → 0.8.4-main.3fbcb4aa9b

package/src/capabilities/react-surface/react-surface.tsx

@@ -1,50 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import React from 'react';
-
-import { Capabilities, Capability } from '@dxos/app-framework';
-import { Surface } from '@dxos/app-framework/ui';
-import { InvocationTraceContainer } from '@dxos/devtools';
-import { Obj } from '@dxos/echo';
-import { Layout } from '@dxos/react-ui';
-import { Pipeline } from '@dxos/types';
-
-import { PipelineContainer, PipelineObjectSettings } from '../../components';
-import { meta } from '../../meta';
-
-export default Capability.makeModule(() =>
-  Effect.succeed(
-    Capability.contributes(Capabilities.ReactSurface, [
-      Surface.create({
-        id: meta.id,
-        role: 'article',
-        filter: (data): data is { subject: Pipeline.Pipeline } => Obj.instanceOf(Pipeline.Pipeline, data.subject),
-        component: ({ data, role }) => <PipelineContainer role={role} subject={data.subject} />,
-      }),
-      Surface.create({
-        id: `${meta.id}/companion/invocations`,
-        role: 'article',
-        filter: (data): data is { companionTo: Pipeline.Pipeline } =>
-          Obj.instanceOf(Pipeline.Pipeline, data.companionTo) && data.subject === 'invocations',
-        component: ({ data, role }) => {
-          const db = Obj.getDatabase(data.companionTo);
-          // TODO(wittjosiah): Filter the invocations to those relevant to the project.
-          return (
-            <Layout.Main role={role}>
-              <InvocationTraceContainer db={db} detailAxis='block' />
-            </Layout.Main>
-          );
-        },
-      }),
-      Surface.create({
-        id: `${meta.id}/object-settings`,
-        role: 'object-settings',
-        filter: (data): data is { subject: Pipeline.Pipeline } => Obj.instanceOf(Pipeline.Pipeline, data.subject),
-        component: ({ data }) => <PipelineObjectSettings pipeline={data.subject} />,
-      }),
-    ]),
-  ),
-);

package/src/components/PipelineComponent.tsx

@@ -1,186 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Atom, type Registry, useAtomValue } from '@effect-atom/atom-react';
-import { createContext } from '@radix-ui/react-context';
-import * as Schema from 'effect/Schema';
-import React, { type FC, type PropsWithChildren, useMemo } from 'react';
-
-import { Obj, Query } from '@dxos/echo';
-import { AtomObj, AtomQuery } from '@dxos/echo-atom';
-import { getQueryTarget } from '@dxos/plugin-space';
-import { getSpace, isSpace } from '@dxos/react-client/echo';
-import { Toolbar, type ToolbarRootProps, useTranslation } from '@dxos/react-ui';
-import { Board, type BoardModel, useBoard, useEventHandlerAdapter } from '@dxos/react-ui-mosaic';
-import { type ProjectionModel } from '@dxos/schema';
-import { Pipeline, type Pipeline as PipelineType } from '@dxos/types';
-
-import { meta } from '../meta';
-
-import { PipelineColumn } from './PipelineColumn';
-
-type ItemProps = {
-  item: Obj.Unknown;
-  projectionModel?: ProjectionModel;
-};
-
-const itemNoOp = ({ item }: ItemProps) => <span>{item.id}</span>;
-
-type PipelineContextValue = {
-  Item: FC<ItemProps>;
-  // TODO(wittjosiah): Support adding items.
-  //   If the created item doesn't match the current query, it will not be visible.
-  // onAddItem?: (schema: Schema.Schema.AnyNoContext) => void;
-  onAddColumn?: () => void;
-};
-
-//
-// Root
-//
-
-type PipelineRootProps = PropsWithChildren<
-  PipelineContextValue & {
-    model: BoardModel<PipelineType.Column, Obj.Unknown>;
-  }
->;
-
-const PIPELINE_ROOT = 'Pipeline.Root';
-
-const [PipelineRootContext, usePipeline] = createContext<PipelineContextValue>(PIPELINE_ROOT, {
-  Item: itemNoOp,
-});
-
-const PipelineRoot = ({ model, children, ...contextValue }: PipelineRootProps) => (
-  <PipelineRootContext {...contextValue}>
-    <Board.Root model={model}>{children}</Board.Root>
-  </PipelineRootContext>
-);
-
-PipelineRoot.displayName = PIPELINE_ROOT;
-
-//
-// usePipelineBoardModel
-//
-
-const emptyColumnsAtom = Atom.make(() => [] as PipelineType.Column[]);
-const emptyItemsAtom = Atom.make(() => [] as Obj.Unknown[]);
-const emptyPipelineModel: BoardModel<PipelineType.Column, Obj.Unknown> = {
-  getColumnId: (data) => (data as PipelineType.Column).view.dxn.toString(),
-  getItemId: (data) => (data as Obj.Unknown).id,
-  isColumn: (obj: unknown): obj is PipelineType.Column => Schema.is(Pipeline.Column)(obj),
-  isItem: (obj): obj is Obj.Unknown => Obj.isObject(obj),
-  columns: emptyColumnsAtom,
-  items: () => emptyItemsAtom,
-  getColumns: () => [],
-  getItems: () => [],
-};
-
-const usePipelineBoardModel = (
-  pipeline: PipelineType.Pipeline | undefined,
-  registry: Registry.Registry,
-): BoardModel<PipelineType.Column, Obj.Unknown> =>
-  useMemo<BoardModel<PipelineType.Column, Obj.Unknown>>(() => {
-    if (pipeline == null) {
-      return emptyPipelineModel;
-    }
-    const space = getSpace(pipeline);
-    const columnsAtom = AtomObj.makeProperty(pipeline, 'columns');
-    const columnAtomFamily = Atom.family<string, Atom.Atom<PipelineType.Column | undefined>>((viewKey: string) =>
-      Atom.make((get) => {
-        const columns = get(columnsAtom);
-        return columns.find((c) => c.view.dxn.toString() === viewKey);
-      }),
-    );
-    const itemsAtomFamily = Atom.family<string, Atom.Atom<Obj.Unknown[]>>((viewKey: string) =>
-      Atom.make((get) => {
-        const column = get(columnAtomFamily(viewKey));
-        if (column == null) {
-          return [];
-        }
-        const viewSnapshot = get(AtomObj.make(column.view));
-        if (!viewSnapshot?.query?.ast) {
-          return [];
-        }
-        const query = Query.fromAst(JSON.parse(JSON.stringify(viewSnapshot.query.ast)));
-        const queryTarget = space ? getQueryTarget(query.ast, space) : undefined;
-        if (!queryTarget) {
-          return [];
-        }
-        const raw = get(AtomQuery.make(queryTarget, query));
-        return isSpace(queryTarget) ? raw : [...raw].reverse();
-      }),
-    );
-    return {
-      getColumnId: (data) => (data as PipelineType.Column).view.dxn.toString(),
-      getItemId: (data) => (data as Obj.Unknown).id,
-      isColumn: (obj: unknown): obj is PipelineType.Column => Schema.is(Pipeline.Column)(obj),
-      isItem: (obj: unknown): obj is Obj.Unknown => Obj.isObject(obj),
-      columns: columnsAtom,
-      items: (column) => itemsAtomFamily(column.view.dxn.toString()),
-      getColumns: () => [...registry.get(columnsAtom)],
-      getItems: (column) => registry.get(itemsAtomFamily(column.view.dxn.toString())) ?? [],
-    };
-  }, [pipeline, registry]);
-
-//
-// Content
-//
-
-const PIPELINE_CONTENT_NAME = 'Pipeline.Content';
-
-type PipelineContentProps = {
-  pipeline: PipelineType.Pipeline;
-};
-
-const PipelineContent = ({ pipeline }: PipelineContentProps) => {
-  const { model } = useBoard(PIPELINE_CONTENT_NAME);
-  const columns = useAtomValue(model.columns);
-  const eventHandler = useEventHandlerAdapter<PipelineType.Column, Obj.Unknown>({
-    id: pipeline.id,
-    // TODO(wittjosiah): Cast because columns array is readonly.
-    items: columns as any,
-    getId: model.getColumnId,
-    get: (data) => data as unknown as Obj.Unknown,
-    make: (object) => object as unknown as PipelineType.Column,
-    canDrop: ({ source }) => model.isColumn(source.data),
-    onChange: (mutate) => Obj.change(pipeline, (p) => mutate(p.columns)),
-  });
-
-  return <Board.Content id='pipeline' eventHandler={eventHandler} Tile={PipelineColumn} />;
-};
-
-PipelineContent.displayName = PIPELINE_CONTENT_NAME;
-
-//
-// Toolbar
-//
-
-const PIPELINE_TOOLBAR_NAME = 'Pipeline.Toolbar';
-
-export const PipelineToolbar = (props: ToolbarRootProps) => {
-  const { t } = useTranslation(meta.id);
-  const { onAddColumn } = usePipeline(PIPELINE_TOOLBAR_NAME);
-
-  return (
-    <Toolbar.Root {...props}>
-      <Toolbar.IconButton icon='ph--plus--regular' iconOnly label={t('add column label')} onClick={onAddColumn} />
-    </Toolbar.Root>
-  );
-};
-
-PipelineToolbar.displayName = PIPELINE_TOOLBAR_NAME;
-
-//
-// Project
-//
-
-export const PipelineComponent = {
-  Root: PipelineRoot,
-  Content: PipelineContent,
-  Toolbar: PipelineToolbar,
-};
-
-export { usePipeline, usePipelineBoardModel };
-
-export type { ItemProps, PipelineContextValue, PipelineRootProps };

package/src/components/PipelineContainer.stories.tsx

@@ -1,226 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type Meta, type StoryObj } from '@storybook/react-vite';
-import * as Effect from 'effect/Effect';
-import React from 'react';
-
-import { withPluginManager } from '@dxos/app-framework/testing';
-import { Filter, Ref } from '@dxos/client/echo';
-import { Obj, Query, Tag, Type } from '@dxos/echo';
-import { ClientPlugin } from '@dxos/plugin-client';
-import { InboxPlugin } from '@dxos/plugin-inbox';
-import { PreviewPlugin } from '@dxos/plugin-preview';
-import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
-import { faker } from '@dxos/random';
-import { useDatabase, useQuery } from '@dxos/react-client/echo';
-import { withTheme } from '@dxos/react-ui/testing';
-import { translations as stackTranslations } from '@dxos/react-ui-stack';
-import { Stack } from '@dxos/react-ui-stack';
-import { Collection, View } from '@dxos/schema';
-import { createObjectFactory } from '@dxos/schema/testing';
-import { Message, Organization, Person, Pipeline, Task } from '@dxos/types';
-
-import { translations } from '../translations';
-
-import { PipelineContainer } from './PipelineContainer';
-import { PipelineObjectSettings } from './PipelineSettings';
-
-faker.seed(0);
-
-const DefaultStory = () => {
-  const db = useDatabase();
-  const pipelines = useQuery(db, Filter.type(Pipeline.Pipeline));
-  const pipeline = pipelines[0];
-
-  if (!pipeline) {
-    return <p>Loading…</p>;
-  }
-
-  return (
-    <Stack orientation='horizontal' size='split' rail={false} classNames='pli-0 bs-full'>
-      <PipelineContainer role='article' subject={pipeline} />
-      <PipelineObjectSettings pipeline={pipeline} classNames='border-is border-separator' />
-    </Stack>
-  );
-};
-
-const meta = {
-  title: 'plugins/plugin-pipeline/PipelineContainer',
-  render: DefaultStory,
-  decorators: [
-    withTheme(),
-    withPluginManager({
-      plugins: [
-        ...corePlugins(),
-        StorybookPlugin({}),
-        ClientPlugin({
-          types: [
-            Tag.Tag,
-            Pipeline.Pipeline,
-            View.View,
-            Collection.Collection,
-            Organization.Organization,
-            Task.Task,
-            Person.Person,
-            Message.Message,
-          ],
-          onClientInitialized: ({ client }) =>
-            Effect.gen(function* () {
-              yield* Effect.promise(() => client.halo.createIdentity());
-              yield* Effect.promise(() => client.spaces.waitUntilReady());
-              const space = client.spaces.default;
-              yield* Effect.promise(() => space.waitUntilReady());
-
-              const tag = space.db.add(Tag.make({ label: 'important', hue: 'green' }));
-              const tagDxn = Obj.getDXN(tag).toString();
-
-              // Create a view for Contacts.
-              const personView = View.make({
-                query: Query.select(Filter.type(Person.Person)),
-                jsonSchema: Type.toJsonSchema(Person.Person),
-              });
-
-              // Create a view for Organizations.
-              const organizationView = View.make({
-                query: Query.select(Filter.type(Organization.Organization)).select(Filter.tag(tagDxn)),
-                jsonSchema: Type.toJsonSchema(Organization.Organization),
-              });
-
-              // Create a view for Tasks.
-              const taskView = View.make({
-                query: Query.select(Filter.type(Task.Task)).select(Filter.tag(tagDxn)),
-                jsonSchema: Type.toJsonSchema(Task.Task),
-              });
-
-              // Create a view for Project-Projects.
-              const projectView = View.make({
-                query: Query.select(Filter.type(Pipeline.Pipeline)),
-                jsonSchema: Type.toJsonSchema(Pipeline.Pipeline),
-              });
-
-              // Create a view for Messages.
-              const messageQueue = space.queues.create();
-              const messageView = View.make({
-                query: Query.select(Filter.type(Message.Message)).options({
-                  queues: [messageQueue.dxn.toString()],
-                }),
-                jsonSchema: Type.toJsonSchema(Message.Message),
-              });
-
-              // Create pipline with columns.
-              const pipeline = Pipeline.make({
-                columns: [
-                  {
-                    name: 'Contacts',
-                    view: Ref.make(personView),
-                    order: [],
-                  },
-                  {
-                    name: 'Organizations',
-                    view: Ref.make(organizationView),
-                    order: [],
-                  },
-                  {
-                    name: 'Tasks',
-                    view: Ref.make(taskView),
-                    order: [],
-                  },
-                  {
-                    name: 'Projects',
-                    view: Ref.make(projectView),
-                    order: [],
-                  },
-                  {
-                    name: 'Messages',
-                    view: Ref.make(messageView),
-                    order: [],
-                  },
-                ],
-              });
-
-              // Add pipeline to space.
-              space.db.add(pipeline);
-
-              // Generate sample Organizations
-              Array.from({ length: 20 }).forEach(() => {
-                const org = Obj.make(
-                  Organization.Organization,
-                  {
-                    name: faker.company.name(),
-                    website: faker.internet.url(),
-                    description: faker.lorem.paragraph(),
-                    image: faker.image.url(),
-                  },
-                  {
-                    tags: faker.datatype.boolean() ? [Obj.getDXN(tag).toString()] : [],
-                  },
-                );
-                space.db.add(org);
-              });
-
-              // Generate sample Tasks
-              Array.from({ length: 20 }).forEach(() => {
-                const task = Obj.make(
-                  Task.Task,
-                  {
-                    title: faker.lorem.sentence(),
-                    status: faker.helpers.arrayElement(['todo', 'in-progress', 'done']) as any,
-                    priority: faker.helpers.arrayElement(['low', 'medium', 'high']) as any,
-                  },
-                  {
-                    tags: faker.datatype.boolean() ? [Obj.getDXN(tag).toString()] : [],
-                  },
-                );
-                space.db.add(task);
-              });
-
-              // Generate sample Contacts
-              const factory = createObjectFactory(space.db, faker as any);
-              yield* Effect.promise(() => factory([{ type: Person.Person, count: 12 }]));
-
-              // Generate sample Projects
-              Array.from({ length: 20 }).forEach(() => {
-                const nestedProject = Pipeline.make({
-                  name: faker.commerce.productName(),
-                  description: faker.lorem.sentence(),
-                });
-                space.db.add(nestedProject);
-              });
-
-              // Generate sample Messages
-              const messages = Array.from({ length: 20 }).map(() => {
-                const message = Obj.make(Message.Message, {
-                  created: faker.date.recent().toISOString(),
-                  sender: { role: 'user' },
-                  blocks: [
-                    {
-                      _tag: 'text' as const,
-                      text: faker.lorem.sentences(2),
-                    },
-                  ],
-                });
-                return message;
-              });
-
-              yield* Effect.promise(() => messageQueue.append(messages));
-            }),
-        }),
-
-        InboxPlugin(),
-        PreviewPlugin(),
-      ],
-    }),
-  ],
-  parameters: {
-    layout: 'fullscreen',
-    translations: [...translations, ...stackTranslations],
-  },
-} satisfies Meta<typeof PipelineContainer>;
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-export const Default: Story = {};

package/src/components/PipelineContainer.tsx

@@ -1,61 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import React, { useCallback } from 'react';
-
-import { Capabilities } from '@dxos/app-framework';
-import { useCapability } from '@dxos/app-framework/ui';
-import { useOperationInvoker } from '@dxos/app-framework/ui';
-import { Surface } from '@dxos/app-framework/ui';
-import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
-import { Obj } from '@dxos/echo';
-import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from '@dxos/plugin-deck/types';
-import { Layout } from '@dxos/react-ui';
-import { useAttention } from '@dxos/react-ui-attention';
-import { type Pipeline as PipelineType } from '@dxos/types';
-
-import { type ItemProps, PipelineComponent, usePipelineBoardModel } from './PipelineComponent';
-
-export type PipelineContainerProps = SurfaceComponentProps<PipelineType.Pipeline>;
-
-export const PipelineContainer = ({ role, subject: pipeline }: PipelineContainerProps) => {
-  const registry = useCapability(Capabilities.AtomRegistry);
-  const model = usePipelineBoardModel(pipeline, registry);
-  const { invokePromise } = useOperationInvoker();
-  const attendableId = Obj.getDXN(pipeline).toString();
-  const { hasAttention } = useAttention(attendableId);
-
-  const handleColumnAdd = useCallback(
-    () =>
-      invokePromise(DeckOperation.ChangeCompanion, {
-        primary: attendableId,
-        companion: `${attendableId}${ATTENDABLE_PATH_SEPARATOR}settings`,
-      }),
-    [invokePromise, attendableId],
-  );
-
-  return (
-    <Layout.Main role={role} toolbar>
-      <PipelineComponent.Root Item={PipelineItem} model={model} onAddColumn={handleColumnAdd}>
-        <PipelineComponent.Toolbar disabled={!hasAttention} />
-        <PipelineComponent.Content pipeline={pipeline} />
-      </PipelineComponent.Root>
-    </Layout.Main>
-  );
-};
-
-const PipelineItem = ({ item, projectionModel }: ItemProps) => {
-  return (
-    <Surface.Surface
-      role='card--content'
-      data={{
-        subject: item,
-        projection: projectionModel,
-      }}
-      limit={1}
-    />
-  );
-};
-
-export default PipelineContainer;

package/src/types/PipelineAction.ts

@@ -1,29 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { Capability } from '@dxos/app-framework';
-import { Operation } from '@dxos/operation';
-import { SpaceSchema } from '@dxos/react-client/echo';
-import { Collection } from '@dxos/schema';
-
-import { meta } from '../meta';
-
-const PIPELINE_OPERATION = `${meta.id}/operation`;
-
-export namespace PipelineOperation {
-  export const OnCreateSpace = Operation.make({
-    meta: { key: `${PIPELINE_OPERATION}/on-create-space`, name: 'On Create Space' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-        rootCollection: Collection.Collection,
-        isDefault: Schema.optional(Schema.Boolean),
-      }),
-      output: Schema.Void,
-    },
-  });
-}