Function fromEnv

packages/effect/src/internal/configProvider.ts:104–150

(
  options?: Partial<ConfigProvider.ConfigProvider.FromEnvConfig>
)

/** @internal */
export const fromEnv = (
  options?: Partial<ConfigProvider.ConfigProvider.FromEnvConfig>
): ConfigProvider.ConfigProvider => {
  const { pathDelim, seqDelim } = Object.assign({}, { pathDelim: "_", seqDelim: "," }, options)
  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Arr.join(pathDelim))
  const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)

  const getEnv = () =>
    typeof process !== "undefined" && "env" in process && typeof process.env === "object" ? process.env : {}

  const load = <A>(
    path: ReadonlyArray<string>,
    primitive: Config.Config.Primitive<A>,
    split = true
  ): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
    const pathString = makePathString(path)
    const current = getEnv()
    const valueOpt = pathString in current ? Option.some(current[pathString]!) : Option.none()
    return pipe(
      valueOpt,
      core.mapError(() => configError.MissingData(path, `Expected ${pathString} to exist in the process context`)),
      core.flatMap((value) => parsePrimitive(value, path, primitive, seqDelim, split))
    )
  }

  const enumerateChildren = (
    path: ReadonlyArray<string>
  ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
    core.sync(() => {
      const current = getEnv()
      const keys = Object.keys(current)
      const keyPaths = keys.map((value) => unmakePathString(value.toUpperCase()))
      const filteredKeyPaths = keyPaths.filter((keyPath) => {
        for (let i = 0; i < path.length; i++) {
          const pathComponent = pipe(path, Arr.unsafeGet(i))
          const currentElement = keyPath[i]
          if (currentElement === undefined || pathComponent !== currentElement) {
            return false
          }
        }
        return true
      }).flatMap((keyPath) => keyPath.slice(path.length, path.length + 1))
      return HashSet.fromIterable(filteredKeyPaths)
    })

  return fromFlat(makeFlat({ load, enumerateChildren, patch: pathPatch.empty }))
}

/** @internal */
export const fromMap = (