@lota-sdk/core 0.4.9 → 0.4.11

package/src/db/service.ts

@@ -1,15 +1,13 @@
-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'
 import type { z } from 'zod'
 
 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,
@@ -63,7 +61,7 @@ export type MutationBuilder = {
   content: (data: Record<string, unknown>) => MutationBuilder
   replace: (data: Record<string, unknown>) => MutationBuilder
   merge: (data: Record<string, unknown>) => MutationBuilder
-  output: (mode: 'after' | 'before') => AwaitableEffect<unknown, SurrealDBError>
+  output: (mode: 'after' | 'before') => Effect.Effect<unknown, SurrealDBError, never>
 }
 
 type CreateBuilderSource = {
@@ -71,24 +69,26 @@ 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>
+  output: (mode: 'after' | 'before') => Effect.Effect<unknown, SurrealDBError, never>
 }
 
 export interface DatabaseTransaction {
-  query: (query: unknown) => AwaitableEffect<unknown, SurrealDBError>
+  query: (query: unknown) => Effect.Effect<unknown, SurrealDBError, never>
   create: (target: unknown) => CreateMutationBuilder
   update: (target: unknown) => MutationBuilder
-  delete: (target: unknown) => AwaitableEffect<unknown, SurrealDBError>
+  delete: (target: unknown) => Effect.Effect<unknown, SurrealDBError, never>
   relate: (
     from: unknown,
     edgeTable: unknown,
     to: unknown,
     data?: Values<Record<string, unknown>>,
-  ) => AwaitableEffect<unknown, SurrealDBError>
-  commit: () => AwaitableEffect<void, SurrealDBError>
-  cancel: () => AwaitableEffect<void, SurrealDBError>
+  ) => Effect.Effect<unknown, SurrealDBError, never>
+  commit: () => Effect.Effect<void, SurrealDBError, never>
+  cancel: () => Effect.Effect<void, SurrealDBError, never>
 }
 
 const CONNECT_MAX_ATTEMPTS = 5
@@ -106,22 +106,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 +158,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
-      }
+        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
+        }
 
-      self.client = new Surreal({ engines: createRemoteEngines(), codecOptions })
-      return self.client
-    })
+        this.client = new Surreal({ engines: createRemoteEngines(), codecOptions })
+        return this.client
+      }.bind(this),
+    )
   }
 
   private resetClient(): Effect.Effect<void, never> {
@@ -206,69 +214,89 @@ export class SurrealDBService {
     )
   }
 
-  connect(): AwaitableEffect<void, SurrealDBError> {
-    if (this.isConnected) {
-      return toAwaitableEffect(Effect.void)
-    }
+  connect(): Effect.Effect<void, SurrealDBError, never> {
+    return 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,
+        // 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),
+    )
+  }
+
+  private connectLockedEffect(): Effect.Effect<void, SurrealDBError> {
+    return Effect.gen(
+      function* (this: SurrealDBService) {
+        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')
             }),
-        }).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())),
-      ),
-      Effect.retry({
-        times: CONNECT_MAX_ATTEMPTS - 1,
-        schedule: Schedule.jittered(Schedule.exponential(Duration.millis(CONNECT_RETRY_BASE_DELAY_MS), 2)),
-        while: isRetriableConnectError,
-      }),
-      Effect.asVoid,
-    )
+          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,
+        )
 
-    return toAwaitableEffect(connectEffect)
+        yield* connectEffect
+      }.bind(this),
+    )
   }
 
-  disconnect(): AwaitableEffect<void, SurrealDBError> {
-    const self = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
-        if (!self.isConnected) {
+  disconnect(): Effect.Effect<void, SurrealDBError, never> {
+    return Effect.gen(
+      function* (this: SurrealDBService) {
+        if (!this.isConnected) {
           return
         }
 
-        self.isConnected = false
+        this.isConnected = false
 
-        const client = self.client
+        const client = this.client
         if (!client) {
-          self.client = null
+          this.client = null
           return
         }
 
@@ -279,11 +307,11 @@ export class SurrealDBService {
         }).pipe(
           Effect.ensuring(
             Effect.sync(() => {
-              self.client = null
+              this.client = null
             }),
           ),
         )
-      }),
+      }.bind(this),
     )
   }
 
