@lota-sdk/core 0.4.10 → 0.4.11

package/src/db/service.ts

@@ -5,8 +5,6 @@ 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, ensureRecordId } from './record-id'
 import { ensureRecordIdEffect } from './record-id'
@@ -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 = {
@@ -75,22 +73,22 @@ 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
@@ -216,22 +214,20 @@ export class SurrealDBService {
     )
   }
 
-  connect(): AwaitableEffect<void, SurrealDBError> {
-    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
-          }
+  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
+        }
 
-          // 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),
-      ),
+        // 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),
     )
   }
 
@@ -289,38 +285,33 @@ export class SurrealDBService {
     )
   }
 
-  disconnect(): AwaitableEffect<void, SurrealDBError> {
-    return toAwaitableEffect(
-      Effect.gen(
-        function* (this: SurrealDBService) {
-          if (!this.isConnected) {
-            return
-          }
+  disconnect(): Effect.Effect<void, SurrealDBError, never> {
+    return Effect.gen(
+      function* (this: SurrealDBService) {
+        if (!this.isConnected) {
+          return
+        }
 
-          this.isConnected = false
+        this.isConnected = false
 
-          const client = this.client
-          if (!client) {
-            this.client = null
-            return
-          }
+        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),
-      ),
+        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),
     )
   }
 
@@ -463,26 +454,24 @@ export class SurrealDBService {
       replace: (data) => this.wrapMutationBuilder(builderEffect, { mutation: 'replace', data }),
       merge: (data) => this.wrapMutationBuilder(builderEffect, { mutation: 'merge', data }),
       output: (mode) =>
-        toAwaitableEffect(
-          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),
-          ),
+        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),
         ),
     }
   }
@@ -494,24 +483,22 @@ export class SurrealDBService {
     return {
       content: (data) => this.wrapCreateBuilder(builderEffect, data),
       output: (mode) =>
-        toAwaitableEffect(
-          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),
-          ),
+        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),
         ),
     }
   }
@@ -519,31 +506,29 @@ export class SurrealDBService {
   private wrapTransaction(tx: SurrealTransaction): DatabaseTransaction {
     return {
       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 })
-              }
+        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),
-          ),
+            return yield* this.normalizeQueryRowsEffect(first.result)
+          }.bind(this),
         ),
       create: (target: unknown) =>
         this.wrapCreateBuilder(
@@ -564,60 +549,52 @@ export class SurrealDBService {
           ),
         ),
       delete: (target: unknown) =>
-        toAwaitableEffect(
-          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),
-          ),
+        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.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),
-          ),
+        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 }),
+        }),
     }
   }
 
@@ -625,76 +602,71 @@ export class SurrealDBService {
     return query.query
   }
 
-  query<T>(query: BoundQuery): AwaitableEffect<T[], SurrealDBError> {
-    return toAwaitableEffect(
-      Effect.gen(
-        function* (this: SurrealDBService) {
-          const boundQuery = yield* this.normalizeBoundQueryEffect(query)
-          const statements = yield* this.queryAll<T>(boundQuery)
-          return statements.at(0) ?? []
-        }.bind(this),
-      ),
+  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> {
-    return toAwaitableEffect(
-      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: 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),
-      ),
+  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) =>
+            new SurrealDBError({
+              message: `Failed to run query: ${getErrorMessage(error)}`,
+              query: queryText,
+              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> {
-    return toAwaitableEffect(
-      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),
-      ),
+  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 ? yield* this.parseSchemaEffect(schema, first) : null
+      }.bind(this),
     )
   }
 
-  queryMany<T extends z.ZodTypeAny>(query: BoundQuery, schema: T): AwaitableEffect<z.infer<T>[], SurrealDBError> {
-    return toAwaitableEffect(
-      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),
-      ),
+  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),
     )
   }
 
@@ -715,39 +687,35 @@ export class SurrealDBService {
     )
   }
 
-  applySchema(schemaFiles: readonly Bun.BunFile[]): AwaitableEffect<void, SurrealDBError> {
-    return toAwaitableEffect(
-      Effect.forEach(schemaFiles, (schemaFile) => this.runSqlFile(schemaFile), { discard: true }),
-    )
+  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> {
-    return toAwaitableEffect(
-      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)
-          }
+  ): 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)
+        }
 
-          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),
-      ),
+        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),
     )
   }
 
