@lota-sdk/core 0.4.8 → 0.4.10

package/src/db/base.service.ts

@@ -1,22 +1,22 @@
+import { Effect } from 'effect'
 import type { z } from 'zod'
 
-import { NotFoundError } from '../utils/errors'
+import type { AwaitableEffect } from '../effect/awaitable-effect'
+import { toAwaitableEffect } from '../effect/awaitable-effect'
+import { NotFoundError } from '../effect/errors'
 import { ensureRecordId } from './record-id'
-import { databaseService as defaultDatabaseService } from './service'
 import type { SurrealDBService } from './service'
+import type { SurrealDBError } from './service-normalization'
 import type { DatabaseTable } from './tables'
 
 export abstract class BaseService<T extends z.ZodType> {
-  protected readonly db: SurrealDBService
   constructor(
     protected readonly table: DatabaseTable,
     protected readonly schema: T,
-    protected readonly databaseService: SurrealDBService = defaultDatabaseService,
-  ) {
-    this.db = this.databaseService
-  }
+    protected readonly databaseService: SurrealDBService,
+  ) {}
 
-  async findById(id: unknown): Promise<z.infer<T> | null> {
+  findById(id: unknown): AwaitableEffect<z.infer<T> | null, SurrealDBError> {
     return this.databaseService.findOne(
       this.table,
       { id: ensureRecordId(id as Parameters<typeof ensureRecordId>[0], this.table) },
@@ -24,37 +24,61 @@ export abstract class BaseService<T extends z.ZodType> {
     )
   }
 
-  async getById(id: unknown): Promise<z.infer<T>> {
-    const record = await this.findById(id)
-    if (!record) {
-      throw new NotFoundError(`${this.table} record not found`)
-    }
-    return record
+  getById(id: unknown): AwaitableEffect<z.infer<T>, SurrealDBError | NotFoundError> {
+    const { table, databaseService, schema } = this
+    return toAwaitableEffect(
+      Effect.gen(function* () {
+        const record = yield* databaseService.findOne(
+          table,
+          { id: ensureRecordId(id as Parameters<typeof ensureRecordId>[0], table) },
+          schema,
+        )
+
+        if (!record) {
+          return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
+        }
+
+        return record
+      }),
+    )
   }
 
-  async findAll(
+  findAll(
     filter: Record<string, unknown> = {},
     options?: { limit?: number; offset?: number; orderBy?: keyof z.infer<T> & string; orderDir?: 'ASC' | 'DESC' },
-  ): Promise<z.infer<T>[]> {
+  ): AwaitableEffect<z.infer<T>[], SurrealDBError> {
     return this.databaseService.findMany(this.table, filter, this.schema, options)
   }
 
-  async create(data: Record<string, unknown>): Promise<z.infer<T>> {
+  create(data: Record<string, unknown>): AwaitableEffect<z.infer<T>, SurrealDBError> {
     return this.databaseService.create(this.table, data, this.schema)
   }
 
-  async update(id: unknown, data: Record<string, unknown>): Promise<z.infer<T>> {
-    const updated = await this.databaseService.update(this.table, id, data, this.schema)
-    if (!updated) {
-      throw new NotFoundError(`${this.table} record not found`)
-    }
-    return updated
+  update(id: unknown, data: Record<string, unknown>): AwaitableEffect<z.infer<T>, SurrealDBError | NotFoundError> {
+    const { table, databaseService, schema } = this
+    return toAwaitableEffect(
+      Effect.gen(function* () {
+        const updated = yield* databaseService.update(table, id, data, schema)
+
+        if (!updated) {
+          return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
+        }
+
+        return updated
+      }),
+    )
   }
 
-  async delete(id: unknown): Promise<void> {
-    const deleted = await this.databaseService.deleteById(this.table, id)
-    if (!deleted) {
-      throw new NotFoundError(`${this.table} record not found`)
-    }
+  delete(id: unknown): AwaitableEffect<void, SurrealDBError | NotFoundError> {
+    const { table, databaseService } = this
+    return toAwaitableEffect(
+      Effect.gen(function* () {
+        const deleted = yield* databaseService.deleteById(table, id)
+
+        if (!deleted) {
+          return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
+        }
+      }),
+    )
   }
 }

package/src/db/cursor-pagination.ts

@@ -1,9 +1,10 @@
 import type { ChatMessage } from '@lota-sdk/shared'
+import { Schema, Effect } from 'effect'
 import type { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
 
 import type { RecordIdRef } from './record-id'
-import { databaseService } from './service'
+import type { SurrealDBService } from './service'
 import type { DatabaseTable } from './tables'
 
 export const CursorRowSchema = z.object({ createdAt: z.coerce.date() })
@@ -24,47 +25,87 @@ export interface CursorPaginationConfig {
   queryBefore: (parentId: RecordIdRef, cursorCreatedAt: Date, cursorId: RecordId, limit: number) => BoundQuery
 }
 
-export async function listMessageHistoryPage(
+class CursorPaginationError extends Schema.TaggedErrorClass<CursorPaginationError>()('CursorPaginationError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+export function listMessageHistoryPage(
+  db: SurrealDBService,
   config: CursorPaginationConfig,
   params: { parentId: RecordIdRef; take: number; beforeMessageId?: string },
 ): Promise<MessageHistoryPage> {
-  const take = Math.max(1, params.take)
-  const beforeMessageId = params.beforeMessageId?.trim()
-  const limit = take + 1
+  return Effect.runPromise(listMessageHistoryPageEffect(db, config, params))
+}
+
+export function listMessageHistoryPageEffect(
+  db: SurrealDBService,
+  config: CursorPaginationConfig,
+  params: { parentId: RecordIdRef; take: number; beforeMessageId?: string },
+): Effect.Effect<MessageHistoryPage, CursorPaginationError> {
+  return Effect.gen(function* () {
+    const take = Math.max(1, params.take)
+    const beforeMessageId = params.beforeMessageId?.trim()
+    const limit = take + 1
 
-  const rows = beforeMessageId
-    ? await listRowsBefore(config, { parentId: params.parentId, beforeMessageId, take: limit })
-    : await databaseService.query<unknown>(config.queryLatest(params.parentId, limit))
+    const rows = beforeMessageId
+      ? yield* listRowsBeforeEffect(db, config, { parentId: params.parentId, beforeMessageId, take: limit })
+      : yield* db
+          .query<unknown>(config.queryLatest(params.parentId, limit))
+          .pipe(
+            Effect.mapError(
+              (cause) => new CursorPaginationError({ message: 'Failed to load latest message history rows.', cause }),
+            ),
+          )
 
-  const parsedRows = rows.map((row) => config.parseRow(row))
-  const hasMore = parsedRows.length > take
-  const pageRows = hasMore ? rows.slice(0, take) : rows
+    const parsedRows = rows.map((row: unknown) => config.parseRow(row))
+    const hasMore = parsedRows.length > take
+    const pageRows = hasMore ? rows.slice(0, take) : rows
 
-  pageRows.reverse()
+    pageRows.reverse()
 
-  return {
-    messages: pageRows.map((row) => config.toMessage(row)),
-    hasMore,
-    prevCursor: hasMore ? config.parseRow(pageRows[0]).messageId : null,
-  }
+    return {
+      messages: pageRows.map((row: unknown) => config.toMessage(row)),
+      hasMore,
+      prevCursor: hasMore ? config.parseRow(pageRows[0]).messageId : null,
+    }
+  })
 }
 
-async function listRowsBefore(
+function listRowsBeforeEffect(
+  db: SurrealDBService,
   config: CursorPaginationConfig,
   params: { parentId: RecordIdRef; beforeMessageId: string; take: number },
-): Promise<unknown[]> {
-  const cursorRow = await databaseService.findOne(
-    config.table,
-    { [config.parentFilterField]: params.parentId, messageId: params.beforeMessageId },
-    CursorRowSchema,
-  )
+): Effect.Effect<unknown[], CursorPaginationError> {
+  return Effect.gen(function* () {
+    const cursorRow = yield* db
+      .findOne(
+        config.table,
+        { [config.parentFilterField]: params.parentId, messageId: params.beforeMessageId },
+        CursorRowSchema,
+      )
+      .pipe(
+        Effect.mapError(
+          (cause) => new CursorPaginationError({ message: 'Failed to load cursor row for pagination.', cause }),
+        ),
+      )
 
-  if (!cursorRow) {
-    throw new Error(`Cursor message not found in ${config.table}: ${params.beforeMessageId}`)
-  }
+    if (!cursorRow) {
+      return yield* new CursorPaginationError({
+        message: `Cursor message not found in ${config.table}: ${params.beforeMessageId}`,
+      })
+    }
 
-  const cursorCreatedAt = cursorRow.createdAt
-  const cursorId = config.toRowId(params.parentId, params.beforeMessageId)
+    const cursorCreatedAt = cursorRow.createdAt
+    const cursorId = config.toRowId(params.parentId, params.beforeMessageId)
 
-  return databaseService.query<unknown>(config.queryBefore(params.parentId, cursorCreatedAt, cursorId, params.take))
+    return yield* db
+      .query<unknown>(config.queryBefore(params.parentId, cursorCreatedAt, cursorId, params.take))
+      .pipe(
+        Effect.mapError(
+          (cause) =>
+            new CursorPaginationError({ message: 'Failed to load message history rows before cursor.', cause }),
+        ),
+      )
+  })
 }

package/src/db/memory-query-builder.ts

@@ -3,8 +3,9 @@
  * Builds type-safe SQL queries with proper parameterization
  */
 
+import { VECTOR_SEARCH_OVERFETCH_MULTIPLIER } from '@lota-sdk/shared'
+
 import { validateKnnLimit } from '../config/constants'
-import { VECTOR_SEARCH_OVERFETCH_MULTIPLIER } from '../config/search'
 import { TABLES } from './tables'
 
 const MEMORY_TABLE = TABLES.MEMORY

package/src/db/memory-store.helpers.ts

@@ -1,3 +1,5 @@
+import { sha256Hex } from '../utils/crypto'
+import { unsafeDateFromUnknown } from '../utils/date-time'
 import type { BasicSearchRow, SurrealMemoryRow } from './memory-store.rows'
 import type { MemoryRecord, MemorySearchResult } from './memory-types'
 import { recordIdToString } from './record-id'
@@ -10,12 +12,7 @@ export function isUniqueIndexConflict(error: unknown, indexName: string): boolea
 }
 
 const coerceDate = (value: unknown): Date => {
-  if (value instanceof Date) return value
-  if (typeof value === 'number') {
-    const millis = value < 1_000_000_000_000 ? value * 1000 : value
-    return new Date(millis)
-  }
-  return new Date(String(value))
+  return unsafeDateFromUnknown(value)
 }
 
 export function mapRowToMemoryRecord(row: SurrealMemoryRow): MemoryRecord {
@@ -112,5 +109,5 @@ export function processGraphAwareRows<T extends BasicSearchRow>(
 }
 
 export function hashContent(content: string, scopeId: string, memoryType: string): string {
-  return new Bun.CryptoHasher('sha256').update(`${scopeId}:${memoryType}:${content}`).digest('hex')
+  return sha256Hex(`${scopeId}:${memoryType}:${content}`)
 }