effect 2.0.0-next.44 → 2.0.0-next.46

package/src/ConfigSecret.ts

@@ -0,0 +1,76 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Chunk from "./Chunk"
+import type * as Equal from "./Equal"
+import * as internal from "./internal/configSecret"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const ConfigSecretTypeId: unique symbol = internal.ConfigSecretTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type ConfigSecretTypeId = typeof ConfigSecretTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface ConfigSecret extends ConfigSecret.Proto, Equal.Equal {
+  /** @internal */
+  readonly raw: Array<number>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace ConfigSecret {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Proto {
+    readonly [ConfigSecretTypeId]: ConfigSecretTypeId
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isConfigSecret: (u: unknown) => u is ConfigSecret = internal.isConfigSecret
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (bytes: Array<number>) => ConfigSecret = internal.make
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromChunk: (chunk: Chunk.Chunk<string>) => ConfigSecret = internal.fromChunk
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromString: (text: string) => ConfigSecret = internal.fromString
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const value: (self: ConfigSecret) => string = internal.value
+
+/**
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeWipe: (self: ConfigSecret) => void = internal.unsafeWipe

package/src/Console.ts

@@ -0,0 +1,222 @@
+/**
+ * @since 2.0.0
+ */
+import type { Effect } from "./Effect"
+import * as internal from "./internal/console"
+import * as defaultConsole from "./internal/defaultServices/console"
+import type * as Layer from "./Layer"
+import type { Scope } from "./Scope"
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = defaultConsole.TypeId
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface Console {
+  readonly [TypeId]: TypeId
+  assert(condition: boolean, ...args: ReadonlyArray<any>): Effect<never, never, void>
+  readonly clear: Effect<never, never, void>
+  count(label?: string): Effect<never, never, void>
+  countReset(label?: string): Effect<never, never, void>
+  debug(...args: ReadonlyArray<any>): Effect<never, never, void>
+  dir(item: any, options?: any): Effect<never, never, void>
+  dirxml(...args: ReadonlyArray<any>): Effect<never, never, void>
+  error(...args: ReadonlyArray<any>): Effect<never, never, void>
+  group(options?: {
+    readonly label?: string
+    readonly collapsed?: boolean
+  }): Effect<never, never, void>
+  readonly groupEnd: Effect<never, never, void>
+  info(...args: ReadonlyArray<any>): Effect<never, never, void>
+  log(...args: ReadonlyArray<any>): Effect<never, never, void>
+  table(tabularData: any, properties?: ReadonlyArray<string>): Effect<never, never, void>
+  time(label?: string): Effect<never, never, void>
+  timeEnd(label?: string): Effect<never, never, void>
+  timeLog(label?: string, ...args: ReadonlyArray<any>): Effect<never, never, void>
+  trace(...args: ReadonlyArray<any>): Effect<never, never, void>
+  warn(...args: ReadonlyArray<any>): Effect<never, never, void>
+  readonly unsafe: UnsafeConsole
+}
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface UnsafeConsole {
+  assert(condition: boolean, ...args: ReadonlyArray<any>): void
+  clear(): void
+  count(label?: string): void
+  countReset(label?: string): void
+  debug(...args: ReadonlyArray<any>): void
+  dir(item: any, options?: any): void
+  dirxml(...args: ReadonlyArray<any>): void
+  error(...args: ReadonlyArray<any>): void
+  group(options?: {
+    readonly label?: string
+    readonly collapsed?: boolean
+  }): void
+  groupEnd(): void
+  info(...args: ReadonlyArray<any>): void
+  log(...args: ReadonlyArray<any>): void
+  table(tabularData: any, properties?: ReadonlyArray<string>): void
+  time(label?: string): void
+  timeEnd(label?: string): void
+  timeLog(label?: string, ...args: ReadonlyArray<any>): void
+  trace(...args: ReadonlyArray<any>): void
+  warn(...args: ReadonlyArray<any>): void
+}
+
+/**
+ * @since 2.0.0
+ * @category default services
+ */
+export const withConsole: {
+  <A extends Console>(console: A): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A extends Console>(effect: Effect<R, E, A>, console: A): Effect<R, E, A>
+} = internal.withConsole
+
+/**
+ * @since 2.0.0
+ * @category default services
+ */
+export const setConsole: <A extends Console>(console: A) => Layer.Layer<never, never, never> = internal.setConsole
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const consoleWith: <R, E, A>(f: (console: Console) => Effect<R, E, A>) => Effect<R, E, A> = internal.consoleWith
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const assert: (condition: boolean, ...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.assert
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const clear: Effect<never, never, void> = internal.clear
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const count: (label?: string) => Effect<never, never, void> = internal.count
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const countReset: (label?: string) => Effect<never, never, void> = internal.countReset
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const debug: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.debug
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const dir: (item: any, options?: any) => Effect<never, never, void> = internal.dir
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const dirxml: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.dirxml
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const error: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.error
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const group: (
+  options?: { label?: string; collapsed?: boolean }
+) => Effect<Scope, never, void> = internal.group
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const info: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.info
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const log: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.log
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const table: (tabularData: any, properties?: ReadonlyArray<string>) => Effect<never, never, void> =
+  internal.table
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const time: (label?: string) => Effect<Scope, never, void> = internal.time
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const timeLog: (label?: string, ...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.timeLog
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const trace: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.trace
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const warn: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.warn
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const withGroup: {
+  (options?: {
+    readonly label?: string
+    readonly collapsed?: boolean
+  }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A>(self: Effect<R, E, A>, options?: {
+    readonly label?: string
+    readonly collapsed?: boolean
+  }): Effect<R, E, A>
+} = internal.withGroup
+
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+export const withTime: {
+  (label?: string): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A>(self: Effect<R, E, A>, label?: string): Effect<R, E, A>
+} = internal.withTime

package/src/Context.ts

@@ -0,0 +1,365 @@
+/**
+ * This module provides a data structure called `Context` that can be used for dependency injection in effectful
+ * programs. It is essentially a table mapping `Tag`s to their implementations (called `Service`s), and can be used to
+ * manage dependencies in a type-safe way. The `Context` data structure is essentially a way of providing access to a set
+ * of related services that can be passed around as a single unit. This module provides functions to create, modify, and
+ * query the contents of a `Context`, as well as a number of utility types for working with tags and services.
+ *
+ * @since 2.0.0
+ */
+import type { Equal } from "./Equal"
+import type { Inspectable } from "./Inspectable"
+import * as C from "./internal/Context"
+import type { Option } from "./Option"
+import type { Pipeable } from "./Pipeable"
+import type * as Unify from "./Unify"
+
+const TagTypeId: unique symbol = C.TagTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TagTypeId = typeof TagTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Tag<Identifier, Service> extends Pipeable, Inspectable {
+  readonly _tag: "Tag"
+  readonly _op: "Tag"
+  readonly [TagTypeId]: {
+    readonly _S: (_: Service) => Service
+    readonly _I: (_: Identifier) => Identifier
+  }
+  of(self: Service): Service
+  context(self: Service): Context<Identifier>
+  readonly stack?: string | undefined
+  readonly identifier?: unknown | undefined
+  [Unify.typeSymbol]?: unknown
+  [Unify.unifySymbol]?: TagUnify<this>
+  [Unify.blacklistSymbol]?: TagUnifyBlacklist
+}
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+export interface TagUnify<A extends { [Unify.typeSymbol]?: any }> {
+  Tag?: () => A[Unify.typeSymbol] extends Tag<infer I0, infer S0> | infer _ ? Tag<I0, S0> : never
+}
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+export interface TagUnifyBlacklist {}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace Tag {
+  /**
+   * @since 2.0.0
+   */
+  export type Service<T extends Tag<any, any>> = T extends Tag<any, infer A> ? A : never
+  /**
+   * @since 2.0.0
+   */
+  export type Identifier<T extends Tag<any, any>> = T extends Tag<infer A, any> ? A : never
+}
+
+/**
+ * Creates a new `Tag` instance with an optional key parameter.
+ *
+ * Specifying the `key` will make the `Tag` global, meaning two tags with the same
+ * key will map to the same instance.
+ *
+ * Note: this is useful for cases where live reload can happen and it is
+ * desireable to preserve the instance across reloads.
+ *
+ * @param key - An optional key that makes the `Tag` global.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ *
+ * assert.strictEqual(Context.Tag() === Context.Tag(), false)
+ * assert.strictEqual(Context.Tag("PORT") === Context.Tag("PORT"), true)
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Tag: <Identifier, Service = Identifier>(identifier?: unknown) => Tag<Identifier, Service> = C.makeTag
+
+const TypeId: unique symbol = C.TypeId as TypeId
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type ValidTagsById<R> = R extends infer S ? Tag<S, any> : never
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Context<Services> extends Equal, Pipeable, Inspectable {
+  readonly [TypeId]: {
+    readonly _S: (_: Services) => unknown
+  }
+  readonly unsafeMap: Map<Tag<any, any>, any>
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unsafeMake: <Services>(unsafeMap: Map<Tag<any, any>, any>) => Context<Services> = C.makeContext
+
+/**
+ * Checks if the provided argument is a `Context`.
+ *
+ * @param input - The value to be checked if it is a `Context`.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ *
+ * assert.strictEqual(Context.isContext(Context.empty()), true)
+ *
+ * @since 2.0.0
+ * @category guards
+ */
+export const isContext: (input: unknown) => input is Context<never> = C.isContext
+
+/**
+ * Checks if the provided argument is a `Tag`.
+ *
+ * @param input - The value to be checked if it is a `Tag`.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ *
+ * assert.strictEqual(Context.isTag(Context.Tag()), true)
+ *
+ * @since 2.0.0
+ * @category guards
+ */
+export const isTag: (input: unknown) => input is Tag<any, any> = C.isTag
+
+/**
+ * Returns an empty `Context`.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ *
+ * assert.strictEqual(Context.isContext(Context.empty()), true)
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty: () => Context<never> = C.empty
+
+/**
+ * Creates a new `Context` with a single service associated to the tag.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ *
+ * const Port = Context.Tag<{ PORT: number }>()
+ *
+ * const Services = Context.make(Port, { PORT: 8080 })
+ *
+ * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 })
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <T extends Tag<any, any>>(tag: T, service: Tag.Service<T>) => Context<Tag.Identifier<T>> = C.make
+
+/**
+ * Adds a service to a given `Context`.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ * import { pipe } from "effect/Function"
+ *
+ * const Port = Context.Tag<{ PORT: number }>()
+ * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ *
+ * const someContext = Context.make(Port, { PORT: 8080 })
+ *
+ * const Services = pipe(
+ *   someContext,
+ *   Context.add(Timeout, { TIMEOUT: 5000 })
+ * )
+ *
+ * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 })
+ * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 })
+ *
+ * @since 2.0.0
+ */
+export const add: {
+  <T extends Tag<any, any>>(
+    tag: T,
+    service: Tag.Service<T>
+  ): <Services>(self: Context<Services>) => Context<Services | Tag.Identifier<T>>
+  <Services, T extends Tag<any, any>>(
+    self: Context<Services>,
+    tag: T,
+    service: Tag.Service<T>
+  ): Context<Services | Tag.Identifier<T>>
+} = C.add
+
+/**
+ * Get a service from the context that corresponds to the given tag.
+ *
+ * @param self - The `Context` to search for the service.
+ * @param tag - The `Tag` of the service to retrieve.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ * import { pipe } from "effect/Function"
+ *
+ * const Port = Context.Tag<{ PORT: number }>()
+ * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ *
+ * const Services = pipe(
+ *   Context.make(Port, { PORT: 8080 }),
+ *   Context.add(Timeout, { TIMEOUT: 5000 })
+ * )
+ *
+ * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 })
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const get: {
+  <Services, T extends ValidTagsById<Services>>(tag: T): (self: Context<Services>) => Tag.Service<T>
+  <Services, T extends ValidTagsById<Services>>(self: Context<Services>, tag: T): Tag.Service<T>
+} = C.get
+
+/**
+ * Get a service from the context that corresponds to the given tag.
+ * This function is unsafe because if the tag is not present in the context, a runtime error will be thrown.
+ *
+ * For a safer version see {@link getOption}.
+ *
+ * @param self - The `Context` to search for the service.
+ * @param tag - The `Tag` of the service to retrieve.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ *
+ * const Port = Context.Tag<{ PORT: number }>()
+ * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ *
+ * const Services = Context.make(Port, { PORT: 8080 })
+ *
+ * assert.deepStrictEqual(Context.unsafeGet(Services, Port), { PORT: 8080 })
+ * assert.throws(() => Context.unsafeGet(Services, Timeout))
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeGet: {
+  <S, I>(tag: Tag<I, S>): <Services>(self: Context<Services>) => S
+  <Services, S, I>(self: Context<Services>, tag: Tag<I, S>): S
+} = C.unsafeGet
+
+/**
+ * Get the value associated with the specified tag from the context wrapped in an `Option` object. If the tag is not
+ * found, the `Option` object will be `None`.
+ *
+ * @param self - The `Context` to search for the service.
+ * @param tag - The `Tag` of the service to retrieve.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ * import * as O from "effect/Option"
+ *
+ * const Port = Context.Tag<{ PORT: number }>()
+ * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ *
+ * const Services = Context.make(Port, { PORT: 8080 })
+ *
+ * assert.deepStrictEqual(Context.getOption(Services, Port), O.some({ PORT: 8080 }))
+ * assert.deepStrictEqual(Context.getOption(Services, Timeout), O.none())
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const getOption: {
+  <S, I>(tag: Tag<I, S>): <Services>(self: Context<Services>) => Option<S>
+  <Services, S, I>(self: Context<Services>, tag: Tag<I, S>): Option<S>
+} = C.getOption
+
+/**
+ * Merges two `Context`s, returning a new `Context` containing the services of both.
+ *
+ * @param self - The first `Context` to merge.
+ * @param that - The second `Context` to merge.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ *
+ * const Port = Context.Tag<{ PORT: number }>()
+ * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ *
+ * const firstContext = Context.make(Port, { PORT: 8080 })
+ * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 })
+ *
+ * const Services = Context.merge(firstContext, secondContext)
+ *
+ * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 })
+ * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 })
+ *
+ * @since 2.0.0
+ */
+export const merge: {
+  <R1>(that: Context<R1>): <Services>(self: Context<Services>) => Context<R1 | Services>
+  <Services, R1>(self: Context<Services>, that: Context<R1>): Context<Services | R1>
+} = C.merge
+
+/**
+ * Returns a new `Context` that contains only the specified services.
+ *
+ * @param self - The `Context` to prune services from.
+ * @param tags - The list of `Tag`s to be included in the new `Context`.
+ *
+ * @example
+ * import * as Context from "effect/Context"
+ * import { pipe } from "effect/Function"
+ * import * as O from "effect/Option"
+ *
+ * const Port = Context.Tag<{ PORT: number }>()
+ * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ *
+ * const someContext = pipe(
+ *   Context.make(Port, { PORT: 8080 }),
+ *   Context.add(Timeout, { TIMEOUT: 5000 })
+ * )
+ *
+ * const Services = pipe(someContext, Context.pick(Port))
+ *
+ * assert.deepStrictEqual(Context.getOption(Services, Port), O.some({ PORT: 8080 }))
+ * assert.deepStrictEqual(Context.getOption(Services, Timeout), O.none())
+ *
+ * @since 2.0.0
+ */
+export const pick: <Services, S extends Array<ValidTagsById<Services>>>(
+  ...tags: S
+) => (self: Context<Services>) => Context<{ [k in keyof S]: Tag.Identifier<S[k]> }[number]> = C.pick
+
+/**
+ * @since 2.0.0
+ */
+export const omit: <Services, S extends Array<ValidTagsById<Services>>>(
+  ...tags: S
+) => (self: Context<Services>) => Context<Exclude<Services, { [k in keyof S]: Tag.Identifier<S[k]> }[keyof S]>> = C.omit