feat(core): set kanban field id

apps/web/components/kanban-ui/kanban.tsx

@@ -1,5 +1,5 @@
-import { QueryRecords } from '@egodb/core'
-import { ITableBaseProps } from '../table/table-base-props'
+import type { QueryRecords } from '@egodb/core'
+import type { ITableBaseProps } from '../table/table-base-props'
 import { SelectKanbanField } from './select-kanban-field'
 
 interface IProps extends ITableBaseProps {

apps/web/components/kanban-ui/select-kanban-field.tsx

@@ -1,11 +1,17 @@
 import { setKanbanFieldSchema } from '@egodb/core'
 import { Button, Card, Center, Container, Group, Radio, Text, useForm, zodResolver } from '@egodb/ui'
 import { trpc } from '../../trpc'
-import { ITableBaseProps } from '../table/table-base-props'
+import type { ITableBaseProps } from '../table/table-base-props'
 
 export const SelectKanbanField: React.FC<ITableBaseProps> = ({ table }) => {
   const selectFields = table.schema.selectFields
-  const setKanbanField = trpc.table.setKanbanField.useMutation()
+  const utils = trpc.useContext()
+  const setKanbanField = trpc.table.setKanbanField.useMutation({
+    onSuccess() {
+      utils.table.get.refetch()
+    },
+  })
+
   const form = useForm({
     initialValues: {
       field: '',

packages/core/__snapshots__/table.factory.test.ts.snap

@@ -46,6 +46,7 @@ ResultType {
             },
             "fieldsOrder": undefined,
             "filter": undefined,
+            "kanban": undefined,
             "name": ViewName {
               "props": {
                 "value": "table",

packages/core/__snapshots__/table.test.ts.snap

@@ -64,6 +64,7 @@ Table {
           },
           "fieldsOrder": undefined,
           "filter": undefined,
+          "kanban": undefined,
           "name": ViewName {
             "props": {
               "value": "name",

packages/core/fixtures/table.fixtuer.test.ts

@@ -48,6 +48,7 @@ test('createTestTable', () => {
               },
               "fieldsOrder": undefined,
               "filter": undefined,
+              "kanban": undefined,
               "name": ViewName {
                 "props": {
                   "value": "name",

packages/core/specifications/interface.ts

@@ -1,6 +1,7 @@
 import type { CompositeSpecification, ISpecVisitor } from '@egodb/domain'
 import { type ISpecification } from '@egodb/domain'
 import { type Table } from '../table'
+import type { WithKanbanField } from '../view'
 import type { WithDisplayType } from '../view/specifications/display-type.specification'
 import type { WithFilter } from './filters.specificaiton'
 import type { WithNewField } from './table-field.specification'
@@ -26,6 +27,7 @@ export interface ITableSpecVisitor extends ISpecVisitor {
   fieldVisibility(s: WithFieldVisibility): void
 
   displayTypeEqual(s: WithDisplayType): void
+  kanbanFieldEqual(s: WithKanbanField): void
 }
 
 export type ITableSpec = ISpecification<Table, ITableSpecVisitor>

packages/core/table.ts

@@ -170,7 +170,7 @@ export class Table {
 
   public switchDisplayType(input: ISwitchDisplayTypeSchema): TableCompositeSpecificaiton {
     const view = this.mustGetView(input.viewName)
-    const spec = view.switchDisplayType(view.name.unpack(), input.displayType)
+    const spec = view.switchDisplayType(input.displayType)
     spec.mutate(this)
     return spec
   }
@@ -184,8 +184,8 @@ export class Table {
 
   public setKanbanField(input: ISetKanbanFieldSchema): TableCompositeSpecificaiton {
     const view = this.mustGetView(input.viewName)
-    const field = this.schema.getField(input.field).unwrap()
-    const spec = view.setKanbanField(field.id)
+    const field = this.schema.getFieldById(input.field).unwrap()
+    const spec = view.setKanbanFieldSpec(field.id)
     spec.mutate(this)
     return spec
   }

packages/core/value-objects/table-schema.vo.ts

@@ -1,7 +1,8 @@
 import { ValueObject } from '@egodb/domain'
 import { Option } from 'oxide.ts'
 import * as z from 'zod'
-import { createFieldSchema, Field, fieldNameSchema, ICreateFieldSchema, SelectField } from '../field'
+import type { Field, ICreateFieldSchema } from '../field'
+import { createFieldSchema, fieldNameSchema, SelectField } from '../field'
 import { FieldFactory } from '../field/field.factory'
 import type { TableCompositeSpecificaiton } from '../specifications/interface'
 import { WithNewField } from '../specifications/table-field.specification'
@@ -55,6 +56,10 @@ export class TableSchema extends ValueObject<Field[]> {
     return Option(this.fields.find((f) => f.name.value === name))
   }
 
+  public getFieldById(id: string): Option<Field> {
+    return Option(this.fields.find((f) => f.id.value === id))
+  }
+
   public addField(field: Field) {
     this.props.push(field)
   }

packages/core/view/kanban.schema.ts

@@ -2,5 +2,7 @@ import { z } from 'zod'
 import { fieldIdSchema } from '../field'
 
 export const kanbanSchema = z.object({
-  selectField: fieldIdSchema,
+  fieldId: fieldIdSchema.optional(),
 })
+
+export type IKanbanSchema = z.infer<typeof kanbanSchema>

packages/core/view/kanban.ts

@@ -1,8 +1,20 @@
 import { ValueObject } from '@egodb/domain'
+import { FieldId } from '../field'
+import type { IKanbanSchema } from './kanban.schema'
 import type { IKanban } from './kanban.type'
 
 export class Kanban extends ValueObject<IKanban> {
-  public get selectField() {
-    return this.props.selectField
+  static from(input: IKanbanSchema) {
+    return new this({
+      fieldId: input.fieldId ? FieldId.from(input.fieldId) : undefined,
+    })
+  }
+
+  public get fieldId() {
+    return this.props.fieldId
+  }
+
+  public set fieldId(fieldId: FieldId | undefined) {
+    this.props.fieldId = fieldId
   }
 }

packages/core/view/kanban.type.ts

@@ -1,5 +1,5 @@
 import type { FieldId } from '../field'
 
 export interface IKanban {
-  selectField: FieldId
+  fieldId?: FieldId
 }

packages/core/view/specifications/display-type.specification.ts

@@ -3,20 +3,20 @@ import type { Result } from 'oxide.ts'
 import { Ok } from 'oxide.ts'
 import type { ITableSpecVisitor } from '../../specifications'
 import type { Table } from '../../table'
+import type { View } from '../view'
 import type { IViewDisplayType } from '../view.type'
 
 export class WithDisplayType extends CompositeSpecification<Table, ITableSpecVisitor> {
-  constructor(public readonly viewName: string, public readonly displayType: IViewDisplayType) {
+  constructor(public readonly view: View, public readonly displayType: IViewDisplayType) {
     super()
   }
 
-  isSatisfiedBy(t: Table): boolean {
-    return t.mustGetView(this.viewName).displayType === this.displayType
+  isSatisfiedBy(): boolean {
+    return this.view.displayType === this.displayType
   }
 
   mutate(t: Table): Result<Table, string> {
-    const view = t.mustGetView(this.viewName)
-    view.displayType = this.displayType
+    this.view.displayType = this.displayType
     return Ok(t)
   }
 

packages/core/view/specifications/kanban.specification.ts

@@ -1,22 +1,27 @@
 import { CompositeSpecification } from '@egodb/domain'
-import { Result } from 'oxide.ts/dist'
-import { FieldId } from '../../field'
-import { ITableSpecVisitor } from '../../specifications'
-import { Table } from '../../table'
-import { View } from '../view'
+import type { Result } from 'oxide.ts'
+import { Ok } from 'oxide.ts'
+import type { FieldId } from '../../field'
+import type { ITableSpecVisitor } from '../../specifications'
+import type { Table } from '../../table'
+import type { View } from '../view'
 
 export class WithKanbanField extends CompositeSpecification<Table, ITableSpecVisitor> {
   constructor(public readonly view: View, public readonly fieldId: FieldId) {
     super()
   }
 
-  isSatisfiedBy(t: Table): boolean {
-    throw new Error('Method not implemented.')
+  isSatisfiedBy(): boolean {
+    return this.view.kanbanSelectFieldId.mapOr(false, (fieldId) => fieldId.equals(this.fieldId))
   }
+
   mutate(t: Table): Result<Table, string> {
-    throw new Error('Method not implemented.')
+    this.view.getOrCreateKanban().fieldId = this.fieldId
+    return Ok(t)
   }
+
   accept(v: ITableSpecVisitor): Result<void, string> {
-    throw new Error('Method not implemented.')
+    v.kanbanFieldEqual(this)
+    return Ok(undefined)
   }
 }

packages/core/view/view-name.vo.ts

@@ -4,6 +4,9 @@ import { z } from 'zod'
 export const viewNameSchema = z.string().min(1, { message: 'view name should has at least one character' })
 
 export class ViewName extends ValueObject<string> {
+  public get value() {
+    return this.props.value
+  }
   static create(name: string): ViewName {
     return new ViewName({ value: viewNameSchema.parse(name) })
   }

packages/core/view/view.schema.ts

@@ -1,13 +1,15 @@
 import { z } from 'zod'
 import { fieldIdSchema, fieldNameSchema } from '../field'
 import { rootFilter } from '../filter/filter'
+import { kanbanSchema } from './kanban.schema'
 import { fieldHiddenSchema, fieldWidthSchema, viewFieldOption } from './view-field-options'
 import { viewNameSchema } from './view-name.vo'
 
 export const viewDisplayType = z.enum(['grid', 'kanban'])
 
 export const createViewInput_internal = z.object({
   name: viewNameSchema,
+  kanban: kanbanSchema.optional(),
   displayType: viewDisplayType.optional(),
   filter: rootFilter.optional(),
   fieldOptions: z.record(viewFieldOption).optional(),
@@ -16,6 +18,7 @@ export const createViewInput_internal = z.object({
 
 export const queryView = z.object({
   name: z.string(),
+  kanban: kanbanSchema.optional(),
   displayType: viewDisplayType,
   filter: rootFilter.optional(),
   fieldOptions: z.record(viewFieldOption).optional(),

packages/core/view/view.ts

@@ -1,7 +1,7 @@
 import type { CompositeSpecification } from '@egodb/domain'
 import { ValueObject } from '@egodb/domain'
 import { None, Option } from 'oxide.ts'
-import { FieldId } from '../field'
+import type { FieldId } from '../field'
 import type { IFilterOrGroupList, IRootFilter } from '../filter'
 import { RootFilter } from '../filter'
 import type { TableCompositeSpecificaiton } from '../specifications/interface'
@@ -40,7 +40,7 @@ export class View extends ValueObject<IView> {
   }
 
   public get kanbanSelectFieldId(): Option<FieldId> {
-    return this.kanban.mapOr(None, (kanban) => Option(kanban.selectField))
+    return this.kanban.mapOr(None, (kanban) => Option(kanban.fieldId))
   }
 
   public get spec(): Option<CompositeSpecification> {
@@ -68,6 +68,14 @@ export class View extends ValueObject<IView> {
     return this.fieldOptions.getOrCreateOption(fieldName)
   }
 
+  public getOrCreateKanban(): Kanban {
+    const kanban = this.kanban
+    if (kanban.isSome()) return kanban.unwrap()
+
+    this.props.kanban = new Kanban({})
+    return this.props.kanban
+  }
+
   public getFieldHidden(fieldName: string): boolean {
     return this.fieldOptions.getHidden(fieldName)
   }
@@ -80,15 +88,15 @@ export class View extends ValueObject<IView> {
     return new WithFieldWidth(fieldName, this.name.unpack(), width)
   }
 
-  public switchDisplayType(viewName: string, type: IViewDisplayType): TableCompositeSpecificaiton {
-    return new WithDisplayType(viewName, type)
+  public switchDisplayType(type: IViewDisplayType): TableCompositeSpecificaiton {
+    return new WithDisplayType(this, type)
   }
 
   public setFieldVisibility(fieldName: string, hidden: boolean): TableCompositeSpecificaiton {
     return new WithFieldVisibility(fieldName, this.name.unpack(), hidden)
   }
 
-  public setKanbanField(fieldId: FieldId): TableCompositeSpecificaiton {
+  public setKanbanFieldSpec(fieldId: FieldId): TableCompositeSpecificaiton {
     return new WithKanbanField(this, fieldId)
   }
 
@@ -115,6 +123,7 @@ export class View extends ValueObject<IView> {
     const parsed = createViewInput_internal.parse(input)
     return new View({
       name: ViewName.create(parsed.name),
+      kanban: input.kanban ? Kanban.from(input.kanban) : undefined,
       displayType: parsed.displayType || defaultViewDiaplyType,
       filter: parsed.filter ? new RootFilter(parsed.filter) : undefined,
       fieldOptions: ViewFieldOptions.from(input.fieldOptions),

packages/core/view/view.type.ts

@@ -2,22 +2,24 @@ import type { z } from 'zod'
 import type { IRootFilter } from '../filter'
 import type { RootFilter } from '../filter/root-filter'
 import type { Kanban } from './kanban'
+import type { IKanbanSchema } from './kanban.schema'
 import type { IViewFieldOption, ViewFieldOptions } from './view-field-options'
 import type { ViewFieldsOrder } from './view-fields-order.vo'
 import type { ViewName } from './view-name.vo'
 import type { createViewInput_internal, viewDisplayType } from './view.schema'
 
 export interface IView {
   name: ViewName
+  kanban?: Kanban
   displayType: IViewDisplayType
   filter?: RootFilter
   fieldOptions: ViewFieldOptions
   fieldsOrder?: ViewFieldsOrder
-  kanban?: Kanban
 }
 
 export interface IQueryView {
   name: string
+  kanban?: IKanbanSchema
   displayType: IViewDisplayType
   filter?: IRootFilter
   fieldOptions?: Record<string, IViewFieldOption>

packages/repositories/in-memory-repository/repositories/table/table-in-memory.mapper.ts

@@ -1,7 +1,7 @@
 import type { Field, Table, TableSchema, View, Views } from '@egodb/core'
 import { TableFactory } from '@egodb/core'
 import type { Result } from 'oxide.ts'
-import type { FieldInMemory, SchemaInMemory, TableInMemory, ViewInMemory, ViewsInMemory } from './table'
+import type { FieldInMemory, KanbanInMemory, SchemaInMemory, TableInMemory, ViewInMemory, ViewsInMemory } from './table'
 
 export class TableInMemoryMapper {
   static toDomain(t: TableInMemory): Result<Table, string> {
@@ -35,9 +35,18 @@ export class TableInMemoryMapper {
     return schema.fields.map((f) => this.fieldToInMemopy(f))
   }
 
+  static kanbanToInMemory(v: View): KanbanInMemory | undefined {
+    if (v.kanban.isSome()) {
+      return { fieldId: v.kanban.unwrap().fieldId?.value }
+    }
+
+    return undefined
+  }
+
   static viewToInMemory(v: View): ViewInMemory {
     return {
       name: v.name.unpack(),
+      kanban: this.kanbanToInMemory(v),
       displayType: v.displayType,
       filter: v.filter?.value,
       fieldOptions: Object.fromEntries(v.fieldOptions.value),

packages/repositories/in-memory-repository/repositories/table/table-in-memory.mutation-visitor.ts

@@ -4,6 +4,7 @@ import type {
   WithFieldVisibility,
   WithFieldWidth,
   WithFilter,
+  WithKanbanField,
   WithNewField,
   WithTableName,
   WithTableSchema,
@@ -89,9 +90,20 @@ export class TableInMemoryMutationVisitor implements ITableSpecVisitor {
   }
 
   displayTypeEqual(s: WithDisplayType): void {
-    const view = this.table.views.find((v) => v.name === s.viewName)
+    const view = this.table.views.find((v) => v.name === s.view.name.value)
     if (view) {
       view.displayType = s.displayType
     }
   }
+
+  kanbanFieldEqual(s: WithKanbanField): void {
+    const view = this.table.views.find((v) => v.name === s.view.name.value)
+    if (view) {
+      if (view.kanban) {
+        view.kanban.fieldId = s.fieldId.value
+      } else {
+        view.kanban = { fieldId: s.fieldId.value }
+      }
+    }
+  }
 }