feat(core): update record

fix #110 #93

packages/core/commands/create-record/create-record.command.handler.ts

@@ -1,5 +1,5 @@
 import type { ICommandHandler } from '@egodb/domain'
-import type { IRecordRepository } from '../../record/repository'
+import type { IRecordRepository } from '../../record/record.repository'
 import type { ITableRepository } from '../../table.repository'
 import type { ICreateTableOutput } from '../create-table'
 import type { CreateRecordCommand } from './create-record.comand'

packages/core/commands/update-record/update-record.command.handler.ts

@@ -1,5 +1,5 @@
 import type { ICommandHandler } from '@egodb/domain'
-import type { IRecordRepository } from '../../record/repository'
+import type { IRecordRepository } from '../../record/record.repository'
 import type { ITableRepository } from '../../table.repository'
 import type { UpdateRecordCommand } from './update-record.command'
 
@@ -8,7 +8,7 @@ export class UpdateRecordCommandHandler implements ICommandHandler<UpdateRecordC
 
   async execute(command: UpdateRecordCommand): Promise<void> {
     const table = (await this.tableRepo.findOneById(command.tableId)).unwrap()
-    const record = (await this.recordRepo.findOneById(command.id)).unwrap()
+    const record = (await this.recordRepo.findOneById(command.id, table.schema.toMap())).unwrap()
 
     const spec = record.updateRecord(table.schema, command.value)
     await this.recordRepo.updateOneById(command.id, spec)

packages/core/record/index.ts

@@ -1,8 +1,9 @@
 export * from './fixtures'
 export * from './query-model'
 export * from './record'
+export * from './record.factory'
+export * from './record.repository'
 export * from './record.schema'
 export * from './record.type'
-export * from './repository'
 export * from './specifications'
 export * from './value-objects'

packages/core/record/record.factory.ts

@@ -1,6 +1,9 @@
 import { and } from '@egodb/domain'
 import type { Result } from 'oxide.ts'
+import type { TableSchemaMap } from '../value-objects'
 import { Record } from './record'
+import type { IQueryRecordSchema } from './record.type'
+import { WithRecordCreatedAt, WithRecordId, WithRecordTableId, WithRecordValues } from './specifications'
 import type { RecordCompositeSpecification } from './specifications/interface'
 
 export class RecordFactory {
@@ -15,4 +18,13 @@ export class RecordFactory {
     }
     return spec.mutate(Record.create())
   }
+
+  static fromQuery(r: IQueryRecordSchema, schema: TableSchemaMap): Result<Record, string> {
+    return this.create(
+      WithRecordId.fromString(r.id),
+      WithRecordTableId.fromString(r.tableId).unwrap(),
+      WithRecordCreatedAt.fromDate(r.createdAt),
+      WithRecordValues.fromObject(schema, r.values),
+    )
+  }
 }

packages/core/record/repository.ts → packages/core/record/record.repository.ts

@@ -1,10 +1,11 @@
 import type { Option } from 'oxide.ts'
+import type { TableSchemaMap } from '../value-objects'
 import type { Record } from './record'
 import type { IRecordSpec } from './specifications/interface'
 
 export interface IRecordRepository {
   insert(record: Record): Promise<void>
-  findOneById(id: string): Promise<Option<Record>>
+  findOneById(id: string, schema: TableSchemaMap): Promise<Option<Record>>
 
   updateOneById(id: string, spec: IRecordSpec): Promise<void>
 }

packages/core/record/specifications/record-values.specification.ts

@@ -2,7 +2,9 @@ import { CompositeSpecification } from '@egodb/domain'
 import type { Result } from 'oxide.ts'
 import { Ok } from 'oxide.ts'
 import type { ICreateFieldsSchema_internal } from '../../field'
+import type { TableSchemaMap } from '../../value-objects'
 import type { Record } from '../record'
+import type { IQueryRecordValues } from '../record.type'
 import { RecordValues } from '../value-objects'
 import type { IRecordVisitor } from './interface'
 
@@ -15,6 +17,10 @@ export class WithRecordValues extends CompositeSpecification<Record, IRecordVisi
     return new this(RecordValues.fromArray(values))
   }
 
+  static fromObject(schema: TableSchemaMap, values: IQueryRecordValues): WithRecordValues {
+    return new this(RecordValues.fromObject(schema, values))
+  }
+
   isSatisfiedBy(t: Record): boolean {
     return t.values.equals(this.values)
   }

