effect-app 0.152.0

package/_src/_ext/date.ts

@@ -0,0 +1,84 @@
+import {
+  addDays,
+  addHours,
+  addMinutes,
+  addMonths,
+  addSeconds,
+  addWeeks,
+  addYears,
+  subDays,
+  subHours,
+  subMinutes,
+  subMonths,
+  subSeconds,
+  subWeeks,
+  subYears
+} from "date-fns"
+
+/**
+ * @tsplus fluent Date addDays
+ */
+export const DateAddDays: (date: Date, amount: number) => Date = addDays
+/**
+ * @tsplus fluent Date subDays
+ */
+export const DateSubDays: (date: Date, amount: number) => Date = subDays
+
+/**
+ * @tsplus fluent Date addHours
+ */
+export const DateAddHours: (date: Date, amount: number) => Date = addHours
+/**
+ * @tsplus fluent Date subHours
+ */
+export const DateSubHours: (date: Date, amount: number) => Date = subHours
+
+/**
+ * @tsplus fluent Date addMinutes
+ */
+export const DateAddMinutes: (date: Date, amount: number) => Date = addMinutes
+
+/**
+ * @tsplus fluent Date subMinutes
+ */
+export const DateSubMinutes: (date: Date, amount: number) => Date = subMinutes
+
+/**
+ * @tsplus fluent Date addSeconds
+ */
+export const DateAddSeconds: (date: Date, amount: number) => Date = addSeconds
+
+/**
+ * @tsplus fluent Date subSeconds
+ */
+export const DateSubSeconds: (date: Date, amount: number) => Date = subSeconds
+
+/**
+ * @tsplus fluent Date addYears
+ */
+export const DateAddYears: (date: Date, amount: number) => Date = addYears
+
+/**
+ * @tsplus fluent Date subYears
+ */
+export const DateSubYears: (date: Date, amount: number) => Date = subYears
+
+/**
+ * @tsplus fluent Date addMonths
+ */
+export const DateAddMonths: (date: Date, amount: number) => Date = addMonths
+
+/**
+ * @tsplus fluent Date subMonths
+ */
+export const DateSubMonths: (date: Date, amount: number) => Date = subMonths
+
+/**
+ * @tsplus fluent Date addWeeks
+ */
+export const DateAddWeeks: (date: Date, amount: number) => Date = addWeeks
+
+/**
+ * @tsplus fluent Date subWeeks
+ */
+export const DateSubWeeks: (date: Date, amount: number) => Date = subWeeks

package/_src/_ext/misc.ts

