@effect-app/infra 2.0.1 → 2.1.0

package/src/services/simpledb/diskdb.ts.bak

@@ -1,165 +0,0 @@
-import { flow, pipe } from "effect-app/Function"
-import fs from "fs"
-import * as PLF from "proper-lockfile"
-
-import { pretty } from "effect-app/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"
-import type { Version } from "./simpledb.js"
-
-export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>() {
-  return <REncode, RDecode, EDecode>(
-    type: string,
-    encode: (record: A) => Effect<EA, never, REncode>,
-    decode: (d: EA) => Effect<A, EDecode, RDecode>,
-    schemaVersion: string,
-    makeIndexKey: (r: A) => Index,
-    dir = "./data.js"
-  ) => {
-    initialise(dir)
-    const globalLock = "global.lock"
-    const typeLockKey = getIdxName(type, globalLock)
-    if (!fs.existsSync(typeLockKey)) {
-      fs.writeFileSync(typeLockKey, "", "utf-8")
-    }
-
-    return {
-      find: simpledb.find(find(type), decode, type),
-      findByIndex: getIdx,
-      save: simpledb.store(find(type), store, lockRecordOnDisk(type), type)
-    }
-
-    function store(record: A, currentVersion: Option<Version>) {
-      const version = currentVersion
-        .map((cv) => (parseInt(cv) + 1).toString())
-        .getOrElse(() => "1")
-      const getData = flow(
-        encode,
-        (_) => _.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
-          )
-          .scoped
-          .map(() => ({ version, data: record } as CachedRecord<A>))
-        : getData(record)
-          .flatMap((serialised) => fu.writeTextFile(getFilename(type, record.id), serialised))
-          .map(() => ({ version, data: record } as CachedRecord<A>))
-    }
-
-    function lockIndex(record: A) {
-      const index = makeIndexKey(record)
-      return lockDiskIndex(index)
-    }
-
-    function lockDiskIndex(_: Index) {
-      /*
-    Disk index locks require a file to exist already, hence for now we use a global index lock.
-    */
-      // const lockKey = getIdxKey(index)
-      const lockKey = globalLock
-      return lockIndexOnDisk(type)(lockKey)
-    }
-
-    function lockRecordOnDisk(type: string) {
-      return (id: string) =>
-        lockFile(getFilename(type, id))
-          .mapBoth({
-            onFailure: (err) => new CouldNotAquireDbLockException(type, id, err as Error),
-            onSuccess: (release) => ({ release })
-          })
-          .acquireRelease(
-            (l) => l.release
-          )
-    }
-
-    function lockIndexOnDisk(type: string) {
-      return (id: string) =>
-        lockFile(getIdxName(type, id))
-          .mapBoth({
-            onFailure: (err) => new CouldNotAquireDbLockException(type, id, err as Error),
-            onSuccess: (release) => ({ release })
-          })
-          .acquireRelease(
-            (l) => l.release
-          )
-    }
-
-    function readFile(filePath: string) {
-      return fu
-        .readTextFile(filePath)
-        .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>)
-        )
-      }
-    }
-
-    function getIdx(index: Index) {
-      return readIndex(index).map((idx) => Option.fromNullable(idx[index.key]))
-    }
-
-    function readIndex(index: Index) {
-      return tryRead(getIdxName(type, index.doc)).map(
-        (_) =>
-          _.match(
-            { onNone: () => ({} as Record<string, TKey>), onSome: (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))
-    }
-
-    function tryRead(filePath: string) {
-      return fu
-        .fileExists(filePath)
-        .flatMap((exists) => !exists ? Effect.sync(() => Option.none()) : readFile(filePath).map(Option.some))
-    }
-
-    function getFilename(type: string, id: string) {
-      return `${dir}/v${schemaVersion}.${getRecordName(type, id)}.json`
-    }
-
-    function getIdxName(type: string, id: string) {
-      return `${dir}/v${schemaVersion}.${getIndexName(type, id)}.json`
-    }
-  }
-}
-
-function lockFile(fileName: string) {
-  return Effect.tryPromise(() => PLF.lock(fileName).then(flow(Effect.tryPromise, Effect.orDie)))
-}
-
-// TODO: ugh.
-let initialised = false
-export function initialise(dir: string) {
-  if (initialised) {
-    return
-  }
-
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir)
-  }
-  initialised = true
-}

package/src/services/simpledb/index.ts.bak

@@ -1,6 +0,0 @@
-export * as disk from "./diskdb.js"
-export * as mem from "./memdb.js"
-export * as mongo from "./mongodb.js"
-export * as redis from "./redisdb.js"
-export * from "./shared.js"
-export * as SDB from "./simpledb.js"

