@lota-sdk/core 0.4.9 → 0.4.10

package/src/db/service.ts

@@ -1,4 +1,4 @@
-import { Duration, Effect, Schedule } from 'effect'
+import { Duration, Effect, Schedule, Semaphore } from 'effect'
 import { BoundQuery, ServerError, Surreal, Table, createRemoteEngines } from 'surrealdb'
 import type { ExprLike, SurrealTransaction, Values } from 'surrealdb'
 import { ZodError } from 'zod'
@@ -8,8 +8,8 @@ import { serverLogger } from '../config/logger'
 import type { AwaitableEffect } from '../effect/awaitable-effect'
 import { toAwaitableEffect } from '../effect/awaitable-effect'
 import { getErrorMessage } from '../utils/errors'
-import type { RecordIdInput } from './record-id'
-import { ensureRecordId } from './record-id'
+import type { RecordIdInput, ensureRecordId } from './record-id'
+import { ensureRecordIdEffect } from './record-id'
 import {
   assertValidIdentifier,
   buildBoundFilterClauses,
@@ -71,6 +71,8 @@ type CreateBuilderSource = {
   output: (mode: 'after' | 'before') => unknown
 }
 
+type PendingMutation = { mutation: RecordMutation; data: Record<string, unknown> }
+
 export type CreateMutationBuilder = {
   content: (data: Record<string, unknown>) => CreateMutationBuilder
   output: (mode: 'after' | 'before') => AwaitableEffect<unknown, SurrealDBError>
@@ -106,22 +108,29 @@ function isRetriableConnectError(error: unknown): boolean {
   )
 }
 
+function isSurrealDBError(error: unknown): error is SurrealDBError {
+  return typeof error === 'object' && error !== null && (error as { _tag?: unknown })._tag === 'SurrealDBError'
+}
+
 export class SurrealDBService {
   private client: Surreal | null = null
   private isConnected = false
+  // Single-permit semaphore acts as a mutex so only one connect attempt runs at a time.
+  // Subsequent waiters re-check `isConnected` after acquiring the permit and become no-ops.
+  private readonly connectMutex = Semaphore.makeUnsafe(1)
 
   constructor(
     private readonly config: SurrealDatabaseConfig,
     private readonly logger?: SurrealDatabaseLogger,
   ) {}
 
-  private toSurrealError(error: unknown, query?: string): SurrealDBError | ZodError {
-    if (error instanceof SurrealDBError) {
+  private toSurrealError(error: unknown, query?: string): SurrealDBError {
+    if (isSurrealDBError(error)) {
       return error
     }
 
     if (error instanceof ZodError) {
-      return error
+      return new SurrealDBError({ message: error.message, query: query, cause: error })
     }
 
     if (error instanceof ServerError) {
@@ -151,33 +160,34 @@ export class SurrealDBService {
 
     const codecOptions = { useNativeDates: true }
 
-    const self = this
-    return Effect.gen(function* () {
-      if (self.client) {
-        return self.client
-      }
+    return Effect.gen(
+      function* (this: SurrealDBService) {
+        if (this.client) {
+          return this.client
+        }
 
-      if (self.isEmbeddedEngine(self.config.url)) {
-        const { createNodeEngines } = yield* Effect.tryPromise({
-          try: () => import('@surrealdb/node'),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to load embedded SurrealDB engine: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })
-        self.client = new Surreal({
-          engines: { ...createRemoteEngines(), ...createNodeEngines() } as NonNullable<
-            ConstructorParameters<typeof Surreal>[0]
-          >['engines'],
-          codecOptions,
-        })
-        return self.client
-      }
-
-      self.client = new Surreal({ engines: createRemoteEngines(), codecOptions })
-      return self.client
-    })
+        if (this.isEmbeddedEngine(this.config.url)) {
+          const { createNodeEngines } = yield* Effect.tryPromise({
+            try: () => import('@surrealdb/node'),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to load embedded SurrealDB engine: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })
+          this.client = new Surreal({
+            engines: { ...createRemoteEngines(), ...createNodeEngines() } as NonNullable<
+              ConstructorParameters<typeof Surreal>[0]
+            >['engines'],
+            codecOptions,
+          })
+          return this.client
+        }
+
+        this.client = new Surreal({ engines: createRemoteEngines(), codecOptions })
+        return this.client
+      }.bind(this),
+    )
   }
 
   private resetClient(): Effect.Effect<void, never> {
@@ -207,83 +217,110 @@ export class SurrealDBService {
   }
 
   connect(): AwaitableEffect<void, SurrealDBError> {
-    if (this.isConnected) {
-      return toAwaitableEffect(Effect.void)
-    }
+    return toAwaitableEffect(
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          // Fast path: already connected. Cheap, runs inside the Effect so callers
+          // observe the same memory barrier the slow path relies on.
+          if (this.isConnected) {
+            return
+          }
 
-    const connectEffect = this.getOrCreateClient().pipe(
-      Effect.flatMap((client) =>
-        Effect.tryPromise({
-          try: () =>
-            client.connect(this.config.url, {
-              namespace: this.config.namespace,
-              database: this.config.database,
-              authentication: this.isEmbeddedEngine(this.config.url)
-                ? undefined
-                : { username: this.config.username ?? '', password: this.config.password ?? '' },
-            }),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to connect to SurrealDB (${this.config.url}): ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        }).pipe(
-          Effect.timeout(Duration.millis(CONNECT_ATTEMPT_TIMEOUT_MS)),
-          Effect.catchTag('TimeoutError', () =>
-            Effect.fail(new SurrealDBError({ message: `Timed out connecting to SurrealDB (${this.config.url})` })),
-          ),
-        ),
-      ),
-      Effect.tap(() =>
-        Effect.sync(() => {
-          this.isConnected = true
-          this.logger?.info?.('Connected to SurrealDB')
-        }),
-      ),
-      Effect.tapError(() =>
-        Effect.sync(() => {
-          this.isConnected = false
-        }).pipe(Effect.andThen(this.resetClient())),
+          // Slow path: serialize concurrent connect attempts behind a single permit
+          // so only one client.connect() ever runs. Late waiters double-check
+          // isConnected after acquiring the permit and become no-ops.
+          yield* this.connectMutex.withPermits(1)(this.connectLockedEffect())
+        }.bind(this),
       ),
-      Effect.retry({
-        times: CONNECT_MAX_ATTEMPTS - 1,
-        schedule: Schedule.jittered(Schedule.exponential(Duration.millis(CONNECT_RETRY_BASE_DELAY_MS), 2)),
-        while: isRetriableConnectError,
-      }),
-      Effect.asVoid,
     )
-
-    return toAwaitableEffect(connectEffect)
   }
 
-  disconnect(): AwaitableEffect<void, SurrealDBError> {
-    const self = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
-        if (!self.isConnected) {
+  private connectLockedEffect(): Effect.Effect<void, SurrealDBError> {
+    return Effect.gen(
+      function* (this: SurrealDBService) {
+        if (this.isConnected) {
           return
         }
 
-        self.isConnected = false
-
-        const client = self.client
-        if (!client) {
-          self.client = null
-          return
-        }
-
-        yield* Effect.tryPromise({
-          try: () => client.close(),
-          catch: (error) =>
-            new SurrealDBError({ message: `Failed to close database client: ${getErrorMessage(error)}`, cause: error }),
-        }).pipe(
-          Effect.ensuring(
+        const connectEffect = this.getOrCreateClient().pipe(
+          Effect.flatMap((client) =>
+            Effect.tryPromise({
+              try: () =>
+                client.connect(this.config.url, {
+                  namespace: this.config.namespace,
+                  database: this.config.database,
+                  authentication: this.isEmbeddedEngine(this.config.url)
+                    ? undefined
+                    : { username: this.config.username ?? '', password: this.config.password ?? '' },
+                }),
+              catch: (error) =>
+                new SurrealDBError({
+                  message: `Failed to connect to SurrealDB (${this.config.url}): ${getErrorMessage(error)}`,
+                  cause: error,
+                }),
+            }).pipe(
+              Effect.timeout(Duration.millis(CONNECT_ATTEMPT_TIMEOUT_MS)),
+              Effect.catchTag('TimeoutError', () =>
+                Effect.fail(new SurrealDBError({ message: `Timed out connecting to SurrealDB (${this.config.url})` })),
+              ),
+            ),
+          ),
+          Effect.tap(() =>
             Effect.sync(() => {
-              self.client = null
+              this.isConnected = true
+              this.logger?.info?.('Connected to SurrealDB')
             }),
           ),
+          Effect.tapError(() =>
+            Effect.sync(() => {
+              this.isConnected = false
+            }).pipe(Effect.andThen(this.resetClient())),
+          ),
+          Effect.retry({
+            times: CONNECT_MAX_ATTEMPTS - 1,
+            schedule: Schedule.jittered(Schedule.exponential(Duration.millis(CONNECT_RETRY_BASE_DELAY_MS), 2)),
+            while: isRetriableConnectError,
+          }),
+          Effect.asVoid,
         )
-      }),
+
+        yield* connectEffect
+      }.bind(this),
+    )
+  }
+
+  disconnect(): AwaitableEffect<void, SurrealDBError> {
+    return toAwaitableEffect(
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          if (!this.isConnected) {
+            return
+          }
+
+          this.isConnected = false
+
+          const client = this.client
+          if (!client) {
+            this.client = null
+            return
+          }
+
+          yield* Effect.tryPromise({
+            try: () => client.close(),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to close database client: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          }).pipe(
+            Effect.ensuring(
+              Effect.sync(() => {
+                this.client = null
+              }),
+            ),
+          )
+        }.bind(this),
+      ),
     )
   }
 
@@ -292,7 +329,7 @@ export class SurrealDBService {
       return this.connect().pipe(
         Effect.flatMap(() => this.getOrCreateClient()),
         Effect.mapError((error) =>
-          error instanceof SurrealDBError
+          isSurrealDBError(error)
             ? error
             : new SurrealDBError({ message: 'Database not connected', query, cause: error }),
         ),
@@ -302,7 +339,10 @@ export class SurrealDBService {
     return Effect.succeed(this.client)
   }
 
-  private normalizeRecordId(id: unknown, table: DatabaseTable): ReturnType<typeof ensureRecordId> {
+  private normalizeRecordIdEffect(
+    id: unknown,
+    table: DatabaseTable,
+  ): Effect.Effect<ReturnType<typeof ensureRecordId>, SurrealDBError> {
     return normalizeRecordIdForTable(id, table)
   }
 
@@ -310,14 +350,35 @@ export class SurrealDBService {
     return normalizeQueryRows(statement, schema, (schemaValue, value) => this.parseSchema(schemaValue, value))
   }
 
+  private normalizeQueryRowsEffect(
+    statement: unknown,
+    schema?: z.ZodTypeAny,
+  ): Effect.Effect<unknown[], SurrealDBError> {
+    return Effect.try({
+      try: () => this.normalizeQueryRows(statement, schema),
+      catch: (error) => this.toSurrealError(error),
+    })
+  }
+
   private normalizeParseValue(value: unknown): unknown {
     return normalizeSurrealValue(value)
   }
 
+  private normalizeParseValueEffect(value: unknown): Effect.Effect<unknown, SurrealDBError> {
+    return Effect.try({ try: () => this.normalizeParseValue(value), catch: (error) => this.toSurrealError(error) })
+  }
+
   private parseSchema<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown): z.infer<TSchema> {
     return schema.parse(this.normalizeParseValue(value))
   }
 
+  private parseSchemaEffect<TSchema extends z.ZodTypeAny>(
+    schema: TSchema,
+    value: unknown,
+  ): Effect.Effect<z.infer<TSchema>, SurrealDBError> {
+    return Effect.try({ try: () => this.parseSchema(schema, value), catch: (error) => this.toSurrealError(error) })
+  }
+
   private parseOptionalSchema<TSchema extends z.ZodTypeAny>(schema: TSchema, value: unknown): z.infer<TSchema> | null {
     if (value === null || value === undefined) {
       return null
@@ -326,22 +387,43 @@ export class SurrealDBService {
     return this.parseSchema(schema, value)
   }
 
+  private parseOptionalSchemaEffect<TSchema extends z.ZodTypeAny>(
+    schema: TSchema,
+    value: unknown,
+  ): Effect.Effect<z.infer<TSchema> | null, SurrealDBError> {
+    return Effect.try({
+      try: () => this.parseOptionalSchema(schema, value),
+      catch: (error) => this.toSurrealError(error),
+    })
+  }
+
   private buildFilterExpression(filter: Record<string, unknown>): ExprLike | undefined {
     return buildFilterExpression(filter)
   }
 
-  private buildBoundFilterClauses(filter: Record<string, unknown>): {
-    clause: string
-    bindings: Record<string, unknown>
-  } {
+  private buildFilterExpressionEffect(
+    filter: Record<string, unknown>,
+  ): Effect.Effect<ExprLike | undefined, SurrealDBError> {
+    return Effect.try({ try: () => this.buildFilterExpression(filter), catch: (error) => this.toSurrealError(error) })
+  }
+
+  private buildBoundFilterClausesEffect(
+    filter: Record<string, unknown>,
+  ): Effect.Effect<{ clause: string; bindings: Record<string, unknown> }, SurrealDBError> {
     return buildBoundFilterClauses(filter)
   }
 
-  private normalizeBoundQuery<T extends unknown[] = unknown[]>(query: BoundQuery<T>): BoundQuery<T> {
+  private assertValidIdentifierEffect(name: string, context: string): Effect.Effect<void, SurrealDBError> {
+    return assertValidIdentifier(name, context)
+  }
+
+  private normalizeBoundQueryEffect<T extends unknown[] = unknown[]>(
+    query: BoundQuery<T>,
+  ): Effect.Effect<BoundQuery<T>, SurrealDBError> {
     return normalizeBoundQuery(query)
   }
 
-  private normalizeTransactionQuery(query: unknown): BoundQuery {
+  private normalizeTransactionQueryEffect(query: unknown): Effect.Effect<BoundQuery, SurrealDBError> {
     return normalizeTransactionQuery(query)
   }
 
@@ -349,114 +431,176 @@ export class SurrealDBService {
     return normalizeMutationData(data)
   }
 
-  private normalizeTableValue(value: unknown): Table<string> {
+  private normalizeMutationDataEffect(
+    data: Record<string, unknown>,
+  ): Effect.Effect<Record<string, unknown>, SurrealDBError> {
+    return Effect.try({ try: () => this.normalizeMutationData(data), catch: (error) => this.toSurrealError(error) })
+  }
+
+  private normalizeTableValueEffect(value: unknown): Effect.Effect<Table<string>, SurrealDBError> {
     return normalizeTableValue(value)
   }
 
-  private normalizeCreateTarget(value: unknown): Table<string> | ReturnType<typeof ensureRecordId> {
+  private normalizeCreateTargetEffect(
+    value: unknown,
+  ): Effect.Effect<Table<string> | ReturnType<typeof ensureRecordId>, SurrealDBError> {
     return normalizeCreateTarget(value)
   }
 
-  private wrapMutationBuilder(builder: MutationBuilderSource): MutationBuilder {
+  private normalizeTransactionRecordIdEffect(
+    value: unknown,
+    context: string,
+  ): Effect.Effect<ReturnType<typeof ensureRecordId>, SurrealDBError> {
+    return normalizeTransactionRecordId(value, context)
+  }
+
+  private wrapMutationBuilder(
+    builderEffect: Effect.Effect<MutationBuilderSource, SurrealDBError>,
+    pendingMutation?: PendingMutation,
+  ): MutationBuilder {
     return {
-      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))),
+      content: (data) => this.wrapMutationBuilder(builderEffect, { mutation: 'content', data }),
+      replace: (data) => this.wrapMutationBuilder(builderEffect, { mutation: 'replace', data }),
+      merge: (data) => this.wrapMutationBuilder(builderEffect, { mutation: 'merge', data }),
       output: (mode) =>
         toAwaitableEffect(
-          Effect.tryPromise({
-            try: () => Promise.resolve(builder.output(mode)),
-            catch: (error) =>
-              new SurrealDBError({
-                message: `Failed to finish mutation output: ${getErrorMessage(error)}`,
-                cause: error,
-              }),
-          }).pipe(Effect.map((value) => this.normalizeParseValue(value))),
+          Effect.gen(
+            function* (this: SurrealDBService) {
+              const builder = yield* builderEffect
+              let configuredBuilder = builder
+              if (pendingMutation) {
+                const normalizedData = yield* this.normalizeMutationDataEffect(pendingMutation.data)
+                configuredBuilder = configureMutation(builder, pendingMutation.mutation, normalizedData)
+              }
+              const value = yield* Effect.tryPromise({
+                try: () => Promise.resolve(configuredBuilder.output(mode)),
+                catch: (error) =>
+                  new SurrealDBError({
+                    message: `Failed to finish mutation output: ${getErrorMessage(error)}`,
+                    cause: error,
+                  }),
+              })
+              return yield* this.normalizeParseValueEffect(value)
+            }.bind(this),
+          ),
         ),
     }
   }
 
-  private wrapCreateBuilder(builder: CreateBuilderSource): CreateMutationBuilder {
+  private wrapCreateBuilder(
+    builderEffect: Effect.Effect<CreateBuilderSource, SurrealDBError>,
+    pendingData?: Record<string, unknown>,
+  ): CreateMutationBuilder {
     return {
-      content: (data) => this.wrapCreateBuilder(builder.content(this.normalizeMutationData(data))),
+      content: (data) => this.wrapCreateBuilder(builderEffect, data),
       output: (mode) =>
         toAwaitableEffect(
-          Effect.tryPromise({
-            try: () => Promise.resolve(builder.output(mode)),
-            catch: (error) =>
-              new SurrealDBError({
-                message: `Failed to finish create output: ${getErrorMessage(error)}`,
-                cause: error,
-              }),
-          }).pipe(Effect.map((value) => this.normalizeParseValue(value))),
+          Effect.gen(
+            function* (this: SurrealDBService) {
+              const builder = yield* builderEffect
+              const configuredBuilder = pendingData
+                ? builder.content(yield* this.normalizeMutationDataEffect(pendingData))
+                : builder
+              const value = yield* Effect.tryPromise({
+                try: () => Promise.resolve(configuredBuilder.output(mode)),
+                catch: (error) =>
+                  new SurrealDBError({
+                    message: `Failed to finish create output: ${getErrorMessage(error)}`,
+                    cause: error,
+                  }),
+              })
+              return yield* this.normalizeParseValueEffect(value)
+            }.bind(this),
+          ),
         ),
     }
   }
 
   private wrapTransaction(tx: SurrealTransaction): DatabaseTransaction {
-    const self = this
     return {
-      query: (query: unknown) => {
-        const boundQuery = self.normalizeTransactionQuery(query)
-        const queryText = self.resolveQueryText(boundQuery)
-        return toAwaitableEffect(
-          Effect.gen(function* () {
-            const responses = yield* Effect.tryPromise({
-              try: () => tx.query(boundQuery).responses(),
-              catch: (error) =>
-                new SurrealDBError({
-                  message: `Failed to run transaction query: ${getErrorMessage(error)}`,
-                  query: queryText,
-                  cause: error,
-                }),
-            })
-            const first = responses.at(0)
-            if (!first) {
-              return []
-            }
-            if (!first.success) {
-              return yield* new SurrealDBError({ message: first.error.message, query: queryText, cause: first.error })
-            }
-
-            return self.normalizeQueryRows(first.result)
-          }),
-        )
-      },
-      create: (target: unknown) => {
-        const normalizedTarget = self.normalizeCreateTarget(target)
-        const builder: CreateBuilderSource =
-          normalizedTarget instanceof Table ? tx.create(normalizedTarget) : tx.create(normalizedTarget)
-        return self.wrapCreateBuilder(builder)
-      },
+      query: (query: unknown) =>
+        toAwaitableEffect(
+          Effect.gen(
+            function* (this: SurrealDBService) {
+              const boundQuery = yield* this.normalizeTransactionQueryEffect(query)
+              const queryText = this.resolveQueryText(boundQuery)
+              const responses = yield* Effect.tryPromise({
+                try: () => tx.query(boundQuery).responses(),
+                catch: (error) =>
+                  new SurrealDBError({
+                    message: `Failed to run transaction query: ${getErrorMessage(error)}`,
+                    query: queryText,
+                    cause: error,
+                  }),
+              })
+              const first = responses.at(0)
+              if (!first) {
+                return []
+              }
+              if (!first.success) {
+                return yield* new SurrealDBError({ message: first.error.message, query: queryText, cause: first.error })
+              }
+
+              return yield* this.normalizeQueryRowsEffect(first.result)
+            }.bind(this),
+          ),
+        ),
+      create: (target: unknown) =>
+        this.wrapCreateBuilder(
+          Effect.gen(
+            function* (this: SurrealDBService) {
+              const normalizedTarget = yield* this.normalizeCreateTargetEffect(target)
+              return normalizedTarget instanceof Table ? tx.create(normalizedTarget) : tx.create(normalizedTarget)
+            }.bind(this),
+          ),
+        ),
       update: (target: unknown) =>
-        self.wrapMutationBuilder(tx.update(normalizeTransactionRecordId(target, 'transaction update'))),
+        this.wrapMutationBuilder(
+          Effect.gen(
+            function* (this: SurrealDBService) {
+              const recordId = yield* this.normalizeTransactionRecordIdEffect(target, 'transaction update')
+              return tx.update(recordId)
+            }.bind(this),
+          ),
+        ),
       delete: (target: unknown) =>
         toAwaitableEffect(
-          Effect.tryPromise({
-            try: () => tx.delete(normalizeTransactionRecordId(target, 'transaction delete')),
-            catch: (error) =>
-              new SurrealDBError({
-                message: `Failed to delete transaction target: ${getErrorMessage(error)}`,
-                cause: error,
-              }),
-          }).pipe(Effect.map((value) => this.normalizeParseValue(value))),
+          Effect.gen(
+            function* (this: SurrealDBService) {
+              const recordId = yield* this.normalizeTransactionRecordIdEffect(target, 'transaction delete')
+              const value = yield* Effect.tryPromise({
+                try: () => tx.delete(recordId),
+                catch: (error) =>
+                  new SurrealDBError({
+                    message: `Failed to delete transaction target: ${getErrorMessage(error)}`,
+                    cause: error,
+                  }),
+              })
+              return yield* this.normalizeParseValueEffect(value)
+            }.bind(this),
+          ),
         ),
       relate: (from: unknown, edgeTable: unknown, to: unknown, data?: Values<Record<string, unknown>>) =>
         toAwaitableEffect(
-          Effect.tryPromise({
-            try: () =>
-              tx.relate(
-                normalizeTransactionRecordId(from, 'transaction relate source'),
-                self.normalizeTableValue(edgeTable),
-                normalizeTransactionRecordId(to, 'transaction relate target'),
-                data ? self.normalizeMutationData(data as Record<string, unknown>) : undefined,
-              ),
-            catch: (error) =>
-              new SurrealDBError({
-                message: `Failed to relate transaction records: ${getErrorMessage(error)}`,
-                cause: error,
-              }),
-          }).pipe(Effect.map((value) => this.normalizeParseValue(value))),
+          Effect.gen(
+            function* (this: SurrealDBService) {
+              const fromRecordId = yield* this.normalizeTransactionRecordIdEffect(from, 'transaction relate source')
+              const normalizedEdgeTable = yield* this.normalizeTableValueEffect(edgeTable)
+              const toRecordId = yield* this.normalizeTransactionRecordIdEffect(to, 'transaction relate target')
+              const normalizedData = data
+                ? yield* this.normalizeMutationDataEffect(data as Record<string, unknown>)
+                : undefined
+              const value = yield* Effect.tryPromise({
+                try: () => tx.relate(fromRecordId, normalizedEdgeTable, toRecordId, normalizedData),
+                catch: (error) =>
+                  new SurrealDBError({
+                    message: `Failed to relate transaction records: ${getErrorMessage(error)}`,
+                    cause: error,
+                  }),
+              })
+              return yield* this.normalizeParseValueEffect(value)
+            }.bind(this),
+          ),
         ),
       commit: () =>
         toAwaitableEffect(
@@ -482,86 +626,93 @@ export class SurrealDBService {
   }
 
   query<T>(query: BoundQuery): AwaitableEffect<T[], SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const boundQuery = self.normalizeBoundQuery(query)
-        const statements = yield* self.queryAll<T>(boundQuery)
-        return statements.at(0) ?? []
-      }),
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const boundQuery = yield* this.normalizeBoundQueryEffect(query)
+          const statements = yield* this.queryAll<T>(boundQuery)
+          return statements.at(0) ?? []
+        }.bind(this),
+      ),
     )
   }
 
   queryAll<T>(query: BoundQuery, schema?: z.ZodTypeAny): AwaitableEffect<T[][], SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const boundQuery = self.normalizeBoundQuery(query)
-        const queryText = self.resolveQueryText(boundQuery)
-        const client = yield* self.ensureConnectedEffect(queryText)
-        const responses = yield* Effect.tryPromise({
-          try: () => client.query(boundQuery).responses(),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to run query: ${getErrorMessage(error)}`,
-              query: queryText,
-              cause: error,
-            }),
-        })
-        return yield* Effect.forEach(responses, (response, index) =>
-          Effect.gen(function* () {
-            if (!response.success) {
-              const failure = response.error
-              return yield* new SurrealDBError({
-                message: `Statement ${index + 1}: ${failure.message}`,
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const boundQuery = yield* this.normalizeBoundQueryEffect(query)
+          const queryText = this.resolveQueryText(boundQuery)
+          const client = yield* this.ensureConnectedEffect(queryText)
+          const responses = yield* Effect.tryPromise({
+            try: () => client.query(boundQuery).responses(),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to run query: ${getErrorMessage(error)}`,
                 query: queryText,
-                cause: failure,
-              })
-            }
-            return self.normalizeQueryRows(response.result, schema) as T[]
-          }),
-        )
-      }),
+                cause: error,
+              }),
+          })
+          return yield* Effect.forEach(responses, (response, index) =>
+            Effect.gen(
+              function* (this: SurrealDBService) {
+                if (!response.success) {
+                  const failure = response.error
+                  return yield* new SurrealDBError({
+                    message: `Statement ${index + 1}: ${failure.message}`,
+                    query: queryText,
+                    cause: failure,
+                  })
+                }
+                return (yield* this.normalizeQueryRowsEffect(response.result, schema)) as T[]
+              }.bind(this),
+            ),
+          )
+        }.bind(this),
+      ),
     )
   }
 
   queryOne<T extends z.ZodTypeAny>(query: BoundQuery, schema: T): AwaitableEffect<z.infer<T> | null, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const boundQuery = self.normalizeBoundQuery(query)