@@ -756,71 +724,69 @@ export class SurrealDBService {
     filter: Record<string, unknown>,
     schema: T,
     options?: FindManyOptions,
-  ): AwaitableEffect<z.infer<T>[], SurrealDBError> {
-    return toAwaitableEffect(
-      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))
-          }
+  ): Effect.Effect<z.infer<T>[], SurrealDBError, never> {
+    return Effect.gen(
+      function* (this: SurrealDBService) {
+        const filterKeys = Object.keys(filter)
+        const selection = yield* this.buildFilterExpressionEffect(filter)
+        const orderBy = options?.orderBy
 
-          const client = yield* this.ensureConnectedEffect(`SELECT * FROM ${table}`)
-          let query = client.select<unknown>(new Table(table))
-          if (selection) {
-            query = query.where(selection)
+        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')
           }
-          if (options?.offset !== undefined) {
-            query = query.start(options.offset)
+          const rawOrderDir: unknown = options?.orderDir
+          if (rawOrderDir !== undefined && rawOrderDir !== 'ASC' && rawOrderDir !== 'DESC') {
+            return yield* new SurrealDBError({
+              message: `Invalid orderDir value: ${describeInvalidValue(rawOrderDir)}`,
+            })
           }
-          if (options?.limit !== undefined) {
-            query = query.limit(options.limit)
+          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}`
           }
-
-          const rows = yield* Effect.tryPromise({
-            try: () => query,
-            catch: (error) =>
-              new SurrealDBError({
-                message: `Failed to run findMany query for ${table}: ${getErrorMessage(error)}`,
-                cause: error,
-              }),
-          })
+          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))
-        }.bind(this),
-      ),
+        }
+
+        const client = yield* this.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 yield* Effect.forEach(rows, (row) => this.parseSchemaEffect(schema, row))
+      }.bind(this),
     )
   }
 
@@ -828,34 +794,32 @@ export class SurrealDBService {
     table: DatabaseTable,
     data: Record<string, unknown>,
     schema: T,
-  ): AwaitableEffect<z.infer<T>, SurrealDBError> {
-    return toAwaitableEffect(
-      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` })
-          }
+  ): 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* 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
+        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 yield* this.parseSchemaEffect(schema, first)
-        }.bind(this),
-      ),
+        return yield* this.parseSchemaEffect(schema, first)
+      }.bind(this),
     )
   }
 
@@ -864,29 +828,27 @@ export class SurrealDBService {
     id: unknown,
     data: Record<string, unknown>,
     schema: T,
-  ): AwaitableEffect<z.infer<T>, SurrealDBError> {
-    return toAwaitableEffect(
-      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` })
-          }
+  ): 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* 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),
-      ),
+        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),
     )
   }
 
@@ -896,31 +858,29 @@ export class SurrealDBService {
     data: Record<string, unknown>,
     schema: T,
     options?: { mutation?: RecordMutation },
-  ): AwaitableEffect<z.infer<T> | null, SurrealDBError> {
-    return toAwaitableEffect(
-      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' })
-          }
+  ): 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* 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),
-      ),
+        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),
     )
   }
 
@@ -930,90 +890,84 @@ export class SurrealDBService {
     data: Record<string, unknown>,
     schema: T,
     options?: { mutation?: RecordMutation },
-  ): AwaitableEffect<z.infer<T>, SurrealDBError> {
-    return toAwaitableEffect(
-      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' })
-          }
+  ): 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* 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),
-      ),
+        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> {
-    return toAwaitableEffect(
-      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)
-              }
+  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(this.toSurrealError(error, `DELETE ${recordId.toString()}`))
-            }),
-          )
-        }.bind(this),
-      ),
+            return Effect.fail(this.toSurrealError(error, `DELETE ${recordId.toString()}`))
+          }),
+        )
+      }.bind(this),
     )
   }
 
-  deleteWhere(table: DatabaseTable, filter: Record<string, unknown>): AwaitableEffect<number, SurrealDBError> {
-    return toAwaitableEffect(
-      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),
-      ),
+  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 } = 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),
     )
   }
 
@@ -1021,58 +975,52 @@ export class SurrealDBService {
     table: DatabaseTable,
     where: ExprLike,
     data: Record<string, unknown>,
-  ): AwaitableEffect<number, SurrealDBError> {
-    return toAwaitableEffect(
-      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` })
-          }
+  ): 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` })
+        }
+        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* 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),
-      ),
+        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),
     )
   }
 
   insert<T extends Record<string, unknown>>(
     table: DatabaseTable,
     data: Values<T> | Array<Values<T>>,
-  ): AwaitableEffect<T[], SurrealDBError> {
-    return toAwaitableEffect(
-      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),
-      ),
+  ): Effect.Effect<T[], SurrealDBError, never> {
+    return 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),
     )
   }
 
@@ -1081,51 +1029,47 @@ export class SurrealDBService {
     edgeTable: DatabaseTable,
     to: RecordIdInput,
     data?: Values<T>,
-  ): AwaitableEffect<T | null, SurrealDBError> {
-    return toAwaitableEffect(
-      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),
-      ),
+  ): 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
+          ? ((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> {
-    return toAwaitableEffect(
-      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),
-      ),
+  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 this.wrapTransaction(tx)
+      }.bind(this),
     )
   }