@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/config.ts

@@ -1,716 +0,0 @@
-import type * as Brand from "../Brand.js"
-import * as Chunk from "../Chunk.js"
-import type * as Config from "../Config.js"
-import * as ConfigError from "../ConfigError.js"
-import * as Duration from "../Duration.js"
-import * as Either from "../Either.js"
-import type { LazyArg } from "../Function.js"
-import { constTrue, dual, pipe } from "../Function.js"
-import type * as HashMap from "../HashMap.js"
-import * as HashSet from "../HashSet.js"
-import { formatUnknown } from "../Inspectable.js"
-import type * as LogLevel from "../LogLevel.js"
-import * as Option from "../Option.js"
-import { hasProperty, type Predicate, type Refinement } from "../Predicate.js"
-import type * as Redacted from "../Redacted.js"
-import type * as Secret from "../Secret.js"
-import * as configError from "./configError.js"
-import * as core from "./core.js"
-import * as defaultServices from "./defaultServices.js"
-import * as effectable from "./effectable.js"
-import * as OpCodes from "./opCodes/config.js"
-import * as redacted_ from "./redacted.js"
-import * as InternalSecret from "./secret.js"
-
-const ConfigSymbolKey = "effect/Config"
-
-/** @internal */
-export const ConfigTypeId: Config.ConfigTypeId = Symbol.for(
-  ConfigSymbolKey
-) as Config.ConfigTypeId
-
-/** @internal */
-export type ConfigPrimitive =
-  | Constant
-  | Described
-  | Fallback
-  | Fail
-  | Lazy
-  | MapOrFail
-  | Nested
-  | Primitive
-  | Sequence
-  | Table
-  | Zipped
-
-const configVariance = {
-  /* c8 ignore next */
-  _A: (_: never) => _
-}
-
-const proto = {
-  ...effectable.CommitPrototype,
-  [ConfigTypeId]: configVariance,
-  commit(this: Config.Config<unknown>) {
-    return defaultServices.config(this)
-  }
-}
-
-/** @internal */
-export type Op<Tag extends string, Body = {}> = Config.Config<never> & Body & {
-  readonly _tag: Tag
-}
-
-/** @internal */
-export interface Constant extends
-  Op<OpCodes.OP_CONSTANT, {
-    readonly value: unknown
-    parse(text: string): Either.Either<unknown, ConfigError.ConfigError>
-  }>
-{}
-
-/** @internal */
-export interface Described extends
-  Op<OpCodes.OP_DESCRIBED, {
-    readonly config: Config.Config<unknown>
-    readonly description: string
-  }>
-{}
-
-/** @internal */
-export interface Fallback extends
-  Op<OpCodes.OP_FALLBACK, {
-    readonly first: Config.Config<unknown>
-    readonly second: Config.Config<unknown>
-    readonly condition: Predicate<ConfigError.ConfigError>
-  }>
-{}
-
-/** @internal */
-export interface Fail extends
-  Op<OpCodes.OP_FAIL, {
-    readonly message: string
-    parse(text: string): Either.Either<unknown, ConfigError.ConfigError>
-  }>
-{}
-
-/** @internal */
-export interface Lazy extends
-  Op<OpCodes.OP_LAZY, {
-    config(): Config.Config<unknown>
-  }>
-{}
-
-/** @internal */
-export interface MapOrFail extends
-  Op<OpCodes.OP_MAP_OR_FAIL, {
-    readonly original: Config.Config<unknown>
-    mapOrFail(value: unknown): Either.Either<unknown, ConfigError.ConfigError>
-  }>
-{}
-
-/** @internal */
-export interface Nested extends
-  Op<OpCodes.OP_NESTED, {
-    readonly name: string
-    readonly config: Config.Config<unknown>
-  }>
-{}
-
-/** @internal */
-export interface Primitive extends
-  Op<OpCodes.OP_PRIMITIVE, {
-    readonly description: string
-    parse(text: string): Either.Either<unknown, ConfigError.ConfigError>
-  }>
-{}
-
-/** @internal */
-export interface Sequence extends
-  Op<OpCodes.OP_SEQUENCE, {
-    readonly config: Config.Config<unknown>
-  }>
-{}
-
-/** @internal */
-export interface Table extends
-  Op<OpCodes.OP_HASHMAP, {
-    readonly op: OpCodes.OP_HASHMAP
-    readonly valueConfig: Config.Config<unknown>
-  }>
-{}
-
-/** @internal */
-export interface Zipped extends
-  Op<OpCodes.OP_ZIP_WITH, {
-    readonly op: OpCodes.OP_ZIP_WITH
-    readonly left: Config.Config<unknown>
-    readonly right: Config.Config<unknown>
-    zip(a: unknown, b: unknown): unknown
-  }>
-{}
-
-/** @internal */
-export const boolean = (name?: string): Config.Config<boolean> => {
-  const config = primitive(
-    "a boolean property",
-    (text) => {
-      switch (text) {
-        case "true":
-        case "yes":
-        case "on":
-        case "1": {
-          return Either.right(true)
-        }
-        case "false":
-        case "no":
-        case "off":
-        case "0": {
-          return Either.right(false)
-        }
-        default: {
-          const error = configError.InvalidData(
-            [],
-            `Expected a boolean value but received ${formatUnknown(text)}`
-          )
-          return Either.left(error)
-        }
-      }
-    }
-  )
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const url = (name?: string): Config.Config<URL> => {
-  const config = primitive(
-    "an URL property",
-    (text) =>
-      Either.try({
-        try: () => new URL(text),
-        catch: (_) => configError.InvalidData([], `Expected an URL value but received ${formatUnknown(text)}`)
-      })
-  )
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const port = (name?: string): Config.Config<number> => {
-  const config = primitive(
-    "a network port property",
-    (text) => {
-      const result = Number(text)
-
-      if (
-        Number.isNaN(result) ||
-        result.toString() !== text.toString() ||
-        !Number.isInteger(result) ||
-        result < 1 ||
-        result > 65535
-      ) {
-        return Either.left(
-          configError.InvalidData(
-            [],
-            `Expected a network port value but received ${formatUnknown(text)}`
-          )
-        )
-      }
-      return Either.right(result)
-    }
-  )
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const array = <A>(config: Config.Config<A>, name?: string): Config.Config<Array<A>> => {
-  return pipe(chunk(config, name), map(Chunk.toArray))
-}
-
-/** @internal */
-export const chunk = <A>(config: Config.Config<A>, name?: string): Config.Config<Chunk.Chunk<A>> => {
-  return map(name === undefined ? repeat(config) : nested(repeat(config), name), Chunk.unsafeFromArray)
-}
-
-/** @internal */
-export const date = (name?: string): Config.Config<Date> => {
-  const config = primitive(
-    "a date property",
-    (text) => {
-      const result = Date.parse(text)
-      if (Number.isNaN(result)) {
-        return Either.left(
-          configError.InvalidData(
-            [],
-            `Expected a Date value but received ${formatUnknown(text)}`
-          )
-        )
-      }
-      return Either.right(new Date(result))
-    }
-  )
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const fail = (message: string): Config.Config<never> => {
-  const fail = Object.create(proto)
-  fail._tag = OpCodes.OP_FAIL
-  fail.message = message
-  fail.parse = () => Either.left(configError.Unsupported([], message))
-  return fail
-}
-
-/** @internal */
-export const number = (name?: string): Config.Config<number> => {
-  const config = primitive(
-    "a number property",
-    (text) => {
-      const result = Number(text)
-      if (Number.isNaN(result)) {
-        return Either.left(
-          configError.InvalidData(
-            [],
-            `Expected a number value but received ${formatUnknown(text)}`
-          )
-        )
-      }
-      return Either.right(result)
-    }
-  )
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const integer = (name?: string): Config.Config<number> => {
-  const config = primitive(
-    "an integer property",
-    (text) => {
-      const result = Number(text)
-      if (!Number.isInteger(result)) {
-        return Either.left(
-          configError.InvalidData(
-            [],
-            `Expected an integer value but received ${formatUnknown(text)}`
-          )
-        )
-      }
-      return Either.right(result)
-    }
-  )
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const literal = <Literals extends ReadonlyArray<Config.LiteralValue>>(...literals: Literals) =>
-(
-  name?: string
-): Config.Config<Literals[number]> => {
-  const valuesString = literals.map(String).join(", ")
-  const config = primitive(`one of (${valuesString})`, (text) => {
-    const found = literals.find((value) => String(value) === text)
-    if (found === undefined) {
-      return Either.left(
-        configError.InvalidData(
-          [],
-          `Expected one of (${valuesString}) but received ${formatUnknown(text)}`
-        )
-      )
-    }
-    return Either.right(found)
-  })
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const logLevel = (name?: string): Config.Config<LogLevel.LogLevel> => {
-  const config = mapOrFail(string(), (value) => {
-    const label = value.toUpperCase()
-    const level = core.allLogLevels.find((level) => level.label === label)
-    return level === undefined
-      ? Either.left(
-        configError.InvalidData([], `Expected a log level but received ${formatUnknown(value)}`)
-      )
-      : Either.right(level)
-  })
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const duration = (name?: string): Config.Config<Duration.Duration> => {
-  const config = mapOrFail(string(), (value) => {
-    const duration = Duration.decodeUnknown(value)
-    return Either.fromOption(
-      duration,
-      () => configError.InvalidData([], `Expected a duration but received ${formatUnknown(value)}`)
-    )
-  })
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const map = dual<
-  <A, B>(f: (a: A) => B) => (self: Config.Config<A>) => Config.Config<B>,
-  <A, B>(self: Config.Config<A>, f: (a: A) => B) => Config.Config<B>
->(2, (self, f) => mapOrFail(self, (a) => Either.right(f(a))))
-
-/** @internal */
-export const mapAttempt = dual<
-  <A, B>(f: (a: A) => B) => (self: Config.Config<A>) => Config.Config<B>,
-  <A, B>(self: Config.Config<A>, f: (a: A) => B) => Config.Config<B>
->(2, (self, f) =>
-  mapOrFail(self, (a) => {
-    try {
-      return Either.right(f(a))
-    } catch (error) {
-      return Either.left(
-        configError.InvalidData(
-          [],
-          error instanceof Error ? error.message : `${error}`
-        )
-      )
-    }
-  }))
-
-/** @internal */
-export const mapOrFail = dual<
-  <A, B>(f: (a: A) => Either.Either<B, ConfigError.ConfigError>) => (self: Config.Config<A>) => Config.Config<B>,
-  <A, B>(self: Config.Config<A>, f: (a: A) => Either.Either<B, ConfigError.ConfigError>) => Config.Config<B>
->(2, (self, f) => {
-  const mapOrFail = Object.create(proto)
-  mapOrFail._tag = OpCodes.OP_MAP_OR_FAIL
-  mapOrFail.original = self
-  mapOrFail.mapOrFail = f
-  return mapOrFail
-})
-
-/** @internal */
-export const nested = dual<
-  (name: string) => <A>(self: Config.Config<A>) => Config.Config<A>,
-  <A>(self: Config.Config<A>, name: string) => Config.Config<A>
->(2, (self, name) => {
-  const nested = Object.create(proto)
-  nested._tag = OpCodes.OP_NESTED
-  nested.name = name
-  nested.config = self
-  return nested
-})
-
-/** @internal */
-export const orElse = dual<
-  <A2>(that: LazyArg<Config.Config<A2>>) => <A>(self: Config.Config<A>) => Config.Config<A | A2>,
-  <A, A2>(self: Config.Config<A>, that: LazyArg<Config.Config<A2>>) => Config.Config<A | A2>
->(2, (self, that) => {
-  const fallback = Object.create(proto)
-  fallback._tag = OpCodes.OP_FALLBACK
-  fallback.first = self
-  fallback.second = suspend(that)
-  fallback.condition = constTrue
-  return fallback
-})
-
-/** @internal */
-export const orElseIf = dual<
-  <A2>(
-    options: {
-      readonly if: Predicate<ConfigError.ConfigError>
-      readonly orElse: LazyArg<Config.Config<A2>>
-    }
-  ) => <A>(self: Config.Config<A>) => Config.Config<A>,
-  <A, A2>(
-    self: Config.Config<A>,
-    options: {
-      readonly if: Predicate<ConfigError.ConfigError>
-      readonly orElse: LazyArg<Config.Config<A2>>
-    }
-  ) => Config.Config<A>
->(2, (self, options) => {
-  const fallback = Object.create(proto)
-  fallback._tag = OpCodes.OP_FALLBACK
-  fallback.first = self
-  fallback.second = suspend(options.orElse)
-  fallback.condition = options.if
-  return fallback
-})
-
-/** @internal */
-export const option = <A>(self: Config.Config<A>): Config.Config<Option.Option<A>> => {
-  return pipe(
-    self,
-    map(Option.some),
-    orElseIf({ orElse: () => succeed(Option.none()), if: ConfigError.isMissingDataOnly })
-  )
-}
-
-/** @internal */
-export const primitive = <A>(
-  description: string,
-  parse: (text: string) => Either.Either<A, ConfigError.ConfigError>
-): Config.Config<A> => {
-  const primitive = Object.create(proto)
-  primitive._tag = OpCodes.OP_PRIMITIVE
-  primitive.description = description
-  primitive.parse = parse
-  return primitive
-}
-
-/** @internal */
-export const repeat = <A>(self: Config.Config<A>): Config.Config<Array<A>> => {
-  const repeat = Object.create(proto)
-  repeat._tag = OpCodes.OP_SEQUENCE
-  repeat.config = self
-  return repeat
-}
-
-/** @internal */
-export const secret = (name?: string): Config.Config<Secret.Secret> => {
-  const config = primitive(
-    "a secret property",
-    (text) => Either.right(InternalSecret.fromString(text))
-  )
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const redacted = <A>(
-  nameOrConfig?: string | Config.Config<A>
-): Config.Config<Redacted.Redacted<A | string>> => {
-  const config: Config.Config<A | string> = isConfig(nameOrConfig) ? nameOrConfig : string(nameOrConfig)
-  return map(config, redacted_.make)
-}
-
-/** @internal */
-export const branded: {
-  <A, B extends Brand.Branded<A, any>>(
-    constructor: Brand.Brand.Constructor<B>
-  ): (config: Config.Config<A>) => Config.Config<B>
-  <B extends Brand.Branded<string, any>>(
-    name: string | undefined,
-    constructor: Brand.Brand.Constructor<B>
-  ): Config.Config<B>
-  <A, B extends Brand.Branded<A, any>>(
-    config: Config.Config<A>,
-    constructor: Brand.Brand.Constructor<B>
-  ): Config.Config<B>
-} = dual(2, <A, B extends Brand.Brand.Constructor<any>>(
-  nameOrConfig: Config.Config<NoInfer<A>> | string | undefined,
-  constructor: B
-) => {
-  const config: Config.Config<string | A> = isConfig(nameOrConfig) ? nameOrConfig : string(nameOrConfig)
-
-  return mapOrFail(config, (a) =>
-    constructor.either(a).pipe(
-      Either.mapLeft((brandErrors) =>
-        configError.InvalidData([], brandErrors.map((brandError) => brandError.message).join("\n"))
-      )
-    ))
-})
-
-/** @internal */
-export const hashSet = <A>(config: Config.Config<A>, name?: string): Config.Config<HashSet.HashSet<A>> => {
-  const newConfig = map(chunk(config), HashSet.fromIterable)
-  return name === undefined ? newConfig : nested(newConfig, name)
-}
-
-/** @internal */
-export const string = (name?: string): Config.Config<string> => {
-  const config = primitive(
-    "a text property",
-    Either.right
-  )
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const nonEmptyString = (name?: string): Config.Config<string> => {
-  const config = primitive(
-    "a non-empty text property",
-    Either.liftPredicate((text) => text.length > 0, () => configError.MissingData([], "Expected a non-empty string"))
-  )
-
-  return name === undefined ? config : nested(config, name)
-}
-
-/** @internal */
-export const all = <const Arg extends Iterable<Config.Config<any>> | Record<string, Config.Config<any>>>(
-  arg: Arg
-): Config.Config<
-  [Arg] extends [ReadonlyArray<Config.Config<any>>] ? {
-      -readonly [K in keyof Arg]: [Arg[K]] extends [Config.Config<infer A>] ? A : never
-    }
-    : [Arg] extends [Iterable<Config.Config<infer A>>] ? Array<A>
-    : [Arg] extends [Record<string, Config.Config<any>>] ? {
-        -readonly [K in keyof Arg]: [Arg[K]] extends [Config.Config<infer A>] ? A : never
-      }
-    : never
-> => {
-  if (Array.isArray(arg)) {
-    return tuple(arg) as any
-  } else if (Symbol.iterator in arg) {
-    return tuple([...(arg as Iterable<Config.Config<any>>)]) as any
-  }
-  return struct(arg) as any
-}
-
-const struct = <NER extends Record<string, Config.Config<any>>>(r: NER): Config.Config<
-  {
-    [K in keyof NER]: [NER[K]] extends [{ [ConfigTypeId]: { _A: (_: never) => infer A } }] ? A : never
-  }
-> => {
-  const entries = Object.entries(r)
-  let result = pipe(entries[0][1], map((value) => ({ [entries[0][0]]: value })))
-  if (entries.length === 1) {
-    return result as any
-  }
-  const rest = entries.slice(1)
-  for (const [key, config] of rest) {
-    result = pipe(
-      result,
-      zipWith(config, (record, value) => ({ ...record, [key]: value }))
-    )
-  }
-  return result as any
-}
-
-/** @internal */
-export const succeed = <A>(value: A): Config.Config<A> => {
-  const constant = Object.create(proto)
-  constant._tag = OpCodes.OP_CONSTANT
-  constant.value = value
-  constant.parse = () => Either.right(value)
-  return constant
-}
-
-/** @internal */
-export const suspend = <A>(config: LazyArg<Config.Config<A>>): Config.Config<A> => {
-  const lazy = Object.create(proto)
-  lazy._tag = OpCodes.OP_LAZY
-  lazy.config = config
-  return lazy
-}
-
-/** @internal */
-export const sync = <A>(value: LazyArg<A>): Config.Config<A> => {
-  return suspend(() => succeed(value()))
-}
-
-/** @internal */
-export const hashMap = <A>(config: Config.Config<A>, name?: string): Config.Config<HashMap.HashMap<string, A>> => {
-  const table = Object.create(proto)
-  table._tag = OpCodes.OP_HASHMAP
-  table.valueConfig = config
-  return name === undefined ? table : nested(table, name)
-}
-
-/** @internal */
-export const isConfig = (u: unknown): u is Config.Config<unknown> => hasProperty(u, ConfigTypeId)
-
-/** @internal */
-const tuple = <T extends ArrayLike<Config.Config<any>>>(tuple: T): Config.Config<
-  {
-    [K in keyof T]: [T[K]] extends [Config.Config<infer A>] ? A : never
-  }
-> => {
-  if (tuple.length === 0) {
-    return succeed([]) as any
-  }
-  if (tuple.length === 1) {
-    return map(tuple[0], (x) => [x]) as any
-  }
-  let result = map(tuple[0], (x) => [x])
-  for (let i = 1; i < tuple.length; i++) {
-    const config = tuple[i]
-    result = pipe(
-      result,
-      zipWith(config, (tuple, value) => [...tuple, value])
-    ) as any
-  }
-  return result as any
-}
-
-/**
- * @internal
- */
-export const unwrap = <A>(wrapped: Config.Config.Wrap<A>): Config.Config<A> => {
-  if (isConfig(wrapped)) {
-    return wrapped
-  }
-  return struct(
-    Object.fromEntries(
-      Object.entries(wrapped).map(([k, a]) => [k, unwrap(a as any)])
-    )
-  ) as any
-}
-
-/** @internal */
-export const validate = dual<
-  {
-    <A, B extends A>(options: {
-      readonly message: string
-      readonly validation: Refinement<A, B>
-    }): (self: Config.Config<A>) => Config.Config<B>
-    <A>(options: {
-      readonly message: string
-      readonly validation: Predicate<A>
-    }): (self: Config.Config<A>) => Config.Config<A>
-  },
-  {
-    <A, B extends A>(self: Config.Config<A>, options: {
-      readonly message: string
-      readonly validation: Refinement<A, B>
-    }): Config.Config<B>
-    <A>(self: Config.Config<A>, options: {
-      readonly message: string
-      readonly validation: Predicate<A>
-    }): Config.Config<A>
-  }
->(2, <A>(self: Config.Config<A>, { message, validation }: {
-  readonly message: string
-  readonly validation: Predicate<A>
-}) =>
-  mapOrFail(self, (a) => {
-    if (validation(a)) {
-      return Either.right(a)
-    }
-    return Either.left(configError.InvalidData([], message))
-  }))
-
-/** @internal */
-export const withDefault = dual<
-  <const A2>(def: A2) => <A>(self: Config.Config<A>) => Config.Config<A | A2>,
-  <A, const A2>(self: Config.Config<A>, def: A2) => Config.Config<A | A2>
->(2, (self, def) =>
-  orElseIf(self, {
-    orElse: () => succeed(def),
-    if: ConfigError.isMissingDataOnly
-  }))
-
-/** @internal */
-export const withDescription = dual<
-  (description: string) => <A>(self: Config.Config<A>) => Config.Config<A>,
-  <A>(self: Config.Config<A>, description: string) => Config.Config<A>
->(2, (self, description) => {
-  const described = Object.create(proto)
-  described._tag = OpCodes.OP_DESCRIBED
-  described.config = self
-  described.description = description
-  return described
-})
-
-/** @internal */
-export const zip = dual<
-  <B>(that: Config.Config<B>) => <A>(self: Config.Config<A>) => Config.Config<[A, B]>,
-  <A, B>(self: Config.Config<A>, that: Config.Config<B>) => Config.Config<[A, B]>
->(2, (self, that) => zipWith(self, that, (a, b) => [a, b]))
-
-/** @internal */
-export const zipWith = dual<
-  <B, A, C>(that: Config.Config<B>, f: (a: A, b: B) => C) => (self: Config.Config<A>) => Config.Config<C>,
-  <A, B, C>(self: Config.Config<A>, that: Config.Config<B>, f: (a: A, b: B) => C) => Config.Config<C>
->(3, (self, that, f) => {
-  const zipWith = Object.create(proto)
-  zipWith._tag = OpCodes.OP_ZIP_WITH
-  zipWith.left = self
-  zipWith.right = that
-  zipWith.zip = f
-  return zipWith
-})