effect 4.0.0-beta.4 → 4.0.0-beta.41

package/src/unstable/sql/SqlClient.ts

@@ -180,7 +180,7 @@ export const make = Effect.fnUntraced(function*(options: SqlClient.MakeOptions)
  * @category transactions
  */
 export const makeWithTransaction = <I, S>(options: {
-  readonly transactionService: ServiceMap.Service<I, readonly [conn: S, counter: number]>
+  readonly transactionService: ServiceMap.Key<I, readonly [conn: S, counter: number]>
   readonly spanAttributes: ReadonlyArray<readonly [string, unknown]>
   readonly acquireConnection: Effect.Effect<readonly [Scope.Closeable | undefined, S], SqlError>
   readonly begin: (conn: NoInfer<S>) => Effect.Effect<void, SqlError>
@@ -215,9 +215,11 @@ export const makeWithTransaction = <I, S>(options: {
                 Effect.flatMap(() =>
                   Effect.provideServices(
                     restore(effect),
-                    ServiceMap.add(services, options.transactionService, [conn, id]).pipe(
-                      ServiceMap.add(Tracer.ParentSpan, span)
-                    )
+                    ServiceMap.mutate(services, (services) =>
+                      services.pipe(
+                        ServiceMap.add(options.transactionService, [conn, id]),
+                        ServiceMap.add(Tracer.ParentSpan, span)
+                      ))
                   )
                 ),
                 Effect.exit,

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,7 +3,7 @@
  * @category models
  */
 import type * as Cause from "../../Cause.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type { Input } from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
 import * as RequestResolver from "../../RequestResolver.ts"
@@ -69,7 +69,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 +107,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 +159,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}`
@@ -210,7 +210,7 @@ export const makeDataLoaders = <
     readonly tableName: string
     readonly spanPrefix: string
     readonly idColumn: Id
-    readonly window: DurationInput
+    readonly window: Input
     readonly maxBatchSize?: number | undefined
   }
 ): Effect.Effect<

package/src/unstable/sql/SqlResolver.ts

@@ -57,9 +57,9 @@ export const request: {
 } = function() {
   if (arguments.length === 1) {
     const resolver = arguments[0]
-    return (payload: any) => Effect.request(SqlRequest(payload), Effect.succeed(resolver))
+    return (payload: any) => Effect.request(SqlRequest(payload), resolver)
   }
-  return Effect.request(SqlRequest(arguments[0]), Effect.succeed(arguments[1]))
+  return Effect.request(SqlRequest(arguments[0]), arguments[1])
 } as any
 
 /**
@@ -104,14 +104,14 @@ export const ordered = <Req extends Schema.Top, Res extends Schema.Top, _, E, R>
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const results = yield* options.execute(inputs as any).pipe(
         Effect.provideServices(entries[0].services)
       )
       if (results.length !== inputs.length) {
-        return yield* Effect.fail(new ResultLengthMismatch({ expected: inputs.length, actual: results.length }))
+        return yield* new ResultLengthMismatch({ expected: inputs.length, actual: results.length })
       }
       const decodedResults = yield* decodeArray(results).pipe(
         Effect.provideServices(entries[0].services)
@@ -160,7 +160,7 @@ export const grouped = <Req extends Schema.Top, Res extends Schema.Top, K, Row,
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const resultMap = MutableHashMap.empty<K, Arr.NonEmptyArray<Res["Type"]>>()
@@ -226,7 +226,11 @@ export const findById = <Id extends Schema.Top, Res extends Schema.Top, Row, E,
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key(entry) {
+      const conn = entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key)
+      if (!conn) return undefined
+      return Equal.byReferenceUnsafe(conn)
+    },
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, idMap] = yield* partitionRequestsById(entries, options.Id)
       const results = yield* options.execute(inputs as any).pipe(
@@ -279,7 +283,7 @@ const void_ = <Req extends Schema.Top, _, E, R>(
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       yield* options.execute(inputs as any).pipe(
@@ -354,3 +358,9 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
 
   return [inputs, byIdMap] as const
 }
+
+function transactionKey<A>(entry: Request.Entry<A>): SqlClient.TransactionConnection["Service"] | undefined {
+  const conn = entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key)
+  if (!conn) return undefined
+  return Equal.byReferenceUnsafe(conn)
+}

package/src/unstable/sql/SqlSchema.ts

@@ -13,7 +13,7 @@ import * as Schema from "../../Schema.ts"
  * @since 4.0.0
  * @category constructor
  */
-export const findMany = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findAll = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -21,25 +21,41 @@ export const findMany = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   }
 ) => {
   const encodeRequest = Schema.encodeEffect(options.Request)
-  const decode = Schema.decodeUnknownEffect(Schema.Array(options.Result))
+  const decode = Schema.decodeUnknownEffect(Schema.mutable(Schema.Array(options.Result)))
   return (
-    request: Req["Encoded"]
+    request: Req["Type"]
+  ): Effect.Effect<
+    Array<Res["Type"]>,
+    E | Schema.SchemaError,
+    Req["EncodingServices"] | Res["DecodingServices"] | R
+  > => Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), decode)
+}
+
+/**
+ * Run a sql query with a request schema and a result schema.
+ *
+ * @since 4.0.0
+ * @category constructor
+ */
+export const findNonEmpty = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+  options: {
+    readonly Request: Req
+    readonly Result: Res
+    readonly execute: (request: Req["Encoded"]) => Effect.Effect<ReadonlyArray<unknown>, E, R>
+  }
+) => {
+  const find = findAll(options)
+  return (
+    request: Req["Type"]
   ): Effect.Effect<
     Arr.NonEmptyArray<Res["Type"]>,
     E | Schema.SchemaError | Cause.NoSuchElementError,
     Req["EncodingServices"] | Res["DecodingServices"] | R
   > =>
-    Effect.flatMap(
-      Effect.flatMap(encodeRequest(request), options.execute),
-      (results): Effect.Effect<
-        Arr.NonEmptyArray<Res["Type"]>,
-        Schema.SchemaError | Cause.NoSuchElementError,
-        Req["EncodingServices"] | Res["DecodingServices"]
-      > =>
-        Arr.isReadonlyArrayNonEmpty(results)
-          ? decode(results) as Effect.Effect<Arr.NonEmptyArray<Res["Type"]>, Schema.SchemaError>
-          : Effect.fail(new Cause.NoSuchElementError())
-    )
+    Effect.flatMap(find(request), (results) =>
+      Arr.isArrayNonEmpty(results)
+        ? Effect.succeed(results)
+        : Effect.fail(new Cause.NoSuchElementError()))
 }
 
 const void_ = <Req extends Schema.Top, E, R>(
@@ -65,7 +81,7 @@ export {
 }
 
 /**
- * Run a sql query with a request schema and a result schema and return the first result, if any.
+ * Run a sql query with a request schema and a result schema and return the first result.
  *
  * @since 4.0.0
  * @category constructor
@@ -82,17 +98,17 @@ export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   return (
     request: Req["Type"]
   ): Effect.Effect<
-    Option.Option<Res["Type"]>,
-    E | Schema.SchemaError,
+    Res["Type"],
+    E | Schema.SchemaError | Cause.NoSuchElementError,
     R | Req["EncodingServices"] | Res["DecodingServices"]
   > =>
     Effect.flatMap(
       Effect.flatMap(encodeRequest(request), options.execute),
       (arr): Effect.Effect<
-        Option.Option<Res["Type"]>,
-        Schema.SchemaError,
+        Res["Type"],
+        Schema.SchemaError | Cause.NoSuchElementError,
         Req["EncodingServices"] | Res["DecodingServices"]
-      > => Arr.isReadonlyArrayNonEmpty(arr) ? Effect.asSome(decode(arr[0])) : Effect.succeedNone
+      > => Arr.isReadonlyArrayNonEmpty(arr) ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementError())
     )
 }
 
@@ -102,7 +118,7 @@ export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
  * @since 4.0.0
  * @category constructor
  */
-export const single = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findOneOption = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -114,16 +130,16 @@ export const single = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   return (
     request: Req["Type"]
   ): Effect.Effect<
-    Res["Type"],
-    E | Schema.SchemaError | Cause.NoSuchElementError,
+    Option.Option<Res["Type"]>,
+    E | Schema.SchemaError,
     R | Req["EncodingServices"] | Res["DecodingServices"]
   > =>
     Effect.flatMap(
       Effect.flatMap(encodeRequest(request), options.execute),
       (arr): Effect.Effect<
-        Res["Type"],
-        Schema.SchemaError | Cause.NoSuchElementError,
+        Option.Option<Res["Type"]>,
+        Schema.SchemaError,
         Req["EncodingServices"] | Res["DecodingServices"]
-      > => Arr.isReadonlyArrayNonEmpty(arr) ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementError())
+      > => Arr.isReadonlyArrayNonEmpty(arr) ? Effect.asSome(decode(arr[0])) : Effect.succeedNone
     )
 }

package/src/unstable/sql/Statement.ts

@@ -1124,7 +1124,6 @@ const makeUnsafe = <A = Row>(
 }
 
 // TODO: figure out why these diagnostics are emitted
-// @effect-diagnostics-next-line missingEffectContext:off missingEffectError:off
 const StatementProto: Omit<
   StatementImpl<any>,
   "segments" | "acquirer" | "compiler" | "spanAttributes" | "transformRows"

package/src/unstable/workers/Worker.ts

@@ -4,6 +4,7 @@
 import type * as Deferred from "../../Deferred.ts"
 import * as Effect from "../../Effect.ts"
 import * as FiberSet from "../../FiberSet.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
@@ -149,7 +150,7 @@ export const makePlatform = <W>() =>
                   WorkerError | E
                 >().pipe(Scope.provide(scope))
                 const run = yield* FiberSet.runtime(fiberSet)<R>()
-                const ready = Effect.makeLatchUnsafe()
+                const ready = Latch.makeUnsafe()
                 yield* options.listen({
                   port,
                   scope,