@@ -292,7 +320,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 +330,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 +341,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 +378,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,58 +422,94 @@ 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* () {
+      query: (query: unknown) =>
+        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) =>
@@ -418,62 +527,74 @@ export class SurrealDBService {
               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)
-      },
+            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(
-          Effect.tryPromise({
-            try: () => tx.commit(),
-            catch: (error) =>
-              new SurrealDBError({ message: `Failed to commit transaction: ${getErrorMessage(error)}`, cause: error }),
-          }),
-        ),
+        Effect.tryPromise({
+          try: () => tx.commit(),
+          catch: (error) =>
+            new SurrealDBError({ message: `Failed to commit transaction: ${getErrorMessage(error)}`, cause: error }),
+        }),
       cancel: () =>
-        toAwaitableEffect(
-          Effect.tryPromise({
-            try: () => tx.cancel(),
-            catch: (error) =>
-              new SurrealDBError({ message: `Failed to cancel transaction: ${getErrorMessage(error)}`, cause: error }),
-          }),
-        ),
+        Effect.tryPromise({
+          try: () => tx.cancel(),
+          catch: (error) =>
+            new SurrealDBError({ message: `Failed to cancel transaction: ${getErrorMessage(error)}`, cause: error }),
+        }),
     }
   }
 
@@ -481,24 +602,22 @@ export class SurrealDBService {
     return query.query
   }
 
-  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)
+  query<T>(query: BoundQuery): Effect.Effect<T[], SurrealDBError, never> {
+    return 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)
+  queryAll<T>(query: BoundQuery, schema?: z.ZodTypeAny): Effect.Effect<T[][], SurrealDBError, never> {
+    return 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) =>
@@ -509,77 +628,78 @@ export class SurrealDBService {
             }),
         })
         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}`,
-                query: queryText,
-                cause: failure,
-              })
-            }
-            return self.normalizeQueryRows(response.result, schema) as T[]
-          }),
+          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)
+  queryOne<T extends z.ZodTypeAny>(
+    query: BoundQuery,
+    schema: T,
+  ): Effect.Effect<z.infer<T> | null, SurrealDBError, never> {
+    return 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 ? self.parseSchema(schema, first) : null
-      }),
+        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))
-      }),
+  queryMany<T extends z.ZodTypeAny>(query: BoundQuery, schema: T): Effect.Effect<z.infer<T>[], SurrealDBError, never> {
+    return 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
+        }
 
-  applySchema(schemaFiles: readonly Bun.BunFile[]): AwaitableEffect<void, SurrealDBError> {
-    return toAwaitableEffect(
-      Effect.forEach(schemaFiles, (schemaFile) => this.runSqlFile(schemaFile), { discard: true }),
+        yield* this.queryAll<unknown>(new BoundQuery(sql))
+      }.bind(this),
     )
   }
 
+  applySchema(schemaFiles: readonly Bun.BunFile[]): Effect.Effect<void, SurrealDBError, never> {
+    return Effect.forEach(schemaFiles, (schemaFile) => this.runSqlFile(schemaFile), { discard: true })
+  }
+
   findOne<T extends z.ZodTypeAny>(
     table: DatabaseTable,
     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`)
+  ): Effect.Effect<z.infer<T> | null, SurrealDBError, never> {
+    return 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)
@@ -594,8 +714,8 @@ export class SurrealDBService {
             }),
         })
         const first = rows.at(0)
-        return first ? self.parseSchema(schema, first) : null
-      }),
+        return first ? yield* this.parseSchemaEffect(schema, first) : null
+      }.bind(this),
     )
   }
 
