@effect/platform 0.18.4 → 0.18.5

package/{internal/keyValueStore.esm.js → dist/KeyValueStore-2f9a70bf.esm.js}

@@ -4,18 +4,18 @@ import * as Effect from 'effect/Effect';
 import { dual, pipe } from 'effect/Function';
 import * as Layer from 'effect/Layer';
 import * as Option from 'effect/Option';
-import { FileSystem } from '../FileSystem/dist/effect-platform-FileSystem.esm.js';
-import { Path } from '../Path/dist/effect-platform-Path.esm.js';
+import { a as FileSystem } from './FileSystem-7e31dccd.esm.js';
+import { a as Path } from './Path-46f84ba7.esm.js';
 
 /** @internal */
-const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/KeyValueStore");
+const TypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/KeyValueStore");
 
 /** @internal */
-const keyValueStoreTag = /*#__PURE__*/Context.Tag(TypeId);
+const keyValueStoreTag = /*#__PURE__*/Context.Tag(TypeId$1);
 
 /** @internal */
-const make = impl => keyValueStoreTag.of({
-  [TypeId]: TypeId,
+const make$1 = impl => keyValueStoreTag.of({
+  [TypeId$1]: TypeId$1,
   has: key => Effect.map(impl.get(key), Option.isSome),
   isEmpty: Effect.map(impl.size, size => size === 0),
   modify: (key, f) => Effect.flatMap(impl.get(key), o => {
@@ -32,7 +32,7 @@ const make = impl => keyValueStoreTag.of({
 });
 
 /** @internal */
-const prefix = /*#__PURE__*/dual(2, (self, prefix) => ({
+const prefix$1 = /*#__PURE__*/dual(2, (self, prefix) => ({
   ...self,
   get: key => self.get(`${prefix}${key}`),
   set: (key, value) => self.set(`${prefix}${key}`, value),
@@ -42,7 +42,7 @@ const prefix = /*#__PURE__*/dual(2, (self, prefix) => ({
 }));
 
 /** @internal */
-const SchemaStoreTypeId = /*#__PURE__*/Symbol.for("@effect/platform/KeyValueStore/SchemaStore");
+const SchemaStoreTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/KeyValueStore/SchemaStore");
 
 /** @internal */
 const makeSchemaStore = (store, schema) => {
@@ -62,7 +62,7 @@ const makeSchemaStore = (store, schema) => {
     return Effect.as(set(key, newValue), Option.some(newValue));
   });
   return {
-    [SchemaStoreTypeId]: SchemaStoreTypeId,
+    [SchemaStoreTypeId$1]: SchemaStoreTypeId$1,
     get,
     set,
     modify,
@@ -75,9 +75,9 @@ const makeSchemaStore = (store, schema) => {
 };
 
 /** @internal */
-const layerMemory = /*#__PURE__*/Layer.sync(keyValueStoreTag, () => {
+const layerMemory$1 = /*#__PURE__*/Layer.sync(keyValueStoreTag, () => {
   const store = new Map();
-  return make({
+  return make$1({
     get: key => Effect.sync(() => Option.fromNullable(store.get(key))),
     set: (key, value) => Effect.sync(() => store.set(key, value)),
     remove: key => Effect.sync(() => store.delete(key)),
@@ -87,7 +87,7 @@ const layerMemory = /*#__PURE__*/Layer.sync(keyValueStoreTag, () => {
 });
 
 /** @internal */
-const layerFileSystem = directory => Layer.effect(keyValueStoreTag, Effect.gen(function* (_) {
+const layerFileSystem$1 = directory => Layer.effect(keyValueStoreTag, Effect.gen(function* (_) {
   const fs = yield* _(FileSystem);
   const path = yield* _(Path);
   const keyPath = key => path.join(directory, encodeURIComponent(key));
@@ -96,7 +96,7 @@ const layerFileSystem = directory => Layer.effect(keyValueStoreTag, Effect.gen(f
       recursive: true
     }));
   }
-  return make({
+  return make$1({
     get: key => pipe(Effect.map(fs.readFileString(keyPath(key)), Option.some), Effect.catchTag("SystemError", sysError => sysError.reason === "NotFound" ? Effect.succeed(Option.none()) : Effect.fail(sysError))),
     set: (key, value) => fs.writeFileString(keyPath(key), value),
     remove: key => fs.remove(keyPath(key)),
@@ -111,7 +111,7 @@ const layerFileSystem = directory => Layer.effect(keyValueStoreTag, Effect.gen(f
 }));
 
 /** @internal */
-const layerSchema = (schema, tagIdentifier) => {
+const layerSchema$1 = (schema, tagIdentifier) => {
   const tag = Context.Tag(tagIdentifier);
   const layer = Layer.effect(tag, Effect.map(keyValueStoreTag, store => store.forSchema(schema)));
   return {
@@ -120,4 +120,91 @@ const layerSchema = (schema, tagIdentifier) => {
   };
 };
 
-export { SchemaStoreTypeId, TypeId, keyValueStoreTag, layerFileSystem, layerMemory, layerSchema, make, prefix };
+/**
+ * @since 1.0.0
+ */
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+const TypeId = TypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+const KeyValueStore = keyValueStoreTag;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+const prefix = prefix$1;
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+const layerMemory = layerMemory$1;
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+const layerFileSystem = layerFileSystem$1;
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+const SchemaStoreTypeId = SchemaStoreTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+const layerSchema = layerSchema$1;
+
+var KeyValueStore$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  TypeId: TypeId,
+  KeyValueStore: KeyValueStore,
+  make: make,
+  prefix: prefix,
+  layerMemory: layerMemory,
+  layerFileSystem: layerFileSystem,
+  SchemaStoreTypeId: SchemaStoreTypeId,
+  layerSchema: layerSchema
+});
+
+export { KeyValueStore$1 as K, SchemaStoreTypeId as S, TypeId as T, KeyValueStore as a, layerFileSystem as b, layerSchema as c, layerMemory as l, make as m, prefix as p };

package/dist/Middleware-27760041.esm.js

@@ -0,0 +1,105 @@
+import * as Effect from 'effect/Effect';
+import { flow } from 'effect/Function';
+import { s as set } from './Headers-58b56a08.esm.js';
+import { schemaExternalSpan } from '../Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.esm.js';
+import { a as ServerRequest } from './ServerRequest-03161edc.esm.js';
+import { s as setHeader } from './ServerResponse-675e9456.esm.js';
+
+/** @internal */
+const make$1 = middleware => middleware;
+
+/** @internal */
+const logger$1 = /*#__PURE__*/make$1(httpApp => {
+  let counter = 0;
+  return Effect.flatMap(ServerRequest, request => Effect.withLogSpan(Effect.onExit(httpApp, exit => exit._tag === "Failure" ? Effect.annotateLogs(Effect.log(exit.cause), {
+    "http.method": request.method,
+    "http.url": request.url,
+    "http.status": 500
+  }) : Effect.annotateLogs(Effect.log(""), {
+    "http.method": request.method,
+    "http.url": request.url,
+    "http.status": exit.value.status
+  })), `http.span.${++counter}`));
+});
+
+/** @internal */
+const tracer$1 = /*#__PURE__*/make$1(httpApp => Effect.flatMap(ServerRequest, request => Effect.flatMap(Effect.orElseSucceed(schemaExternalSpan(request), () => undefined), parent => Effect.withSpan(Effect.tap(httpApp, response => Effect.annotateCurrentSpan("http.status", response.status)), `http ${request.method}`, {
+  attributes: {
+    "http.method": request.method,
+    "http.url": request.url
+  },
+  parent
+}))));
+
+/** @internal */
+const b3Response$1 = /*#__PURE__*/make$1(httpApp => Effect.flatMap(Effect.currentSpan, span => span._tag === "Some" ? Effect.map(httpApp, res => setHeader(res, "b3", `${span.value.traceId}-${span.value.spanId}-1${span.value.parent._tag === "Some" ? `-${span.value.parent.value.spanId}` : ""}`)) : httpApp));
+
+/** @internal */
+const xForwardedHeaders$1 = /*#__PURE__*/make$1(httpApp => Effect.updateService(httpApp, ServerRequest, request => request.headers["x-forwarded-host"] ? request.modify({
+  headers: set(request.headers, "host", request.headers["x-forwarded-host"]),
+  remoteAddress: request.headers["x-forwarded-for"]?.split(",")[0].trim()
+}) : request));
+
+/** @internal */
+const loggerTracer$1 = /*#__PURE__*/flow(tracer$1, logger$1);
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const b3Response = b3Response$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const logger = logger$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const tracer = tracer$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const loggerTracer = loggerTracer$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const xForwardedHeaders = xForwardedHeaders$1;
+
+var Middleware = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  make: make,
+  b3Response: b3Response,
+  logger: logger,
+  tracer: tracer,
+  loggerTracer: loggerTracer,
+  xForwardedHeaders: xForwardedHeaders
+});
+
+export { Middleware as M, loggerTracer as a, b3Response as b, logger as l, make as m, tracer as t, xForwardedHeaders as x };

package/{internal/path.esm.js → dist/Path-46f84ba7.esm.js}

@@ -3,13 +3,13 @@ import * as Effect from 'effect/Effect';
 import { identity } from 'effect/Function';
 import * as Layer from 'effect/Layer';
 import * as PathB from 'path-browserify';
-import { BadArgument } from '../Error/dist/effect-platform-Error.esm.js';
+import { B as BadArgument } from './Error-3099667c.esm.js';
 
 /** @internal */
-const Path = /*#__PURE__*/Tag("@effect/platform/Path");
+const Path$2 = /*#__PURE__*/Tag("@effect/platform/Path");
 
 /** @internal */
-const layer = /*#__PURE__*/Layer.succeed(Path, /*#__PURE__*/Path.of({
+const layer$1 = /*#__PURE__*/Layer.succeed(Path$2, /*#__PURE__*/Path$2.of({
   ...PathB,
   fromFileUrl,
   toFileUrl,
@@ -89,4 +89,40 @@ function encodePathChars(filepath) {
   return filepath;
 }
 
-export { Path, layer };
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category tag
+ */
+const Path = Path$2;
+
+/**
+ * An implementation of the Path interface that can be used in all environments
+ * (including browsers).
+ *
+ * It uses the POSIX standard for paths.
+ *
+ * @since 1.0.0
+ * @category layer
+ */
+const layer = layer$1;
+
+var Path$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Path: Path,
+  layer: layer
+});
+
+export { Path$1 as P, Path as a, layer as l };