effect-app 4.0.0 → 4.0.2

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)
+}

package/src/Effect.ts

@@ -2,15 +2,13 @@
 /* eslint-disable prefer-destructuring */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
-import * as Def from "effect/Deferred"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Ref from "effect/Ref"
-import type { Scope } from "effect/Scope"
 import type { Semaphore } from "effect/Semaphore"
+import * as Struct from "effect/Struct"
 import type * as Context from "./Context.ts"
 import { curry } from "./Function.ts"
-import { typedKeysOf } from "./utils.ts"
 
 export * from "effect/Effect"
 // v4: Effect interface not re-exported by `export *` due to local binding collision
@@ -94,9 +92,6 @@ export function ifDiff<I, R, E, A>(n: I, orig: I) {
   return (f: (i: I) => Effect.Effect<A, E, R>) => ifDiff_(n, orig, f)
 }
 
-// NOTE: await extension doesnt work via tsplus somehow
-export const await_ = Def.await
-
 /**
  * Ref has atomic modify support if synchronous, for Effect we need a Semaphore.
  */
@@ -151,9 +146,9 @@ export function allLower<T extends Record<string, Context.Service<any, any> | Ef
   services: T
 ) {
   return Effect.all(
-    typedKeysOf(services).reduce((prev, cur) => {
+    Struct.keys(services).reduce((prev, cur) => {
       const svc = services[cur]!
-      prev[((cur as string)[0]!.toLowerCase() + (cur as string).slice(1)) as unknown as LowerFirst<typeof cur>] = svc
+      prev[(cur[0]!.toLowerCase() + cur.slice(1)) as unknown as LowerFirst<typeof cur>] = svc
       return prev
     }, {} as any),
     { concurrency: "unbounded" }
@@ -186,17 +181,3 @@ export function catchAllMap<E, A2>(f: (e: E) => A2) {
   return <R, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A2 | A, never, R> =>
     Effect.catch(self, (err: E) => Effect.sync(() => f(err)))
 }
-
-/**
- * Annotates each log in this scope with the specified log annotation.
- */
-export function annotateLogscoped(key: string, value: string): Effect.Effect<void, never, Scope> {
-  return Effect.annotateLogsScoped(key, value)
-}
-
-/**
- * Annotates each log in this scope with the specified log annotations.
- */
-export function annotateLogsScoped(kvps: Record<string, string>): Effect.Effect<void, never, Scope> {
-  return Effect.annotateLogsScoped(kvps)
-}

package/src/Function.ts

@@ -1,13 +1,6 @@
 export * from "effect/Function"
 export type { Predicate, Refinement } from "effect/Predicate"
 
-/**
- * Construct tuples
- */
-export function tuple<T extends ReadonlyArray<any>>(...t: T): Readonly<T> {
-  return t
-}
-
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 export function tupledCurry<A, B, C>(f: (b: B) => (a: A) => C) {

package/src/Model/Repository/internal/internal.ts

@@ -12,7 +12,6 @@ import type * as Scope from "effect/Scope"
 import * as Unify from "effect/Unify"
 import * as Array from "../../../Array.ts"
 import type { NonEmptyReadonlyArray } from "../../../Array.ts"
-import { toNonEmptyArray } from "../../../Array.ts"
 import * as Chunk from "../../../Chunk.ts"
 import { NotFoundError } from "../../../client/errors.ts"
 import * as Context from "../../../Context.ts"
@@ -407,7 +406,7 @@ export function makeRepoInternal<
           const saveAllE = (a: Iterable<Encoded>) =>
             flatMapOption(
               Effect
-                .sync(() => toNonEmptyArray([...a])),
+                .sync(() => Option.liftPredicate(Array.isReadonlyArrayNonEmpty)([...a])),
               (a) =>
                 Effect.gen(function*() {
                   const { get, set } = yield* cms
@@ -442,7 +441,7 @@ export function makeRepoInternal<
               })
               return yield* saveAll(it)
                 .pipe(
-                  Effect.andThen(Effect.sync(() => toNonEmptyArray(evts))),
+                  Effect.andThen(Effect.sync(() => Option.liftPredicate(Array.isReadonlyArrayNonEmpty)(evts))),
                   // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
                   (_) => flatMapOption(_, pub),
                   Effect.andThen(changeFeed.publish([Chunk.toArray(it), "save"] as [T[], "save" | "remove"])),
@@ -473,7 +472,7 @@ export function makeRepoInternal<
                   set(e[idKey], undefined)
                 }
                 yield* Effect
-                  .sync(() => toNonEmptyArray(evts))
+                  .sync(() => Option.liftPredicate(Array.isReadonlyArrayNonEmpty)(evts))
                   // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
                   .pipe((_) => flatMapOption(_, pub))
 

package/src/Model/dsl.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { NonEmptyReadonlyArray } from "../Array.ts"
-import { toNonEmptyArray } from "../Array.ts"
+import { isReadonlyArrayNonEmpty, type NonEmptyReadonlyArray } from "../Array.ts"
 import * as Effect from "../Effect.ts"
+import * as Option from "../Option.ts"
 import { type FixEnv, get, logMany, type Pure, type PureEnvEnv, type PureLogT, set } from "../Pure.ts"
 
 export interface PureDSL<S, S2, W> {
@@ -118,12 +118,13 @@ export function makeDSL<S1, S2, Evt>() {
 export interface DSLExt<S1, S2, Evt> extends ReturnType<typeof makeDSL<S1, S2, Evt>> {}
 
 export function ifAny<T, R, E, A>(fn: (items: NonEmptyReadonlyArray<T>) => Effect.Effect<A, E, R>) {
-  return (items: Iterable<T>) => Effect.flatMapOption(Effect.sync(() => toNonEmptyArray([...items])), fn)
+  return (items: Iterable<T>) =>
+    Effect.flatMapOption(Effect.sync(() => Option.liftPredicate(isReadonlyArrayNonEmpty)([...items])), fn)
 }
 
 export function ifAny_<T, R, E, A>(
   items: Iterable<T>,
   fn: (items: NonEmptyReadonlyArray<T>) => Effect.Effect<A, E, R>
 ) {
-  return Effect.flatMapOption(Effect.sync(() => toNonEmptyArray([...items])), fn)
+  return Effect.flatMapOption(Effect.sync(() => Option.liftPredicate(isReadonlyArrayNonEmpty)([...items])), fn)
 }

package/src/Model/query/new-kid-interpreter.ts

@@ -2,7 +2,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import { identity } from "effect/Function"
 import * as Array from "../../Array.ts"
-import { toNonEmptyArray } from "../../Array.ts"
 import * as Option from "../../Option.ts"
 import * as S from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
@@ -439,10 +438,10 @@ export const toFilter = <
       t: null as unknown as TFieldValues,
       limit: a.limit,
       skip: a.skip,
-      select: Option.getOrUndefined(toNonEmptyArray(aggSelect)) as any,
+      select: Option.getOrUndefined(Option.liftPredicate(Array.isReadonlyArrayNonEmpty)(aggSelect)) as any,
       schema: a.schema,
       computed: undefined,
-      order: Option.getOrUndefined(toNonEmptyArray(a.order)),
+      order: Option.getOrUndefined(Option.liftPredicate(Array.isReadonlyArrayNonEmpty)(a.order)),
       ttype: a.ttype,
       mode: "aggregate" as const,
       filter: a.filter.length ? a.filter : undefined
@@ -519,10 +518,10 @@ export const toFilter = <
     t: null as unknown as TFieldValues,
     limit: a.limit,
     skip: a.skip,
-    select: Option.getOrUndefined(toNonEmptyArray(select)),
+    select: Option.getOrUndefined(Option.liftPredicate(Array.isReadonlyArrayNonEmpty)(select)),
     schema,
     computed,
-    order: Option.getOrUndefined(toNonEmptyArray(a.order)),
+    order: Option.getOrUndefined(Option.liftPredicate(Array.isReadonlyArrayNonEmpty)(a.order)),
     ttype: a.ttype,
     mode: a.mode ?? "transform",
     filter: a.filter.length

package/src/Option.ts

@@ -4,22 +4,15 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 // eslint-disable-next-line import/no-unassigned-import
 import "./builtin.ts"
-import { getOrUndefined as value, type Some } from "effect/Option"
+import { type Some } from "effect/Option"
 import * as Option from "effect/Option"
 
 export * from "effect/Option"
 
-export const getOrUndefined = value
-
 export function omitableToNullable<T>(om: Option.Option<T> | undefined) {
   return om ?? Option.fromNullishOr(om)
 }
 
-export const toBool = Option.match({
-  onNone: () => false,
-  onSome: () => true
-})
-
 export const fromBool = (b: boolean) => (b ? Option.some(true) : Option.none())
 
 /**