@effect-app/infra 0.198.1 → 0.199.0

package/src/services/Store/codeFilter.test.ts

@@ -1,4 +1,5 @@
 import type { StoreWhereFilter, Where } from "@effect-app/infra/services/Store"
+import { ReadonlyArray } from "effect-app"
 import { Filters, makeFilters } from "../../filter.js"
 import { codeFilter } from "./utils.js"
 
@@ -44,98 +45,122 @@ type Something = {
 
 test("works", () => {
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("b", (_) => "b2"))
-      ))
+      )
+    )
   )
     .toEqual([somethings[1]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("b", Filters.contains("b")))
-      ))
+      )
+    )
   )
     .toEqual([somethings[0], somethings[1]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("b", Filters.contains("2")))
-      ))
+      )
+    )
   )
     .toEqual([somethings[1]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("b", Filters.endsWith("b")))
-      ))
+      )
+    )
   )
     .toEqual([somethings[0]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("b", Filters.endsWith("2")))
-      ))
+      )
+    )
   )
     .toEqual([somethings[1]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("b", Filters.startsWith("b")))
-      ))
+      )
+    )
   )
     .toEqual([somethings[0], somethings[1]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("b", Filters.startsWith("2")))
-      ))
+      )
+    )
   )
     .toEqual([])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("b", (_) => "b"))
-      ))
+      )
+    )
   )
     .toEqual([somethings[0]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("c", Filters.includes("c")))
-      ))
+      )
+    )
   )
     .toEqual([somethings[0]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("d.-1.a", (_) => "a5"))
-      ))
+      )
+    )
   )
     .toEqual([somethings[1]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("d.-1.a", (_) => "a"))
-      ))
+      )
+    )
   )
     .toEqual([somethings[0]])
 
   expect(
-    somethings
-      .filterMap(codeFilter(
+    ReadonlyArray.filterMap(
+      somethings,
+      codeFilter(
         somethingsWhere((_) => _("d.-1.a", Filters.isnt("a")))
-      ))
+      )
+    )
   )
     .toEqual([somethings[1]])
 })

package/src/services/Store/codeFilter.ts

