@effect-app/infra 0.43.1 → 0.44.1

package/_src/services/RepositoryBase.ts

@@ -0,0 +1,366 @@
+import type { ParserEnv } from "@effect-app/schema/custom/Parser"
+import type { Repository } from "./Repository.js"
+import type { RequestContextContainer } from "./RequestContextContainer.js"
+import { ContextMap, StoreMaker } from "./Store.js"
+import type { Filter, StoreConfig, Where } from "./Store.js"
+import type {} from "@effect/data/Equal"
+import type {} from "@effect/data/Hash"
+import type { Opt } from "@effect-app/core/Option"
+import { makeCodec } from "@effect-app/infra/api/codec"
+import { makeFilters } from "@effect-app/infra/filter"
+import type { Chunk, Schema } from "@effect-app/prelude"
+import { EParserFor } from "@effect-app/prelude/schema"
+import type { InvalidStateError, OptimisticConcurrencyException } from "../errors.js"
+
+/**
+ * A base for creating an abstract class usable as Tag, Companion and interface to create your own implementation.
+ */
+export const RepositoryBase = <Service>() => {
+  return <T extends { id: string }, PM extends { id: string; _etag: string | undefined }, Evt, ItemType extends string>(
+    itemType: ItemType
+  ) => {
+    abstract class RepositoryBaseC implements Repository<T, PM, Evt, ItemType> {
+      itemType: ItemType = itemType
+      abstract find: (id: T["id"]) => Effect<ContextMap | RequestContextContainer, never, Opt<T>>
+      abstract all: Effect<ContextMap, never, Chunk<T>>
+      abstract saveAndPublish: (
+        items: Iterable<T>,
+        events?: Iterable<Evt>
+      ) => Effect<ContextMap | RequestContextContainer, InvalidStateError | OptimisticConcurrencyException, void>
+      abstract utils: {
+        mapReverse: (
+          pm: PM,
+          setEtag: (id: string, eTag: string | undefined) => void
+        ) => unknown // TODO
+        parse: (a: unknown, env?: ParserEnv | undefined) => T
+        all: Effect<ContextMap, never, Chunk<PM>>
+        filter: (filter: Filter<PM>, cursor?: { limit?: number; skip?: number }) => Effect<ContextMap, never, Chunk<PM>>
+      }
+      abstract remove: (item: T) => Effect<ContextMap, never, void>
+      static where = makeWhere<PM>()
+      static flatMap<R1, E1, B>(f: (a: Service) => Effect<R1, E1, B>): Effect<Service | R1, E1, B> {
+        return Effect.flatMap(this as unknown as Tag<Service, Service>, f)
+      }
+      static map<B>(f: (a: Service) => B): Effect<Service, never, B> {
+        return Effect.map(this as unknown as Tag<Service, Service>, f)
+      }
+    }
+    return assignTag<Service>()(RepositoryBaseC)
+  }
+}
+
+/**
+ * A base implementation to create a repository.
+ */
+export function makeRepo<
+  PM extends { id: string; _etag: string | undefined },
+  Evt = never
+>() {
+  return <
+    ItemType extends string,
+    T extends { id: string },
+    ConstructorInput,
+    Api,
+    E extends { id: string }
+  >(
+    name: ItemType,
+    schema: Schema.Schema<unknown, T, ConstructorInput, E, Api>,
+    mapFrom: (pm: Omit<PM, "_etag">) => E,
+    mapTo: (e: E, etag: string | undefined) => PM
+  ) => {
+    const where = makeWhere<PM>()
+
+    function mapToPersistenceModel(
+      e: E,
+      getEtag: (id: string) => string | undefined
+    ): PM {
+      return mapTo(e, getEtag(e.id))
+    }
+
+    function mapReverse(
+      { _etag, ...e }: PM,
+      setEtag: (id: string, eTag: string | undefined) => void
+    ): E {
+      setEtag(e.id, _etag)
+      return mapFrom(e)
+    }
+
+    const mkStore = makeStore<PM>()(name, schema, mapTo)
+
+    function make(
+      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+      makeInitial?: Effect<never, never, readonly T[]>,
+      config?: Omit<StoreConfig<PM>, "partitionValue"> & {
+        partitionValue?: (a: PM) => string
+      }
+    ) {
+      return Do($ => {
+        const store = $(mkStore(makeInitial, config))
+
+        const allE = store.all.flatMap(items =>
+          Do($ => {
+            const { set } = $(ContextMap)
+            return items.map(_ => mapReverse(_, set))
+          })
+        )
+
+        const all = allE.flatMap(_ => _.forEachEffect(EParserFor(schema).condemnDie))
+
+        function findE(id: T["id"]) {
+          return store.find(id)
+            .flatMap(items =>
+              Do($ => {
+                const { set } = $(ContextMap)
+                return items.map(_ => mapReverse(_, set))
+              })
+            )
+        }
+
+        function find(id: T["id"]) {
+          return findE(id).flatMapOpt(EParserFor(schema).condemnDie)
+        }
+
+        const saveAllE = (a: Iterable<E>) =>
+          Effect(a.toNonEmptyArray)
+            .flatMapOpt(a =>
+              Do($ => {
+                const { get, set } = $(ContextMap)
+                const items = a.mapNonEmpty(_ => mapToPersistenceModel(_, get))
+                const ret = $(store.batchSet(items))
+                ret.forEach(_ => set(_.id, _._etag))
+              })
+            )
+
+        const saveAll = (a: Iterable<T>) => saveAllE(a.toChunk.map(Encoder.for(schema)))
+
+        const saveAndPublish = (items: Iterable<T>, events: Iterable<Evt> = []) =>
+          saveAll(items)
+            > Effect(events.toNonEmptyArray)
+              // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+              .flatMapOpt(publishEvents)
+
+        const encode = Encoder.for(schema)
+        function remove(item: T) {
+          return Do($ => {
+            const { get, set } = $(ContextMap)
+            const e = encode(item)
+            $(store.remove(mapToPersistenceModel(e, get)))
+            set(item.id, undefined)
+          })
+        }
+
+        const r: Repository<T, PM, Evt, ItemType> = {
+          /**
+           * @internal
+           */
+          utils: {
+            mapReverse,
+            parse: Parser.for(schema).unsafe,
+            filter: store.filter
+              .flow(_ => _.tap(items => ContextMap.map(({ set }) => items.forEach(_ => set(_.id, _._etag))))),
+            all: store.all.tap(items => ContextMap.map(({ set }) => items.forEach(_ => set(_.id, _._etag))))
+          },
+          itemType: name,
+          find,
+          all,
+          saveAndPublish,
+          remove
+        }
+        return r
+      })
+    }
+
+    return {
+      make,
+      where
+    }
+  }
+}
+
+/**
+ * @tsplus fluent Repository removeById
+ */
+export function removeById<
+  T extends { id: string },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string
+>(
+  self: Repository<T, PM, Evt, ItemType>,
+  id: T["id"]
+) {
+  return self.get(id).flatMap(_ => self.remove(_))
+}
+
+export function makeWhere<PM extends { id: string; _etag: string | undefined }>() {
+  const f_ = makeFilters<PM>()
+  type WhereFilter = typeof f_
+
+  function makeFilter_(filter: (f: WhereFilter) => Filter<PM>) {
+    return filter(f_)
+  }
+
+  function where(
+    makeWhere: (
+      f: WhereFilter
+    ) => Where | readonly [Where, ...Where[]],
+    mode?: "or" | "and"
+  ) {
+    return makeFilter_(f => {
+      const m = makeWhere ? makeWhere(f) : []
+      return ({
+        mode,
+        where: (Array.isArray(m) ? m as unknown as [Where, ...Where[]] : [m]) as readonly [Where, ...Where[]]
+      })
+    })
+  }
+  return where
+}
+
+const pluralize = (s: string) =>
+  s.endsWith("s")
+    ? s + "es"
+    : s.endsWith("y")
+    ? s.substring(0, s.length - 1) + "ies"
+    : s + "s"
+
+export function makeStore<
+  PM extends { id: string; _etag: string | undefined }
+>() {
+  return <
+    ItemType extends string,
+    T extends { id: string },
+    ConstructorInput,
+    Api,
+    E extends { id: string }
+  >(
+    name: ItemType,
+    schema: Schema.Schema<unknown, T, ConstructorInput, E, Api>,
+    mapTo: (e: E, etag: string | undefined) => PM
+  ) => {
+    const [_dec, encode] = makeCodec(schema)
+    function encodeToPM() {
+      const getEtag = () => undefined
+      return flow(encode, v => mapToPersistenceModel(v, getEtag))
+    }
+
+    function mapToPersistenceModel(
+      e: E,
+      getEtag: (id: string) => string | undefined
+    ): PM {
+      return mapTo(e, getEtag(e.id))
+    }
+
+    function makeStore(
+      makeInitial?: Effect<never, never, readonly T[]>,
+      config?: Omit<StoreConfig<PM>, "partitionValue"> & {
+        partitionValue?: (a: PM) => string
+      }
+    ) {
+      return Do($ => {
+        const { make } = $(StoreMaker)
+
+        const store = $(
+          make<PM, string>(
+            pluralize(name),
+            makeInitial
+              ? makeInitial
+                .map(_ => _.map(encodeToPM()))
+              : undefined,
+            {
+              ...config,
+              partitionValue: config?.partitionValue ?? (_ => "primary") /*(isIntegrationEvent(r) ? r.companyId : r.id*/
+            }
+          )
+        )
+        return store
+      })
+    }
+
+    return makeStore
+  }
+}
+
+export const RepositoryBaseImpl = <Service>() => {
+  return <
+    PM extends { id: string; _etag: string | undefined },
+    Evt = never
+  >() =>
+  <ItemType extends string, T extends { id: string }, ConstructorInput, Api, E extends { id: string }>(
+    itemType: ItemType,
+    schema: Schema.Schema<unknown, T, ConstructorInput, E, Api>,
+    mapFrom: (pm: Omit<PM, "_etag">) => E,
+    mapTo: (e: E, etag: string | undefined) => PM
+  ): (abstract new() => Repository<T, PM, Evt, ItemType>) & Tag<Service, Service> & {
+    make(
+      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+      makeInitial?: Effect<never, never, readonly T[]>,
+      config?: Omit<StoreConfig<PM>, "partitionValue"> & {
+        partitionValue?: (a: PM) => string
+      }
+    ): Effect<StoreMaker, never, Repository<T, PM, Evt, ItemType>>
+    where: ReturnType<typeof makeWhere<PM>>
+    flatMap: <R1, E1, B>(f: (a: Service) => Effect<R1, E1, B>) => Effect<Service | R1, E1, B>
+    map: <B>(f: (a: Service) => B) => Effect<Service, never, B>
+  } => {
+    const mkRepo = makeRepo<PM, Evt>()(itemType, schema, mapFrom, mapTo)
+    abstract class Cls extends RepositoryBase<Service>()<T, PM, Evt, ItemType>(itemType) {
+      static readonly make = mkRepo.make
+    }
+    return Cls
+  }
+}
+
+export const RepositoryDefaultImpl = <Service>() => {
+  return <
+    PM extends { id: string; _etag: string | undefined },
+    Evt = never
+  >() =>
+  <ItemType extends string, T extends { id: string }, ConstructorInput, Api, E extends { id: string }>(
+    itemType: ItemType,
+    schema: Schema.Schema<unknown, T, ConstructorInput, E, Api>,
+    mapFrom: (pm: Omit<PM, "_etag">) => E,
+    mapTo: (e: E, etag: string | undefined) => PM
+  ): Tag<Service, Service> & {
+    new(
+      impl: Repository<T, PM, Evt, ItemType>
+    ): Repository<T, PM, Evt, ItemType>
+    make(
+      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+      makeInitial?: Effect<never, never, readonly T[]>,
+      config?: Omit<StoreConfig<PM>, "partitionValue"> & {
+        partitionValue?: (a: PM) => string
+      }
+    ): Effect<StoreMaker, never, Repository<T, PM, Evt, ItemType>>
+    toLayer(
+      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+      makeInitial?: Effect<never, never, readonly T[]>,
+      config?: Omit<StoreConfig<PM>, "partitionValue"> & {
+        partitionValue?: (a: PM) => string
+      }
+    ): Layer<StoreMaker, never, Service>
+    where: ReturnType<typeof makeWhere<PM>>
+    flatMap: <R1, E1, B>(f: (a: Service) => Effect<R1, E1, B>) => Effect<Service | R1, E1, B>
+    map: <B>(f: (a: Service) => B) => Effect<Service, never, B>
+    repo: Repository<T, PM, Evt, ItemType> // just a helper to type the constructor
+  } => {
+    return class extends RepositoryBaseImpl<Service>()<PM, Evt>()(itemType, schema, mapFrom, mapTo) {
+      static toLayer(
+        publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+        makeInitial?: Effect<never, never, readonly T[]>,
+        config?: Omit<StoreConfig<PM>, "partitionValue"> & {
+          partitionValue?: (a: PM) => string
+        }
+      ) {
+        return this.make(publishEvents, makeInitial, config).map(impl => new this(impl) as any as Service).toLayer(this)
+      }
+      static repo: any
+      constructor(
+        impl: Repository<T, PM, Evt, ItemType>
+      ) {
+        super()
+        Object.assign(this, impl)
+      }
+    }
+  }
+}

