@dxos/plugin-kanban 0.7.4 → 0.7.5-main.499c70c

package/dist/types/src/components/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU;;GAAqC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/index.ts"],"names":[],"mappings":"AAIA,cAAc,mBAAmB,CAAC"}

package/dist/types/src/translations.d.ts

@@ -1,5 +1,36 @@
 declare const _default: {
     'en-US': {
+        [x: string]: {
+            'typename label': string;
+            'plugin name'?: undefined;
+            'kanban title label'?: undefined;
+            'kanban title placeholder'?: undefined;
+            'column title label'?: undefined;
+            'column title placeholder'?: undefined;
+            'item title label'?: undefined;
+            'item title placeholder'?: undefined;
+            'add column label'?: undefined;
+            'add item label'?: undefined;
+            'delete column label'?: undefined;
+            'delete item label'?: undefined;
+            'create kanban label'?: undefined;
+            'card field deleted label'?: undefined;
+        } | {
+            'plugin name': string;
+            'kanban title label': string;
+            'kanban title placeholder': string;
+            'column title label': string;
+            'column title placeholder': string;
+            'item title label': string;
+            'item title placeholder': string;
+            'add column label': string;
+            'add item label': string;
+            'delete column label': string;
+            'delete item label': string;
+            'create kanban label': string;
+            'card field deleted label': string;
+            'typename label'?: undefined;
+        };
         "dxos.org/plugin/kanban": {
             'plugin name': string;
             'kanban title label': string;
@@ -13,6 +44,7 @@ declare const _default: {
             'delete column label': string;
             'delete item label': string;
             'create kanban label': string;
+            'card field deleted label': string;
         };
     };
 }[];

package/dist/types/src/translations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/translations.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAMA,wBAmBE"}
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/translations.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,wBAuBE"}

package/dist/types/src/types.d.ts

@@ -0,0 +1,61 @@
+import type { IntentResolverProvides, MetadataRecordsProvides, SurfaceProvides, TranslationsProvides } from '@dxos/app-framework';
+import { S } from '@dxos/echo-schema';
+import { type SchemaProvides } from '@dxos/plugin-space';
+import { type Space } from '@dxos/react-client/echo';
+import { KanbanType } from '@dxos/react-ui-kanban';
+/**
+ * Kanban data model.
+ * A Kanban board is a collection of columns, each of which contains a collection of items.
+ * The layout of columns and items is controlled by models.
+ * The underlying data model may be represented by direct object relationships
+ * (e.g., a column object containing an array of ordered items) or projections constructed
+ * by the model (e.g., a query of items based on metadata within a column object).
+ */
+export declare namespace KanbanAction {
+    const Create_base: S.TaggedClass<Create, "dxos.org/plugin/kanban/action/create", {
+        readonly _tag: S.tag<"dxos.org/plugin/kanban/action/create">;
+    } & {
+        input: S.Struct<{
+            name: S.optional<typeof S.String>;
+            space: S.Schema<Space, Space, never>;
+        }>;
+        output: S.Struct<{
+            object: typeof KanbanType;
+        }>;
+    }>;
+    export class Create extends Create_base {
+    }
+    const DeleteCardField_base: S.TaggedClass<DeleteCardField, "dxos.org/plugin/kanban/action/delete-card-field", {
+        readonly _tag: S.tag<"dxos.org/plugin/kanban/action/delete-card-field">;
+    } & {
+        input: S.Struct<{
+            kanban: typeof KanbanType;
+            fieldId: typeof S.String;
+            deletionData: S.optional<S.Struct<{
+                field: S.mutable<S.Struct<{
+                    id: typeof S.String;
+                    path: S.Schema<import("@dxos/echo-schema").JsonPath, import("@dxos/echo-schema").JsonPath, never>;
+                    visible: S.optional<typeof S.Boolean>;
+                    size: S.optional<typeof S.Number>;
+                    referencePath: S.optional<S.Schema<import("@dxos/echo-schema").JsonPath, import("@dxos/echo-schema").JsonPath, never>>;
+                }>>;
+                props: typeof S.Any;
+                index: typeof S.Number;
+            }>>;
+        }>;
+        output: typeof S.Void;
+    }>;
+    export class DeleteCardField extends DeleteCardField_base {
+    }
+    export {};
+}
+export type KanbanPluginProvides = SurfaceProvides & IntentResolverProvides & MetadataRecordsProvides & TranslationsProvides & SchemaProvides;
+export interface KanbanModel {
+    root: KanbanType;
+}
+export type Location = {
+    idx?: number;
+};
+export declare const isKanban: (object: unknown) => object is KanbanType;
+export declare const createKanban: (space: Space) => Promise<KanbanType>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACvB,eAAe,EACf,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AACtC,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAMnD;;;;;;;GAOG;AAEH,yBAAiB,YAAY,CAAC;;;;;;;;;;;;IAG5B,MAAM,OAAO,MAAO,SAAQ,WAQ1B;KAAG;;;;;;;;;+BA5B+B,EAAG,MAAM;0BAC/C,EAAG,MAAM;6BAAyC,EAAG,QAAQ,QAC5D,EAAG,OAAO;0BAAY,EAAI,QAAO,QAAO,EAAG,MAAM;mCAC/B,EAAG,QAAQ,CAAC,EAAE,MAAM;;;;;;;;IA2BrC,MAAM,OAAO,eAAgB,SAAQ,oBAgBnC;KAAG;;CACN;AAED,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAChD,sBAAsB,GACtB,uBAAuB,GACvB,oBAAoB,GACpB,cAAc,CAAC;AAUjB,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,QAAQ,WAAY,OAAO,KAAG,MAAM,IAAI,UAA4D,CAAC;AAElH,eAAO,MAAM,YAAY,UAAiB,KAAK,wBAG9C,CAAC"}

package/dist/types/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.7.2"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/plugin-kanban",
-  "version": "0.7.4",
+  "version": "0.7.5-main.499c70c",
   "description": "Kanban DXOS Surface plugin",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -40,41 +40,39 @@
     "src"
   ],
   "dependencies": {
-    "@dnd-kit/core": "^6.0.5",
-    "@dnd-kit/modifiers": "^6.0.0",
-    "@dnd-kit/sortable": "^7.0.1",
-    "@dnd-kit/utilities": "^3.2.0",
     "@effect/schema": "^0.75.5",
     "@preact/signals-core": "^1.6.0",
-    "@dxos/app-framework": "0.7.4",
-    "@dxos/async": "0.7.4",
-    "@dxos/echo-schema": "0.7.4",
-    "@dxos/plugin-client": "0.7.4",
-    "@dxos/plugin-graph": "0.7.4",
-    "@dxos/live-object": "0.7.4",
-    "@dxos/plugin-space": "0.7.4",
-    "@dxos/react-client": "0.7.4",
-    "@dxos/react-ui-editor": "0.7.4",
-    "@dxos/util": "0.7.4"
+    "@dxos/app-framework": "0.7.5-main.499c70c",
+    "@dxos/async": "0.7.5-main.499c70c",
+    "@dxos/echo-schema": "0.7.5-main.499c70c",
+    "@dxos/invariant": "0.7.5-main.499c70c",
+    "@dxos/plugin-client": "0.7.5-main.499c70c",
+    "@dxos/plugin-search": "0.7.5-main.499c70c",
+    "@dxos/plugin-graph": "0.7.5-main.499c70c",
+    "@dxos/random": "0.7.5-main.499c70c",
+    "@dxos/plugin-space": "0.7.5-main.499c70c",
+    "@dxos/react-client": "0.7.5-main.499c70c",
+    "@dxos/react-ui-form": "0.7.5-main.499c70c",
+    "@dxos/react-ui-kanban": "0.7.5-main.499c70c",
+    "@dxos/util": "0.7.5-main.499c70c",
+    "@dxos/react-ui-stack": "0.7.5-main.499c70c",
+    "@dxos/schema": "0.7.5-main.499c70c"
   },
   "devDependencies": {
-    "@phosphor-icons/react": "^2.1.5",
     "@types/react": "~18.2.0",
     "@types/react-dom": "~18.2.0",
     "react": "~18.2.0",
     "react-dom": "~18.2.0",
     "vite": "5.4.7",
-    "@dxos/random": "0.7.4",
-    "@dxos/react-ui": "0.7.4",
-    "@dxos/react-ui-theme": "0.7.4",
-    "@dxos/storybook-utils": "0.7.4"
+    "@dxos/react-ui": "0.7.5-main.499c70c",
+    "@dxos/react-ui-theme": "0.7.5-main.499c70c",
+    "@dxos/storybook-utils": "0.7.5-main.499c70c"
   },
   "peerDependencies": {
-    "@phosphor-icons/react": "^2.1.5",
     "react": "~18.2.0",
     "react-dom": "~18.2.0",
-    "@dxos/react-ui": "0.7.4",
-    "@dxos/react-ui-theme": "0.7.4"
+    "@dxos/react-ui": "0.7.5-main.499c70c",
+    "@dxos/react-ui-theme": "0.7.5-main.499c70c"
   },
   "publishConfig": {
     "access": "public"

package/src/KanbanPlugin.tsx

@@ -4,18 +4,17 @@
 
 import React from 'react';
 
-import { resolvePlugin, type PluginDefinition, parseIntentPlugin, NavigationAction } from '@dxos/app-framework';
-import { create } from '@dxos/live-object';
-import { parseClientPlugin } from '@dxos/plugin-client';
-import { type ActionGroup, createExtension, isActionGroup } from '@dxos/plugin-graph';
-import { SpaceAction } from '@dxos/plugin-space';
-import { loadObjectReferences } from '@dxos/react-client/echo';
+import { type PluginDefinition, createSurface, createIntent, createResolver } from '@dxos/app-framework';
+import { invariant } from '@dxos/invariant';
+import { getSpace, type Space } from '@dxos/react-client/echo';
+import { KanbanType, translations as kanbanTranslations } from '@dxos/react-ui-kanban';
+import { ViewProjection } from '@dxos/schema';
 
-import { KanbanMain } from './components';
+import { KanbanContainer } from './components';
+import KanbanViewEditor from './components/KanbanViewEditor';
 import meta, { KANBAN_PLUGIN } from './meta';
 import translations from './translations';
-import { KanbanColumnType, KanbanItemType, KanbanType } from './types';
-import { KanbanAction, type KanbanPluginProvides } from './types';
+import { isKanban, KanbanAction, type KanbanPluginProvides, createKanban } from './types';
 
 export const KanbanPlugin = (): PluginDefinition<KanbanPluginProvides> => {
   return {
@@ -24,87 +23,60 @@ export const KanbanPlugin = (): PluginDefinition<KanbanPluginProvides> => {
       metadata: {
         records: {
           [KanbanType.typename]: {
-            createObject: KanbanAction.CREATE,
+            createObject: (props: { name?: string; space: Space }) => createIntent(KanbanAction.Create, props),
             placeholder: ['kanban title placeholder', { ns: KANBAN_PLUGIN }],
             icon: 'ph--kanban--regular',
-            // TODO(wittjosiah): Move out of metadata.
-            loadReferences: (kanban: KanbanType) => loadObjectReferences(kanban, (kanban) => kanban.columns),
-          },
-          [KanbanColumnType.typename]: {
-            // TODO(wittjosiah): Move out of metadata.
-            loadReferences: (column: KanbanColumnType) => loadObjectReferences(column, (column) => column.items),
-          },
-          [KanbanItemType.typename]: {
-            // TODO(wittjosiah): Move out of metadata.
-            loadReferences: (item: KanbanItemType) => [], // loadObjectReferences(item, (item) => item.object),
           },
         },
       },
       echo: {
         schema: [KanbanType],
-        system: [KanbanColumnType, KanbanItemType],
-      },
-      translations,
-      graph: {
-        builder: (plugins) => {
-          const client = resolvePlugin(plugins, parseClientPlugin)?.provides.client;
-          const dispatch = resolvePlugin(plugins, parseIntentPlugin)?.provides.intent.dispatch;
-          if (!client || !dispatch) {
-            return [];
-          }
-
-          return createExtension({
-            id: KanbanAction.CREATE,
-            filter: (node): node is ActionGroup => isActionGroup(node) && node.id.startsWith(SpaceAction.ADD_OBJECT),
-            actions: ({ node }) => {
-              const id = node.id.split('/').at(-1);
-              const [spaceId, objectId] = id?.split(':') ?? [];
-              const space = client.spaces.get().find((space) => space.id === spaceId);
-              const object = objectId && space?.db.getObjectById(objectId);
-              const target = objectId ? object : space;
-              if (!target) {
-                return;
-              }
-
-              return [
-                {
-                  id: `${KANBAN_PLUGIN}/create/${node.id}`,
-                  data: async () => {
-                    await dispatch([
-                      { plugin: KANBAN_PLUGIN, action: KanbanAction.CREATE },
-                      { action: SpaceAction.ADD_OBJECT, data: { target } },
-                      { action: NavigationAction.OPEN },
-                    ]);
-                  },
-                  properties: {
-                    label: ['create kanban label', { ns: KANBAN_PLUGIN }],
-                    icon: 'ph--kanban--regular',
-                    testId: 'kanbanPlugin.createObject',
-                  },
-                },
-              ];
-            },
-          });
-        },
       },
+      translations: [...translations, ...kanbanTranslations],
       surface: {
-        component: ({ data, role }) => {
-          switch (role) {
-            case 'main':
-              return data.active instanceof KanbanType ? <KanbanMain kanban={data.active} /> : null;
-            default:
-              return null;
-          }
-        },
+        definitions: () => [
+          createSurface({
+            id: `${KANBAN_PLUGIN}/kanban`,
+            role: ['article', 'section'],
+            filter: (data): data is { subject: KanbanType } => isKanban(data.subject),
+            component: ({ data, role }) => <KanbanContainer kanban={data.subject} role={role} />,
+          }),
+          createSurface({
+            id: `${KANBAN_PLUGIN}/settings`,
+            role: 'complementary--settings',
+            filter: (data): data is { subject: KanbanType } => isKanban(data.subject),
+            component: ({ data }) => <KanbanViewEditor kanban={data.subject} />,
+          }),
+        ],
       },
       intent: {
-        resolver: (intent) => {
-          switch (intent.action) {
-            case KanbanAction.CREATE: {
-              return { data: create(KanbanType, { columns: [] }) };
+        resolvers: () => [
+          createResolver(KanbanAction.Create, async ({ space }) => ({
+            data: { object: await createKanban(space) },
+          })),
+          createResolver(KanbanAction.DeleteCardField, ({ kanban, fieldId, deletionData }, undo) => {
+            invariant(kanban.cardView);
+
+            const schema =
+              kanban.cardView.target &&
+              getSpace(kanban)?.db.schemaRegistry.getSchema(kanban.cardView.target.query.type);
+            invariant(schema);
+            const projection = new ViewProjection(schema, kanban.cardView.target!);
+
+            if (!undo) {
+              const { deleted, index } = projection.deleteFieldProjection(fieldId);
+              return {
+                undoable: {
+                  message: translations[0]['en-US'][KANBAN_PLUGIN]['card field deleted label'],
+                  data: { deletionData: { ...deleted, index } },
+                },
+              };
+            } else if (undo && deletionData) {
+              const { field, props, index } = deletionData;
+              projection.setFieldProjection({ field, props }, index);
             }
-          }
-        },
+          }),
+        ],
       },
     },
   };

package/src/components/KanbanContainer.tsx

@@ -0,0 +1,79 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useCallback, useEffect, useState } from 'react';
+
+import { type EchoSchema } from '@dxos/echo-schema';
+import { invariant } from '@dxos/invariant';
+import { useGlobalFilteredObjects } from '@dxos/plugin-search';
+import { Filter, useQuery, getSpace, create } from '@dxos/react-client/echo';
+import { type KanbanType, useKanbanModel, Kanban } from '@dxos/react-ui-kanban';
+import { StackItem } from '@dxos/react-ui-stack';
+
+export const KanbanContainer = ({ kanban }: { kanban: KanbanType; role: string }) => {
+  const [cardSchema, setCardSchema] = useState<EchoSchema>();
+  const space = getSpace(kanban);
+  useEffect(() => {
+    if (kanban.cardView && space) {
+      setCardSchema(space.db.schemaRegistry.getSchema(kanban.cardView.target!.query.type));
+    }
+  }, [kanban.cardView, space]);
+
+  const objects = useQuery(space, cardSchema ? Filter.schema(cardSchema) : Filter.nothing());
+  const filteredObjects = useGlobalFilteredObjects(objects);
+
+  const model = useKanbanModel({
+    kanban,
+    cardSchema,
+    items: filteredObjects,
+  });
+
+  const handleAddColumn = useCallback((columnValue: string) => model?.addEmptyColumn(columnValue), [model]);
+
+  const handleAddCard = useCallback(
+    (columnValue: string) => {
+      if (space && cardSchema) {
+        space.db.add(
+          create(cardSchema, {
+            title: '',
+            description: '',
+            state: columnValue,
+          }),
+        );
+      }
+    },
+    [space, cardSchema],
+  );
+
+  const handleRemoveCard = useCallback(
+    (card: { id: string }) => {
+      invariant(space);
+      space.db.remove(card);
+    },
+    [space],
+  );
+
+  const handleRemoveEmptyColumn = useCallback(
+    (columnValue: string) => {
+      model?.removeColumnFromArrangement(columnValue);
+    },
+    [model],
+  );
+
+  return (
+    <StackItem.Content toolbar={false}>
+      {model ? (
+        <Kanban
+          model={model}
+          onAddCard={handleAddCard}
+          onAddColumn={handleAddColumn}
+          onRemoveCard={handleRemoveCard}
+          onRemoveEmptyColumn={handleRemoveEmptyColumn}
+        />
+      ) : (
+        <span>Loading</span>
+      )}
+    </StackItem.Content>
+  );
+};

package/src/components/KanbanViewEditor.tsx

@@ -0,0 +1,72 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React, { useCallback, useEffect, useState } from 'react';
+
+import { createIntent, useIntentDispatcher } from '@dxos/app-framework';
+import { getSpace } from '@dxos/react-client/echo';
+import { ViewEditor, Form } from '@dxos/react-ui-form';
+import { type KanbanType, KanbanPropsSchema } from '@dxos/react-ui-kanban';
+
+import { KanbanAction } from '../types';
+
+type KanbanViewEditorProps = { kanban: KanbanType };
+
+const KanbanViewEditor = ({ kanban }: KanbanViewEditorProps) => {
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const space = getSpace(kanban);
+
+  // TODO(ZaymonFC): The schema registry needs an API where we can query with initial value and
+  // endure typename changes. We shouldn't need to manage a subscription at this layer.
+  const [schema, setSchema] = useState(
+    space && kanban?.cardView?.target?.query?.type
+      ? space.db.schemaRegistry.getSchema(kanban.cardView.target.query.type)
+      : undefined,
+  );
+
+  useEffect(() => {
+    if (space && kanban?.cardView?.target?.query?.type) {
+      const unsubscribe = space.db.schemaRegistry
+        .query({ typename: kanban?.cardView?.target?.query?.type })
+        .subscribe((query) => {
+          const [schema] = query.results;
+          if (schema) {
+            setSchema(schema);
+          }
+        });
+
+      return unsubscribe;
+    }
+  }, [space, kanban?.cardView?.target?.query?.type]);
+
+  const handleDelete = useCallback(
+    (fieldId: string) => dispatch?.(createIntent(KanbanAction.DeleteCardField, { kanban, fieldId })),
+    [dispatch, kanban],
+  );
+
+  if (!space || !schema || !kanban.cardView?.target) {
+    return null;
+  }
+
+  return (
+    <>
+      <Form
+        schema={KanbanPropsSchema}
+        values={{ columnField: kanban.columnField }}
+        onSave={({ columnField }) => {
+          kanban.columnField = columnField;
+          kanban.arrangement = undefined;
+        }}
+      />
+      <ViewEditor
+        registry={space.db.schemaRegistry}
+        schema={schema}
+        view={kanban.cardView.target}
+        onDelete={handleDelete}
+      />
+    </>
+  );
+};
+
+export default KanbanViewEditor;

package/src/components/index.ts

@@ -1,7 +1,5 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2024 DXOS.org
 //
 
-import { lazy } from 'react';
-
-export const KanbanMain = lazy(() => import('./KanbanMain'));
+export * from './KanbanContainer';

package/src/translations.ts

@@ -2,11 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
+import { KanbanType } from '@dxos/react-ui-kanban';
+
 import { KANBAN_PLUGIN } from './meta';
 
 export default [
   {
     'en-US': {
+      [KanbanType.typename]: {
+        'typename label': 'Kanban',
+      },
       [KANBAN_PLUGIN]: {
         'plugin name': 'Kanban',
         'kanban title label': 'Title',
@@ -16,10 +21,11 @@ export default [
         'item title label': 'Item title',
         'item title placeholder': 'New item',
         'add column label': 'Add column',
-        'add item label': 'Add item',
+        'add item label': 'Add card',
         'delete column label': 'Delete column',
-        'delete item label': 'Delete item',
+        'delete item label': 'Delete card',
         'create kanban label': 'Create kanban',
+        'card field deleted label': 'Card field deleted',
       },
     },
   },

package/src/{types/types.ts → types.ts}

@@ -3,16 +3,19 @@
 //
 
 import type {
-  GraphBuilderProvides,
   IntentResolverProvides,
   MetadataRecordsProvides,
   SurfaceProvides,
   TranslationsProvides,
 } from '@dxos/app-framework';
+import { S } from '@dxos/echo-schema';
 import { type SchemaProvides } from '@dxos/plugin-space';
+import { type Space, SpaceSchema } from '@dxos/react-client/echo';
+import { KanbanType } from '@dxos/react-ui-kanban';
+import { initializeKanban } from '@dxos/react-ui-kanban/testing';
+import { FieldSchema } from '@dxos/schema';
 
-import { type KanbanColumnType, type KanbanItemType, type KanbanType } from './kanban';
-import { KANBAN_PLUGIN } from '../meta';
+import { KANBAN_PLUGIN } from './meta';
 
 /**
  * Kanban data model.
@@ -23,15 +26,40 @@ import { KANBAN_PLUGIN } from '../meta';
  * by the model (e.g., a query of items based on metadata within a column object).
  */
 
-const KANBAN_ACTION = `${KANBAN_PLUGIN}/action`;
+export namespace KanbanAction {
+  const KANBAN_ACTION = `${KANBAN_PLUGIN}/action`;
 
-export enum KanbanAction {
-  CREATE = `${KANBAN_ACTION}/create`,
+  export class Create extends S.TaggedClass<Create>()(`${KANBAN_ACTION}/create`, {
+    input: S.Struct({
+      name: S.optional(S.String),
+      space: SpaceSchema,
+    }),
+    output: S.Struct({
+      object: KanbanType,
+    }),
+  }) {}
+
+  export class DeleteCardField extends S.TaggedClass<DeleteCardField>()(`${KANBAN_ACTION}/delete-card-field`, {
+    input: S.Struct({
+      kanban: KanbanType,
+      fieldId: S.String,
+      // TODO(wittjosiah): Separate fields for undo data?
+      deletionData: S.optional(
+        S.Struct({
+          field: FieldSchema,
+          // TODO(wittjosiah): This creates a type error.
+          // props: PropertySchema,
+          props: S.Any,
+          index: S.Number,
+        }),
+      ),
+    }),
+    output: S.Void,
+  }) {}
 }
 
 export type KanbanPluginProvides = SurfaceProvides &
   IntentResolverProvides &
-  GraphBuilderProvides &
   MetadataRecordsProvides &
   TranslationsProvides &
   SchemaProvides;
@@ -46,12 +74,15 @@ export type KanbanPluginProvides = SurfaceProvides &
 // TODO(burdon): Extend model for moving items (in and across columns).
 export interface KanbanModel {
   root: KanbanType;
-  createColumn(): KanbanColumnType;
-  createItem(column: KanbanColumnType): KanbanItemType;
 }
 
 export type Location = {
-  column: KanbanColumnType;
-  item?: KanbanItemType;
   idx?: number;
 };
+
+export const isKanban = (object: unknown): object is KanbanType => object != null && object instanceof KanbanType;
+
+export const createKanban = async (space: Space) => {
+  const { kanban } = await initializeKanban({ space });
+  return kanban;
+};