-        const results = yield* self.query<unknown>(boundQuery)
-        const first = results.at(0)
-        return first ? self.parseSchema(schema, first) : null
-      }),
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const boundQuery = yield* this.normalizeBoundQueryEffect(query)
+          const results = yield* this.query<unknown>(boundQuery)
+          const first = results.at(0)
+          return first ? yield* this.parseSchemaEffect(schema, first) : null
+        }.bind(this),
+      ),
     )
   }
 
   queryMany<T extends z.ZodTypeAny>(query: BoundQuery, schema: T): AwaitableEffect<z.infer<T>[], SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const boundQuery = self.normalizeBoundQuery(query)
-        const results = yield* self.query<unknown>(boundQuery)
-        return results.map((row) => self.parseSchema(schema, row))
-      }),
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const boundQuery = yield* this.normalizeBoundQueryEffect(query)
+          const results = yield* this.query<unknown>(boundQuery)
+          return yield* Effect.forEach(results, (row) => this.parseSchemaEffect(schema, row))
+        }.bind(this),
+      ),
     )
   }
 
   private runSqlFile(file: Bun.BunFile): Effect.Effect<void, SurrealDBError> {
-    const self = this
-    return Effect.gen(function* () {
-      const sql = (yield* Effect.tryPromise({
-        try: () => file.text(),
-        catch: (error) =>
-          new SurrealDBError({ message: `Failed to read schema file: ${getErrorMessage(error)}`, cause: error }),
-      })).trim()
-      if (!sql) {
-        return
-      }
-
-      yield* self.queryAll<unknown>(new BoundQuery(sql))
-    })
+    return Effect.gen(
+      function* (this: SurrealDBService) {
+        const sql = (yield* Effect.tryPromise({
+          try: () => file.text(),
+          catch: (error) =>
+            new SurrealDBError({ message: `Failed to read schema file: ${getErrorMessage(error)}`, cause: error }),
+        })).trim()
+        if (!sql) {
+          return
+        }
+
+        yield* this.queryAll<unknown>(new BoundQuery(sql))
+      }.bind(this),
+    )
   }
 
   applySchema(schemaFiles: readonly Bun.BunFile[]): AwaitableEffect<void, SurrealDBError> {
@@ -575,27 +726,28 @@ export class SurrealDBService {
     filter: Record<string, unknown>,
     schema: T,
   ): AwaitableEffect<z.infer<T> | null, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const selection = self.buildFilterExpression(filter)
-        const client = yield* self.ensureConnectedEffect(`SELECT * FROM ${table} LIMIT 1`)
-        let query = client.select<unknown>(new Table(table))
-        if (selection) {
-          query = query.where(selection)
-        }
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const selection = yield* this.buildFilterExpressionEffect(filter)
+          const client = yield* this.ensureConnectedEffect(`SELECT * FROM ${table} LIMIT 1`)
+          let query = client.select<unknown>(new Table(table))
+          if (selection) {
+            query = query.where(selection)
+          }
 
-        const rows = yield* Effect.tryPromise({
-          try: () => query.limit(1),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to find record in ${table}: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })
-        const first = rows.at(0)
-        return first ? self.parseSchema(schema, first) : null
-      }),
+          const rows = yield* Effect.tryPromise({
+            try: () => query.limit(1),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to find record in ${table}: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })
+          const first = rows.at(0)
+          return first ? yield* this.parseSchemaEffect(schema, first) : null
+        }.bind(this),
+      ),
     )
   }
 
