effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/unstable/sql/SqlError.ts

@@ -1,35 +1,389 @@
 /**
  * @since 4.0.0
  */
-import * as Data from "../../Data.ts"
+import * as Predicate from "../../Predicate.ts"
+import * as Schema from "../../Schema.ts"
 
-const TypeId = "~effect/sql/SqlError"
+const TypeId = "~effect/sql/SqlError" as const
+const ReasonTypeId = "~effect/sql/SqlError/Reason" as const
+
+const ReasonFields = {
+  cause: Schema.Defect,
+  message: Schema.optional(Schema.String),
+  operation: Schema.optional(Schema.String)
+}
 
 /**
  * @since 4.0.0
  */
-export class SqlError extends Data.TaggedError("SqlError")<{
-  cause: unknown
-  message?: string
-}> {
+export class ConnectionError extends Schema.TaggedErrorClass<ConnectionError>("effect/sql/SqlError/ConnectionError")(
+  "ConnectionError",
+  ReasonFields
+) {
   /**
    * @since 4.0.0
    */
-  readonly [TypeId] = TypeId
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return true
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export class AuthenticationError extends Schema.TaggedErrorClass<AuthenticationError>(
+  "effect/sql/SqlError/AuthenticationError"
+)("AuthenticationError", ReasonFields) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return false
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export class AuthorizationError extends Schema.TaggedErrorClass<AuthorizationError>(
+  "effect/sql/SqlError/AuthorizationError"
+)("AuthorizationError", ReasonFields) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return false
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export class SqlSyntaxError extends Schema.TaggedErrorClass<SqlSyntaxError>("effect/sql/SqlError/SqlSyntaxError")(
+  "SqlSyntaxError",
+  ReasonFields
+) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return false
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export class ConstraintError extends Schema.TaggedErrorClass<ConstraintError>("effect/sql/SqlError/ConstraintError")(
+  "ConstraintError",
+  ReasonFields
+) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return false
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export class DeadlockError extends Schema.TaggedErrorClass<DeadlockError>("effect/sql/SqlError/DeadlockError")(
+  "DeadlockError",
+  ReasonFields
+) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return true
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export class SerializationError extends Schema.TaggedErrorClass<SerializationError>(
+  "effect/sql/SqlError/SerializationError"
+)("SerializationError", ReasonFields) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return true
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export class LockTimeoutError extends Schema.TaggedErrorClass<LockTimeoutError>("effect/sql/SqlError/LockTimeoutError")(
+  "LockTimeoutError",
+  ReasonFields
+) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return true
+  }
 }
 
 /**
  * @since 4.0.0
  */