package/src/services/simpledb/memdb.ts.bak

@@ -1,78 +0,0 @@
-import { flow } from "effect-app/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 = S.decodeUnknown(SerializedDBRecord)
-
-export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>() {
-  return <REncode, RDecode, EDecode>(
-    type: string,
-    encode: (record: A) => Effect<EA, never, REncode>,
-    decode: (d: EA) => Effect<A, EDecode, RDecode>
-  ) => {
-    return {
-      find: simpledb.find(find, decode, type),
-      findBy,
-      save: simpledb.store(find, store, bogusLock, type)
-    }
-
-    function find(id: string) {
-      return storage
-        .find(getRecordName(type, id))
-        .map((_) => _.map((s) => JSON.parse(s)))
-        .flatMapOpt(parseSDB)
-        .mapOpt(({ data, version }) => ({
-          data: JSON.parse(data) as EA,
-          version
-        }))
-    }
-
-    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)
-                .filterOrFail((d) => eq(keys, d as unknown as V), () => "not equals")
-                .exit
-            )
-            if (r.isSuccess()) {
-              return r.value
-            }
-          }
-          return null
-        })
-        .map(Option.fromNullable)
-    }
-
-    function store(record: A, currentVersion: Option<Version>) {
-      const version = currentVersion
-        .map((cv) => (parseInt(cv) + 1).toString())
-        .getOrElse(() => "1")
-
-      const getData = flow(
-        encode,
-        (_) => _.map(JSON.stringify).map((data) => JSON.stringify({ version, timestamp: new Date(), data }))
-      )
-      return getData(record)
-        .flatMap((serialised) => storage.set(getRecordName(type, record.id), serialised))
-        .map(() => ({ version, data: record } as CachedRecord<A>))
-    }
-  }
-}
-
-function bogusLock() {
-  return Effect.unit.acquireRelease(() => Effect.unit)
-}

package/src/services/simpledb/mongodb.ts.bak

@@ -1,107 +0,0 @@
-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"
-import * as simpledb from "./simpledb.js"
-import type { Version } from "./simpledb.js"
-
-// const makeFromIndexKeys = (indexKeys: string[], unique: boolean) => indexKeys.reduce((prev, cur) => {
-//   prev[cur] = 1
-//   return prev
-// }, {} as Record<string, number>)
-
-const setup = (type: string, indexes: IndexDescription[]) =>
-  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>(
-    type: string,
-    encode: (record: A) => Effect<EA, never, REncode>,
-    decode: (d: EA) => Effect<A, EDecode, RDecode>,
-    // schemaVersion: string,
-    indexes: IndexDescription[]
-  ) => {
-    return setup(type, indexes).map(() => ({
-      find: simpledb.find(find, decode, type),
-      findBy,
-      save: simpledb.storeDirectly(store, type)
-    }))
-
-    function find(id: string) {
-      return MongoClient
-        .flatMap(({ db }) =>
-          Effect.tryPromise(() =>
-            db
-              .collection(type)
-              .findOne<{ _id: TKey; version: Version; data: EA }>({ _id: { equals: id } })
-          )
-        )
-        .map(Option.fromNullable)
-        .mapOpt(({ data, version }) => ({ version, data } as CachedRecord<EA>))
-    }
-
-    function findBy(keys: Record<string, string>) {
-      return MongoClient
-        .flatMap(({ db }) =>
-          Effect.tryPromise(() => db.collection(type).findOne<{ _id: TKey }>(keys, { projection: { _id: 1 } }))
-        )
-        .map(Option.fromNullable)
-        .mapOpt(({ _id }) => _id)
-    }
-
-    function store(record: A, currentVersion: Option<Version>) {
-      return Effect.gen(function*($) {
-        const version = currentVersion
-          .map((cv) => (parseInt(cv) + 1).toString())
-          .getOrElse(() => "1")
-
-        const { db } = yield* $(MongoClient)
-        const data = yield* $(encode(record))
-        yield* $(
-          currentVersion.match(
-            {
-              onNone: () =>
-                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,
-              onSome: (currentVersion) =>
-                Effect
-                  .tryPromise(() =>
-                    db.collection(type).replaceOne(
-                      { _id: record.id as any, version: currentVersion },
-                      {
-                        version,
-                        timestamp: new Date(),
-                        data
-                      },
-                      { upsert: false }
-                    )
-                  )
-                  .orDie
-                  .flatMap((x) => {
-                    if (!x.modifiedCount) {
-                      return new OptimisticLockException(type, record.id)
-                    }
-                    return Effect.unit
-                  })
-            }
-          )
-        )
-        return { version, data: record } as CachedRecord<A>
-      })
-    }
-  }
-}