@@ -605,69 +757,70 @@ export class SurrealDBService {
     schema: T,
     options?: FindManyOptions,
   ): AwaitableEffect<z.infer<T>[], SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const filterKeys = Object.keys(filter)
-        const selection = self.buildFilterExpression(filter)
-        const orderBy = options?.orderBy
-
-        if (orderBy !== undefined) {
-          assertValidIdentifier(orderBy, 'orderBy field')
-          assertValidIdentifier(table, 'table name')
-          for (const key of filterKeys) {
-            assertValidIdentifier(key, 'filter field')
-          }
-          const rawOrderDir: unknown = options?.orderDir
-          if (rawOrderDir !== undefined && rawOrderDir !== 'ASC' && rawOrderDir !== 'DESC') {
-            return yield* new SurrealDBError({
-              message: `Invalid orderDir value: ${describeInvalidValue(rawOrderDir)}`,
-            })
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const filterKeys = Object.keys(filter)
+          const selection = yield* this.buildFilterExpressionEffect(filter)
+          const orderBy = options?.orderBy
+
+          if (orderBy !== undefined) {
+            yield* this.assertValidIdentifierEffect(orderBy, 'orderBy field')
+            yield* this.assertValidIdentifierEffect(table, 'table name')
+            for (const key of filterKeys) {
+              yield* this.assertValidIdentifierEffect(key, 'filter field')
+            }
+            const rawOrderDir: unknown = options?.orderDir
+            if (rawOrderDir !== undefined && rawOrderDir !== 'ASC' && rawOrderDir !== 'DESC') {
+              return yield* new SurrealDBError({
+                message: `Invalid orderDir value: ${describeInvalidValue(rawOrderDir)}`,
+              })
+            }
+            const orderDir = rawOrderDir ?? 'ASC'
+            const limit = options?.limit
+            const offset = options?.offset
+            const vars: Record<string, unknown> = yield* this.normalizeMutationDataEffect(filter)
+            let sql = `SELECT * FROM ${table}`
+            if (filterKeys.length > 0) {
+              const conditions = filterKeys.map((key) => `${key} = $${key}`).join(' AND ')
+              sql += ` WHERE ${conditions}`
+            }
+            sql += ` ORDER BY ${orderBy} ${orderDir}`
+            if (limit !== undefined) {
+              sql += ' LIMIT $limitParam'
+              vars.limitParam = limit
+            }
+            if (offset !== undefined) {
+              sql += ' START $offsetParam'
+              vars.offsetParam = offset
+            }
+            const rows = yield* this.query<unknown>(new BoundQuery(sql, vars))
+            return yield* Effect.forEach(rows, (row) => this.parseSchemaEffect(schema, row))
           }
-          const orderDir = rawOrderDir ?? 'ASC'
-          const limit = options?.limit
-          const offset = options?.offset
-          const vars: Record<string, unknown> = self.normalizeMutationData(filter)
-          let sql = `SELECT * FROM ${table}`
-          if (filterKeys.length > 0) {
-            const conditions = filterKeys.map((key) => `${key} = $${key}`).join(' AND ')
-            sql += ` WHERE ${conditions}`
+
+          const client = yield* this.ensureConnectedEffect(`SELECT * FROM ${table}`)
+          let query = client.select<unknown>(new Table(table))
+          if (selection) {
+            query = query.where(selection)
           }
-          sql += ` ORDER BY ${orderBy} ${orderDir}`
-          if (limit !== undefined) {
-            sql += ' LIMIT $limitParam'
-            vars.limitParam = limit
+          if (options?.offset !== undefined) {
+            query = query.start(options.offset)
           }
-          if (offset !== undefined) {
-            sql += ' START $offsetParam'
-            vars.offsetParam = offset
+          if (options?.limit !== undefined) {
+            query = query.limit(options.limit)
           }
-          const rows = yield* self.query<unknown>(new BoundQuery(sql, vars))
-          return rows.map((row) => self.parseSchema(schema, row))
-        }
 
-        const client = yield* self.ensureConnectedEffect(`SELECT * FROM ${table}`)
-        let query = client.select<unknown>(new Table(table))
-        if (selection) {
-          query = query.where(selection)
-        }
-        if (options?.offset !== undefined) {
-          query = query.start(options.offset)
-        }
-        if (options?.limit !== undefined) {
-          query = query.limit(options.limit)
-        }
-
-        const rows = yield* Effect.tryPromise({
-          try: () => query,
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to run findMany query for ${table}: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })
-        return rows.map((row) => self.parseSchema(schema, row))
-      }),
+          const rows = yield* Effect.tryPromise({
+            try: () => query,
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to run findMany query for ${table}: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })
+          return yield* Effect.forEach(rows, (row) => this.parseSchemaEffect(schema, row))
+        }.bind(this),
+      ),
     )
   }
 
