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

package/src/unstable/schema/VariantSchema.ts

@@ -4,20 +4,17 @@
 import type { Brand } from "../../Brand.ts"
 import * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
-import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
-import * as Getter from "../../SchemaGetter.ts"
-import * as Transformation from "../../SchemaTransformation.ts"
 import * as Struct_ from "../../Struct.ts"
 
 /**
  * @since 4.0.0
  * @category Type IDs
  */
-export const TypeId = "~effect/unstable/schema/VariantSchema"
+export const TypeId = "~effect/schema/VariantSchema"
 
 const cacheSymbol = Symbol.for(`${TypeId}/cache`)
 
@@ -71,7 +68,7 @@ export declare namespace Struct {
   }
 }
 
-const FieldTypeId = "~effect/unstable/schema/VariantSchema/Field"
+const FieldTypeId = "~effect/schema/VariantSchema/Field"
 
 /**
  * @since 4.0.0
@@ -238,7 +235,7 @@ export interface Class<
   new(
     props: S["~type.make.in"],
     options?: {
-      readonly disableValidation?: boolean
+      readonly disableChecks?: boolean
     } | undefined
   ): S["Type"]
 
@@ -301,12 +298,12 @@ export const make = <
     config: A & { readonly [K in Exclude<keyof A, Variants[number]>]: never }
   ) => Field<A>
   readonly FieldOnly: <const Keys extends ReadonlyArray<Variants[number]>>(
-    ...keys: Keys
+    keys: Keys
   ) => <S extends Schema.Top>(
     schema: S
   ) => Field<{ readonly [K in Keys[number]]: S }>
   readonly FieldExcept: <const Keys extends ReadonlyArray<Variants[number]>>(
-    ...keys: Keys
+    keys: Keys
   ) => <S extends Schema.Top>(
     schema: S
   ) => Field<{ readonly [K in Exclude<Variants[number], Keys[number]>]: S }>
@@ -364,7 +361,7 @@ export const make = <
         readonly [V in Variants[number]]: Extract<V, Struct<Fields>>
       }
   readonly Union: <const Members extends ReadonlyArray<Struct<any>>>(
-    ...members: Members
+    members: Members
   ) => Union<Members> & Union.Variants<Members, Variants[number]>
   readonly extract: {
     <V extends Variants[number]>(
@@ -403,7 +400,7 @@ export const make = <
       return Base
     }
   }
-  function FieldOnly<Keys extends Variants>(...keys: Keys) {
+  function FieldOnly<const Keys extends ReadonlyArray<Variants[number]>>(keys: Keys) {
     return function<S extends Schema.Top>(schema: S) {
       const obj: Record<string, S> = {}
       for (const key of keys) {
@@ -412,7 +409,7 @@ export const make = <
       return Field(obj)
     }
   }
-  function FieldExcept<Keys extends Variants>(...keys: Keys) {
+  function FieldExcept<const Keys extends ReadonlyArray<Variants[number]>>(keys: Keys) {
     return function<S extends Schema.Top>(schema: S) {
       const obj: Record<string, S> = {}
       for (const variant of options.variants) {
@@ -423,7 +420,7 @@ export const make = <
       return Field(obj)
     }
   }
-  function UnionVariants(...members: ReadonlyArray<Struct<any>>) {
+  function UnionVariants(members: ReadonlyArray<Struct<any>>) {
     return Union(members, options.variants)
   }
   const fieldEvolve = dual(
@@ -470,7 +467,7 @@ export const Override = <A>(value: A): A & Brand<"Override"> => value as any
  */
 export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDefault> extends
   Schema.Bottom<
-    (S["Type"] & Brand<"Override">) | undefined,
+    S["Type"] & Brand<"Override">,
     S["Encoded"],
     S["DecodingServices"],
     S["EncodingServices"],
@@ -481,7 +478,7 @@ export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDe
     S["~type.parameters"],
     (S["Type"] & Brand<"Override">) | undefined,
     S["~type.mutability"],
-    "optional",
+    "required",
     "with-default",
     S["~encoded.mutability"],
     S["~encoded.optionality"]