package/src/services/simpledb/redisdb.ts.bak

@@ -1,202 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { flow } from "effect-app/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"
-import { ConnectionException, CouldNotAquireDbLockException, getIndexName, getRecordName } from "./shared.js"
-import * as simpledb from "./simpledb.js"
-
-const ttl = 10 * 1000
-
-export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>() {
-  return <REncode, RDecode, EDecode>(
-    type: string,
-    encode: (record: A) => Effect<EA, never, REncode>,
-    decode: (d: EA) => Effect<A, EDecode, RDecode>,
-    schemaVersion: string,
-    makeIndexKey: (r: A) => Index
-  ) => {
-    const getData = flow(encode, (_) => _.map(JSON.stringify))
-    return {
-      find: simpledb.find(find, decode, type),
-      findByIndex: getIdx,
-      save: simpledb.store(find, store, lockRedisRecord, type)
-    }
-
-    function find(id: string) {
-      return Effect
-        .flatMap(RedisClient, (_) => _.hmgetAll(getKey(id)))
-        .flatMapOpt((v) =>
-          RedisSerializedDBRecord
-            .decodeUnknown(v)
-            .map(({ data, version }) => ({
-              data: JSON.parse(data) as EA,
-              version
-            }))
-            .mapError((e) => new ConnectionException(new Error(e.toString())))
-        )
-        .orDie
-    }
-    function store(record: A, currentVersion: Option<string>) {
-      const version = currentVersion
-        .map((cv) => (parseInt(cv) + 1).toString())
-        .getOrElse(() => "1")
-      return currentVersion.match(
-        {
-          onNone: () =>
-            lockIndex(record)
-              .zipRight(
-                getIndex(record)
-                  .zipRightOpt(
-                    Effect.fail(() => new Error("Combination already exists, abort"))
-                  )
-                  .zipRight(getData(record))
-                  // TODO: instead use MULTI & EXEC to make it in one command?
-                  .flatMap((data) =>
-                    hmSetRec(
-                      getKey(record.id),
-                      new RedisSerializedDBRecord({
-                        version,
-                        timestamp: new Date(),
-                        data
-                      })
-                    )
-                  )
-                  .zipRight(setIndex(record))
-                  .orDie
-                  .map(() => ({ version, data: record } as CachedRecord<A>))
-              )
-              .scoped,
-          onSome: () =>
-            getData(record)
-              .flatMap((data) =>
-                hmSetRec(
-                  getKey(record.id),
-                  new RedisSerializedDBRecord({
-                    version,
-                    timestamp: new Date(),
-                    data
-                  })
-                )
-              )
-              .orDie
-              .map(() => ({ version, data: record } as CachedRecord<A>))
-        }
-      )
-    }
-
-    function getIndex(record: A) {
-      const index = makeIndexKey(record)
-      return getIdx(index)
-    }
-
-    function setIndex(record: A) {
-      const index = makeIndexKey(record)
-      return setIdx(index, record)
-    }
-
-    function lockIndex(record: A) {
-      const index = makeIndexKey(record)
-      return lockRedisIdx(index)
-    }
-
-    function getIdx(index: Index) {
-      return Effect.flatMap(RedisClient, (_) => _.hget(getIdxKey(index), index.key).map((_) => _.map((i) => i as TKey)))
-    }
-
-    function setIdx(index: Index, r: A) {
-      return Effect.flatMap(RedisClient, (_) => _.hset(getIdxKey(index), index.key, r.id))
-    }
-
-    function lockRedisIdx(index: Index) {
-      const lockKey = getIdxLockKey(index)
-      // acquire
-      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
-          onSuccess: (lock) => ({
-            release: Effect
-              .tryPromise(() => lock.unlock() as unknown as Promise<void>)
-              .orDie
-          })
-        })
-        .acquireRelease(
-          (l) => l.release
-        )
-    }
-
-    function lockRedisRecord(id: string) {
-      // acquire
-      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
-          onSuccess: (lock) => ({
-            // TODO
-            release: Effect
-              .tryPromise(() => lock.unlock() as unknown as Promise<void>)
-              .orDie
-          })
-        })
-        .acquireRelease(
-          (l) => l.release
-        )
-    }
-
-    function getKey(id: string) {
-      return `v${schemaVersion}.${getRecordName(type, id)}`
-    }
-
-    function getLockKey(id: string) {
-      return `v${schemaVersion}.locks.${getRecordName(type, id)}`
-    }
-
-    function getIdxKey(index: Index) {
-      return `v${schemaVersion}.${getIndexName(type, index.doc)}`
-    }
-    function getIdxLockKey(index: Index) {
-      return `v${schemaVersion}.locks.${getIndexName(type, index.doc)}_${index.key}`
-    }
-  }
-
-  function hmSetRec(key: string, val: RedisSerializedDBRecord) {
-    const enc = S.encodeSync(RedisSerializedDBRecord)(val)
-    return Effect.flatMap(RedisClient, ({ client }) =>
-      Effect
-        .async<void, ConnectionException>((res) => {
-          client.hmset(
-            key,
-            "version",
-            enc.version,
-            "timestamp",
-            enc.timestamp,
-            "data",
-            enc.data,
-            (err) =>
-              err
-                ? res(new ConnectionException(err))
-                : res(Effect.sync(() => void 0))
-          )
-        })
-        .uninterruptible)
-  }
-}
-
-export class RedisSerializedDBRecord extends S.Class<RedisSerializedDBRecord>()({
-  version: S.string,
-  timestamp: S.Date,
-  data: S.string
-}) {}