@@ -676,31 +829,33 @@ export class SurrealDBService {
     data: Record<string, unknown>,
     schema: T,
   ): AwaitableEffect<z.infer<T>, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const keys = Object.keys(data)
-        if (keys.length === 0) {
-          return yield* new SurrealDBError({ message: `Cannot create record in ${table} with empty data` })
-        }
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const keys = Object.keys(data)
+          if (keys.length === 0) {
+            return yield* new SurrealDBError({ message: `Cannot create record in ${table} with empty data` })
+          }
 
-        const client = yield* self.ensureConnectedEffect(`CREATE ${table}`)
-        const created = yield* Effect.tryPromise({
-          try: () => client.create<unknown>(new Table(table)).content(self.normalizeMutationData(data)).output('after'),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to create record in ${table}: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })
-        const first = Array.isArray(created) ? created.at(0) : created
+          const client = yield* this.ensureConnectedEffect(`CREATE ${table}`)
+          const normalizedData = yield* this.normalizeMutationDataEffect(data)
+          const created = yield* Effect.tryPromise({
+            try: () => client.create<unknown>(new Table(table)).content(normalizedData).output('after'),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to create record in ${table}: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })
+          const first = Array.isArray(created) ? created.at(0) : created
 
-        if (!first) {
-          return yield* new SurrealDBError({ message: `Failed to create record in ${table}` })
-        }
+          if (!first) {
+            return yield* new SurrealDBError({ message: `Failed to create record in ${table}` })
+          }
 
