@effect/platform 0.67.1 → 0.68.1

package/src/internal/httpClientRequest.ts

@@ -1,18 +1,16 @@
 import type { ParseOptions } from "@effect/schema/AST"
 import type * as Schema from "@effect/schema/Schema"
-import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
-import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
+import { pipeArguments } from "effect/Pipeable"
 import * as Redacted from "effect/Redacted"
 import type * as Stream from "effect/Stream"
 import type * as PlatformError from "../Error.js"
 import type * as FileSystem from "../FileSystem.js"
 import * as Headers from "../Headers.js"
 import type * as Body from "../HttpBody.js"
-import type { HttpClient } from "../HttpClient.js"
 import type * as ClientRequest from "../HttpClientRequest.js"
 import type { HttpMethod } from "../HttpMethod.js"
 import * as UrlParams from "../UrlParams.js"
@@ -21,16 +19,9 @@ import * as internalBody from "./httpBody.js"
 /** @internal */
 export const TypeId: ClientRequest.TypeId = Symbol.for("@effect/platform/HttpClientRequest") as ClientRequest.TypeId
 
-/** @internal */
-export const clientTag = Context.GenericTag<HttpClient.Service>("@effect/platform/HttpClient")
-
 const Proto = {
   [TypeId]: TypeId,
-  ...Effectable.CommitPrototype,
   ...Inspectable.BaseProto,
-  commit(this: ClientRequest.HttpClientRequest) {
-    return Effect.flatMap(clientTag, (client) => client.execute(this))
-  },
   toJSON(this: ClientRequest.HttpClientRequest): unknown {
     return {
       _id: "@effect/platform/HttpClientRequest",
@@ -41,6 +32,9 @@ const Proto = {
       headers: this.headers,
       body: this.body.toJSON()
     }
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
   }
 }
 

package/src/internal/platformConfigProvider.ts

@@ -0,0 +1,148 @@
+import type { PlatformError } from "@effect/platform/Error"
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as ConfigProvider from "effect/ConfigProvider"
+import * as Context from "effect/Context"
+import * as DefaultServices from "effect/DefaultServices"
+import * as Effect from "effect/Effect"
+import * as FiberRef from "effect/FiberRef"
+import * as Layer from "effect/Layer"
+
+/**
+ * dot env ConfigProvider
+ *
+ * Based on
+ * - https://github.com/motdotla/dotenv
+ * - https://github.com/motdotla/dotenv-expand
+ */
+
+/** @internal */
+export const fromDotEnv = (
+  path: string
+): Effect.Effect<ConfigProvider.ConfigProvider, PlatformError, FileSystem.FileSystem> =>
+  Effect.gen(function*(_) {
+    const fs = yield* FileSystem.FileSystem
+    const content = yield* fs.readFileString(path)
+    const obj = parseDotEnv(content)
+    return ConfigProvider.fromJson(obj)
+  })
+
+/** @internal */
+export const layerDotEnv = (path: string): Layer.Layer<never, PlatformError, FileSystem.FileSystem> =>
+  fromDotEnv(path).pipe(
+    Effect.map(Layer.setConfigProvider),
+    Layer.unwrapEffect
+  )
+
+/** @internal */
+export const layerDotEnvAdd = (path: string): Layer.Layer<never, never, FileSystem.FileSystem> =>
+  Effect.gen(function*(_) {
+    const dotEnvConfigProvider = yield* Effect.orElseSucceed(fromDotEnv(path), () => null)
+
+    if (dotEnvConfigProvider === null) {
+      yield* Effect.logDebug(`File '${path}' not found, skipping dotenv ConfigProvider.`)
+      return Layer.empty
+    }
+
+    const currentConfigProvider = yield* FiberRef.get(DefaultServices.currentServices).pipe(
+      Effect.map((services) => Context.get(services, ConfigProvider.ConfigProvider))
+    )
+    const configProvider = ConfigProvider.orElse(currentConfigProvider, () => dotEnvConfigProvider)
+    return Layer.setConfigProvider(configProvider)
+  }).pipe(Layer.unwrapEffect)
+
+/** @internal */
+const DOT_ENV_LINE =
+  /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg
+
+/** @internal */
+const parseDotEnv = (lines: string): Record<string, string> => {
+  const obj: Record<string, string> = {}
+
+  // Convert line breaks to same format
+  lines = lines.replace(/\r\n?/gm, "\n")
+
+  let match: RegExpExecArray | null
+  while ((match = DOT_ENV_LINE.exec(lines)) != null) {
+    const key = match[1]
+
+    // Default undefined or null to empty string
+    let value = match[2] || ""
+
+    // Remove whitespace
+    value = value.trim()
+
+    // Check if double quoted
+    const maybeQuote = value[0]
+
+    // Remove surrounding quotes
+    value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2")
+
+    // Expand newlines if double quoted
+    if (maybeQuote === "\"") {
+      value = value.replace(/\\n/g, "\n")
+      value = value.replace(/\\r/g, "\r")
+    }
+
+    // Add to object
+    obj[key] = value
+  }
+
+  return expand(obj)
+}
+
+/** @internal */
+const expand = (parsed: Record<string, string>) => {
+  const newParsed: Record<string, string> = {}
+
+  for (const configKey in parsed) {
+    // resolve escape sequences
+    newParsed[configKey] = interpolate(parsed[configKey], parsed).replace(/\\\$/g, "$")
+  }
+
+  return newParsed
+}
+
+/** @internal */
+const interpolate = (envValue: string, parsed: Record<string, string>) => {
+  // find the last unescaped dollar sign in the
+  // value so that we can evaluate it
+  const lastUnescapedDollarSignIndex = searchLast(envValue, /(?!(?<=\\))\$/g)
+
+  // If we couldn't match any unescaped dollar sign
+  // let's return the string as is
+  if (lastUnescapedDollarSignIndex === -1) return envValue
+
+  // This is the right-most group of variables in the string
+  const rightMostGroup = envValue.slice(lastUnescapedDollarSignIndex)
+
+  /**
+   * This finds the inner most variable/group divided
+   * by variable name and default value (if present)
+   * (
+   *   (?!(?<=\\))\$        // only match dollar signs that are not escaped
+   *   {?                   // optional opening curly brace
+   *     ([\w]+)            // match the variable name
+   *     (?::-([^}\\]*))?   // match an optional default value
+   *   }?                   // optional closing curly brace
+   * )
+   */
+  const matchGroup = /((?!(?<=\\))\${?([\w]+)(?::-([^}\\]*))?}?)/
+  const match = rightMostGroup.match(matchGroup)
+
+  if (match !== null) {
+    const [_, group, variableName, defaultValue] = match
+
+    return interpolate(
+      envValue.replace(group, defaultValue || parsed[variableName] || ""),
+      parsed
+    )
+  }
+
+  return envValue
+}
+
+/** @internal */
+const searchLast = (str: string, rgx: RegExp) => {
+  const matches = Array.from(str.matchAll(rgx))
+  return matches.length > 0 ? matches.slice(-1)[0].index : -1
+}