@@ -499,18 +496,8 @@ export const Overrideable = <S extends Schema.Top & Schema.WithoutConstructorDef
   }
 ): Overrideable<S> =>
   schema.pipe(
-    Schema.decodeTo(
-      Schema.optional(Schema.brand("Override")(Schema.toType(schema))),
-      Transformation.make({
-        decode: Getter.passthrough(),
-        encode: new Getter.Getter((o) => {
-          if (Option.isSome(o) && o.value !== undefined) {
-            return Effect.succeed(o)
-          }
-          return Effect.asSome(options.defaultValue)
-        })
-      })
-    )
+    Schema.decodeTo(Schema.brand("Override")(Schema.toType(schema))),
+    Schema.withConstructorDefault(Effect.map(options.defaultValue, Override))
   ) as any
 
 const StructProto = {
@@ -542,7 +529,7 @@ const Union = <Members extends ReadonlyArray<Struct<any>>, Variants extends Read
   members: Members,
   variants: Variants
 ) => {
-  class VariantUnion extends (Schema.Union(members.filter((member) => Schema.isSchema(member))) as any) {}
+  const VariantUnion = Schema.Union(members.filter((member) => Schema.isSchema(member))) as any
   for (const variant of variants) {
     Object.defineProperty(VariantUnion, variant, {
       value: Schema.Union(members.map((member) => extract(member, variant)))

package/src/unstable/socket/Socket.ts

@@ -4,12 +4,14 @@
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
+import * as Context from "../../Context.ts"
 import * as Deferred from "../../Deferred.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as FiberSet from "../../FiberSet.ts"
 import { constVoid, dual, flow } from "../../Function.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Pull from "../../Pull.ts"
@@ -17,7 +19,6 @@ import * as Queue from "../../Queue.ts"
 import * as Result from "../../Result.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * @since 4.0.0
@@ -35,7 +36,7 @@ export const isSocket = (u: unknown): u is Socket => Predicate.hasProperty(u, Ty
  * @since 4.0.0
  * @category tags
  */
-export const Socket: ServiceMap.Service<Socket, Socket> = ServiceMap.Service<Socket>("effect/socket/Socket")
+export const Socket: Context.Service<Socket, Socket> = Context.Service<Socket>("effect/socket/Socket")
 
 /**
  * @since 4.0.0
@@ -213,7 +214,7 @@ export type SocketErrorReason =
  * @since 4.0.0
  * @category errors
  */
-export class SocketError extends Schema.ErrorClass<SocketError>(SocketErrorTypeId)({
+export class SocketError extends Schema.TaggedErrorClass<SocketError>(SocketErrorTypeId)("SocketError", {
   _tag: Schema.tag("SocketError"),
   reason: SocketErrorReason
 }) {
@@ -242,6 +243,8 @@ export class SocketError extends Schema.ErrorClass<SocketError>(SocketErrorTypeI
   static is(u: unknown): u is SocketError {
     return isSocketError(u)
   }
+
+  override readonly message = this.reason.message
 }
 
 /**
@@ -280,7 +283,7 @@ export const toChannelMap = <IE, A>(
         return writeChunk
       }),
       Effect.forever({ disableYield: true }),
-      Effect.catchCauseIf(
+      Effect.catchCauseFilter(
         Pull.filterNoDone,
         (cause) => Queue.failCause(queue, cause)
       ),
@@ -389,13 +392,13 @@ export const makeChannel = <IE = never>(): Channel.Channel<
 /**
  * @since 4.0.0
  */
-export const defaultCloseCodeIsError = (code: number) => code !== 1000 && code !== 1006
+export const defaultCloseCodeIsError = (_code: number) => true
 
 /**
  * @since 4.0.0
  * @category tags
  */
-export class WebSocket extends ServiceMap.Service<WebSocket, globalThis.WebSocket>()(
+export class WebSocket extends Context.Service<WebSocket, globalThis.WebSocket>()(
   "~effect/socket/Socket/WebSocket"
 ) {}
 
@@ -403,7 +406,7 @@ export class WebSocket extends ServiceMap.Service<WebSocket, globalThis.WebSocke
  * @since 4.0.0
  * @category tags
  */
-export class WebSocketConstructor extends ServiceMap.Service<
+export class WebSocketConstructor extends Context.Service<
   WebSocketConstructor,
   (url: string, protocols?: string | Array<string> | undefined) => globalThis.WebSocket
 >()("@effect/platform/Socket/WebSocketConstructor") {}
@@ -422,17 +425,19 @@ export const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor>
  */
 export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
   readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-  readonly openTimeout?: DurationInput | undefined
+  readonly openTimeout?: Duration.Input | undefined
   readonly protocols?: string | Array<string> | undefined
 }): Effect.Effect<Socket, never, WebSocketConstructor> =>
-  fromWebSocket(
-    Effect.acquireRelease(
-      (typeof url === "string" ? Effect.succeed(url) : url).pipe(
-        Effect.flatMap((url) => Effect.map(WebSocketConstructor.asEffect(), (f) => f(url, options?.protocols)))
+  WebSocketConstructor.use((makeWs) =>
+    fromWebSocket(
+      Effect.acquireRelease(
+        (typeof url === "string" ? Effect.succeed(url) : url).pipe(
+          Effect.map((url) => makeWs(url, options?.protocols))
+        ),
+        (ws) => Effect.sync(() => ws.close(1000))
       ),
-      (ws) => Effect.sync(() => ws.close(1000))
-    ),
-    options
+      options
+    )
   )
 
 /**
@@ -443,13 +448,13 @@ export const fromWebSocket = <RO>(
   acquire: Effect.Effect<globalThis.WebSocket, SocketError, RO>,
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-    readonly openTimeout?: DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
   } | undefined
 ): Effect.Effect<Socket, never, Exclude<RO, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
     let currentWS: globalThis.WebSocket | undefined
-    const latch = Effect.makeLatchUnsafe(false)
-    const acquireContext = fiber.services as ServiceMap.ServiceMap<RO>
+    const latch = Latch.makeUnsafe(false)
+    const acquireContext = fiber.context as Context.Context<RO>
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
 
     const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
@@ -499,6 +504,7 @@ export const fromWebSocket = <RO>(
           )
         }
         function onClose(event: globalThis.CloseEvent) {
+          const code = typeof event.code === "number" ? event.code : 1001
           ws.removeEventListener("message", onMessage)
           ws.removeEventListener("error", onError)
           Deferred.doneUnsafe(
@@ -506,7 +512,7 @@ export const fromWebSocket = <RO>(
             Effect.fail(
               new SocketError({
                 reason: new SocketCloseError({
-                  code: event.code,
+                  code,
                   closeReason: event.reason
                 })
               })
@@ -527,7 +533,7 @@ export const fromWebSocket = <RO>(
           yield* Deferred.await(openDeferred).pipe(
             Effect.timeoutOrElse({
               duration: options?.openTimeout ?? 10000,
-              onTimeout: () =>
+              orElse: () =>
                 Effect.fail(
                   new SocketError({
                     reason: new SocketOpenError({
@@ -544,14 +550,13 @@ export const fromWebSocket = <RO>(
         currentWS = ws
         latch.openUnsafe()
         if (opts?.onOpen) yield* opts.onOpen
-        return yield* FiberSet.join(fiberSet).pipe(
-          Effect.catchIf(
-            SocketCloseError.filterClean((_) => !closeCodeIsError(_)) as any,
-            (_: any) => Effect.void
-          )
+        return yield* Effect.catchFilter(
+          FiberSet.join(fiberSet),
+          SocketCloseError.filterClean((_) => !closeCodeIsError(_)),
+          () => Effect.void
         )
       })).pipe(
-        Effect.updateServices((input: ServiceMap.ServiceMap<R>) => ServiceMap.merge(acquireContext, input)),
+        Effect.updateContext((input: Context.Context<R>) => Context.merge(acquireContext, input)),
         Effect.ensuring(Effect.sync(() => {
           latch.closeUnsafe()
           currentWS = undefined
@@ -575,7 +580,7 @@ export const fromWebSocket = <RO>(
         if (isCloseEvent(chunk)) {
           ws.close(chunk.code, chunk.reason)
         } else {
-          ws.send(chunk)
+          ws.send(chunk as string | Uint8Array<ArrayBuffer>)
         }
       }))
     const writer = Effect.succeed(write)
@@ -618,7 +623,7 @@ export const layerWebSocket: (
   url: string | Effect.Effect<string>,
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-    readonly openTimeout?: DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
     readonly protocols?: string | Array<string> | undefined
   } | undefined
 ) => Layer.Layer<Socket, never, WebSocketConstructor> = flow(makeWebSocket, Layer.effect(Socket))
@@ -627,7 +632,7 @@ export const layerWebSocket: (
  * @since 4.0.0
  * @category fiber refs
  */
-export const SendQueueCapacity = ServiceMap.Reference<number>("~effect/socket/Socket/SendQueueCapacity", {
+export const SendQueueCapacity = Context.Reference<number>("~effect/socket/Socket/SendQueueCapacity", {
   defaultValue: () => 16
 })
 
@@ -648,12 +653,12 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
   readonly closeCodeIsError?: (code: number) => boolean
 }): Effect.Effect<Socket, never, Exclude<R, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
-    const latch = Effect.makeLatchUnsafe(false)
+    const latch = Latch.makeUnsafe(false)
     let currentStream: {
       readonly stream: InputTransformStream
       readonly fiberSet: FiberSet.FiberSet<any, any>
     } | undefined
-    const acquireServices = fiber.services as ServiceMap.ServiceMap<R>
+    const acquireServices = fiber.context as Context.Context<R>
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
     const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
       readonly onOpen?: Effect.Effect<void> | undefined
@@ -692,15 +697,14 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
         yield* latch.open
         if (opts?.onOpen) yield* opts.onOpen
 
-        return yield* FiberSet.join(fiberSet).pipe(
-          Effect.catchIf(
-            SocketCloseError.filterClean((_) => !closeCodeIsError(_)) as any,
-            (_: any) => Effect.void
-          )
+        return yield* Effect.catchFilter(
+          FiberSet.join(fiberSet),
+          SocketCloseError.filterClean((_) => !closeCodeIsError(_)),
+          () => Effect.void
         )
       })).pipe(
         (_) => _,
-        Effect.updateServices((input: ServiceMap.ServiceMap<R>) => ServiceMap.merge(acquireServices, input)),
+        Effect.updateContext((input: Context.Context<R>) => Context.merge(acquireServices, input)),
         Effect.ensuring(Effect.sync(() => {
           latch.closeUnsafe()
           currentStream = undefined

package/src/unstable/socket/SocketServer.ts

@@ -1,16 +1,16 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import type * as Effect from "../../Effect.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Socket from "./Socket.ts"
 
 /**
  * @since 4.0.0
  * @category tags
  */
-export class SocketServer extends ServiceMap.Service<SocketServer, {
+export class SocketServer extends Context.Service<SocketServer, {
   readonly address: Address
   readonly run: <R, E, _>(
     handler: (socket: Socket.Socket) => Effect.Effect<_, E, R>

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/SqlClient.ts

@@ -2,13 +2,13 @@
  * @since 4.0.0
  */
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Option from "../../Option.ts"
 import type * as Queue from "../../Queue.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
 import type { NoInfer } from "../../Types.ts"
@@ -69,7 +69,7 @@ export interface SqlClient extends Constructor {
  * @category models
  * @since 4.0.0
  */
-export const SqlClient = ServiceMap.Service<SqlClient>("effect/sql/SqlClient")
+export const SqlClient = Context.Service<SqlClient>("effect/sql/SqlClient")
 
 /**
  * @category models
@@ -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: Context.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>
@@ -199,9 +199,9 @@ export const makeWithTransaction = <I, S>(options: {
           for (const [key, value] of options.spanAttributes) {
             span.attribute(key, value)
           }
-          const services = fiber.services
+          const services = fiber.context
           const clock = fiber.getRef(Clock)
-          const connOption = ServiceMap.getOption(services, options.transactionService)
+          const connOption = Context.getOption(services, options.transactionService)
           const conn = connOption._tag === "Some"
             ? Effect.succeed([undefined, connOption.value[0]] as const)
             : options.acquireConnection
@@ -213,11 +213,13 @@ export const makeWithTransaction = <I, S>(options: {
             ) =>
               (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(
                 Effect.flatMap(() =>
-                  Effect.provideServices(
+                  Effect.provideContext(
                     restore(effect),
-                    ServiceMap.add(services, options.transactionService, [conn, id]).pipe(
-                      ServiceMap.add(Tracer.ParentSpan, span)
-                    )
+                    Context.mutate(services, (services) =>
+                      services.pipe(
+                        Context.add(options.transactionService, [conn, id]),
+                        Context.add(Tracer.ParentSpan, span)
+                      ))
                   )
                 ),
                 Effect.exit,
@@ -252,7 +254,7 @@ export const makeWithTransaction = <I, S>(options: {
  * @since 4.0.0
  */
 export class TransactionConnection
-  extends ServiceMap.Service<TransactionConnection, readonly [conn: Connection.Connection, depth: number]>()(
+  extends Context.Service<TransactionConnection, readonly [conn: Connection.Connection, depth: number]>()(
     "effect/sql/SqlClient/TransactionConnection"
   )
 {}
@@ -260,6 +262,6 @@ export class TransactionConnection
 /**
  * @since 4.0.0
  */
-export const SafeIntegers = ServiceMap.Reference<boolean>("effect/sql/SqlClient/SafeIntegers", {
+export const SafeIntegers = Context.Reference<boolean>("effect/sql/SqlClient/SafeIntegers", {
   defaultValue: () => false
 })

package/src/unstable/sql/SqlConnection.ts

@@ -1,9 +1,9 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import type { Effect } from "../../Effect.ts"
 import type { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { Stream } from "../../Stream.ts"
 import type { SqlError } from "./SqlError.ts"
 
@@ -55,7 +55,7 @@ export type Acquirer = Effect<Connection, SqlError, Scope>
  * @category tag
  * @since 4.0.0
  */
-export const Connection = ServiceMap.Service<Connection>("effect/sql/SqlConnection")
+export const Connection = Context.Service<Connection>("effect/sql/SqlConnection")
 
 /**
  * @category model