-        return self.parseSchema(schema, first)
-      }),
+          return yield* this.parseSchemaEffect(schema, first)
+        }.bind(this),
+      ),
     )
   }
 
@@ -710,26 +865,28 @@ export class SurrealDBService {
     data: Record<string, unknown>,
     schema: T,
   ): AwaitableEffect<z.infer<T>, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const recordId = self.normalizeRecordId(id, table)
-        const keys = Object.keys(data)
-        if (keys.length === 0) {
-          return yield* new SurrealDBError({ message: `Cannot create record in ${table} with empty data` })
-        }
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const recordId = yield* this.normalizeRecordIdEffect(id, table)
+          const keys = Object.keys(data)
+          if (keys.length === 0) {
+            return yield* new SurrealDBError({ message: `Cannot create record in ${table} with empty data` })
+          }
 
-        const client = yield* self.ensureConnectedEffect(`CREATE ${recordId.toString()}`)
-        const created = yield* Effect.tryPromise({
-          try: () => client.create<unknown>(recordId).content(self.normalizeMutationData(data)).output('after'),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to create record in ${table}: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })
-        return self.parseSchema(schema, created)
-      }),
+          const client = yield* this.ensureConnectedEffect(`CREATE ${recordId.toString()}`)
+          const normalizedData = yield* this.normalizeMutationDataEffect(data)
+          const created = yield* Effect.tryPromise({
+            try: () => client.create<unknown>(recordId).content(normalizedData).output('after'),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to create record in ${table}: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })
+          return yield* this.parseSchemaEffect(schema, created)
+        }.bind(this),
+      ),
     )
   }
 
