mattiamanzati

import { Show } from "@fp-ts/codec/Show"
import * as C from "@fp-ts/data/Context"

interface Meta<P> {
  meta: P
}

interface MetaSchema<C> extends Meta<unknown> {
  _tag: unknown
  _C?: C

mattiamanzati

import * as T from "@effect/core/io/Effect"
import * as SE from "@effect/core/stm/TSemaphore"
import * as HM from "@tsplus/stdlib/collections/HashMap"
import { pipe } from "@tsplus/stdlib/data/Function"
import * as O from "@tsplus/stdlib/data/Maybe"

/**
 * Given a function (key: K) => Effect<R, E, A> this DataLoader
 * batches and caches requests such as concurrent lookups
 * for the same key cannot happen.

mattiamanzati

import * as T from "@effect/core/io/Effect"
import type * as EX from "@effect/core/io/Exit"
import * as FID from "@effect/core/io/FiberId"
import * as HUB from "@effect/core/io/Hub"
import type * as RU from "@effect/core/io/Runtime"
import * as S from "@effect/core/stream/Stream"
import * as C from "@effect-ts/core/Case"
import { pipe } from "@tsplus/stdlib/data/Function"
import * as O from "@tsplus/stdlib/data/Maybe"
import * as ENV from "@tsplus/stdlib/service/Env"

mattiamanzati

import * as T from "@effect/core/io/Effect"
import type * as EX from "@effect/core/io/Exit"
import * as FID from "@effect/core/io/FiberId"
import * as HUB from "@effect/core/io/Hub"
import * as S from "@effect/core/stream/Stream"
import * as C from "@effect-ts/core/Case"
import { pipe } from "@tsplus/stdlib/data/Function"
import * as O from "@tsplus/stdlib/data/Maybe"
import * as ENV from "@tsplus/stdlib/service/Env"
import { Tag } from "@tsplus/stdlib/service/Tag"

mattiamanzati

import { pipe } from "@effect-ts/core"
import * as T from "@effect-ts/core/Effect"
import * as P from "@effect-ts/core/Effect/Promise"
import { tuple } from "@effect-ts/core/Function"
import * as O from "@effect-ts/core/Option"

export class ConcurrencyLock {
  executing: P.Promise<never, void>[] = []

  constructor(readonly maxConcurrency: number) {}

mattiamanzati

class DataLoader<K, R, E, A> {
  hitMap: HM.HashMap<K, number> = HM.make();
  promiseMap: HM.HashMap<K, P.Promise<E, A>> = HM.make();

  constructor(readonly resolve: (key: K) => T.Effect<R, E, A>) {}

  acquire(key: K): readonly [isFirst: boolean, promise: P.Promise<E, A>] {
    return pipe(
      HM.get_(this.promiseMap, key),

mattiamanzati

/**
 * @tsplus type Codec
 */
export interface Codec<A> {
  decode: (value: unknown) => E.Either<string, A>;
  encode: (value: A) => unknown;
}

/**

mattiamanzati

/* Just a fake NodeJS db api exposed by mysql, mssql, etc...*/
interface FakeTrans {}
interface FakeConnection {
  query(sql: string, trans?: FakeTrans): Promise<ResultSet>;
  beginTransaction(): Promise<FakeTrans>;
  commitTransaction(trans: FakeTrans): Promise<void>;
  rollbackTransaction(trans: FakeTrans): Promise<void>;
  close(): Promise<void>;
}
declare function fakeConnect(): Promise<FakeConnection>;

mattiamanzati

/* Just a fake NodeJS db api exposed by mysql, mssql, etc...*/
interface FakeTrans {}
interface FakeConnection {
  query(sql: string, trans?: FakeTrans): Promise<ResultSet>;
  beginTransaction(): Promise<FakeTrans>;
  commitTransaction(trans: FakeTrans): Promise<void>;
  rollbackTransaction(trans: FakeTrans): Promise<void>;
}
declare function fakeConnect(): Promise<FakeConnection>;

mattiamanzati

import * as E from "@effect-ts/core/Either";
import * as O from "@effect-ts/core/Option";
import * as D from "@effect-ts/core/Collections/Immutable/Dictionary";
import * as CA from "@effect-ts/core/Case";
import * as C from "@effect-ts/core/Collections/Immutable/Chunk";
import * as Q from "@effect-ts/query/Query";
import * as T from "@effect-ts/core/Effect";
import * as CRM from "@effect-ts/query/CompletedRequestMap";
import * as RQ from "@effect-ts/query/Request";
import * as DS from "@effect-ts/query/DataSource";