package/src/services/simpledb/shared.ts.bak

@@ -1,117 +0,0 @@
-import { Data, Effect, Option } from "effect-app"
-import * as S from "effect-app/Schema"
-
-export class CouldNotAquireDbLockException
-  extends Data.TaggedError("CouldNotAquireDbLockException")<{ type: string; id: string; error: Error; message: string }>
-{
-  constructor(type: string, id: string, error: Error) {
-    super({ type, id, error, message: `Couldn't lock db record ${type}: ${id}` })
-  }
-}
-
-export class OptimisticLockException
-  extends Data.TaggedError("OptimisticLockException")<{ type: string; id: string; message: string }>
-{
-  constructor(type: string, id: string) {
-    super({ type, id, message: `Existing ${type} ${id} record changed` })
-  }
-}
-
-export class ConnectionException extends Data.TaggedError("ConnectionException")<{ cause: Error; message: string }> {
-  readonly _errorTag = "ConnectionException"
-  constructor(cause: Error) {
-    super({ cause, message: "A connection error ocurred" })
-  }
-}
-
-export interface DBRecord<TKey extends string> {
-  id: TKey
-}
-
-export class SerializedDBRecord extends S.Class<SerializedDBRecord>()({
-  version: S.string,
-  timestamp: S.Date,
-  data: S.string
-}) {}
-
-// unknown -> string -> SDB?
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function makeSerialisedDBRecord(s: S.Schema<any>) {
-  return S.Struct({
-    version: S.number,
-    timestamp: S.Date,
-    data: s
-  })
-}
-
-export interface CachedRecord<T> {
-  version: string
-  data: T
-}
-
-export interface Index {
-  doc: string
-  key: string
-}
-
-export function getIndexName(type: string, id: string) {
-  return `${type}-idx_${id}`
-}
-
-export function getRecordName(type: string, id: string) {
-  return `${type}-r_${id}`
-}
-
-export function makeMap<TKey, T>() {
-  const map = new Map<TKey, T>()
-  return {
-    find: (k: TKey) => Effect.sync(() => Option.fromNullable(map.get(k))),
-    [Symbol.iterator]: () => map[Symbol.iterator](),
-    set: (k: TKey, v: T) =>
-      Effect.sync(() => {
-        map.set(k, v)
-      })
-  } as EffectMap<TKey, T>
-}
-
-export interface EffectMap<TKey, T> {
-  [Symbol.iterator](): IterableIterator<[TKey, T]>
-  find: (k: TKey) => Effect<Option<T>>
-  set: (k: TKey, v: T) => Effect<void>
-}
-
-// export function encodeOnlyWhenStrictMatch<A, E>(
-//   encode: S.HasEncoder<A, E>["encode_"],
-//   v: A
-// ) {
-//   const e1 = Sync.run(encode(v, "strict"))
-//   const e2 = Sync.run(encode(v, "classic"))
-//   try {
-//     assert.deepStrictEqual(e1, e2)
-//   } catch (err) {
-//     throw new Error(
-//       // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-//       "The strict encoding of these objects does not match the classic encoding of these objects. This means that there is a chance of a data-loss, and is probably a programming error\n" +
-//         err
-//     )
-//   }
-//   return e1
-// }
-
-// export function decodeOnlyWhenStrictMatch<A, E>(
-//   decode: S.HasDecoder<A, E>["decode_"],
-//   u: unknown
-// ) {
-//   return pipe(
-//     decode(u, "strict"),
-//     Sync.tap((v) =>
-//       pipe(
-//         decode(u),
-//         Sync.tap((v2) => {
-//           assert.deepStrictEqual(v, v2)
-//           return Sync.succeed(v2)
-//         })
-//       )
-//     )
-//   )
-// }