@@ -740,28 +897,30 @@ export class SurrealDBService {
     schema: T,
     options?: { mutation?: RecordMutation },
   ): AwaitableEffect<z.infer<T> | null, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const recordId = self.normalizeRecordId(id, table)
-        const keys = Object.keys(data)
-        if (keys.length === 0) {
-          return yield* new SurrealDBError({ message: 'Cannot update record with empty data' })
-        }
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const recordId = yield* this.normalizeRecordIdEffect(id, table)
+          const keys = Object.keys(data)
+          if (keys.length === 0) {
+            return yield* new SurrealDBError({ message: 'Cannot update record with empty data' })
+          }
 
-        const mutation = options?.mutation ?? 'merge'
-        const client = yield* self.ensureConnectedEffect(`UPDATE ${recordId.toString()}`)
-        const builder = client.update<unknown>(recordId)
-        const updated: Record<string, unknown> | null | undefined = yield* Effect.tryPromise({
-          try: () => configureMutation(builder, mutation, self.normalizeMutationData(data)).output('after'),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to update record in ${table}: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })
-        return self.parseOptionalSchema(schema, updated)
-      }),
+          const mutation = options?.mutation ?? 'merge'
+          const client = yield* this.ensureConnectedEffect(`UPDATE ${recordId.toString()}`)
+          const builder = client.update<unknown>(recordId)
+          const normalizedData = yield* this.normalizeMutationDataEffect(data)
+          const updated: Record<string, unknown> | null | undefined = yield* Effect.tryPromise({
+            try: () => configureMutation(builder, mutation, normalizedData).output('after'),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to update record in ${table}: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })
+          return yield* this.parseOptionalSchemaEffect(schema, updated)
+        }.bind(this),
+      ),
     )
   }
 