-export class ResultLengthMismatch extends Data.TaggedError("ResultLengthMismatch")<{
-  readonly expected: number
-  readonly actual: number
-}> {
+export class StatementTimeoutError extends Schema.TaggedErrorClass<StatementTimeoutError>(
+  "effect/sql/SqlError/StatementTimeoutError"
+)("StatementTimeoutError", ReasonFields) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return true
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export class UnknownError extends Schema.TaggedErrorClass<UnknownError>("effect/sql/SqlError/UnknownError")(
+  "UnknownError",
+  ReasonFields
+) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return false
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export type SqlErrorReason =
+  | ConnectionError
+  | AuthenticationError
+  | AuthorizationError
+  | SqlSyntaxError
+  | ConstraintError
+  | DeadlockError
+  | SerializationError
+  | LockTimeoutError
+  | StatementTimeoutError
+  | UnknownError
+
+/**
+ * @since 4.0.0
+ */
+export const SqlErrorReason: Schema.Union<[
+  typeof ConnectionError,
+  typeof AuthenticationError,
+  typeof AuthorizationError,
+  typeof SqlSyntaxError,
+  typeof ConstraintError,
+  typeof DeadlockError,
+  typeof SerializationError,
+  typeof LockTimeoutError,
+  typeof StatementTimeoutError,
+  typeof UnknownError
+]> = Schema.Union([
+  ConnectionError,
+  AuthenticationError,
+  AuthorizationError,
+  SqlSyntaxError,
+  ConstraintError,
+  DeadlockError,
+  SerializationError,
+  LockTimeoutError,
+  StatementTimeoutError,
+  UnknownError
+])
+
+/**
+ * @since 4.0.0
+ */
+export class SqlError extends Schema.TaggedErrorClass<SqlError>("effect/sql/SqlError")("SqlError", {
+  reason: SqlErrorReason
+}) {
   /**
    * @since 4.0.0
    */
   readonly [TypeId] = TypeId
 
+  /**
+   * @since 4.0.0
+   */
+  override readonly cause = this.reason
+
+  /**
+   * @since 4.0.0
+   */
+  override get message(): string {
+    return this.reason.message || this.reason._tag
+  }
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return this.reason.isRetryable
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export const isSqlError = (u: unknown): u is SqlError => Predicate.hasProperty(u, TypeId)
+
+/**
+ * @since 4.0.0
+ */
+export const isSqlErrorReason = (u: unknown): u is SqlErrorReason => Predicate.hasProperty(u, ReasonTypeId)
+
+type SqliteClassifyOptions = {
+  readonly message?: string | undefined
+  readonly operation?: string | undefined
+}
+
+const sqliteCodeFromCause = (cause: unknown): string | number | undefined => {
+  if (!Predicate.hasProperty(cause, "code")) {
+    return undefined
+  }
+  const code = cause.code
+  return typeof code === "string" || typeof code === "number" ? code : undefined
+}
+
+const sqliteNumericCodeFromCause = (cause: unknown): number | undefined => {
+  const code = sqliteCodeFromCause(cause)
+  if (typeof code === "number") {
+    return code
+  }
+  if (!Predicate.hasProperty(cause, "errno")) {
+    return undefined
+  }
+  const errno = cause.errno
+  return typeof errno === "number" ? errno : undefined
+}
+
+const matchesSqliteCode = (code: string, expected: string): boolean =>
+  code === expected || code.startsWith(expected + "_")
+
+/**
+ * @since 4.0.0
+ */
+export const classifySqliteError = (
+  cause: unknown,
+  { message, operation }: SqliteClassifyOptions = {}
+): SqlErrorReason => {
+  const props = {
+    cause,
+    message,
+    operation
+  }
+  const code = sqliteCodeFromCause(cause)
+
+  if (typeof code === "string") {
+    if (matchesSqliteCode(code, "SQLITE_AUTH")) {
+      return new AuthenticationError(props)
+    }
+    if (matchesSqliteCode(code, "SQLITE_PERM")) {
+      return new AuthorizationError(props)
+    }
+    if (matchesSqliteCode(code, "SQLITE_CONSTRAINT")) {
+      return new ConstraintError(props)
+    }
+    if (matchesSqliteCode(code, "SQLITE_BUSY") || matchesSqliteCode(code, "SQLITE_LOCKED")) {
+      return new LockTimeoutError(props)
+    }
+    if (matchesSqliteCode(code, "SQLITE_CANTOPEN")) {
+      return new ConnectionError(props)
+    }
+  }
+
+  const numericCode = sqliteNumericCodeFromCause(cause)
+  if (typeof numericCode === "number") {
+    const code = numericCode & 0xff
+    switch (code) {
+      case 23:
+        return new AuthenticationError(props)
+      case 3:
+        return new AuthorizationError(props)
+      case 19:
+        return new ConstraintError(props)
+      case 5:
+      case 6:
+        return new LockTimeoutError(props)
+      case 14:
+        return new ConnectionError(props)
+      default:
+        return new UnknownError(props)
+    }
+  }
+
+  return new UnknownError(props)
+}
+
+/**
+ * @since 4.0.0
+ */
+export class ResultLengthMismatch
+  extends Schema.TaggedErrorClass<ResultLengthMismatch>("effect/sql/ResultLengthMismatch")("ResultLengthMismatch", {
+    expected: Schema.Number,
+    actual: Schema.Number
+  })
+{
   /**
    * @since 4.0.0
    */

package/src/unstable/sql/SqlModel.ts

@@ -3,15 +3,13 @@
  * @category models
  */
 import type * as Cause from "../../Cause.ts"
-import type { DurationInput } from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
-import { identity } from "../../Function.ts"
 import * as RequestResolver from "../../RequestResolver.ts"
 import type * as Schema from "../../Schema.ts"
 import type { Scope } from "../../Scope.ts"
 import type * as Model from "../schema/Model.ts"
 import { SqlClient } from "./SqlClient.ts"
-import type { SqlError } from "./SqlError.ts"
+import type { ResultLengthMismatch, SqlError } from "./SqlError.ts"
 import * as SqlResolver from "./SqlResolver.ts"
 import * as SqlSchema from "./SqlSchema.ts"
 
@@ -69,7 +67,7 @@ export const makeRepository = <
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
 
-    const insertSchema = SqlSchema.single({
+    const insertSchema = SqlSchema.findOne({
       Request: Model.insert,
       Result: Model,
       execute: (request) =>
@@ -107,7 +105,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const updateSchema = SqlSchema.single({
+    const updateSchema = SqlSchema.findOne({
       Request: Model.update,
       Result: Model,
       execute: (request: any) =>
@@ -159,7 +157,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
         })
       ) as any
 
-    const findByIdSchema = SqlSchema.single({
+    const findByIdSchema = SqlSchema.findOne({
       Request: idSchema,
       Result: Model,
       execute: (id: any) => sql`select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${id}`
@@ -201,7 +199,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
  * @since 4.0.0
  * @category repository
  */
-export const makeDataLoaders = <
+export const makeResolvers = <
   S extends Model.Any,
   Id extends (keyof S["Type"]) & (keyof S["update"]["Type"]) & (keyof S["fields"])
 >(
@@ -210,31 +208,36 @@ export const makeDataLoaders = <
     readonly tableName: string
     readonly spanPrefix: string
     readonly idColumn: Id
-    readonly window: DurationInput
-    readonly maxBatchSize?: number | undefined
   }
 ): Effect.Effect<
   {
-    readonly insert: (
-      insert: S["insert"]["Type"]
-    ) => Effect.Effect<
-      S["Type"],
-      SqlError | Schema.SchemaError,
-      S["DecodingServices"] | S["insert"]["EncodingServices"]
+    readonly insert: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["insert"]["Type"],
+        S["Type"],
+        ResultLengthMismatch | SqlError,
+        S["insert"]["EncodingServices"]
+      >
     >
-    readonly insertVoid: (
-      insert: S["insert"]["Type"]
-    ) => Effect.Effect<void, SqlError | Schema.SchemaError, S["insert"]["EncodingServices"]>
-    readonly findById: (
-      id: S["fields"][Id]["Type"]
-    ) => Effect.Effect<
-      S["Type"],
-      SqlError | Schema.SchemaError | Cause.NoSuchElementError,
-      S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
+    readonly insertVoid: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<S["insert"]["Type"], void, SqlError, S["insert"]["EncodingServices"]>
+    >
+    readonly findById: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        S["Type"],
+        Cause.NoSuchElementError | SqlError,
+        S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
+      >
+    >
+    readonly delete: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        void,
+        SqlError,
+        S["fields"][Id]["EncodingServices"]
+      >
     >
-    readonly delete: (
-      id: S["fields"][Id]["Type"]
-    ) => Effect.Effect<void, SqlError | Schema.SchemaError, S["fields"][Id]["EncodingServices"]>
   },
   never,
   SqlClient | Scope
@@ -243,9 +246,15 @@ export const makeDataLoaders = <
     const sql = yield* SqlClient
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
-    const setMaxBatchSize = options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity
 
-    const insertResolver = SqlResolver.ordered({
+    const insert: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["insert"]["Type"],
+        S["Type"],
+        ResultLengthMismatch | SqlError,
+        S["DecodingServices"] | S["insert"]["EncodingServices"]
+      >
+    > = SqlResolver.ordered({
       Request: Model.insert,
       Result: Model,
       execute: (request: any) =>
@@ -259,44 +268,26 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
           orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
         })
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.insertResolver`)
     )
-    const insertExecute = SqlResolver.request(insertResolver)
-    const insert = (
-      insert: S["insert"]["Type"]
-    ): Effect.Effect<
-      S["Type"],
-      SqlError | Schema.SchemaError,
-      S["DecodingServices"] | S["insert"]["EncodingServices"]
-    > =>
-      insertExecute(insert).pipe(
-        Effect.catchTag("ResultLengthMismatch", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.insert`, {}, {
-          captureStackTrace: false
-        })
-      ) as any
 
-    const insertVoidResolver = SqlResolver.void({
+    const insertVoid: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<S["insert"]["Type"], void, Schema.SchemaError | SqlError, S["insert"]["EncodingServices"]>
+    > = SqlResolver.void({
       Request: Model.insert,
       execute: (request: any) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.insertVoidResolver`)
     )
-    const insertVoidExecute = SqlResolver.request(insertVoidResolver)
-    const insertVoid = (
-      insert: S["insert"]["Type"]
-    ): Effect.Effect<void, SqlError | Schema.SchemaError, S["insert"]["EncodingServices"]> =>
-      insertVoidExecute(insert).pipe(
-        Effect.withSpan(`${options.spanPrefix}.insertVoid`, {}, {
-          captureStackTrace: false
-        })
-      ) as any
 
-    const findByIdResolver = SqlResolver.findById({
+    const findById: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        S["Type"],
+        Cause.NoSuchElementError | Schema.SchemaError | SqlError,
+        S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
+      >
+    > = SqlResolver.findById({
       Id: idSchema,
       Result: Model,
       ResultId(request: any) {
@@ -304,41 +295,22 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       },
       execute: (ids: any) => sql`select * from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.findByIdResolver`)
     )
-    const findByIdExecute = SqlResolver.request(findByIdResolver)
-    const findById = (
-      id: S["fields"][Id]["Type"]
-    ): Effect.Effect<
-      S["Type"],
-      Cause.NoSuchElementError | SqlError | Schema.SchemaError,
-      S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
-    > =>
-      findByIdExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.findById`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
-      ) as any
 
-    const deleteResolver = SqlResolver.void({
+    const delete_: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        void,
+        Schema.SchemaError | SqlError,
+        S["fields"][Id]["EncodingServices"]
+      >
+    > = SqlResolver.void({
       Request: idSchema,
       execute: (ids: any) => sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.deleteResolver`)
     )
-    const deleteExecute = SqlResolver.request(deleteResolver)
-    const delete_ = (
-      id: S["fields"][Id]["Type"]
-    ): Effect.Effect<void, SqlError | Schema.SchemaError, S["fields"][Id]["EncodingServices"]> =>
-      deleteExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.delete`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
-      ) as any
 
     return { insert, insertVoid, findById, delete: delete_ } as const
   })