packages/core/record/value-objects/record-values.vo.ts

@@ -6,13 +6,27 @@ import type { FieldValue, ICreateFieldsSchema_internal, IFieldValue, UnpackedFie
 import { DateRangeFieldValue } from '../../field/date-range-field-value'
 import type { IDateRangeFieldValue } from '../../field/date-range-field.type'
 import { SelectFieldValue } from '../../field/select-field-value'
+import type { TableSchemaMap } from '../../value-objects'
+import type { IQueryRecordValues } from '../record.type'
 
 export class RecordValues extends ValueObject<Map<string, FieldValue>> {
   static fromArray(inputs: ICreateFieldsSchema_internal): RecordValues {
     const values = new Map(inputs.map((v) => [v.field.name.value, v.field.createValue(v.value as never)]))
     return new RecordValues(values)
   }
 
+  static fromObject(schema: TableSchemaMap, inputs: IQueryRecordValues): RecordValues {
+    const values = new Map(
+      Object.entries(inputs).map(([fieldName, fieldValue]) => [
+        fieldName,
+        // TODO: handler missing field
+        schema.get(fieldName)!.createValue(fieldValue as never),
+      ]),
+    )
+
+    return new RecordValues(values)
+  }
+
   static empty(): RecordValues {
     return new RecordValues(new Map())
   }

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

@@ -22,6 +22,8 @@ export const createTableSchemaSchema = z
 
 export type ICreateTableSchemaInput = z.infer<typeof createTableSchemaSchema>
 
+export type TableSchemaMap = Map<string, Field>
+
 /**
  * Table Schema is a collection of fields
  */
@@ -36,6 +38,10 @@ export class TableSchema extends ValueObject<Field[]> {
     return new TableSchema(fields)
   }
 
+  public toMap(): TableSchemaMap {
+    return new Map(this.fields.map((f) => [f.name.value, f]))
+  }
+
   public get fields(): Field[] {
     return this.props
   }

packages/repositories/in-memory-repository/repositories/record/record-in-memory-repository.ts

@@ -1,31 +1,28 @@
-import type { IRecordRepository, IRecordSpec, Record } from '@egodb/core'
+import type { IRecordRepository, IRecordSpec, Record, TableSchemaMap } from '@egodb/core'
 import type { Option } from 'oxide.ts'
 import { None, Some } from 'oxide.ts'
 import { db } from '../db.js'
 import { RecordInMemoryMapper } from './record-in-memory.mapper.js'
+import { RecordInMemoryMutationVisitor } from './record-in-memory.mutation-visitor.js'
 
 export class RecordInMemoryRepository implements IRecordRepository {
-  async findOneById(id: string): Promise<Option<Record>> {
+  async findOneById(id: string, schema: TableSchemaMap): Promise<Option<Record>> {
     const r = db.data?.records.find((t) => t.id === id)
     if (!r) return None
 
-    const record = RecordInMemoryMapper.toDomain(r).unwrap()
+    const record = RecordInMemoryMapper.toDomain(r, schema).unwrap()
     return Some(record)
   }
 
-  async findOne(spec: IRecordSpec): Promise<Option<Record>> {
-    throw new Error('unimplemented')
-  }
-
-  async find(spec: IRecordSpec): Promise<Record[]> {
-    throw new Error('unimplemented')
-  }
-
   async insert(record: Record): Promise<void> {
     db.data?.records.push(RecordInMemoryMapper.toInMemory(record))
   }
 
   async updateOneById(id: string, spec: IRecordSpec): Promise<void> {
-    throw new Error('Method not implemented.')
+    const record = db.data?.records.find((r) => r.id === id)
+    if (!record) return
+
+    const visitor = new RecordInMemoryMutationVisitor(record)
+    spec.accept(visitor)
   }
 }

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

@@ -1,10 +1,11 @@
-import type { Record } from '@egodb/core'
+import type { Record, TableSchemaMap } from '@egodb/core'
+import { RecordFactory } from '@egodb/core'
 import type { Result } from 'oxide.ts'
 import type { RecordInMemory } from './record.type'
 
 export class RecordInMemoryMapper {
-  static toDomain(t: RecordInMemory): Result<Record, Error> {
-    throw new Error('unimplemented')
+  static toDomain(t: RecordInMemory, schema: TableSchemaMap): Result<Record, string> {
+    return RecordFactory.fromQuery(t, schema)
   }
 
   static toInMemory(r: Record): RecordInMemory {