@@ -772,82 +931,89 @@ export class SurrealDBService {
     schema: T,
     options?: { mutation?: RecordMutation },
   ): AwaitableEffect<z.infer<T>, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const recordId = self.normalizeRecordId(id, table)
-        const keys = Object.keys(data)
-        if (keys.length === 0) {
-          return yield* new SurrealDBError({ message: 'Cannot upsert record with empty data' })
-        }
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const recordId = yield* this.normalizeRecordIdEffect(id, table)
+          const keys = Object.keys(data)
+          if (keys.length === 0) {
+            return yield* new SurrealDBError({ message: 'Cannot upsert record with empty data' })
+          }
 
-        const mutation = options?.mutation ?? 'merge'
-        const client = yield* self.ensureConnectedEffect(`UPSERT ${recordId.toString()}`)
-        const builder = client.upsert<unknown>(recordId)
-        const upserted: Record<string, unknown> | null | undefined = yield* Effect.tryPromise({
-          try: () => configureMutation(builder, mutation, self.normalizeMutationData(data)).output('after'),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to upsert record in ${table}: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })
-        const parsed = self.parseOptionalSchema(schema, upserted)
-        if (parsed === null) {
-          return yield* new SurrealDBError({ message: `Failed to upsert record in ${table}` })
-        }
-        return parsed
-      }),
+          const mutation = options?.mutation ?? 'merge'
+          const client = yield* this.ensureConnectedEffect(`UPSERT ${recordId.toString()}`)
+          const builder = client.upsert<unknown>(recordId)
+          const normalizedData = yield* this.normalizeMutationDataEffect(data)
+          const upserted: Record<string, unknown> | null | undefined = yield* Effect.tryPromise({
+            try: () => configureMutation(builder, mutation, normalizedData).output('after'),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to upsert record in ${table}: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })
+          const parsed = yield* this.parseOptionalSchemaEffect(schema, upserted)
+          if (parsed === null) {
+            return yield* new SurrealDBError({ message: `Failed to upsert record in ${table}` })
+          }
+          return parsed
+        }.bind(this),
+      ),
     )
   }
 
   deleteById(table: DatabaseTable, id: unknown): AwaitableEffect<boolean, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const recordId = self.normalizeRecordId(id, table)
-        return yield* self.query<unknown>(new BoundQuery(`DELETE $recordId RETURN BEFORE`, { recordId })).pipe(
-          Effect.map((result) => result.length > 0),
-          Effect.catchTag('SurrealDBError', (error) => {
-            if (error.message.includes('does not exist')) {
-              return Effect.succeed(false)
-            }
-
-            return Effect.fail(self.toSurrealError(error, `DELETE ${recordId.toString()}`) as SurrealDBError)
-          }),
-        )
-      }),
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const recordId = yield* this.normalizeRecordIdEffect(id, table)
+          return yield* this.query<unknown>(new BoundQuery(`DELETE $recordId RETURN BEFORE`, { recordId })).pipe(
+            Effect.map((result) => result.length > 0),
+            Effect.catchTag('SurrealDBError', (error) => {
+              if (error.message.includes('does not exist')) {
+                return Effect.succeed(false)
+              }
+
+              return Effect.fail(this.toSurrealError(error, `DELETE ${recordId.toString()}`))
+            }),
+          )
+        }.bind(this),
+      ),
     )
   }
 
   deleteWhere(table: DatabaseTable, filter: Record<string, unknown>): AwaitableEffect<number, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        assertValidIdentifier(table, 'table name')
-        const filterKeys = Object.keys(filter)
-        if (filterKeys.length === 0) {
-          return yield* new SurrealDBError({ message: `Refusing to delete all records in ${table} without a filter` })
-        }
-        const { clause, bindings } = self.buildBoundFilterClauses(filter)
-        return yield* self.withTransaction((tx) =>
-          Effect.gen(function* () {
-            const matchedRows = (yield* tx.query(
-              new BoundQuery(`SELECT id FROM ${table} WHERE ${clause}`, bindings),
-            )) as Array<{ id: unknown }>
-
-            if (matchedRows.length === 0) {
-              return 0
-            }
-
-            for (const row of matchedRows) {
-              yield* tx.delete(self.normalizeRecordId(row.id, table))
-            }
-
-            return matchedRows.length
-          }),
-        )
-      }),
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          yield* this.assertValidIdentifierEffect(table, 'table name')
+          const filterKeys = Object.keys(filter)
+          if (filterKeys.length === 0) {
+            return yield* new SurrealDBError({ message: `Refusing to delete all records in ${table} without a filter` })
+          }
+          const { clause, bindings } = yield* this.buildBoundFilterClausesEffect(filter)
+          return yield* this.withTransaction((tx) =>
+            Effect.gen(
+              function* (this: SurrealDBService) {
+                const matchedRows = (yield* tx.query(
+                  new BoundQuery(`SELECT id FROM ${table} WHERE ${clause}`, bindings),
+                )) as Array<{ id: unknown }>
+
+                if (matchedRows.length === 0) {
+                  return 0
+                }
+
+                for (const row of matchedRows) {
+                  const recordId = yield* this.normalizeRecordIdEffect(row.id, table)
+                  yield* tx.delete(recordId)
+                }
+
+                return matchedRows.length
+              }.bind(this),
+            ),
+          )
+        }.bind(this),
+      ),
     )
   }
 
@@ -856,33 +1022,32 @@ export class SurrealDBService {
     where: ExprLike,
     data: Record<string, unknown>,
   ): AwaitableEffect<number, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        if (!where) {
-          return yield* new SurrealDBError({ message: `Refusing to update records in ${table} without a where clause` })
-        }
-        const keys = Object.keys(data)
-        if (keys.length === 0) {
-          return yield* new SurrealDBError({ message: `Cannot update records in ${table} with empty data` })
-        }
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          if (!where) {
+            return yield* new SurrealDBError({
+              message: `Refusing to update records in ${table} without a where clause`,
+            })
+          }
+          const keys = Object.keys(data)
+          if (keys.length === 0) {
+            return yield* new SurrealDBError({ message: `Cannot update records in ${table} with empty data` })
+          }
 