@@ -0,0 +1,161 @@
+import * as Either from "effect/Either"
+import type { Option } from "effect/Option"
+
+export type _R<T extends Effect<any, any, any>> = [T] extends [
+  Effect<any, any, infer R>
+] ? R
+  : never
+
+export type _E<T extends Effect<any, any, any>> = [T] extends [
+  Effect<any, infer E, any>
+] ? E
+  : never
+
+/**
+ * @tsplus fluent effect/data/Option encaseInEffect
+ */
+export function encaseMaybeInEffect_<E, A>(
+  o: Option<A>,
+  onError: LazyArg<E>
+): Effect<A, E> {
+  return o.match({ onNone: () => Effect.fail(onError()), onSome: Effect.succeed })
+}
+
+/**
+ * @tsplus fluent effect/data/Option encaseInEither
+ */
+export function encaseMaybeEither_<E, A>(
+  o: Option<A>,
+  onError: LazyArg<E>
+): Either.Either<E, A> {
+  return o.match({ onNone: () => Either.left(onError()), onSome: Either.right })
+}
+
+/**
+ * @tsplus getter effect/io/Effect toNullable
+ */
+export function toNullable<R, E, A>(
+  self: Effect<Option<A>, E, R>
+) {
+  return self.map((_) => _.getOrNull)
+}
+
+/**
+ * @tsplus fluent effect/io/Effect scope
+ */
+export function scope<R, E, A, R2, E2, A2>(
+  scopedEffect: Effect<A, E, R | Scope>,
+  effect: Effect<A2, E2, R2>
+): Effect<A2, E | E2, Exclude<R | R2, Scope>> {
+  return scopedEffect.zipRight(effect).scoped
+}
+
+/**
+ * @tsplus fluent effect/io/Effect flatMapScoped
+ */
+export function flatMapScoped<R, E, A, R2, E2, A2>(
+  scopedEffect: Effect<A, E, R | Scope>,
+  effect: (a: A) => Effect<A2, E2, R2>
+): Effect<A2, E | E2, Exclude<R | R2, Scope>> {
+  return scopedEffect.flatMap(effect).scoped
+}
+
+// /**
+//  * @tsplus fluent effect/io/Effect withScoped
+//  */
+// export function withScoped<R, E, A, R2, E2, A2>(
+//   effect: Effect<R2, E2, A2>,
+//   scopedEffect: Effect<R | Scope, E, A>
+// ): Effect<Exclude<R | R2, Scope>, E | E2, A2> {
+//   return scopedEffect.zipRight(effect).scoped
+// }
+
+// /**
+//  * @tsplus fluent effect/io/Effect withScoped
+//  */
+// export function withScopedFlatMap<R, E, A, R2, E2, A2>(
+//   effect: (a: A) => Effect<R2, E2, A2>,
+//   scopedEffect: Effect<R | Scope, E, A>
+// ): Effect<Exclude<R | R2, Scope>, E | E2, A2> {
+//   return scopedEffect.flatMap(effect).scoped
+// }
+
+/**
+ * Recovers from all errors.
+ *
+ * @tsplus static effect/io/Effect.Ops catchAllMap
+ * @tsplus pipeable effect/io/Effect catchAllMap
+ */
+export function catchAllMap<E, A2>(f: (e: E) => A2) {
+  return <R, A>(self: Effect<A, E, R>): Effect<A2 | A, never, R> => self.catchAll((err) => Effect.sync(() => f(err)))
+}
+
+/**
+ * Annotates each log in this effect with the specified log annotations.
+ * @tsplus static effect/io/Effect.Ops annotateLogs
+ */
+export function annotateLogs(kvps: Record<string, string>) {
+  return <R, E, A>(effect: Effect<A, E, R>): Effect<A, E, R> =>
+    FiberRef
+      .currentLogAnnotations
+      .get
+      .flatMap((annotations) =>
+        Effect.suspend(() =>
+          pipe(
+            effect,
+            FiberRef.currentLogAnnotations.locally(
+              HashMap.fromIterable([...annotations, ...kvps.$$.entries])
+            )
+          )
+        )
+      )
+}
+
+/**
+ * Annotates each log in this scope with the specified log annotation.
+ *
+ * @tsplus static effect/io/Effect.Ops annotateLogscoped
+ */
+export function annotateLogscoped(key: string, value: string) {
+  return FiberRef
+    .currentLogAnnotations
+    .get
+    .flatMap((annotations) =>
+      Effect.suspend(() => FiberRef.currentLogAnnotations.locallyScoped(annotations.set(key, value)))
+    )
+}
+
+/**
+ * Annotates each log in this scope with the specified log annotations.
+ *
+ * @tsplus static effect/io/Effect.Ops annotateLogsScoped
+ */
+export function annotateLogsScoped(kvps: Record<string, string>) {
+  return FiberRef
+    .currentLogAnnotations
+    .get
+    .flatMap((annotations) =>
+      Effect.suspend(() =>
+        FiberRef.currentLogAnnotations.locallyScoped(HashMap.fromIterable([...annotations, ...kvps.$$.entries]))
+      )
+    )
+}
+
+/**
+ * @tsplus fluent function flow
+ */
+export function flow<Args extends readonly any[], B, C>(f: (...args: Args) => B, g: (b: B) => C): (...args: Args) => C {
+  return (...args) => g(f(...args))
+}
+
+/** @tsplus fluent effect/platform/Http/Client request */
+export const client: {
+  <A, B, C, R, E>(
+    client: HttpClient<A, B, C>,
+    req: Effect<ClientRequest, E, R>
+  ): Effect<C, B | E, A | R>
+  <A, B, C>(client: HttpClient<A, B, C>, req: ClientRequest): Effect<C, B, A>
+} = (client: HttpClient<any, any, any>, req: Effect<ClientRequest, any, any> | ClientRequest) =>
+  Effect.isEffect(req)
+    ? req.flatMap(client)
+    : client(req)

package/_src/_global/stm.ts.bak

@@ -0,0 +1,35 @@
+
+/**
+ * @tsplus global
+ */
+import { TSemaphore } from "effect/TSemaphore"
+
+/**
+ * @tsplus global
+ */
+import { TRef } from "effect/TRef"
+
+/**
+ * @tsplus global
+ */
+import { STM } from "effect/STM"
+
+/**
+ * @tsplus global
+ */
+import { Stream } from "effect/Stream"
+
+/**
+ * @tsplus global
+ */
+import { Channel } from "effect/Channel"
+
+/**
+ * @tsplus global
+ */
+import { Sink } from "effect/Sink"
+
+/**
+ * @tsplus global
+ */
+import { SubscriptionRef } from "effect/SubscriptionRef"

package/_src/_global.ext.ts

@@ -0,0 +1,3 @@
+// import "./EffectOption.ext.js"
+import "./_ext/date.js"
+import "./_ext/misc.js"

package/_src/_global.schema.ts

