@lota-sdk/core 0.1.14 → 0.1.16

package/src/db/service.ts

@@ -12,6 +12,9 @@ import {
 import type { ExprLike, Mutation, SurrealTransaction, Values } from 'surrealdb'
 import type { z } from 'zod'
 
+import { serverLogger } from '../config/logger'
+import { withTimeout } from '../utils/async'
+import { isRecord } from '../utils/string'
 import type { RecordIdInput } from './record-id'
 import { ensureRecordId, readCustomStringValue } from './record-id'
 import type { DatabaseTable } from './tables'
@@ -88,12 +91,8 @@ function configureMutation(
   return builder.merge(data)
 }
 
-function isRecordValue(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
 function isBoundQueryLike(value: unknown): value is BoundQueryLike {
-  if (!isRecordValue(value)) {
+  if (!isRecord(value)) {
     return false
   }
 
@@ -101,7 +100,7 @@ function isBoundQueryLike(value: unknown): value is BoundQueryLike {
     return false
   }
 
-  return value.bindings === undefined || isRecordValue(value.bindings)
+  return value.bindings === undefined || isRecord(value.bindings)
 }
 
 function toStringLikeValue(value: unknown): string | null {
@@ -122,23 +121,6 @@ const CONNECT_RETRY_BASE_DELAY_MS = 100
 const CONNECT_RETRY_JITTER_MS = 50
 const CONNECT_ATTEMPT_TIMEOUT_MS = 5_000
 
-async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
-  let timeoutId: ReturnType<typeof setTimeout> | undefined
-
-  try {
-    return await Promise.race([
-      promise,
-      new Promise<T>((_, reject) => {
-        timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs)
-      }),
-    ])
-  } finally {
-    if (timeoutId) {
-      clearTimeout(timeoutId)
-    }
-  }
-}
-
 export class SurrealDBService {
   private client: Surreal | null = null
   private isConnected = false
@@ -204,7 +186,8 @@ export class SurrealDBService {
 
     try {
       await this.client.close()
-    } catch {
+    } catch (error) {
+      serverLogger.warn`Failed to close database client: ${error}`
     } finally {
       this.client = null
     }
@@ -252,7 +235,7 @@ export class SurrealDBService {
                 : { username: this.config.username ?? '', password: this.config.password ?? '' },
             }),
             CONNECT_ATTEMPT_TIMEOUT_MS,
-            `Timed out connecting to SurrealDB at ${this.config.url}`,
+            `SurrealDB connect (${this.config.url})`,
           )
 
           this.isConnected = true
@@ -278,7 +261,7 @@ export class SurrealDBService {
         }
       }
 
-      this.toSurrealError(lastError)
+      return this.toSurrealError(lastError)
     })()
 
     try {
@@ -327,8 +310,16 @@ export class SurrealDBService {
 
   private normalizeRecordId(id: unknown, table: DatabaseTable): ReturnType<typeof ensureRecordId> {
     try {
-      return ensureRecordId(id as RecordIdInput, table)
+      const recordId = ensureRecordId(id as RecordIdInput, table)
+      const resolvedTable = String(recordId.table)
+      if (resolvedTable !== table) {
+        throw new SurrealDBError(`Record id table mismatch: expected "${table}" but got "${resolvedTable}"`)
+      }
+      return recordId
     } catch (error) {
+      if (error instanceof SurrealDBError) {
+        throw error
+      }
       if (error instanceof Error) {
         throw new SurrealDBError(`Invalid record id for table "${table}": ${error.message}`, undefined, {
           cause: error,
@@ -338,14 +329,39 @@ export class SurrealDBService {
     }
   }
 
-  private normalizeQueryRows<T>(statement: unknown, schema?: z.ZodType<T>): T[] {
+  private normalizeQueryRows(statement: unknown, schema?: z.ZodTypeAny): unknown[] {
     if (Array.isArray(statement)) {
-      return schema ? statement.map((row) => schema.parse(row)) : (statement as T[])
+      return schema ? statement.map((row) => this.parseSchema(schema, row)) : (statement as unknown[])
     }
     if (statement === null || statement === undefined) {
       return []
     }
-    return schema ? [schema.parse(statement)] : [statement as T]
+    return schema ? [this.parseSchema(schema, statement)] : [statement]
+  }
+
+  private normalizeParseValue(value: unknown): unknown {
+    if (
+      value instanceof Date ||
+      value instanceof RecordId ||
+      value instanceof StringRecordId ||
+      value instanceof Table
+    ) {
+      return value
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((entry) => this.normalizeParseValue(entry))
+    }
+
+    if (!isRecord(value)) {
+      return value
+    }
+
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, this.normalizeParseValue(entry)]))
+  }
+
+  private parseSchema<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown): z.infer<TSchema> {
+    return schema.parse(this.normalizeParseValue(value))
   }
 
   private buildFilterExpression(filter: Record<string, unknown>): ExprLike | undefined {
@@ -362,6 +378,33 @@ export class SurrealDBService {
     return and(...expressions)
   }
 
+  private assertValidIdentifier(name: string, context: string): void {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(name)) {
+      throw new SurrealDBError(`Invalid ${context}: "${name}"`)
+    }
+  }
+
+  private buildBoundFilterClauses(filter: Record<string, unknown>): {
+    clause: string
+    bindings: Record<string, unknown>
+  } {
+    const entries = Object.entries(filter)
+    if (entries.length === 0) {
+      throw new SurrealDBError('Expected a non-empty filter')
+    }
+
+    const bindings: Record<string, unknown> = {}
+    const clauses = entries.map(([field, value], index) => {
+      this.assertValidIdentifier(field, 'filter field')
+
+      const bindingKey = `filter_${index}`
+      bindings[bindingKey] = this.normalizeRuntimeValue(value)
+      return `${field} = $${bindingKey}`
+    })
+
+    return { clause: clauses.join(' AND '), bindings }
+  }
+
   private normalizeBoundQuery(query: BoundQuery | BoundQueryLike): BoundQuery {
     if (!(query instanceof BoundQuery) && !isBoundQueryLike(query)) {
       throw new SurrealDBError('Invalid query object: expected a BoundQuery-like value')
@@ -392,11 +435,11 @@ export class SurrealDBService {
       return value.map((entry) => this.normalizeRuntimeValue(entry))
     }
 
-    if (!isRecordValue(value)) {
+    if (!isRecord(value)) {
       return value
     }
 
-    if ('tb' in value && 'id' in value) {
+    if ('tb' in value && 'id' in value && Object.keys(value).length === 2) {
       return ensureRecordId(value as RecordIdInput)
     }
 
@@ -413,6 +456,8 @@ export class SurrealDBService {
     return Object.fromEntries(entries.map(([key, entryValue]) => [key, this.normalizeRuntimeValue(entryValue)]))
   }
 
+  // Cast is safe: normalizeRuntimeValue preserves Record shape when input is a Record
+  // (non-array objects are mapped entry-by-entry and returned as Object.fromEntries)
   private normalizeBindings(bindings?: Record<string, unknown>): Record<string, unknown> | undefined {
     if (!bindings) {
       return undefined
@@ -421,24 +466,19 @@ export class SurrealDBService {
     return this.normalizeRuntimeValue(bindings) as Record<string, unknown>
   }
 
-  private normalizeMutationData(data: Record<string, unknown>): Record<string, unknown> {
-    const normalized = this.normalizeRuntimeValue(data) as Record<string, unknown>
-    return this.stripNullValues(normalized)
-  }
-
-  /**
-   * SurrealDB v3 `option<T>` fields expect `NONE` (key omitted), not `null`.
-   * Strip top-level `null` values so they are omitted from the serialized payload,
-   * which the driver interprets as NONE.
-   */
-  private stripNullValues(data: Record<string, unknown>): Record<string, unknown> {
-    const result: Record<string, unknown> = {}
-    for (const [key, value] of Object.entries(data)) {
-      if (value !== null) {
-        result[key] = value
-      }
+  private normalizeMutationFieldValue(value: unknown): unknown {
+    if (value === null || value === undefined) {
+      return undefined
     }
-    return result
+
+    return this.normalizeRuntimeValue(value)
+  }
+
+  // Cast is safe: normalizeRuntimeValue preserves Record shape when input is a Record
+  private normalizeMutationData(data: Record<string, unknown>): Record<string, unknown> {
+    return Object.fromEntries(
+      Object.entries(data).map(([key, value]) => [key, this.normalizeMutationFieldValue(value)]),
+    ) as Record<string, unknown>
   }
 
   private normalizeTableValue(value: unknown): Table {
@@ -469,7 +509,7 @@ export class SurrealDBService {
 
     if (value && typeof value === 'object') {
       const record = value as { tb?: unknown; id?: unknown }
-      if (typeof record.tb === 'string' && record.id !== undefined) {
+      if (typeof record.tb === 'string' && record.id !== undefined && Object.keys(value).length === 2) {
         return true
       }
 
@@ -495,36 +535,59 @@ export class SurrealDBService {
       content: (data) => this.wrapMutationBuilder(builder.content(this.normalizeMutationData(data))),
       replace: (data) => this.wrapMutationBuilder(builder.replace(this.normalizeMutationData(data))),
       merge: (data) => this.wrapMutationBuilder(builder.merge(this.normalizeMutationData(data))),
-      output: (mode) => builder.output(mode),
+      output: async (mode) => this.normalizeParseValue(await builder.output(mode)),
     }
   }
 
   private wrapCreateBuilder(builder: CreateMutationBuilder): CreateMutationBuilder {
     return {
       content: (data) => this.wrapCreateBuilder(builder.content(this.normalizeMutationData(data))),
-      output: (mode) => builder.output(mode),
+      output: async (mode) => this.normalizeParseValue(await builder.output(mode)),
     }
   }
 
   private wrapTransaction(tx: SurrealTransaction): DatabaseTransaction {
     return {
-      query: (query: unknown) => tx.query(this.normalizeBoundQuery(query as BoundQuery | BoundQueryLike)),
+      query: async (query: unknown) => {
+        const boundQuery = this.normalizeBoundQuery(query as BoundQuery | BoundQueryLike)
+        const queryText = this.resolveQueryText(boundQuery)
+
+        try {
+          const responses = await tx.query(boundQuery).responses()
+          const first = responses.at(0)
+          if (!first) {
+            return []
+          }
+          if (!first.success) {
+            throw new SurrealDBError(first.error.message, queryText, { cause: first.error })
+          }
+
+          return this.normalizeQueryRows(first.result)
+        } catch (error) {
+          return this.toSurrealError(error, queryText)
+        }
+      },
       create: (target: unknown) => {
         const normalizedTarget = this.normalizeCreateTarget(target)
         const builder = normalizedTarget instanceof Table ? tx.create(normalizedTarget) : tx.create(normalizedTarget)
+        // Cast needed: SurrealDB SDK transaction builder type differs nominally from internal CreateMutationBuilder interface
         return this.wrapCreateBuilder(builder as unknown as CreateMutationBuilder)
       },
       update: (target: unknown) =>
+        // Cast needed: SurrealDB SDK transaction builder type differs nominally from internal MutationBuilder interface
         this.wrapMutationBuilder(tx.update(ensureRecordId(target as RecordIdInput)) as unknown as MutationBuilder),
-      delete: (target: unknown) => tx.delete(ensureRecordId(target as RecordIdInput)),
-      relate: (from: unknown, edgeTable: unknown, to: unknown, data?: Values<Record<string, unknown>>) =>
-        tx.relate(
-          ensureRecordId(from as RecordIdInput),
-          this.normalizeTableValue(edgeTable),
-          ensureRecordId(to as RecordIdInput),
-          data
-            ? (this.normalizeMutationData(data as Record<string, unknown>) as Values<Record<string, unknown>>)
-            : undefined,
+      delete: async (target: unknown) =>
+        this.normalizeParseValue(await tx.delete(ensureRecordId(target as RecordIdInput))),
+      relate: async (from: unknown, edgeTable: unknown, to: unknown, data?: Values<Record<string, unknown>>) =>
+        this.normalizeParseValue(
+          await tx.relate(
+            ensureRecordId(from as RecordIdInput),
+            this.normalizeTableValue(edgeTable),
+            ensureRecordId(to as RecordIdInput),
+            data
+              ? (this.normalizeMutationData(data as Record<string, unknown>) as Values<Record<string, unknown>>)
+              : undefined,
+          ),
         ),
       commit: () => tx.commit(),
       cancel: () => tx.cancel(),
@@ -540,7 +603,7 @@ export class SurrealDBService {
     return statements.at(0) ?? []
   }
 
-  async queryAll<T>(query: BoundQuery | BoundQueryLike, schema?: z.ZodType<T>): Promise<T[][]> {
+  async queryAll<T>(query: BoundQuery | BoundQueryLike, schema?: z.ZodTypeAny): Promise<T[][]> {
     const client = await this.ensureConnected()
     const boundQuery = this.normalizeBoundQuery(query)
     const queryText = this.resolveQueryText(boundQuery)
@@ -553,22 +616,22 @@ export class SurrealDBService {
           const failure = response.error
           throw new SurrealDBError(`Statement ${index + 1}: ${failure.message}`, queryText, { cause: failure })
         }
-        return this.normalizeQueryRows<T>(response.result, schema)
+        return this.normalizeQueryRows(response.result, schema) as T[]
       })
     } catch (error) {
-      this.toSurrealError(error, queryText)
+      return this.toSurrealError(error, queryText)
     }
   }
 
-  async queryOne<T extends z.ZodType>(query: BoundQuery | BoundQueryLike, schema: T): Promise<z.infer<T> | null> {
+  async queryOne<T extends z.ZodTypeAny>(query: BoundQuery | BoundQueryLike, schema: T): Promise<z.infer<T> | null> {
     const results = await this.query<unknown>(query)
     const first = results.at(0)
-    return first ? schema.parse(first) : null
+    return first ? this.parseSchema(schema, first) : null
   }
 
-  async queryMany<T extends z.ZodType>(query: BoundQuery | BoundQueryLike, schema: T): Promise<z.infer<T>[]> {
+  async queryMany<T extends z.ZodTypeAny>(query: BoundQuery | BoundQueryLike, schema: T): Promise<z.infer<T>[]> {
     const results = await this.query<unknown>(query)
-    return results.map((row) => schema.parse(row))
+    return results.map((row) => this.parseSchema(schema, row))
   }
 
   private async runSqlFile(file: Bun.BunFile): Promise<void> {
@@ -580,13 +643,13 @@ export class SurrealDBService {
     await this.queryAll<unknown>(new BoundQuery(sql))
   }
 
-  async applySchemaAndMigrations(schemaFiles: readonly Bun.BunFile[]): Promise<void> {
+  async applySchema(schemaFiles: readonly Bun.BunFile[]): Promise<void> {
     for (const schemaFile of schemaFiles) {
       await this.runSqlFile(schemaFile)
     }
   }
 
-  async findOne<T extends z.ZodType>(
+  async findOne<T extends z.ZodTypeAny>(
     table: DatabaseTable,
     filter: Record<string, unknown>,
     schema: T,
@@ -602,13 +665,13 @@ export class SurrealDBService {
 
       const rows = await query.limit(1)
       const first = rows.at(0)
-      return first ? schema.parse(first) : null
+      return first ? this.parseSchema(schema, first) : null
     } catch (error) {
-      this.toSurrealError(error, `SELECT * FROM ${table} LIMIT 1`)
+      return this.toSurrealError(error, `SELECT * FROM ${table} LIMIT 1`)
     }
   }
 
-  async findMany<T extends z.ZodType>(
+  async findMany<T extends z.ZodTypeAny>(
     table: DatabaseTable,
     filter: Record<string, unknown>,
     schema: T,
@@ -620,8 +683,15 @@ export class SurrealDBService {
     const selection = this.buildFilterExpression(filter)
     const orderBy = options?.orderBy
 
-    if (options && orderBy) {
-      const { orderDir = 'ASC', limit, offset } = options
+    if (orderBy !== undefined) {
+      this.assertValidIdentifier(orderBy, 'orderBy field')
+      this.assertValidIdentifier(table, 'table name')
+      for (const key of filterKeys) {
+        this.assertValidIdentifier(key, 'filter field')
+      }
+      const orderDir = options?.orderDir ?? 'ASC'
+      const limit = options?.limit
+      const offset = options?.offset
       const vars: Record<string, unknown> = this.normalizeMutationData(filter)
       let sql = `SELECT * FROM ${table}`
       if (filterKeys.length > 0) {
@@ -638,7 +708,7 @@ export class SurrealDBService {
         vars.offsetParam = offset
       }
       const rows = await this.query<unknown>(new BoundQuery(sql, vars))
-      return rows.map((row) => schema.parse(row))
+      return rows.map((row) => this.parseSchema(schema, row))
     }
 
     try {
@@ -654,13 +724,13 @@ export class SurrealDBService {
       }
 
       const rows = await query
-      return rows.map((row) => schema.parse(row))
+      return rows.map((row) => this.parseSchema(schema, row))
     } catch (error) {
-      this.toSurrealError(error, `SELECT * FROM ${table}`)
+      return this.toSurrealError(error, `SELECT * FROM ${table}`)
     }
   }
 
-  async create<T extends z.ZodType>(
+  async create<T extends z.ZodTypeAny>(
     table: DatabaseTable,
     data: Record<string, unknown>,
     schema: T,
@@ -683,13 +753,13 @@ export class SurrealDBService {
         throw new SurrealDBError(`Failed to create record in ${table}`)
       }
 
-      return schema.parse(first)
+      return this.parseSchema(schema, first)
     } catch (error) {
-      this.toSurrealError(error, `CREATE ${table}`)
+      return this.toSurrealError(error, `CREATE ${table}`)
     }
   }
 
-  async createWithId<T extends z.ZodType>(
+  async createWithId<T extends z.ZodTypeAny>(
     table: DatabaseTable,
     id: unknown,
     data: Record<string, unknown>,
@@ -705,13 +775,13 @@ export class SurrealDBService {
 
     try {
       const created = await client.create<unknown>(recordId).content(this.normalizeMutationData(data)).output('after')
-      return schema.parse(created)
+      return this.parseSchema(schema, created)
     } catch (error) {
-      this.toSurrealError(error, `CREATE ${recordId.toString()}`)
+      return this.toSurrealError(error, `CREATE ${recordId.toString()}`)
     }
   }
 
-  async update<T extends z.ZodType>(
+  async update<T extends z.ZodTypeAny>(
     table: DatabaseTable,
     id: unknown,
     data: Record<string, unknown>,
@@ -732,13 +802,13 @@ export class SurrealDBService {
       const builder = client.update<unknown>(recordId)
       const configured = configureMutation(builder, mutation, this.normalizeMutationData(data))
       const updated = await configured.output('after')
-      return updated ? schema.parse(updated) : null
+      return updated ? this.parseSchema(schema, updated) : null
     } catch (error) {
-      this.toSurrealError(error, `UPDATE ${recordId.toString()}`)
+      return this.toSurrealError(error, `UPDATE ${recordId.toString()}`)
     }
   }
 
-  async upsert<T extends z.ZodType>(
+  async upsert<T extends z.ZodTypeAny>(
     table: DatabaseTable,
     id: unknown,
     data: Record<string, unknown>,
@@ -761,55 +831,52 @@ export class SurrealDBService {
       if (!upserted) {
         throw new SurrealDBError(`Failed to upsert record in ${table}`)
       }
-      return schema.parse(upserted)
+      return this.parseSchema(schema, upserted)
     } catch (error) {
-      this.toSurrealError(error, `UPSERT ${recordId.toString()}`)
+      return this.toSurrealError(error, `UPSERT ${recordId.toString()}`)
     }
   }
 
   async deleteById(table: DatabaseTable, id: unknown): Promise<boolean> {
     const recordId = this.normalizeRecordId(id, table)
-    const client = await this.ensureConnected()
 
     try {
-      const matched = await client.select<{ id: unknown }>(new Table(table)).where(eq('id', recordId)).limit(1)
-      if (matched.length === 0) {
+      const result = await this.query<unknown>(new BoundQuery(`DELETE $recordId RETURN BEFORE`, { recordId }))
+      return result.length > 0
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('does not exist')) {
         return false
       }
-      await client.delete<unknown>(recordId).output('before')
-      return true
-    } catch (error) {
-      this.toSurrealError(error, `DELETE ${recordId.toString()}`)
+      return this.toSurrealError(error, `DELETE ${recordId.toString()}`)
     }
   }
 
   async deleteWhere(table: DatabaseTable, filter: Record<string, unknown>): Promise<number> {
+    this.assertValidIdentifier(table, 'table name')
     const filterKeys = Object.keys(filter)
     if (filterKeys.length === 0) {
       throw new SurrealDBError(`Refusing to delete all records in ${table} without a filter`)
     }
-
-    const selection = this.buildFilterExpression(filter)
-    if (!selection) {
-      throw new SurrealDBError(`Invalid delete filter for table ${table}`)
-    }
-
-    const client = await this.ensureConnected()
+    const { clause, bindings } = this.buildBoundFilterClauses(filter)
 
     try {
-      const matched = await client.select<{ id: unknown }>(new Table(table)).where(selection)
-      if (matched.length === 0) {
-        return 0
-      }
+      return await this.withTransaction(async (tx) => {
+        const matched = (await tx.query(new BoundQuery(`SELECT id FROM ${table} WHERE ${clause}`, bindings))) as Array<{
+          id: unknown
+        }>
 
-      for (const row of matched) {
-        const id = this.normalizeRecordId(row.id, table)
-        await client.delete(id)
-      }
+        if (matched.length === 0) {
+          return 0
+        }
+
+        for (const row of matched) {
+          await tx.delete(this.normalizeRecordId(row.id, table))
+        }
 
-      return matched.length
+        return matched.length
+      })
     } catch (error) {
-      this.toSurrealError(error, `DELETE ${table} WHERE ...`)
+      return this.toSurrealError(error, `DELETE ${table} WHERE ...`)
     }
   }
 
@@ -835,7 +902,7 @@ export class SurrealDBService {
       }
       return 1
     } catch (error) {
-      this.toSurrealError(error, `UPDATE ${table} WHERE ...`)
+      return this.toSurrealError(error, `UPDATE ${table} WHERE ...`)
     }
   }
 
@@ -854,7 +921,7 @@ export class SurrealDBService {
         .output('after')
       return inserted as T[]
     } catch (error) {
-      this.toSurrealError(error, `INSERT ${table}`)
+      return this.toSurrealError(error, `INSERT ${table}`)
     }
   }
 
@@ -884,7 +951,7 @@ export class SurrealDBService {
       }
       return related
     } catch (error) {
-      this.toSurrealError(error, `RELATE ${fromRef.toString()}->${edgeTable}->${toRef.toString()}`)
+      return this.toSurrealError(error, `RELATE ${fromRef.toString()}->${edgeTable}->${toRef.toString()}`)
     }
   }
 
@@ -893,7 +960,7 @@ export class SurrealDBService {
     try {
       return this.wrapTransaction(await client.beginTransaction())
     } catch (error) {
-      this.toSurrealError(error, 'BEGIN TRANSACTION')
+      return this.toSurrealError(error, 'BEGIN TRANSACTION')
     }
   }
 
@@ -942,10 +1009,14 @@ export const databaseService = new Proxy({} as SurrealDBService, {
       return databaseServiceOverrides.get(property)
     }
 
-    const target = resolveConfiguredDatabaseService() as unknown as Record<PropertyKey, unknown>
-    const value = target[property]
+    const resolved = resolveConfiguredDatabaseService()
+    const value: unknown = Reflect.get(resolved, property)
     if (typeof value === 'function') {
-      return bindTargetMethod(target, value as (...args: unknown[]) => unknown)
+      // SurrealDB SDK type gap — Reflect.get returns unknown, but we know the resolved target shape
+      return bindTargetMethod(
+        resolved as unknown as Record<PropertyKey, unknown>,
+        value as (...args: unknown[]) => unknown,
+      )
     }
 
     return value

package/src/db/startup.ts

@@ -1,9 +1,10 @@
+import { recordIdSchema } from '@lota-sdk/shared'
 import { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
 
-import type { SurrealDBService, SurrealDatabaseLogger } from '../db/service'
-import { TABLES } from '../db/tables'
-import { getErrorMessage } from '../utils/error'
+import { getErrorMessage } from '../utils/errors'
+import type { SurrealDBService, SurrealDatabaseLogger } from './service'
+import { TABLES } from './tables'
 
 const DATABASE_BOOTSTRAP_KEY = 'database-schema-ready'
 const DEFAULT_RETRY_DELAY_MS = 1_000
@@ -11,11 +12,11 @@ const DEFAULT_MAX_WAIT_MS = 3 * 60 * 1_000
 const RETRY_LOG_INTERVAL = 5
 
 const RuntimeBootstrapRecordSchema = z.object({
-  id: z.unknown(),
+  id: recordIdSchema,
   key: z.string(),
   schemaFingerprint: z.string(),
-  readyAt: z.union([z.date(), z.string(), z.number()]),
-  updatedAt: z.union([z.date(), z.string(), z.number()]),
+  readyAt: z.coerce.date(),
+  updatedAt: z.coerce.date().optional().nullable(),
 })
 
 type StartupLogger = Pick<SurrealDatabaseLogger, 'info' | 'warn' | 'error'>
@@ -62,7 +63,7 @@ export async function connectWithStartupRetry(params: {
 async function readDatabaseBootstrapRecord(
   databaseService: SurrealDBService,
 ): Promise<z.infer<typeof RuntimeBootstrapRecordSchema> | null> {
-  return await databaseService.queryOne(
+  return databaseService.queryOne(
     new BoundQuery(
       `SELECT *
        FROM ${TABLES.RUNTIME_BOOTSTRAP}
@@ -141,12 +142,7 @@ export async function publishDatabaseBootstrap(params: {
   await params.databaseService.upsert(
     TABLES.RUNTIME_BOOTSTRAP,
     new RecordId(TABLES.RUNTIME_BOOTSTRAP, DATABASE_BOOTSTRAP_KEY),
-    {
-      key: DATABASE_BOOTSTRAP_KEY,
-      schemaFingerprint: params.schemaFingerprint,
-      readyAt: new Date(),
-      updatedAt: new Date(),
-    },
+    { key: DATABASE_BOOTSTRAP_KEY, schemaFingerprint: params.schemaFingerprint, readyAt: new Date() },
     RuntimeBootstrapRecordSchema,
   )
 }