@effect-app/infra 0.47.2 → 0.49.0

package/_src/services/simpledb/cosmosdb.ts

@@ -12,11 +12,12 @@ class CosmosDbOperationError {
 }
 
 const setup = (type: string, indexingPolicy: IndexingPolicy) =>
-  Cosmos.db.tap(db =>
+  Cosmos.CosmosClient.tap(({ db }) =>
     Effect.tryPromise(() =>
-      db.containers
+      db
+        .containers
         .create({ id: type, indexingPolicy })
-        .catch(err => console.warn(err))
+        .catch((err) => console.warn(err))
     )
   )
 // TODO: Error if current indexingPolicy does not match
@@ -36,11 +37,12 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     }))
 
     function find(id: string) {
-      return Cosmos.db
-        .flatMap(db => Effect.tryPromise(() => db.container(type).item(id).read<{ data: EA }>()))
-        .map(i => Option.fromNullable(i.resource))
+      return Cosmos
+        .CosmosClient
+        .flatMap(({ db }) => Effect.tryPromise(() => db.container(type).item(id).read<{ data: EA }>()))
+        .map((i) => Option.fromNullable(i.resource))
         .map(
-          _ =>
+          (_) =>
             _.map(
               ({ _etag, data }) => ({ version: _etag, data } as CachedRecord<EA>)
             )
@@ -48,24 +50,26 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     }
 
     function findBy(parameters: Record<string, string>) {
-      return Cosmos.db
-        .flatMap(db =>
+      return Cosmos
+        .CosmosClient
+        .flatMap(({ db }) =>
           Effect.tryPromise(() =>
             db
               .container(type)
-              .items.query({
+              .items
+              .query({
                 query: `
 SELECT TOP 1 ${type}.id
 FROM ${type} i
 WHERE (
   ${
                   typedKeysOf(parameters)
-                    .map(k => `i.${k} = @${k}`)
+                    .map((k) => `i.${k} = @${k}`)
                     .join(" and ")
                 }
 )
 `,
-                parameters: typedKeysOf(parameters).map(p => ({
+                parameters: typedKeysOf(parameters).map((p) => ({
                   name: `@${p}`,
                   value: parameters[p]!
                 }))
@@ -73,58 +77,64 @@ WHERE (
               .fetchAll()
           )
         )
-        .map(x => x.resources.head)
-        .map(_ => _.map(_ => _.id))
+        .map((x) => x.resources.head)
+        .map((_) => _.map((_) => _.id))
     }
 
     function store(record: A, currentVersion: Option<Version>) {
       return Effect.gen(function*($) {
         const version = "_etag" // we get this from the etag anyway.
 
-        const db = yield* $(Cosmos.db)
+        const { db } = yield* $(Cosmos.CosmosClient)
         const data = yield* $(encode(record))
 
         yield* $(
           currentVersion.match(
             () =>
-              Effect.tryPromise(() =>
-                db.container(type).items.create({
-                  id: record.id,
-                  timestamp: new Date(),
-                  data
-                })
-              ).asUnit.orDie,
-            currentVersion =>
-              Effect.tryPromise(() =>
-                db
-                  .container(type)
-                  .item(record.id)
-                  .replace(
-                    {
-                      id: record.id,
-                      timestamp: new Date(),
-                      data
-                    },
-                    {
-                      accessCondition: {
-                        type: "IfMatch",
-                        condition: currentVersion
+              Effect
+                .tryPromise(() =>
+                  db.container(type).items.create({
+                    id: record.id,
+                    timestamp: new Date(),
+                    data
+                  })
+                )
+                .asUnit
+                .orDie,
+            (currentVersion) =>
+              Effect
+                .tryPromise(() =>
+                  db
+                    .container(type)
+                    .item(record.id)
+                    .replace(
+                      {
+                        id: record.id,
+                        timestamp: new Date(),
+                        data
+                      },
+                      {
+                        accessCondition: {
+                          type: "IfMatch",
+                          condition: currentVersion
+                        }
                       }
-                    }
-                  )
-              ).orDie.flatMap(x => {
-                if (x.statusCode === 412) {
-                  return Effect.fail(new OptimisticLockException(type, record.id))
-                }
-                if (x.statusCode > 299 || x.statusCode < 200) {
-                  return Effect.die(
-                    new CosmosDbOperationError(
-                      "not able to update record: " + x.statusCode
                     )
-                  )
-                }
-                return Effect.unit
-              })
+                )
+                .orDie
+                .flatMap((x) => {
+                  if (x.statusCode === 412) {
+                    return Effect.fail(new OptimisticLockException(type, record.id))
+                  }
+                  if (x.statusCode > 299 || x.statusCode < 200) {
+                    return Effect.die(
+                      new CosmosDbOperationError(
+                        "not able to update record: " + x.statusCode
+                      )
+                    )
+                  }
+                  return Effect.unit
+                })
           )
         )
         return { version, data: record } as CachedRecord<A>

package/_src/services/simpledb/diskdb.ts

@@ -33,28 +33,31 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
 
     function store(record: A, currentVersion: Option<Version>) {
       const version = currentVersion
-        .map(cv => (parseInt(cv) + 1).toString())
+        .map((cv) => (parseInt(cv) + 1).toString())
         .getOrElse(() => "1")
       const getData = flow(
         encode,
-        _ => _.map(data => pretty({ version, timestamp: new Date(), data }))
+        (_) => _.map((data) => pretty({ version, timestamp: new Date(), data }))
       )
 
       const idx = makeIndexKey(record)
       return currentVersion.isSome()
         ? lockIndex(record)
           .zipRight(
-            readIndex(idx).flatMap(x =>
-              x[record.id]
-                ? Effect.fail(() => new Error("Combination already exists, abort"))
-                : getData(record)
-                  .flatMap(serialised => fu.writeTextFile(getFilename(type, record.id), serialised))
-                  .zipRight(writeIndex(idx, { ...x, [idx.key]: record.id }))
-            ).orDie
+            readIndex(idx)
+              .flatMap((x) =>
+                x[record.id]
+                  ? Effect.fail(() => new Error("Combination already exists, abort"))
+                  : getData(record)
+                    .flatMap((serialised) => fu.writeTextFile(getFilename(type, record.id), serialised))
+                    .zipRight(writeIndex(idx, { ...x, [idx.key]: record.id }))
+              )
+              .orDie
           )
-          .scoped.map(() => ({ version, data: record } as CachedRecord<A>))
+          .scoped
+          .map(() => ({ version, data: record } as CachedRecord<A>))
         : getData(record)
-          .flatMap(serialised => fu.writeTextFile(getFilename(type, record.id), serialised))
+          .flatMap((serialised) => fu.writeTextFile(getFilename(type, record.id), serialised))
           .map(() => ({ version, data: record } as CachedRecord<A>))
     }
 
@@ -74,60 +77,64 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
 
     function lockRecordOnDisk(type: string) {
       return (id: string) =>
-        lockFile(getFilename(type, id)).mapBoth(
-          err => new CouldNotAquireDbLockException(type, id, err as Error),
-          release => ({ release })
-        ).acquireRelease(
-          l => l.release
-        )
+        lockFile(getFilename(type, id))
+          .mapBoth(
+            (err) => new CouldNotAquireDbLockException(type, id, err as Error),
+            (release) => ({ release })
+          )
+          .acquireRelease(
+            (l) => l.release
+          )
     }
 
     function lockIndexOnDisk(type: string) {
       return (id: string) =>
-        lockFile(getIdxName(type, id)).mapBoth(
-          err => new CouldNotAquireDbLockException(type, id, err as Error),
-          release => ({ release })
-        ).acquireRelease(
-          l => l.release
-        )
+        lockFile(getIdxName(type, id))
+          .mapBoth(
+            (err) => new CouldNotAquireDbLockException(type, id, err as Error),
+            (release) => ({ release })
+          )
+          .acquireRelease(
+            (l) => l.release
+          )
     }
 
     function readFile(filePath: string) {
       return fu
         .readTextFile(filePath)
-        .catchAll(err => Effect.die(new ConnectionException(err as Error)))
+        .catchAll((err) => Effect.die(new ConnectionException(err as Error)))
     }
 
     function find(type: string) {
       return (id: string) => {
         return tryRead(getFilename(type, id)).map(
-          _ => _.map(s => JSON.parse(s) as CachedRecord<EA>)
+          (_) => _.map((s) => JSON.parse(s) as CachedRecord<EA>)
         )
       }
     }
 
     function getIdx(index: Index) {
-      return readIndex(index).map(idx => Option.fromNullable(idx[index.key]))
+      return readIndex(index).map((idx) => Option.fromNullable(idx[index.key]))
     }
 
     function readIndex(index: Index) {
       return tryRead(getIdxName(type, index.doc)).map(
-        _ =>
+        (_) =>
           _.match(
             () => ({} as Record<string, TKey>),
-            x => JSON.parse(x) as Record<string, TKey>
+            (x) => JSON.parse(x) as Record<string, TKey>
           )
       )
     }
 
     function writeIndex(index: Index, content: Record<string, TKey>) {
-      return pipe(JSON.stringify(content), serialised => fu.writeTextFile(getIdxName(type, index.doc), serialised))
+      return pipe(JSON.stringify(content), (serialised) => fu.writeTextFile(getIdxName(type, index.doc), serialised))
     }
 
     function tryRead(filePath: string) {
       return fu
         .fileExists(filePath)
-        .flatMap(exists => !exists ? Effect(Option.none) : readFile(filePath).map(Option.some))
+        .flatMap((exists) => !exists ? Effect(Option.none) : readFile(filePath).map(Option.some))
     }
 
     function getFilename(type: string, id: string) {
@@ -141,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, (_) => _.orDie)))
 }
 
 // TODO: ugh.

package/_src/services/simpledb/memdb.ts

@@ -27,7 +27,7 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     function find(id: string) {
       return storage
         .find(getRecordName(type, id))
-        .map(_ => _.map(s => JSON.parse(s)))
+        .map((_) => _.map((s) => JSON.parse(s)))
         .flatMapOpt(parseSDB)
         .mapOpt(({ data, version }) => ({
           data: JSON.parse(data) as EA,
@@ -37,37 +37,41 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
 
     function findBy<V extends Partial<A>>(keys: V, eq: Equivalence<V>) {
       // Naive implementation, fine for in memory testing purposes.
-      return Effect.gen(function*($) {
-        for (const [, value] of storage) {
-          const sdb_ = JSON.parse(value)
-          const sdb = yield* $(parseSDB(sdb_))
-          const cr = { data: JSON.parse(sdb.data) as EA, version: sdb.version }
-          const r = yield* $(
-            decode(cr.data).flatMap(d =>
-              eq(keys, d as unknown as V)
-                ? Effect(d)
-                : Effect.fail("not equals")
-            ).exit
-          )
-          if (r.isSuccess()) {
-            return r.value
+      return Effect
+        .gen(function*($) {
+          for (const [, value] of storage) {
+            const sdb_ = JSON.parse(value)
+            const sdb = yield* $(parseSDB(sdb_))
+            const cr = { data: JSON.parse(sdb.data) as EA, version: sdb.version }
+            const r = yield* $(
+              decode(cr.data)
+                .flatMap((d) =>
+                  eq(keys, d as unknown as V)
+                    ? Effect(d)
+                    : Effect.fail("not equals")
+                )
+                .exit
+            )
+            if (r.isSuccess()) {
+              return r.value
+            }
           }
-        }
-        return null
-      }).map(Option.fromNullable)
+          return null
+        })
+        .map(Option.fromNullable)
     }
 
     function store(record: A, currentVersion: Option<Version>) {
       const version = currentVersion
-        .map(cv => (parseInt(cv) + 1).toString())
+        .map((cv) => (parseInt(cv) + 1).toString())
         .getOrElse(() => "1")
 
       const getData = flow(
         encode,
-        _ => _.map(JSON.stringify).map(data => JSON.stringify({ version, timestamp: new Date(), data }))
+        (_) => _.map(JSON.stringify).map((data) => JSON.stringify({ version, timestamp: new Date(), data }))
       )
       return getData(record)
-        .flatMap(serialised => storage.set(getRecordName(type, record.id), serialised))
+        .flatMap((serialised) => storage.set(getRecordName(type, record.id), serialised))
         .map(() => ({ version, data: record } as CachedRecord<A>))
     }
   }

package/_src/services/simpledb/mongodb.ts

@@ -1,6 +1,5 @@
+import { MongoClient } from "@effect-app/infra-adapters/mongo-client"
 import type { IndexDescription, InsertOneOptions } from "mongodb"
-
-import * as Mongo from "@effect-app/infra-adapters/mongo-client"
 import type { CachedRecord, DBRecord } from "./shared.js"
 import { OptimisticLockException } from "./shared.js"
 import * as simpledb from "./simpledb.js"
@@ -12,9 +11,9 @@ import type { Version } from "./simpledb.js"
 // }, {} as Record<string, number>)
 
 const setup = (type: string, indexes: IndexDescription[]) =>
-  Mongo.db
-    .tap(db => Effect.tryPromise(() => db.createCollection(type).catch(err => console.warn(err))))
-    .flatMap(db => Effect.tryPromise(() => db.collection(type).createIndexes(indexes)))
+  MongoClient
+    .tap(({ db }) => Effect.tryPromise(() => db.createCollection(type).catch((err) => console.warn(err))))
+    .flatMap(({ db }) => Effect.tryPromise(() => db.collection(type).createIndexes(indexes)))
 
 export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>() {
   return <REncode, RDecode, EDecode>(
@@ -31,8 +30,8 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     }))
 
     function find(id: string) {
-      return Mongo.db
-        .flatMap(db =>
+      return MongoClient
+        .flatMap(({ db }) =>
           Effect.tryPromise(() =>
             db
               .collection(type)
@@ -44,8 +43,8 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     }
 
     function findBy(keys: Record<string, string>) {
-      return Mongo.db
-        .flatMap(db =>
+      return MongoClient
+        .flatMap(({ db }) =>
           Effect.tryPromise(() => db.collection(type).findOne<{ _id: TKey }>(keys, { projection: { _id: 1 } }))
         )
         .map(Option.fromNullable)
@@ -55,41 +54,47 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     function store(record: A, currentVersion: Option<Version>) {
       return Effect.gen(function*($) {
         const version = currentVersion
-          .map(cv => (parseInt(cv) + 1).toString())
+          .map((cv) => (parseInt(cv) + 1).toString())
           .getOrElse(() => "1")
 
-        const db = yield* $(Mongo.db)
+        const { db } = yield* $(MongoClient)
         const data = yield* $(encode(record))
         yield* $(
           currentVersion.match(
             () =>
-              Effect.tryPromise(() =>
-                db
-                  .collection(type)
-                  .insertOne(
-                    { _id: record.id as any, version, timestamp: new Date(), data },
+              Effect
+                .tryPromise(() =>
+                  db
+                    .collection(type)
+                    .insertOne(
+                      { _id: record.id as any, version, timestamp: new Date(), data },
+                      {
+                        checkKeys: false // support for keys with `.` and `$`. NOTE: you can write them, read them, but NOT query for them.
+                      } as InsertOneOptions
+                    )
+                )
+                .asUnit
+                .orDie,
+            (currentVersion) =>
+              Effect
+                .tryPromise(() =>
+                  db.collection(type).replaceOne(
+                    { _id: record.id, version: currentVersion },
                     {
-                      checkKeys: false // support for keys with `.` and `$`. NOTE: you can write them, read them, but NOT query for them.
-                    } as InsertOneOptions
+                      version,
+                      timestamp: new Date(),
+                      data
+                    },
+                    { upsert: false }
                   )
-              ).asUnit.orDie,
-            currentVersion =>
-              Effect.tryPromise(() =>
-                db.collection(type).replaceOne(
-                  { _id: record.id, version: currentVersion },
-                  {
-                    version,
-                    timestamp: new Date(),
-                    data
-                  },
-                  { upsert: false }
                 )
-              ).orDie.flatMap(x => {
-                if (!x.modifiedCount) {
-                  return Effect.fail(new OptimisticLockException(type, record.id))
-                }
-                return Effect.unit
-              })
+                .orDie
+                .flatMap((x) => {
+                  if (!x.modifiedCount) {
+                    return Effect.fail(new OptimisticLockException(type, record.id))
+                  }
+                  return Effect.unit
+                })
           )
         )
         return { version, data: record } as CachedRecord<A>