@@ -0,0 +1,106 @@
+/* eslint-disable unused-imports/no-unused-imports */
+
+/**
+ * @tsplus global
+ */
+import {
+  annotate,
+  array,
+  boolean,
+  Class,
+  Date,
+  Email,
+  ExtendedClass,
+  ExtendedTaggedClass,
+  FromClass,
+  inputDate,
+  literal,
+  nonEmptyArray,
+  NonEmptyString,
+  NonEmptyString255,
+  NonEmptyString2k,
+  NonEmptyString50,
+  NonEmptyString64k,
+  NonNegativeDecimal,
+  NonNegativeInt,
+  NonNegativeNumber,
+  nullable,
+  number,
+  ParseResult,
+  PhoneNumber,
+  PositiveDecimal,
+  PositiveInt,
+  PositiveNumber,
+  readonlyMap,
+  readonlySet,
+  Schema,
+  string,
+  StringId,
+  struct,
+  TaggedClass,
+  union,
+  UnionBrand,
+  unknown,
+  useClassFeaturesForSchema,
+  useClassNameForSchema,
+  void_ as Void
+} from "effect-app/schema"
+
+// nonEmptyArray,
+// arbitrary,
+// array,
+// bool,
+// Class,
+// ClassFrom,
+// condemnCustom,
+// ConstructorInputApi,
+// date,
+// defaultProp,
+// Email,
+// Encoder,
+// enhanceClassUnion,
+// enhanceUnion,
+// ExtendedClass,
+// fakerArb,
+// field,
+// FieldsClass,
+// From,
+// FromApi,
+// FromClass,
+// inputDate,
+// json,
+// literal,
+// literalNumber,
+// named,
+// nonEmptyArray,
+// NonEmptyString255,
+// NonEmptyString2k,
+// NonEmptyString50,
+// NonEmptyString64k,
+// nullable,
+// number,
+// NumberAsInt,
+// OpaqueSchema,
+// optProp,
+// Parser,
+// PositiveDecimal,
+// PositiveInt,
+// PositiveNumber,
+// PositiveNumberAsInt,
+// propFrom,
+// smartClassUnion,
+// string,
+// StringId,
+// struct,
+// To,
+// union,
+// UnionBrand,
+// unknown,
+// unsafe,
+// useClassConstructorForSchema,
+// useClassFeaturesForSchema,
+// useClassNameForSchema,
+// // unsafe,
+// UUID,
+// Void,
+// withDefaults

package/_src/_global.ts

@@ -0,0 +1,119 @@
+/* eslint-disable unused-imports/no-unused-imports */
+// /**
+//  * @tsplus global
+//  */
+// import { Predicate } from "@effect-app/core/Function"
+
+/**
+ * @tsplus global
+ */
+import { Runtime } from "effect/Runtime"
+
+/**
+ * @tsplus global
+ */
+import { Config } from "effect/Config"
+
+/**
+ * @tsplus global
+ */
+import { SecretURL } from "effect-app/Config/SecretURL"
+
+/**
+ * @tsplus global
+ */
+import { Secret } from "effect/Secret"
+
+/**
+ * @tsplus global
+ */
+import { ConfigError } from "effect/ConfigError"
+
+/**
+ * @tsplus global
+ */
+import { ConfigProvider } from "effect/ConfigProvider"
+
+/**
+ * @tsplus global
+ */
+import { Cache, CacheStats, ConsumerCache, EntryStats } from "effect/Cache"
+
+/**
+ * @tsplus global
+ */
+import { Request } from "effect/Request"
+
+/**
+ * @tsplus global
+ */
+import { ClientRequest } from "@effect/platform/Http/ClientRequest"
+
+/**
+ * @tsplus global
+ */
+import { EffectCache, EffectRequest, HttpClient } from "effect-app/Request"
+
+/**
+ * @tsplus global
+ */
+import { RequestResolver } from "effect/RequestResolver"
+
+/* eslint-disable unused-imports/no-unused-imports */
+
+/**
+ * @tsplus global
+ */
+import { Pure, PureEnv, PureEnvEnv } from "effect-app/Pure"
+
+/**
+ * @tsplus global
+ */
+import { exhaustiveMatch, exhaustiveMatch_, spread, spreadS } from "effect-app/utils"
+/**
+ * @tsplus global
+ */
+import {
+  // Cause,
+  // Chunk,
+  // Effect,
+  // EffectMaybe as EffectMaybe,
+  // Either,
+  // Equivalence,
+  // Exit,
+  // Fiber,
+  Fnc,
+  // Has,
+  // Layer,
+  Lens,
+  // Managed,
+  // Maybe,
+  NonEmptySet,
+  // Ord,
+  // Queue,
+  Record,
+  // Ref,
+  ReadonlySet,
+  // Schedule,
+  S,
+  // Semaphore,
+  Utils
+  // XPure,
+} from "effect-app"
+
+/**
+ * @tsplus global
+ */
+import { assignTag, ServiceTagged, TagClass, TagClassMake } from "effect-app/service"
+
+/**
+ * @tsplus global
+ */
+import { match, Pattern } from "ts-pattern"
+
+import "@effect-app/core/_global"
+import "@effect-app/core/Prelude"
+import "@effect-app/schema/_global"
+
+import "./_global.ext.js"
+import "./refinements.js"