@@ -604,19 +724,18 @@ export class SurrealDBService {
     filter: Record<string, unknown>,
     schema: T,
     options?: FindManyOptions,
-  ): AwaitableEffect<z.infer<T>[], SurrealDBError> {
-    const self = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
+  ): Effect.Effect<z.infer<T>[], SurrealDBError, never> {
+    return Effect.gen(
+      function* (this: SurrealDBService) {
         const filterKeys = Object.keys(filter)
-        const selection = self.buildFilterExpression(filter)
+        const selection = yield* this.buildFilterExpressionEffect(filter)
         const orderBy = options?.orderBy
 
         if (orderBy !== undefined) {
-          assertValidIdentifier(orderBy, 'orderBy field')
-          assertValidIdentifier(table, 'table name')
+          yield* this.assertValidIdentifierEffect(orderBy, 'orderBy field')
+          yield* this.assertValidIdentifierEffect(table, 'table name')
           for (const key of filterKeys) {
-            assertValidIdentifier(key, 'filter field')
+            yield* this.assertValidIdentifierEffect(key, 'filter field')
           }
           const rawOrderDir: unknown = options?.orderDir
           if (rawOrderDir !== undefined && rawOrderDir !== 'ASC' && rawOrderDir !== 'DESC') {
@@ -627,7 +746,7 @@ export class SurrealDBService {
           const orderDir = rawOrderDir ?? 'ASC'
           const limit = options?.limit
           const offset = options?.offset
-          const vars: Record<string, unknown> = self.normalizeMutationData(filter)
+          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 ')
@@ -642,11 +761,11 @@ export class SurrealDBService {
             sql += ' START $offsetParam'
             vars.offsetParam = offset
           }
-          const rows = yield* self.query<unknown>(new BoundQuery(sql, vars))
-          return rows.map((row) => self.parseSchema(schema, row))
+          const rows = yield* this.query<unknown>(new BoundQuery(sql, vars))
+          return yield* Effect.forEach(rows, (row) => this.parseSchemaEffect(schema, row))
         }
 
-        const client = yield* self.ensureConnectedEffect(`SELECT * FROM ${table}`)
+        const client = yield* this.ensureConnectedEffect(`SELECT * FROM ${table}`)
         let query = client.select<unknown>(new Table(table))
         if (selection) {
           query = query.where(selection)
@@ -666,8 +785,8 @@ export class SurrealDBService {
               cause: error,
             }),
         })
-        return rows.map((row) => self.parseSchema(schema, row))
-      }),
+        return yield* Effect.forEach(rows, (row) => this.parseSchemaEffect(schema, row))
+      }.bind(this),
     )
   }
 
@@ -675,18 +794,18 @@ export class SurrealDBService {
     table: DatabaseTable,
     data: Record<string, unknown>,
     schema: T,
-  ): AwaitableEffect<z.infer<T>, SurrealDBError> {
-    const self = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
+  ): Effect.Effect<z.infer<T>, SurrealDBError, never> {
+    return 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 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(self.normalizeMutationData(data)).output('after'),
+          try: () => client.create<unknown>(new Table(table)).content(normalizedData).output('after'),
           catch: (error) =>
             new SurrealDBError({
               message: `Failed to create record in ${table}: ${getErrorMessage(error)}`,
@@ -699,8 +818,8 @@ export class SurrealDBService {
           return yield* new SurrealDBError({ message: `Failed to create record in ${table}` })
         }
 
-        return self.parseSchema(schema, first)
-      }),
+        return yield* this.parseSchemaEffect(schema, first)
+      }.bind(this),
     )
   }
 
@@ -709,27 +828,27 @@ export class SurrealDBService {
     id: unknown,
     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)
+  ): Effect.Effect<z.infer<T>, SurrealDBError, never> {
+    return 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 client = yield* this.ensureConnectedEffect(`CREATE ${recordId.toString()}`)
+        const normalizedData = yield* this.normalizeMutationDataEffect(data)
         const created = yield* Effect.tryPromise({
-          try: () => client.create<unknown>(recordId).content(self.normalizeMutationData(data)).output('after'),
+          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 self.parseSchema(schema, created)
-      }),
+        return yield* this.parseSchemaEffect(schema, created)
+      }.bind(this),
     )
   }
 
