effect-app 4.0.0-beta.99 → 4.0.1

package/src/DataDependencies.ts

@@ -0,0 +1,171 @@
+import type { NonEmptyReadonlyArray } from "effect/Array"
+import * as Ref from "effect/Ref"
+import * as Stream from "effect/Stream"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as RequestScopedDependencies from "./RequestScopedDependencies.ts"
+import * as S from "./Schema.ts"
+
+export const DataDependency = S.Union([
+  S.Struct({
+    type: S.Literal("repo"),
+    name: S.String,
+    ids: S.optional(S.NonEmptyArray(S.String))
+  }),
+  S.Struct({
+    type: S.Literal("signal"),
+    name: S.String,
+    ids: S.optional(S.NonEmptyArray(S.String))
+  })
+])
+export type DataDependency = S.Schema.Type<typeof DataDependency>
+
+export const DataDependencies = S.ReadonlySet(DataDependency)
+export type DataDependencies = S.Schema.Type<typeof DataDependencies>
+
+export const empty = (): DataDependencies => new Set()
+
+export const DataDependencySet = S.Struct({
+  reads: DataDependencies,
+  writes: DataDependencies
+})
+export type DataDependencySet = S.Schema.Type<typeof DataDependencySet>
+
+export interface DataDependencyRecorderService {
+  readonly read: (dependency: DataDependency) => Effect.Effect<void>
+  readonly write: (dependency: DataDependency) => Effect.Effect<void>
+  readonly get: Effect.Effect<DataDependencySet>
+  readonly drain: Effect.Effect<DataDependencySet>
+  readonly drainWrites: Effect.Effect<DataDependencies>
+}
+
+const sameDomain = (a: DataDependency, b: DataDependency) => a.type === b.type && a.name === b.name
+
+const dependenciesOverlap = (a: DataDependency, b: DataDependency) => {
+  if (!sameDomain(a, b)) return false
+  if (a.ids === undefined || b.ids === undefined) return true
+  return a.ids.some((id) => b.ids?.includes(id))
+}
+
+const containsDependency = (dependencies: ReadonlySet<DataDependency>, dependency: DataDependency) => {
+  for (const _ of dependencies) {
+    if (dependenciesOverlap(_, dependency)) return true
+  }
+  return false
+}
+
+const appendDependency = (dependency: DataDependency) => (dependencies: DataDependencies): DataDependencies => {
+  const existing = [...dependencies].find((_) => sameDomain(_, dependency))
+  if (existing === undefined) return new Set([...dependencies, dependency])
+  if (existing.ids === undefined) return dependencies
+  if (dependency.ids === undefined) {
+    return new Set([...dependencies].filter((_) => _ !== existing).concat(dependency))
+  }
+  const first = existing.ids[0]
+  const ids: NonEmptyReadonlyArray<string> = [
+    first,
+    ...new Set([...existing.ids.slice(1), ...dependency.ids].filter((id) => id !== first))
+  ]
+  if (ids.length === existing.ids.length) return dependencies
+  const merged = existing.type === "repo" ? repo(existing.name, ids) : signal(existing.name, ids)
+  return new Set([...dependencies].filter((_) => _ !== existing).concat(merged))
+}
+
+export const merge = (...groups: ReadonlyArray<DataDependencies>): DataDependencies => {
+  let merged = empty()
+  for (const group of groups) {
+    for (const dependency of group) merged = appendDependency(dependency)(merged)
+  }
+  return merged
+}
+
+export const DataDependencyRecorder = RequestScopedDependencies.make(
+  "effect-app/DataDependencyRecorder",
+  Effect.gen(function*() {
+    const readsRef = yield* Ref.make(empty())
+    const writesRef = yield* Ref.make(empty())
+    return makeDataDependencyRecorder(readsRef, writesRef)
+  })
+)
+export type DataDependencyRecorder = typeof DataDependencyRecorder
+
+export type DataDependencyRecorderNotStartedError = RequestScopedDependencies.RequestScopedDependencyNotStartedError
+
+export const getDataDependencyRecorder = DataDependencyRecorder.current
+
+/**
+ * Guarantee a recorder is in scope for `self`, providing a fresh one per request when none is
+ * (e.g. a top-level client call with no parent query/command tracking its dependencies). An
+ * existing recorder is inherited, so nested calls forward into their parent rather than shadow it.
+ */
+export const ensureDataDependencyRecorder = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.flatMap(
+    DataDependencyRecorder,
+    (current) => current === "root" ? Effect.provide(self, DataDependencyRecorder.layer) : self
+  )
+
+/** Stream variant of {@link ensureDataDependencyRecorder}. */
+export const ensureDataDependencyRecorderStream = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
+  Stream.unwrap(
+    Effect.map(
+      DataDependencyRecorder,
+      (current) => current === "root" ? Stream.provide(self, DataDependencyRecorder.layer) : self
+    )
+  )
+
+export const makeDataDependencyRecorder = (
+  readsRef: Ref.Ref<DataDependencies>,
+  writesRef: Ref.Ref<DataDependencies>
+): DataDependencyRecorderService => ({
+  read: (dependency) => Ref.update(readsRef, appendDependency(dependency)),
+  write: (dependency) => Ref.update(writesRef, appendDependency(dependency)),
+  get: Effect.all({
+    reads: Ref.get(readsRef),
+    writes: Ref.get(writesRef)
+  }),
+  drain: Effect.all({
+    reads: Ref.getAndSet(readsRef, empty()),
+    writes: Ref.getAndSet(writesRef, empty())
+  }),
+  drainWrites: Ref.getAndSet(writesRef, empty())
+})
+
+export const repo = (name: string, ids?: NonEmptyReadonlyArray<string>): DataDependency =>
+  ids === undefined ? { type: "repo", name } : { type: "repo", name, ids }
+export const signal = (name: string, ids?: NonEmptyReadonlyArray<string>): DataDependency =>
+  ids === undefined ? { type: "signal", name } : { type: "signal", name, ids }
+
+const RepoReadScope = Context.Reference<DataDependency | undefined>("effect-app/DataDependencies/RepoReadScope", {
+  defaultValue: () => undefined
+})
+
+export const readRepo = (name: string) =>
+  Effect.flatMap(
+    RepoReadScope,
+    (scope) => read(scope?.type === "repo" && scope.name === name ? scope : repo(name))
+  )
+
+export const withRepoReadScope =
+  (name: string, ids: NonEmptyReadonlyArray<string>) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.provideService(self, RepoReadScope, repo(name, ids))
+
+export const QueryReadDependenciesMetaKey = "effect-app.query.readDependencies"
+
+export const read = (dependency: DataDependency) =>
+  getDataDependencyRecorder.pipe(Effect.flatMap((_) => _.read(dependency)))
+
+export const write = (dependency: DataDependency) =>
+  getDataDependencyRecorder.pipe(Effect.flatMap((_) => _.write(dependency)))
+
+export const intersects = (
+  a: ReadonlySet<DataDependency>,
+  b: ReadonlySet<DataDependency>
+) => {
+  for (const dependency of a) {
+    if (containsDependency(b, dependency)) return true
+  }
+  return false
+}
+
+export const isNonEmpty = (dependencies: DataDependencies) => dependencies.size > 0