package/_src/services/Store/Cosmos.ts

@@ -25,9 +25,9 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
   return Effect.gen(function*($) {
     const { db } = yield* $(CosmosClient.CosmosClient)
     return {
-      make: <Id extends string, PM extends PersistenceModelType<Id>, Id2 extends Id>(
+      make: <Id extends string, PM extends PersistenceModelType<Id>>(
         name: string,
-        seed?: Effect<never, never, ReadonlyMap<Id2, PM>>,
+        seed?: Effect<never, never, Iterable<PM>>,
         config?: StoreConfig<PM>
       ) =>
         Effect.gen(function*($) {
@@ -337,7 +337,7 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
             if (seed) {
               const m = yield* $(seed)
               yield* $(
-                Effect([...m.values()].toNonEmpty)
+                Effect(m.toNonEmptyArray)
                   .flatMapOpt(a =>
                     s
                       .bulkSet(a)

package/_src/services/Store/Disk.ts

@@ -7,12 +7,12 @@ import { makeMemoryStoreInt, storeId } from "./Memory.js"
 import type { PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
 import { StoreMaker } from "./service.js"
 
-function makeDiskStoreInt<Id extends string, Id2 extends Id, PM extends PersistenceModelType<Id>>(
+function makeDiskStoreInt<Id extends string, PM extends PersistenceModelType<Id>>(
   prefix: string,
   namespace: string,
   dir: string,
   name: string,
-  seed?: Effect<never, never, ReadonlyMap<Id2, PM>>
+  seed?: Effect<never, never, Iterable<PM>>
 ) {
   return Effect.gen(function*($) {
     const file = dir + "/" + prefix + name + (namespace === "primary" ? "" : "-" + namespace) + ".json"
@@ -25,11 +25,11 @@ function makeDiskStoreInt<Id extends string, Id2 extends Id, PM extends Persiste
     }
 
     const store = yield* $(
-      makeMemoryStoreInt<Id, Id, PM>(
+      makeMemoryStoreInt<Id, PM>(
         name,
         !fs.existsSync(file)
-          ? seed ?? Effect(new Map())
-          : fsStore.get.map(x => new Map(x.map(x => [x.id, x] as const)))
+          ? seed
+          : fsStore.get
       )
     )
 
@@ -70,9 +70,9 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
       fs.mkdirSync(dir)
     }
     return {
-      make: <Id extends string, Id2 extends Id, PM extends PersistenceModelType<Id>>(
+      make: <Id extends string, PM extends PersistenceModelType<Id>>(
         name: string,
-        seed?: Effect<never, never, ReadonlyMap<Id2, PM>>,
+        seed?: Effect<never, never, Iterable<PM>>,
         config?: StoreConfig<PM>
       ) =>
         Effect.gen(function*($) {
@@ -91,7 +91,7 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
               Effect.suspend(() => {
                 const existing = stores.get(namespace)
                 if (existing) return Effect(existing)
-                return makeDiskStoreInt<Id, Id2, PM>(prefix, namespace, dir, name, seed).tap(store =>
+                return makeDiskStoreInt<Id, PM>(prefix, namespace, dir, name, seed).tap(store =>
                   Effect.sync(() => stores.set(namespace, store))
                 )
               })

package/_src/services/Store/Memory.ts

@@ -28,13 +28,14 @@ export const restoreFromRequestContext = RequestContextContainer.get.flatMap(ctx
   storeId.set(ctx.namespace ?? "primary")
 )
 
-export function makeMemoryStoreInt<Id extends string, Id2 extends Id, PM extends PersistenceModelType<Id>>(
+export function makeMemoryStoreInt<Id extends string, PM extends PersistenceModelType<Id>>(
   name: string,
-  seed?: Effect<never, never, ReadonlyMap<Id2, PM>>
+  seed?: Effect<never, never, Iterable<PM>>
 ) {
   return Effect.gen(function*($) {
     const updateETag = makeUpdateETag(name)
-    const items: ReadonlyMap<Id, PM> = yield* $(seed ?? Effect(new Map<Id, PM>()))
+    const items_ = yield* $(seed ?? Effect([]))
+    const items = new Map(items_.toChunk.map(_ => [_.id, _] as const))
     const makeStore = (): ReadonlyMap<Id, PM> => new Map([...items.entries()].map(([id, e]) => [id, makeETag(e)]))
     const store = Ref.unsafeMake(makeStore())
     const sem = Semaphore.unsafeMake(1)
@@ -78,14 +79,14 @@ export function makeMemoryStoreInt<Id extends string, Id2 extends Id, PM extends
 }
 
 export const makeMemoryStore = () => ({
-  make: <Id extends string, Id2 extends Id, PM extends PersistenceModelType<Id>>(
+  make: <Id extends string, PM extends PersistenceModelType<Id>>(
     name: string,
-    seed?: Effect<never, never, ReadonlyMap<Id2, PM>>,
+    seed?: Effect<never, never, Iterable<PM>>,
     config?: StoreConfig<PM>
   ) =>
     Effect.gen(function*($) {
       const storesSem = Semaphore.unsafeMake(1)
-      const primary = yield* $(makeMemoryStoreInt<Id, Id2, PM>(name, seed))
+      const primary = yield* $(makeMemoryStoreInt<Id, PM>(name, seed))
       const stores = new Map([["primary", primary]])
       const getStore = !config?.allowNamespace ? Effect.succeed(primary) : storeId.get.flatMap(namespace => {
         const store = stores.get(namespace)

package/_src/services/Store/Redis.ts

@@ -11,9 +11,9 @@ export function makeRedisStore({ prefix }: StorageConfig) {
   return Effect.gen(function*($) {
     const redis = yield* $(RedisClient.RedisClient)
     return {
-      make: <Id extends string, PM extends PersistenceModelType<Id>, Id2 extends Id>(
+      make: <Id extends string, PM extends PersistenceModelType<Id>>(
         name: string,
-        seed?: Effect<never, never, ReadonlyMap<Id2, PM>>,
+        seed?: Effect<never, never, Iterable<PM>>,
         _config?: StoreConfig<PM>
       ) =>
         Effect.gen(function*($) {
@@ -22,9 +22,9 @@ export function makeRedisStore({ prefix }: StorageConfig) {
           const key = `${prefix}${name}`
           const current = yield* $(RedisClient.get(key).orDie.provideService(RedisClient.RedisClient, redis))
           if (!current.isSome()) {
-            const m = yield* $(seed ?? Effect(new Map()))
+            const m = yield* $(seed ?? Effect([]))
             yield* $(
-              RedisClient.set(key, JSON.stringify({ data: [...m.values()].map(e => makeETag(e)) }))
+              RedisClient.set(key, JSON.stringify({ data: [...m].map(e => makeETag(e)) }))
                 .orDie
                 .provideService(RedisClient.RedisClient, redis)
             )

package/_src/services/Store/service.ts

@@ -84,11 +84,11 @@ export interface Store<PM extends PersistenceModelType<Id>, Id extends string> {
  * @tsplus companion StoreMaker.Ops
  */
 export abstract class StoreMaker extends TagClass<StoreMaker>() {
-  abstract make: <E extends PersistenceModelType<Id>, Id extends string, Id2 extends Id>(
+  abstract make: <PM extends PersistenceModelType<Id>, Id extends string>(
     name: string,
-    seed?: Effect<never, never, ReadonlyMap<Id2, E>>,
-    config?: StoreConfig<E>
-  ) => Effect<never, never, Store<E, Id>>
+    seed?: Effect<never, never, Iterable<PM>>,
+    config?: StoreConfig<PM>
+  ) => Effect<never, never, Store<PM, Id>>
 }
 
 /**

package/dist/api/codec.d.ts

@@ -1,7 +1,6 @@
-import { Effect } from "@effect/io/Effect";
 import * as MO from "@effect-app/schema";
-import type { ParserEnv } from "@effect-app/schema/custom/Parser";
+import { Encoder, Parser } from "@effect-app/schema";
 export declare function makeCodec<ParsedShape extends {
     id: Id;
-}, ConstructorInput, Encoded, Api, Id>(self: MO.Schema<unknown, ParsedShape, ConstructorInput, Encoded, Api>): readonly [(e: Encoded, env?: ParserEnv) => import("@effect/io/Effect").Effect<never, never, ParsedShape>, (u: ParsedShape) => import("@effect/io/Effect").Effect<never, never, Encoded>, (a: readonly ParsedShape[]) => import("@effect/io/Effect").Effect<never, never, Map<ParsedShape["id"], Encoded>>];
+}, ConstructorInput, Encoded, Api, Id>(self: MO.Schema<unknown, ParsedShape, ConstructorInput, Encoded, Api>): readonly [(a: unknown, env?: Parser.ParserEnv | undefined) => import("@effect/io/Effect").Effect<never, never, ParsedShape>, Encoder.Encoder<ParsedShape, Encoded>];
 //# sourceMappingURL=codec.d.ts.map

package/dist/api/codec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../_src/api/codec.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAExC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAEjE,wBAAgB,SAAS,CACvB,WAAW,SAAS;IAAE,EAAE,EAAE,EAAE,CAAA;CAAE,EAC9B,gBAAgB,EAChB,OAAO,EACP,GAAG,EACH,EAAE,EACF,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,OAAO,EAAE,GAAG,CAAC,iBAGlD,OAAO,QAAQ,SAAS,wEAGxB,WAAW,kLAG/B"}
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../_src/api/codec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAEpD,wBAAgB,SAAS,CACvB,WAAW,SAAS;IAAE,EAAE,EAAE,EAAE,CAAA;CAAE,EAC9B,gBAAgB,EAChB,OAAO,EACP,GAAG,EACH,EAAE,EACF,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,OAAO,EAAE,GAAG,CAAC,uKAKtE"}

package/dist/api/codec.js

@@ -1,17 +1,9 @@
-import * as tsplus_module_1 from "@effect/io/Effect";
-import * as tsplus_module_2 from "@effect-app/core/_ext/Iterable";
 import * as MO from "@effect-app/schema";
 import { Encoder, Parser } from "@effect-app/schema";
 export function makeCodec(self) {
-    const parse = MO.condemnDie(Parser.for(self));
+    const decode = MO.condemnDie(Parser.for(self));
     // TODO: strict
-    const decode = (e, env) => parse(e, env);
-    const enc = Encoder.for(self);
-    const encode = (u) => tsplus_module_1.sync(() => enc(u));
-    const encodeToMap = toMap(encode);
-    return [decode, encode, encodeToMap];
+    const encode = Encoder.for(self);
+    return [decode, encode];
 }
-function toMap(encode) {
-    return (a) => tsplus_module_1.map(tsplus_module_2.ext_collectAll(a.map(task => tsplus_module_1.all(tsplus_module_1.sync(() => task.id), encode(task)))), _ => new Map(_));
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29kZWMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9fc3JjL2FwaS9jb2RlYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUFDeEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUdwRCxNQUFNLFVBQVUsU0FBUyxDQU12QixJQUFxRTtJQUNyRSxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQTtJQUM3QyxlQUFlO0lBQ2YsTUFBTSxNQUFNLEdBQUcsQ0FBQyxDQUFVLEVBQUUsR0FBZSxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFBO0lBQzdELE1BQU0sR0FBRyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUE7SUFFN0IsTUFBTSxNQUFNLEdBQUcsQ0FBQyxDQUFjLEVBQUUsRUFBRSxDQUFDLDJCQUFPLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ2pELE1BQU0sV0FBVyxHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUNqQyxPQUFPLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxXQUFXLENBQVUsQ0FBQTtBQUMvQyxDQUFDO0FBRUQsU0FBUyxLQUFLLENBQThCLE1BQXlDO0lBQ25GLE9BQU8sQ0FBQyxDQUFtQixFQUFFLEVBQUUsQ0FDN0Isb0JBQUEsK0JBQUEsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLG9CQUFXLDJCQUFPLElBQUksQ0FBQyxFQUFhLENBQUMsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUNwRCxFQUNSLENBQUMsQ0FBQyxFQUFFLENBQUMsSUFBSSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQUMzQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29kZWMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9fc3JjL2FwaS9jb2RlYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLG9CQUFvQixDQUFBO0FBQ3hDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUFFcEQsTUFBTSxVQUFVLFNBQVMsQ0FNdkIsSUFBcUU7SUFDckUsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUE7SUFDOUMsZUFBZTtJQUNmLE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDaEMsT0FBTyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQVUsQ0FBQTtBQUNsQyxDQUFDIn0=