@@ -739,29 +858,29 @@ export class SurrealDBService {
     data: Record<string, unknown>,
     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)
+  ): Effect.Effect<z.infer<T> | null, SurrealDBError, never> {
+    return 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 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, self.normalizeMutationData(data)).output('after'),
+          try: () => configureMutation(builder, mutation, normalizedData).output('after'),
           catch: (error) =>
             new SurrealDBError({
               message: `Failed to update record in ${table}: ${getErrorMessage(error)}`,
               cause: error,
             }),
         })
-        return self.parseOptionalSchema(schema, updated)
-      }),
+        return yield* this.parseOptionalSchemaEffect(schema, updated)
+      }.bind(this),
     )
   }
 
@@ -771,83 +890,84 @@ export class SurrealDBService {
     data: Record<string, unknown>,
     schema: T,
     options?: { mutation?: RecordMutation },
-  ): AwaitableEffect<z.infer<T>, SurrealDBError> {
-    const self = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
-        const recordId = self.normalizeRecordId(id, table)
+  ): Effect.Effect<z.infer<T>, SurrealDBError, never> {
+    return 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 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, self.normalizeMutationData(data)).output('after'),
+          try: () => configureMutation(builder, mutation, normalizedData).output('after'),
           catch: (error) =>
             new SurrealDBError({
               message: `Failed to upsert record in ${table}: ${getErrorMessage(error)}`,
               cause: error,
             }),
         })
-        const parsed = self.parseOptionalSchema(schema, upserted)
+        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(
+  deleteById(table: DatabaseTable, id: unknown): Effect.Effect<boolean, SurrealDBError, never> {
+    return 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(self.toSurrealError(error, `DELETE ${recordId.toString()}`) as SurrealDBError)
+            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')
+  deleteWhere(table: DatabaseTable, filter: Record<string, unknown>): Effect.Effect<number, SurrealDBError, never> {
+    return 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 } = 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
-          }),
+        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),
     )
   }
 
@@ -855,10 +975,9 @@ export class SurrealDBService {
     table: DatabaseTable,
     where: ExprLike,
     data: Record<string, unknown>,
-  ): AwaitableEffect<number, SurrealDBError> {
-    const self = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
+  ): Effect.Effect<number, SurrealDBError, never> {
+    return Effect.gen(
+      function* (this: SurrealDBService) {
         if (!where) {
           return yield* new SurrealDBError({ message: `Refusing to update records in ${table} without a where clause` })
         }
@@ -867,14 +986,10 @@ export class SurrealDBService {
           return yield* new SurrealDBError({ message: `Cannot update records in ${table} with empty data` })
         }
 
-        const client = yield* self.ensureConnectedEffect(`UPDATE ${table} WHERE ...`)
+        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(self.normalizeMutationData(data))
-              .output('after'),
+          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)}`,
@@ -882,21 +997,20 @@ export class SurrealDBService {
             }),
         })
         return Array.isArray(updated) ? updated.length : 1
-      }),
+      }.bind(this),
     )
   }
 
   insert<T extends Record<string, unknown>>(
     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}`)
+  ): Effect.Effect<T[], SurrealDBError, never> {
+    return Effect.gen(
+      function* (this: SurrealDBService) {
+        const client = yield* this.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>)
+          ? 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) =>
@@ -906,7 +1020,7 @@ export class SurrealDBService {
             }),
         })
         return inserted as T[]
-      }),
+      }.bind(this),
     )
   }
 
@@ -915,18 +1029,16 @@ export class SurrealDBService {
     edgeTable: DatabaseTable,
     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(
+  ): Effect.Effect<T | null, SurrealDBError, never> {
+    return 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
-          ? (self.normalizeMutationData(data as Record<string, unknown>) as Values<T>)
+          ? ((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'),
@@ -943,45 +1055,45 @@ export class SurrealDBService {
           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')
+  beginTransaction(): Effect.Effect<DatabaseTransaction, SurrealDBError, never> {
+    return 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 self.wrapTransaction(tx)
-      }),
+        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),
+    )
   }
 }