package/src/DateTime.ts

@@ -0,0 +1,473 @@
+import * as DateTime from "effect/DateTime"
+
+/**
+ * The same instant as `date`, zoned with the process timezone.
+ *
+ * A JavaScript `Date` stores no zone. This attaches `DateTime.zoneMakeLocal()` without moving the instant.
+ */
+export const makeZonedLocal = (date: Date): DateTime.Zoned =>
+  DateTime.makeZonedUnsafe(date, { timeZone: DateTime.zoneMakeLocal() })
+
+/**
+ * Zones `date` with the process timezone, runs the functions, then returns the instant with `DateTime.toDateUtc`.
+ *
+ * Accepts as many functions as `pipe`. The last function must return a `DateTime`. Calendar parts follow the process timezone, as `Date#setDate` does.
+ */
+export function pipeZonedLocal(date: Date): Date
+export function pipeZonedLocal<A extends DateTime.DateTime = never>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A
+): Date
+export function pipeZonedLocal<A = never, B extends DateTime.DateTime = never>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B
+): Date
+export function pipeZonedLocal<A = never, B = never, C extends DateTime.DateTime = never>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J = never,
+  K extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J,
+  kl: (j: J) => K
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J = never,
+  K = never,
+  L extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J,
+  kl: (j: J) => K,
+  lm: (k: K) => L
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J = never,
+  K = never,
+  L = never,
+  M extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J,
+  kl: (j: J) => K,
+  lm: (k: K) => L,
+  mn: (l: L) => M
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J = never,
+  K = never,
+  L = never,
+  M = never,
+  N extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J,
+  kl: (j: J) => K,
+  lm: (k: K) => L,
+  mn: (l: L) => M,
+  no: (m: M) => N
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J = never,
+  K = never,
+  L = never,
+  M = never,
+  N = never,
+  O extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J,
+  kl: (j: J) => K,
+  lm: (k: K) => L,
+  mn: (l: L) => M,
+  no: (m: M) => N,
+  op: (n: N) => O
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J = never,
+  K = never,
+  L = never,
+  M = never,
+  N = never,
+  O = never,
+  P extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J,
+  kl: (j: J) => K,
+  lm: (k: K) => L,
+  mn: (l: L) => M,
+  no: (m: M) => N,
+  op: (n: N) => O,
+  pq: (o: O) => P
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J = never,
+  K = never,
+  L = never,
+  M = never,
+  N = never,
+  O = never,
+  P = never,
+  Q extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J,
+  kl: (j: J) => K,
+  lm: (k: K) => L,
+  mn: (l: L) => M,
+  no: (m: M) => N,
+  op: (n: N) => O,
+  pq: (o: O) => P,
+  qr: (p: P) => Q
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J = never,
+  K = never,
+  L = never,
+  M = never,
+  N = never,
+  O = never,
+  P = never,
+  Q = never,
+  R extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J,
+  kl: (j: J) => K,
+  lm: (k: K) => L,
+  mn: (l: L) => M,
+  no: (m: M) => N,
+  op: (n: N) => O,
+  pq: (o: O) => P,
+  qr: (p: P) => Q,
+  rs: (q: Q) => R
+): Date
+export function pipeZonedLocal<
+  A = never,
+  B = never,
+  C = never,
+  D = never,
+  E = never,
+  F = never,
+  G = never,
+  H = never,
+  I = never,
+  J = never,
+  K = never,
+  L = never,
+  M = never,
+  N = never,
+  O = never,
+  P = never,
+  Q = never,
+  R = never,
+  S extends DateTime.DateTime = never
+>(
+  date: Date,
+  ab: (self: DateTime.Zoned) => A,
+  bc: (a: A) => B,
+  cd: (b: B) => C,
+  de: (c: C) => D,
+  ef: (d: D) => E,
+  fg: (e: E) => F,
+  gh: (f: F) => G,
+  hi: (g: G) => H,
+  ij: (h: H) => I,
+  jk: (i: I) => J,
+  kl: (j: J) => K,
+  lm: (k: K) => L,
+  mn: (l: L) => M,
+  no: (m: M) => N,
+  op: (n: N) => O,
+  pq: (o: O) => P,
+  qr: (p: P) => Q,
+  rs: (q: Q) => R,
+  st: (r: R) => S
+): Date
+export function pipeZonedLocal(date: Date, ...steps: ReadonlyArray<(value: any) => any>): Date {
+  let current: unknown = makeZonedLocal(date)
+  for (const step of steps) {
+    current = step(current)
+  }
+  if (!DateTime.isDateTime(current)) {
+    throw new TypeError("pipeZonedLocal must finish on a DateTime")
+  }
+  return DateTime.toDateUtc(current)
+}