-        const client = yield* self.ensureConnectedEffect(`UPDATE ${table} WHERE ...`)
-        const updated = yield* Effect.tryPromise({
-          try: () =>
-            client
-              .update<unknown>(new Table(table))
-              .where(where)
-              .merge(self.normalizeMutationData(data))
-              .output('after'),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to update records in ${table}: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })
-        return Array.isArray(updated) ? updated.length : 1
-      }),
+          const client = yield* this.ensureConnectedEffect(`UPDATE ${table} WHERE ...`)
+          const normalizedData = yield* this.normalizeMutationDataEffect(data)
+          const updated = yield* Effect.tryPromise({
+            try: () => client.update<unknown>(new Table(table)).where(where).merge(normalizedData).output('after'),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to update records in ${table}: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })
+          return Array.isArray(updated) ? updated.length : 1
+        }.bind(this),
+      ),
     )
   }
 
@@ -890,23 +1055,24 @@ export class SurrealDBService {
     table: DatabaseTable,
     data: Values<T> | Array<Values<T>>,
   ): AwaitableEffect<T[], SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const client = yield* self.ensureConnectedEffect(`INSERT ${table}`)
-        const normalized = Array.isArray(data)
-          ? data.map((item) => self.normalizeMutationData(item as Record<string, unknown>))
-          : self.normalizeMutationData(data as Record<string, unknown>)
-        const inserted = yield* Effect.tryPromise({
-          try: () => client.insert<T>(new Table(table), normalized as Values<T> | Array<Values<T>>).output('after'),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to insert rows into ${table}: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })
-        return inserted as T[]
-      }),
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const client = yield* this.ensureConnectedEffect(`INSERT ${table}`)
+          const normalized = Array.isArray(data)
+            ? yield* Effect.forEach(data, (item) => this.normalizeMutationDataEffect(item as Record<string, unknown>))
+            : yield* this.normalizeMutationDataEffect(data as Record<string, unknown>)
+          const inserted = yield* Effect.tryPromise({
+            try: () => client.insert<T>(new Table(table), normalized as Values<T> | Array<Values<T>>).output('after'),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to insert rows into ${table}: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })
+          return inserted as T[]
+        }.bind(this),
+      ),
     )
   }
 
@@ -916,72 +1082,74 @@ export class SurrealDBService {
     to: RecordIdInput,
     data?: Values<T>,
   ): AwaitableEffect<T | null, SurrealDBError> {
-    const fromRef = ensureRecordId(from)
-    const toRef = ensureRecordId(to)
-
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const client = yield* self.ensureConnectedEffect(
-          `RELATE ${fromRef.toString()}->${edgeTable}->${toRef.toString()}`,
-        )
-        const normalizedData = data
-          ? (self.normalizeMutationData(data as Record<string, unknown>) as Values<T>)
-          : undefined
-        const related = (yield* Effect.tryPromise({
-          try: () => client.relate<T>(fromRef, new Table(edgeTable), toRef, normalizedData).output('after'),
-          catch: (error) =>
-            new SurrealDBError({
-              message: `Failed to relate records ${fromRef.toString()} -> ${edgeTable} -> ${toRef.toString()}: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        })) as T | T[] | null
-        if (related === null) {
-          return null
-        }
-        if (Array.isArray(related)) {
-          return related.at(0) ?? null
-        }
-        return related
-      }),
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const fromRef = yield* ensureRecordIdEffect(from).pipe(Effect.mapError((error) => this.toSurrealError(error)))
+          const toRef = yield* ensureRecordIdEffect(to).pipe(Effect.mapError((error) => this.toSurrealError(error)))
+          const client = yield* this.ensureConnectedEffect(
+            `RELATE ${fromRef.toString()}->${edgeTable}->${toRef.toString()}`,
+          )
+          const normalizedData = data
+            ? ((yield* this.normalizeMutationDataEffect(data as Record<string, unknown>)) as Values<T>)
+            : undefined
+          const related = (yield* Effect.tryPromise({
+            try: () => client.relate<T>(fromRef, new Table(edgeTable), toRef, normalizedData).output('after'),
+            catch: (error) =>
+              new SurrealDBError({
+                message: `Failed to relate records ${fromRef.toString()} -> ${edgeTable} -> ${toRef.toString()}: ${getErrorMessage(error)}`,
+                cause: error,
+              }),
+          })) as T | T[] | null
+          if (related === null) {
+            return null
+          }
+          if (Array.isArray(related)) {
+            return related.at(0) ?? null
+          }
+          return related
+        }.bind(this),
+      ),
     )
   }
 
   beginTransaction(): AwaitableEffect<DatabaseTransaction, SurrealDBError> {
-    const self = this
     return toAwaitableEffect(
-      Effect.gen(function* () {
-        const client = yield* self.ensureConnectedEffect('BEGIN TRANSACTION')
-        const tx = yield* Effect.tryPromise({
-          try: () => client.beginTransaction(),
-          catch: (error) =>
-            new SurrealDBError({ message: `Failed to begin transaction: ${getErrorMessage(error)}`, cause: error }),
-        })
-        return self.wrapTransaction(tx)
-      }),
+      Effect.gen(
+        function* (this: SurrealDBService) {
+          const client = yield* this.ensureConnectedEffect('BEGIN TRANSACTION')
+          const tx = yield* Effect.tryPromise({
+            try: () => client.beginTransaction(),
+            catch: (error) =>
+              new SurrealDBError({ message: `Failed to begin transaction: ${getErrorMessage(error)}`, cause: error }),
+          })
+          return this.wrapTransaction(tx)
+        }.bind(this),
+      ),
     )
   }
 
   withTransaction<T, E, R>(
     work: (tx: DatabaseTransaction) => Effect.Effect<T, E, R>,
   ): Effect.Effect<T, SurrealDBError | E, R> {
-    const self = this
-    return Effect.gen(function* () {
-      const tx = yield* self.beginTransaction()
-      const cancelEffect = tx.cancel().pipe(
-        Effect.catch((cancelError: SurrealDBError) =>
-          Effect.sync(() => {
-            self.logger?.warn?.(`Failed to cancel transaction after error: ${cancelError.message}`)
-          }),
-        ),
-        Effect.asVoid,
-      )
+    return Effect.gen(
+      function* (this: SurrealDBService) {
+        const tx = yield* this.beginTransaction()
+        const cancelEffect = tx.cancel().pipe(
+          Effect.catch((cancelError: SurrealDBError) =>
+            Effect.sync(() => {
+              this.logger?.warn?.(`Failed to cancel transaction after error: ${cancelError.message}`)
+            }),
+          ),
+          Effect.asVoid,
+        )
 
-      return yield* Effect.gen(function* () {
-        const result = yield* work(tx)
-        yield* tx.commit()
-        return result
-      }).pipe(Effect.onError(() => cancelEffect))
-    })
+        return yield* Effect.gen(function* () {
+          const result = yield* work(tx)
+          yield* tx.commit()
+          return result
+        }).pipe(Effect.onError(() => cancelEffect))
+      }.bind(this),
+    )
   }
 }