@@ -1,3 +1,4 @@
+import { ReadonlyArray } from "effect-app"
 import { assertUnreachable, get } from "effect-app/utils"
 import type { FilterR, FilterResult } from "./filterApi/query.js"
 import { compare, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.js"

package/src/services/Store/filterApi/query.ts

@@ -1,3 +1,4 @@
+import { ReadonlyArray } from "effect-app"
 import type { FieldValues } from "../../../filter/types.js"
 import type { FieldPath, FieldPathValue } from "../../../filter/types/path/eager.js"
 import type { Filter, Ops } from "./proxy.js"

package/src/services/Store/index.ts

@@ -1,15 +1,16 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { Secret } from "effect-app"
 import { CosmosStoreLayer } from "./Cosmos.js"
 import { DiskStoreLayer } from "./Disk.js"
 import { MemoryStoreLive } from "./Memory.js"
-import { RedisStoreLayer } from "./Redis.js"
+// import { RedisStoreLayer } from "./Redis.js"
 import type { StorageConfig } from "./service.js"
 
 /**
  * @tsplus static StoreMaker.Ops Layer
  */
 export function StoreMakerLayer(cfg: StorageConfig) {
-  const storageUrl = cfg.url.value
+  const storageUrl = Secret.value(cfg.url)
   if (storageUrl.startsWith("mem://")) {
     console.log("Using in memory store")
     return MemoryStoreLive
@@ -19,10 +20,10 @@ export function StoreMakerLayer(cfg: StorageConfig) {
     console.log("Using disk store at " + dir)
     return DiskStoreLayer(cfg, dir)
   }
-  if (storageUrl.startsWith("redis://")) {
-    console.log("Using Redis store")
-    return RedisStoreLayer(cfg)
-  }
+  // if (storageUrl.startsWith("redis://")) {
+  //   console.log("Using Redis store")
+  //   return RedisStoreLayer(cfg)
+  // }
 
   console.log("Using Cosmos DB store")
   return CosmosStoreLayer(cfg)

package/src/services/Store/service.ts

@@ -1,5 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { UniqueKey } from "@azure/cosmos"
+import { Effect } from "effect-app"
+import type { NonEmptyReadonlyArray, Option, Secret } from "effect-app"
+import { TagClassId, TagClassMakeId } from "effect-app/service"
 import type { OptimisticConcurrencyException } from "../../errors.js"
 import type { FieldValues } from "../../filter/types.js"
 import type { QueryBuilder } from "./filterApi/query.js"
@@ -194,7 +197,7 @@ export interface PersistenceModelType<Id> extends Record<string, any> {
 }
 
 export interface StorageConfig {
-  url: Secret
+  url: Secret.Secret
   prefix: string
   dbName: string
 }

package/src/services/Store/utils.ts

@@ -1,11 +1,9 @@
+import { Effect, Option, ReadonlyArray } from "effect-app"
 import { get } from "effect-app/utils"
-
-import { OptimisticConcurrencyException } from "../../errors.js"
-
-import type { Filter, FilterJoinSelect, PersistenceModelType, SupportedValues2 } from "./service.js"
-
 import objectHash from "object-hash"
+import { OptimisticConcurrencyException } from "../../errors.js"
 import { codeFilter3_ } from "./codeFilter.js"
+import type { Filter, FilterJoinSelect, PersistenceModelType, SupportedValues2 } from "./service.js"
 
 export const makeETag = <E extends PersistenceModelType<Id>, Id extends string>(
   { _etag, ...e }: E
@@ -18,11 +16,13 @@ export const makeUpdateETag =
     Effect.gen(function*($) {
       if (e._etag) {
         yield* $(
-          current
-            .encaseInEffect(() => new OptimisticConcurrencyException({ type, id: e.id, current: "", found: e._etag }))
+          Effect.mapError(
+            current,
+            () => new OptimisticConcurrencyException({ type, id: e.id, current: "", found: e._etag })
+          )
         )
       }
-      if (current.isSome() && current.value._etag !== e._etag) {
+      if (Option.isSome(current) && current.value._etag !== e._etag) {
         return yield* $(
           new OptimisticConcurrencyException({
             type,
@@ -167,22 +167,24 @@ export function codeFilterJoinSelect<E extends { id: string }, NE>(
   filter: FilterJoinSelect
 ) {
   return (x: E) =>
-    filter
-      .keys
-      .filterMap((k) => {
-        const value = get(x, k)
-        // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
-        return value
-          ? Option.some(
-            (value as readonly NE[]).filterMap((v) =>
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              compare((v as any)[filter.valueKey], filter.value)
-                ? Option.some({ ...v, _rootId: x.id })
-                : Option.none()
+    ReadonlyArray
+      .filterMap(
+        filter
+          .keys,
+        (k) => {
+          const value = get(x, k)
+          // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
+          return value
+            ? Option.some(
+              ReadonlyArray.filterMap(value as readonly NE[], (v) =>
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                compare((v as any)[filter.valueKey], filter.value)
+                  ? Option.some({ ...v, _rootId: x.id })
+                  : Option.none())
             )
-          )
-          : Option.none()
-      })
+            : Option.none()
+        }
+      )
       .flatMap((_) => _)
 }
 

package/src/services/query.ts

@@ -1,11 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { toNonEmptyArray } from "@effect-app/core/Array"
 import type { FieldValues } from "@effect-app/infra/filter/types"
 import type { FieldPath, FieldPathValue } from "@effect-app/infra/filter/types/path/eager"
 import type { Repository } from "@effect-app/infra/services/Repository"
 import type { PersistenceModelType } from "@effect-app/infra/services/Store"
 import type { Ops } from "@effect-app/infra/services/Store/filterApi/proxy"
 import type { FilterResult, QueryBuilder } from "@effect-app/infra/services/Store/filterApi/query"
-import { Data, Effect, Match, pipe, S, Unify } from "effect-app"
+import { Data, Effect, Match, Option, pipe, S, Unify } from "effect-app"
 import type { NoInfer } from "effect/Types"
 
 export type QAll<TFieldValues extends FieldValues, A = TFieldValues, R = never> =
@@ -367,7 +368,6 @@ const interpret = <TFieldValues extends FieldValues, A = TFieldValues, R = never
       },
       order: ({ current }) => {
         upd(interpret(current))
-        console.log("missing order implementation")
       },
       page: (v) => {
         upd(interpret(v.current))
@@ -442,7 +442,7 @@ export const query: {
       : repo.utils.filter({
         limit: a.limit,
         skip: a.skip,
-        select: select.toNonEmpty.value ?? undefined,
+        select: Option.getOrUndefined(toNonEmptyArray(select)),
         filter: a.filter.length
           ? {
             type: "new-kid" as const,

package/src/services/simpledb/{cosmosdb.ts → cosmosdb.ts.bak}

@@ -2,6 +2,7 @@ import type { IndexingPolicy } from "@azure/cosmos"
 import { typedKeysOf } from "@effect-app/core/utils"
 
 import * as Cosmos from "@effect-app/infra-adapters/cosmos-client"
+import { Data, Effect, Option } from "effect-app"
 import type { CachedRecord, DBRecord } from "./shared.js"
 import { OptimisticLockException } from "./shared.js"
 import * as simpledb from "./simpledb.js"

package/src/services/simpledb/{diskdb.ts → diskdb.ts.bak}

@@ -4,6 +4,7 @@ import * as PLF from "proper-lockfile"
 
 import { pretty } from "@effect-app/core/utils"
 import * as fu from "@effect-app/infra-adapters/fileUtil"
+import { Effect, Option } from "effect-app"
 import type { CachedRecord, DBRecord, Index } from "./shared.js"
 import { ConnectionException, CouldNotAquireDbLockException, getIndexName, getRecordName } from "./shared.js"
 import * as simpledb from "./simpledb.js"
@@ -147,7 +148,7 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
 }
 
 function lockFile(fileName: string) {
-  return Effect.tryPromise(() => PLF.lock(fileName).then(flow(Effect.tryPromise, (_) => _.orDie)))
+  return Effect.tryPromise(() => PLF.lock(fileName).then(flow(Effect.tryPromise, Effect.orDie)))
 }
 
 // TODO: ugh.

package/src/services/simpledb/{memdb.ts → memdb.ts.bak}

@@ -1,15 +1,16 @@
 import { flow } from "@effect-app/core/Function"
 
+import { Effect, Option } from "effect-app"
+import type { Equivalence } from "effect-app"
 import type { CachedRecord, DBRecord } from "./shared.js"
 import { getRecordName, makeMap, SerializedDBRecord } from "./shared.js"
 import * as simpledb from "./simpledb.js"
 import type { Version } from "./simpledb.js"
-
 // When we are in-process, we want to share the same Storage
 // Do not try this at home.
 const storage = makeMap<string, string>()
 
-const parseSDB = SerializedDBRecord.decodeUnknown
+const parseSDB = S.decodeUnknown(SerializedDBRecord)
 
 export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>() {
   return <REncode, RDecode, EDecode>(

package/src/services/simpledb/{mongodb.ts → mongodb.ts.bak}

@@ -1,4 +1,5 @@
 import { MongoClient } from "@effect-app/infra-adapters/mongo-client"
+import { Effect, Option } from "effect-app"
 import type { IndexDescription, InsertOneOptions } from "mongodb"
 import type { CachedRecord, DBRecord } from "./shared.js"
 import { OptimisticLockException } from "./shared.js"

package/src/services/simpledb/{redisdb.ts → redisdb.ts.bak}

@@ -2,6 +2,8 @@
 
 import { flow } from "@effect-app/core/Function"
 import { RedisClient } from "@effect-app/infra-adapters/redis-client"
+import { Effect } from "effect-app"
+import type { Option } from "effect-app"
 import * as S from "effect-app/schema"
 import type { Lock } from "redlock"
 import type { CachedRecord, DBRecord, Index } from "./shared.js"
@@ -26,8 +28,8 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     }
 
     function find(id: string) {
-      return RedisClient
-        .flatMap((_) => _.hmgetAll(getKey(id)))
+      return Effect
+        .flatMap(RedisClient, (_) => _.hmgetAll(getKey(id)))
         .flatMapOpt((v) =>
           RedisSerializedDBRecord
             .decodeUnknown(v)
@@ -103,18 +105,21 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     }
 
     function getIdx(index: Index) {
-      return RedisClient.flatMap((_) => _.hget(getIdxKey(index), index.key).map((_) => _.map((i) => i as TKey)))
+      return Effect.flatMap(RedisClient, (_) => _.hget(getIdxKey(index), index.key).map((_) => _.map((i) => i as TKey)))
     }
 
     function setIdx(index: Index, r: A) {
-      return RedisClient.flatMap((_) => _.hset(getIdxKey(index), index.key, r.id))
+      return Effect.flatMap(RedisClient, (_) => _.hset(getIdxKey(index), index.key, r.id))
     }
 
     function lockRedisIdx(index: Index) {
       const lockKey = getIdxLockKey(index)
       // acquire
-      return RedisClient
-        .flatMap(({ lock }) => Effect.tryPromise(() => lock.lock(lockKey, ttl) as unknown as Promise<Lock>))
+      return Effect
+        .flatMap(
+          RedisClient,
+          ({ lock }) => Effect.tryPromise(() => lock.lock(lockKey, ttl) as unknown as Promise<Lock>)
+        )
         .mapBoth({
           onFailure: (err) => new CouldNotAquireDbLockException(type, lockKey, err as Error),
           // release
@@ -131,12 +136,11 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
 
     function lockRedisRecord(id: string) {
       // acquire
-      return RedisClient
-        .flatMap(({ lock }) =>
+      return Effect
+        .flatMap(RedisClient, ({ lock }) =>
           Effect.tryPromise(
             () => lock.lock(getLockKey(id), ttl) as unknown as Promise<Lock>
-          )
-        )
+          ))
         .mapBoth({
           onFailure: (err) => new CouldNotAquireDbLockException(type, id, err as Error),
           // release
@@ -169,8 +173,8 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
   }
 
   function hmSetRec(key: string, val: RedisSerializedDBRecord) {
-    const enc = RedisSerializedDBRecord.encodeSync(val)
-    return RedisClient.flatMap(({ client }) =>
+    const enc = S.encodeSync(RedisSerializedDBRecord)(val)
+    return Effect.flatMap(RedisClient, ({ client }) =>
       Effect
         .async<void, ConnectionException>((res) => {
           client.hmset(
@@ -187,8 +191,7 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
                 : res(Effect.sync(() => void 0))
           )
         })
-        .uninterruptible
-    )
+        .uninterruptible)
   }
 }
 

package/src/services/simpledb/{shared.ts → shared.ts.bak}

@@ -1,3 +1,4 @@
+import { Data, Effect, Option } from "effect-app"
 import * as S from "effect-app/schema"
 
 export class CouldNotAquireDbLockException
@@ -35,7 +36,7 @@ export class SerializedDBRecord extends S.Class<SerializedDBRecord>()({
 
 // unknown -> string -> SDB?
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function makeSerialisedDBRecord(s: Schema<any>) {
+export function makeSerialisedDBRecord(s: S.Schema<any>) {
   return S.struct({
     version: S.number,
     timestamp: S.Date,

package/src/services/simpledb/{simpledb.ts → simpledb.ts.bak}

@@ -1,3 +1,5 @@
+import type { Scope } from "effect-app"
+import { Context, Effect, Option, Unify } from "effect-app"
 import type { CachedRecord, DBRecord, EffectMap } from "./shared.js"
 import { makeMap, OptimisticLockException } from "./shared.js"
 
@@ -26,7 +28,7 @@ export function makeLiveRecordCache() {
 export interface RecordCache extends ReturnType<typeof makeLiveRecordCache> {}
 
 // module tag
-export const RecordCache = GenericTag<RecordCache>("@services/RecordCache")
+export const RecordCache = Context.GenericTag<RecordCache>("@services/RecordCache")
 
 export const LiveRecordCache = Effect.sync(() => makeLiveRecordCache()).toLayer(RecordCache)
 
@@ -90,7 +92,9 @@ export function store<R, E, R2, E2, TKey extends string, EA, A extends DBRecord<
       c
         .find(record.id)
         .mapOpt((x) => x.version)
-        .flatMap((_) => _.match({ onNone: () => save(record, Option.none()), onSome: confirmVersionAndSave(record) }))
+        .flatMap((_) =>
+          Unify.unify(_.match({ onNone: () => save(record, Option.none()), onSome: confirmVersionAndSave(record) }))
+        )
         .tap((r) => c.set(record.id, r))
         .map((r) => r.data)
     )

package/tsconfig.json

@@ -11,7 +11,7 @@
     "noUncheckedIndexedAccess": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
-    "importsNotUsedAsValues": "preserve",
+    "isolatedModules": true,
     "checkJs": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
@@ -20,6 +20,7 @@
     "lib": [
       "esnext"
     ],
+    "baseUrl": "./",
     "target": "es2022",
     "inlineSourceMap": true,
     "incremental": true,
@@ -36,35 +37,17 @@
     "downlevelIteration": true,
     "noErrorTruncation": true,
     "ignoreDeprecations": "5.0",
-    "tsPlusTypes": [
-      "./node_modules/@effect-app/core/vendor/effect-data-tsplus.json",
-      "./node_modules/@effect-app/core/vendor/effect-io-tsplus.json",
-      "./node_modules/@effect-app/core/vendor/effect-match-tsplus.json",
-      "./node_modules/@effect-app/core/vendor/effect-stm-tsplus.json",
-      "./node_modules/@effect-app/core/vendor/effect-stream-tsplus.json",
-      "./node_modules/@effect-app/core/vendor/fp-ts-optic-tsplus.json",
-      "./node_modules/@effect-app/core/vendor/effect-schema-tsplus.json",
-      "./node_modules/@effect-app/core/vendor/effect-platform-tsplus.json"
-    ],
-    "plugins": [
-      {
-        "name": "@effect/language-service",
-        "diagnostics": {
-          "1002": "none"
-        }
-      }
-    ],
     "types": [
       "vitest/globals",
       "./types/modules"
     ],
-    "tsPlusConfig": "./tsplus.config.json",
     "rootDir": "./src",
     "tsBuildInfoFile": "./dist/.tsbuildinfo",
-    "noEmit": true
+    "importsNotUsedAsValues": "preserve"
   },
   "$schema": "https://json.schemastore.org/tsconfig",
   "display": "Strictest",
+  "_version": "2.0.0",
   "watchOptions": {
     "watchFile": "useFsEvents",
     "watchDirectory": "useFsEvents",

package/tsconfig.json.bak

@@ -4,10 +4,6 @@
         "lib": [
             "esnext"
         ],
-        "tsPlusConfig": "../../tsplus.config.json",
-        //        "tsPlusGlobalFiles": [
-        //            "./src/_global.ts"
-        //        ],
         "moduleResolution": "Node16",
         "outDir": "./dist",
         "rootDir": "./src",

package/_cjs/_global.cjs

@@ -1,6 +0,0 @@
-"use strict";
-
-require("effect-app/_global");
-require("@effect-app/infra-adapters/_global");
-require("./_global.ext.cjs");
-//# sourceMappingURL=_global.cjs.map

package/_cjs/_global.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"_global.cjs","names":["require"],"sources":["../src/_global.ts"],"sourcesContent":[null],"mappings":";;AAMAA,OAAA;AAKAA,OAAA;AAEAA,OAAA"}

package/_cjs/_global.ext.cjs

@@ -1,5 +0,0 @@
-"use strict";
-
-require("@effect-app/infra/test.arbs");
-require("@effect-app/infra/api/reportError");
-//# sourceMappingURL=_global.ext.cjs.map

package/_cjs/_global.ext.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"_global.ext.cjs","names":["require"],"sources":["../src/_global.ext.ts"],"sourcesContent":[null],"mappings":";;AAiBAA,OAAA;AAkBAA,OAAA"}

package/_cjs/_global.schema.cjs

@@ -1,5 +0,0 @@
-"use strict";
-
-require("effect-app/schema");
-require("effect-app/_global.schema");
-//# sourceMappingURL=_global.schema.cjs.map

package/_cjs/_global.schema.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"_global.schema.cjs","names":["require"],"sources":["../src/_global.schema.ts"],"sourcesContent":[null],"mappings":";;AAOAA,OAAA;AAEAA,OAAA"}

package/_cjs/api/defaultErrorHandler.cjs

@@ -1,37 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.defaultBasicErrorHandler = defaultBasicErrorHandler;
-exports.defaultErrorHandler = defaultErrorHandler;
-var tsplus_module_1 = _interopRequireWildcard(require("effect/Effect"));
-var tsplus_module_2 = _interopRequireWildcard(require("effect/Cause"));
-var tsplus_module_3 = _interopRequireWildcard(require("effect/Schedule"));
-var _errorReporter = require("../errorReporter.cjs");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const logRequestError = (0, _errorReporter.logError)("Request");
-function defaultBasicErrorHandler(_req, res, r2) {
-  const sendError = code => body => tsplus_module_1.sync(() => res.status(code).send(body));
-  return tsplus_module_1.catchAll(tsplus_module_1.catchTag(tsplus_module_1.tapErrorCause(r2, cause => tsplus_module_2.isFailure(cause) ? logRequestError(cause) : tsplus_module_1.unit), "ValidationError", err => sendError(400)(err.errors))
-  // final catch all; expecting never so that unhandled known errors will show up
-  , err => tsplus_module_1.logError("Program error, compiler probably silenced, got an unsupported Error in Error Channel of Effect" + err).map(() => err).flatMap(tsplus_module_1.die));
-}
-const optimisticConcurrencySchedule = tsplus_module_3.once && tsplus_module_3.recurWhile(a => a._tag === "OptimisticConcurrencyException");
-function defaultErrorHandler(req, res, r2) {
-  const r3 = req.method === "PATCH" ? tsplus_module_1.retry(r2, optimisticConcurrencySchedule) : r2;
-  const sendError = code => body => tsplus_module_1.sync(() => res.status(code).send(body));
-  return tsplus_module_1.catchAll(tsplus_module_1.catchTags(tsplus_module_1.tapErrorCause(r3, cause => tsplus_module_2.isFailure(cause) ? logRequestError(cause) : tsplus_module_1.unit), {
-    "ValidationError": err => sendError(400)(err.errors),
-    "NotFoundError": sendError(404),
-    "NotLoggedInError": sendError(401),
-    "UnauthorizedError": sendError(403),
-    "InvalidStateError": sendError(422),
-    // 412 or 409.. https://stackoverflow.com/questions/19122088/which-http-status-code-to-use-to-reject-a-put-due-to-optimistic-locking-failure
-    "OptimisticConcurrencyException": sendError(412)
-  })
-  // final catch all; expecting never so that unhandled known errors will show up
-  , err => tsplus_module_1.logError("Program error, compiler probably silenced, got an unsupported Error in Error Channel of Effect" + err).map(() => err).flatMap(tsplus_module_1.die));
-}
-//# sourceMappingURL=defaultErrorHandler.cjs.map