package/_src/client/QueryResult.ts

@@ -0,0 +1,120 @@
+// TODO: Convert to effect/core
+
+/* eslint-disable @typescript-eslint/ban-types */
+import * as Either from "effect/Either"
+
+export class Initial extends Data.TaggedClass("Initial")<{}> {}
+
+export class Loading extends Data.TaggedClass("Loading")<{}> {}
+
+export class Refreshing<E, A> extends Data.TaggedClass("Refreshing")<{
+  readonly current: Either.Either<E, A>
+  readonly previous: Option<A>
+}> {
+  static succeed<A, E = never>(a: A) {
+    return new Refreshing<E, A>({ current: Either.right(a), previous: Option.none() })
+  }
+  static fail<E, A = never>(e: E, previous?: A) {
+    return new Refreshing<E, A>({
+      current: Either.left(e),
+      previous: previous === undefined ? Option.none() : Option.some(previous)
+    })
+  }
+  static fromDone<E, A>(d: Done<E, A>) {
+    return new Refreshing(d)
+  }
+}
+
+export class Done<E, A> extends Data.TaggedClass("Done")<{
+  readonly current: Either.Either<E, A>
+  readonly previous: Option<A>
+}> {
+  static succeed<A, E = never>(this: void, a: A) {
+    return new Done<E, A>({ current: Either.right(a), previous: Option.none() })
+  }
+  static fail<E, A = never>(this: void, e: E, previous?: A) {
+    return new Done<E, A>({
+      current: Either.left(e),
+      previous: previous === undefined ? Option.none() : Option.some(previous)
+    })
+  }
+
+  static refresh<E, A>(d: Done<E, A>) {
+    return new Refreshing(d)
+  }
+}
+
+/**
+ * @tsplus type QueryResult
+ */
+export type QueryResult<E, A> = Initial | Loading | Refreshing<E, A> | Done<E, A>
+
+type Result<E, A> = Omit<Done<E, A>, "current"> | Omit<Refreshing<E, A>, "current">
+
+/**
+ * @tsplus fluent QueryResult isSuccess
+ */
+export function isSuccess<E, A>(
+  qr: QueryResult<E, A>
+): qr is Result<E, A> & { current: Either.Right<E, A> } {
+  return qr.hasValue() && qr.current.isRight()
+}
+
+/**
+ * @tsplus fluent QueryResult hasValue
+ */
+export function hasValue<E, A>(
+  qr: QueryResult<E, A>
+): qr is Done<E, A> | Refreshing<E, A> {
+  return qr.isDone() || qr.isRefreshing()
+}
+
+/**
+ * @tsplus fluent QueryResult isRefreshing
+ */
+export function isRefreshing<E, A>(
+  qr: QueryResult<E, A>
+): qr is Refreshing<E, A> {
+  return qr._tag === "Refreshing"
+}
+
+/**
+ * @tsplus fluent QueryResult isDone
+ */
+export function isDone<E, A>(
+  qr: QueryResult<E, A>
+): qr is Done<E, A> {
+  return qr._tag === "Done"
+}
+
+/**
+ * @tsplus fluent QueryResult isInitializing
+ */
+export function isInitializing<E, A>(
+  qr: QueryResult<E, A>
+): qr is Initial | Loading {
+  return qr._tag === "Initial" || qr._tag === "Loading"
+}
+
+/**
+ * @tsplus fluent QueryResult isFailed
+ */
+export function isFailed<E, A>(
+  qr: QueryResult<E, A>
+): qr is Result<E, A> & { current: Either.Left<E, A> } {
+  return qr.hasValue() && qr.current.isLeft()
+}
+
+export type ResultTuple<Result> = readonly [result: Result, refresh: () => void]
+export type QueryResultTuple<E, A> = ResultTuple<QueryResult<E, A>>
+
+export const { fail, succeed } = Done
+
+/**
+ * @tsplus getter effect/io/Effect asQueryResult
+ */
+export function queryResult<R, E, A>(
+  self: Effect<A, E, R>
+): Effect<QueryResult<E, A>, never, R> {
+  return self.match({ onFailure: fail, onSuccess: succeed })
+}