effect 4.0.0-beta.36 → 4.0.0-beta.37

package/src/unstable/http/HttpClientRequest.ts

@@ -15,10 +15,11 @@ import type * as Redacted from "../../Redacted.ts"
 import * as Result from "../../Result.ts"
 import type * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
-import type * as Stream from "../../Stream.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
+import * as Stream from "../../Stream.ts"
 import * as Headers from "./Headers.ts"
 import * as HttpBody from "./HttpBody.ts"
-import type { HttpMethod } from "./HttpMethod.ts"
+import { hasBody, type HttpMethod } from "./HttpMethod.ts"
 import * as UrlParams from "./UrlParams.ts"
 
 const TypeId = "~effect/http/HttpClientRequest"
@@ -954,3 +955,104 @@ export function toUrl(self: HttpClientRequest): Option.Option<URL> {
   }
   return Option.none()
 }
+
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const fromWeb = (request: globalThis.Request): HttpClientRequest => {
+  const method = request.method.toUpperCase() as HttpMethod
+  return modify(empty, {
+    method,
+    url: new URL(request.url),
+    headers: request.headers,
+    body: fromWebBody(request, method)
+  })
+}
+
+const fromWebBody = (request: globalThis.Request, method: HttpMethod): HttpBody.HttpBody => {
+  if (!hasBody(method) || request.body === null) {
+    return HttpBody.empty
+  }
+  return HttpBody.raw(request.body, {
+    contentType: request.headers.get("content-type") ?? undefined,
+    contentLength: parseContentLength(request.headers.get("content-length"))
+  })
+}
+
+const parseContentLength = (contentLength: string | null): number | undefined => {
+  if (contentLength === null) {
+    return undefined
+  }
+  const parsed = Number.parseInt(contentLength, 10)
+  return Number.isNaN(parsed) ? undefined : parsed
+}
+
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const toWebResult = (self: HttpClientRequest, options?: {
+  readonly signal?: AbortSignal | undefined
+  readonly services?: ServiceMap.ServiceMap<never> | undefined
+}): Result.Result<Request, UrlParams.UrlParamsError> => {
+  const url = UrlParams.makeUrl(self.url, self.urlParams, Option.getOrUndefined(self.hash))
+  if (Result.isFailure(url)) {
+    return Result.fail(url.failure)
+  }
+  const requestInit: RequestInit = {
+    method: self.method,
+    headers: self.headers
+  }
+  if (options?.signal) {
+    requestInit.signal = options.signal
+  }
+  if (hasBody(self.method)) {
+    switch (self.body._tag) {
+      case "Empty": {
+        break
+      }
+      case "Raw": {
+        requestInit.body = self.body.body as any
+        if (isReadableStream(self.body.body)) {
+          ;(requestInit as any).duplex = "half"
+        }
+        break
+      }
+      case "Uint8Array": {
+        requestInit.body = self.body.body as any
+        break
+      }
+      case "FormData": {
+        requestInit.body = self.body.formData
+        break
+      }
+      case "Stream": {
+        requestInit.body = Stream.toReadableStreamWith(self.body.stream, options?.services ?? ServiceMap.empty())
+        ;(requestInit as any).duplex = "half"
+        break
+      }
+    }
+  }
+  return Result.try({
+    try: () => new Request(url.success, requestInit),
+    catch: (cause) => new UrlParams.UrlParamsError({ cause })
+  })
+}
+
+const isReadableStream = (u: unknown): u is ReadableStream<Uint8Array> =>
+  typeof ReadableStream !== "undefined" && u instanceof ReadableStream
+
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const toWeb = (self: HttpClientRequest, options?: {
+  readonly signal?: AbortSignal | undefined
+}): Effect.Effect<Request, UrlParams.UrlParamsError> =>
+  Effect.servicesWith((services) =>
+    toWebResult(self, {
+      services,
+      signal: options?.signal
+    }).asEffect()
+  )

package/src/unstable/http/HttpServerResponse.ts

@@ -1225,12 +1225,16 @@ export const fromWeb = (response: Response): HttpServerResponse => {
     cookies: Cookies.fromSetCookie(setCookieHeaders)
   })
   if (response.body) {
+    const contentType = response.headers.get("content-type")
     self = setBody(
       self,
-      Body.stream(Stream.fromReadableStream({
-        evaluate: () => response.body!,
-        onError: (e) => e
-      }))
+      Body.stream(
+        Stream.fromReadableStream({
+          evaluate: () => response.body!,
+          onError: (e) => e
+        }),
+        contentType ?? undefined
+      )
     )
   }
   return self

package/src/unstable/sql/Migrator.ts

@@ -236,11 +236,13 @@ export const make = <RD = never>({
       if (required.length > 0) {
         yield* pipe(
           insertMigrations(required.map(([id, name]) => [id, name])),
-          Effect.mapError((_) =>
-            new MigrationError({
-              kind: "Locked",
-              message: "Migrations already running"
-            })
+          Effect.mapError((error): MigrationError | SqlError =>
+            error.reason._tag === "ConstraintError"
+              ? new MigrationError({
+                kind: "Locked",
+                message: "Migrations already running"
+              })
+              : error
           )
         )
       }

package/src/unstable/sql/SqlError.ts

@@ -1,21 +1,378 @@
 /**
  * @since 4.0.0
  */
+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 ConnectionError extends Schema.TaggedErrorClass<ConnectionError>("effect/sql/SqlError/ConnectionError")(
+  "ConnectionError",
+  ReasonFields
+) {
+  /**
+   * @since 4.0.0
+   */
+  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 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", {
-  cause: Schema.Defect,
-  message: Schema.optional(Schema.String)
+  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)
 }
 
 /**
@@ -27,11 +384,6 @@ export class ResultLengthMismatch
     actual: Schema.Number
   })
 {
-  /**
-   * @since 4.0.0
-   */
-  readonly [TypeId] = TypeId
-
   /**
    * @since 4.0.0
    */