effect-app 4.0.0 → 4.0.2

package/src/Pure.ts

@@ -3,8 +3,8 @@ import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Result from "effect/Result"
+import * as Tuple from "effect/Tuple"
 import * as Context from "./Context.ts"
-import { tuple } from "./Function.ts"
 
 const S1 = Symbol()
 const S2 = Symbol()
@@ -159,10 +159,10 @@ export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
         )
         .pipe(
           Effect.map(
-            ({ log, state }) => tuple(log, Result.succeed(tuple(state, x)))
+            ({ log, state }) => Tuple.make(log, Result.succeed(Tuple.make(state, x)))
           )
         ))
-    .pipe(Effect.catch((err: any) => tagg.useSync((env) => tuple(env.env.log, Result.fail(err)))))
+    .pipe(Effect.catch((err: any) => tagg.useSync((env) => Tuple.make(env.env.log, Result.fail(err)))))
   return Effect.provide(a, Layer.succeed(tagg, { env: makePureEnv<W3, S3, S4>(s) as any }) as any) as any
 }
 
@@ -170,7 +170,7 @@ export function runResult<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ) {
-  return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Result.map(r, ([s]) => s)))
+  return Effect.map(runAll(self, s), ([log, r]) => Tuple.make(log, Result.map(r, ([s]) => s)))
 }
 
 export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
@@ -179,7 +179,7 @@ export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
 ) {
   return Effect.flatMap(
     runAll(self, s),
-    ([evts, r]) => Effect.map(Effect.fromResult(r), ([s3, a]) => tuple(s3, Chunk.toArray(evts), a))
+    ([evts, r]) => Effect.map(Effect.fromResult(r), ([s3, a]) => Tuple.make(s3, Chunk.toArray(evts), a))
   )
 }
 
@@ -187,14 +187,14 @@ export function runTermDiscard<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ) {
-  return Effect.map(runTerm(self, s), ([s3, w3]) => tuple(s3, w3))
+  return Effect.map(runTerm(self, s), ([s3, w3]) => Tuple.make(s3, w3))
 }
 
 export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ) {
-  return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Result.map(r, ([, a]) => a)))
+  return Effect.map(runAll(self, s), ([log, r]) => Tuple.make(log, Result.map(r, ([, a]) => a)))
 }
 
 export function modify<S2, A, S3>(
@@ -224,14 +224,14 @@ export function modifyM<W, R, E, A, S2, S3>(
 export function updateWith<S2, S3>(upd: (s: S2) => S3) {
   return modify((_: S2) => {
     const r = upd(_)
-    return tuple(r, r)
+    return Tuple.make(r, r)
   })
 }
 
 export function updateWithEffect<W, R, E, S2, S3>(
   upd: (s: S2, log: (evt: W) => PureLogT<W>) => Effect.Effect<S3, E, FixEnv<R, W, S2, S3>>
 ): Effect.Effect<S3, E, FixEnv<R, W, S2, S3>> {
-  return modifyM((_: S2) => Effect.map(upd(_, log), (_) => tuple(_, _)))
+  return modifyM((_: S2) => Effect.map(upd(_, log), (_) => Tuple.make(_, _)))
 }
 
 export type FixEnv<R, W, S, S2> =
@@ -301,11 +301,11 @@ export type FixEnv<R, W, S, S2> =
 //   }
 
 //   function update<S3>(upd: (s: S2) => S3) {
-//     return modify(_ => tuple(upd(_), void 0 as void))
+//     return modify(_ => Tuple.make(upd(_), void 0 as void))
 //   }
 
 //   function updateM<R, E, S3>(upd: (s: S2) => Effect.Effect<R, E, S3>) {
-//     return modifyM(_ => upd(_).map(_ => tuple(_, void 0 as void)))
+//     return modifyM(_ => upd(_).map(_ => Tuple.make(_, void 0 as void)))
 //   }
 
 //   const accessLog = Effect.serviceWithEffect(tag, _ => _.env.log.get)
@@ -321,12 +321,12 @@ export type FixEnv<R, W, S, S2> =
 //       ).map(
 //         (
 //           { log, state }
-//         ) => tuple(log, Either.right(tuple(state, x)) as Either.Either<E, readonly [S3, A]>)
+//         ) => Tuple.make(log, Either.right(Tuple.make(state, x)) as Either.Either<E, readonly [S3, A]>)
 //       )
 //     ).catchAll(
 //       err =>
 //         accessLog.map(log =>
-//           tuple(log, Either.left(err) as Either.Either<E, readonly [S3, A]>)
+//           Tuple.make(log, Either.left(err) as Either.Either<E, readonly [S3, A]>)
 //         )
 //     ).provideService(tag, { env: makePureEnv<W3, S3, S4>(s) as any }) as any
 //   }
@@ -335,14 +335,14 @@ export type FixEnv<R, W, S, S2> =
 //     self: Effect.Effect<FixEnv<R, W3, S1, S3>, E, A>,
 //     s: S4
 //   ) {
-//     return runAll(self, s).map(([log, r]) => tuple(log, r.map(([s]) => s)))
+//     return runAll(self, s).map(([log, r]) => Tuple.make(log, r.map(([s]) => s)))
 //   }
 
 //   function runA<R, E, A, W3, S1, S3, S4 extends S1>(
 //     self: Effect.Effect<FixEnv<R, W3, S1, S3>, E, A>,
 //     s: S4
 //   ) {
-//     return runAll(self, s).map(([log, r]) => tuple(log, r.map(([, a]) => a)))
+//     return runAll(self, s).map(([log, r]) => Tuple.make(log, r.map(([, a]) => a)))
 //   }
 
 //   return {

package/src/Schema/ext.ts

@@ -43,7 +43,7 @@ import * as Struct from "effect/Struct"
 import { type NonEmptyReadonlyArray } from "../Array.ts"
 import * as Context from "../Context.ts"
 import * as SchemaAST from "../SchemaAST.ts"
-import { extendM, typedKeysOf } from "../utils.ts"
+import { extendM } from "../utils.ts"
 import { type AST } from "./schema.ts"
 
 type ProvidedCodec<Self extends S.Top, R> = S.Codec<
@@ -134,13 +134,6 @@ const dateHelpers = (s: S.Date) => ({
 /** Like the default Schema `Date` (Encoded is `Date`) with default helpers. */
 export const Date = extendM(S.Date, dateHelpers)
 
-/**
- * Alias of {@link Date}. Core `Schema.Date` already rejects invalid Dates.
- *
- * @deprecated Use {@link Date}.
- */
-export const DateValid = Date
-
 /** Like the default Schema `Boolean` but with default helpers. */
 export const Boolean = Object.assign(S.Boolean, {
   /**
@@ -522,7 +515,7 @@ export function makeOptional<NER extends S.Struct.Fields>(
 ): {
   [K in keyof NER]: NER[K] extends S.Top ? ReturnType<typeof S.optional<NER[K] & S.Top>> : any
 } {
-  return typedKeysOf(t).reduce((prev, cur) => {
+  return Struct.keys(t).reduce((prev, cur) => {
     prev[cur] = S.optional(t[cur] as any)
     return prev
   }, {} as any)
@@ -601,7 +594,7 @@ export function makeExactOptional<NER extends S.Struct.Fields>(
   [K in keyof NER]: NER[K] extends S.Top ? DropConstructorDefault<ReturnType<typeof S.optionalKey<NER[K] & S.Top>>>
     : any
 } {
-  return typedKeysOf(t).reduce((prev, cur) => {
+  return Struct.keys(t).reduce((prev, cur) => {
     prev[cur] = dropConstructorDefault(S.optionalKey(t[cur] as any))
     return prev
   }, {} as any)

package/src/Schema.ts

@@ -115,7 +115,7 @@ export * from "./Schema/Class.ts"
 export { Class, ErrorClass, Opaque, OpaqueErrorFacadeClass, OpaqueFacade, OpaqueShape, OpaqueType, TaggedClass, TaggedErrorClass } from "./Schema/Class.ts"
 
 export { fromBrand, nominal } from "./Schema/brand.ts"
-export { Array, Boolean, Date, DateFromString, DateValid, Finite, Literals, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.ts"
+export { Array, Boolean, Date, DateFromString, Finite, Literals, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.ts"
 export { Int, NonNegativeInt } from "./Schema/numbers.ts"
 
 export * from "./Schema/email.ts"

package/src/Set.ts

@@ -6,7 +6,8 @@ import * as Option from "effect/Option"
 import type * as Order from "effect/Order"
 import { not } from "effect/Predicate"
 import type * as Result from "effect/Result"
-import { identity, pipe, type Predicate, type Refinement, tuple } from "./Function.ts"
+import * as Tuple from "effect/Tuple"
+import { identity, pipe, type Predicate, type Refinement } from "./Function.ts"
 
 export function find_<A, B extends A>(
   as: ReadonlySet<A>,
@@ -309,7 +310,7 @@ export function partition_<A>(
       left.add(value)
     }
   }
-  return tuple(left, right)
+  return Tuple.make(left, right)
 }
 
 /**
@@ -375,7 +376,7 @@ export function partitionMap_<B, C>(
           break
       }
     }
-    return tuple(left, right)
+    return Tuple.make(left, right)
   }
 }
 
@@ -552,7 +553,7 @@ export function separate<E, A>(
           break
       }
     })
-    return tuple(left, right)
+    return Tuple.make(left, right)
   }
 }
 

package/src/client/apiClientFactory.ts

@@ -4,6 +4,7 @@ import * as Layer from "effect/Layer"
 import * as ManagedRuntime from "effect/ManagedRuntime"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
+import * as Record from "effect/Record"
 import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/rpc"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
@@ -15,7 +16,6 @@ import * as Effect from "../Effect.ts"
 import { HttpClient, HttpClientRequest } from "../http.ts"
 import { Invalidation } from "../rpc.ts"
 import type * as S from "../Schema.ts"
-import { typedKeysOf, typedValuesOf } from "../utils.ts"
 import type { Client, ClientForOptions, ExtractModuleName, RequestsAny } from "./clientFor.ts"
 import { InvalidationKeysFromServer } from "./InvalidationKeys.ts"
 
@@ -94,7 +94,7 @@ const getFiltered = <M extends RequestsAny>(resource: M) => {
     [K in keyof M as M[K] extends Req ? K : never]: M[K] extends Req ? M[K] : never
   }
   // TODO: Record.filter
-  const filtered = typedKeysOf(resource).reduce((acc, cur) => {
+  const filtered = Struct.keys(resource).reduce((acc, cur) => {
     if (
       Predicate.isObjectKeyword(resource[cur])
       && (resource[cur].success)
@@ -110,7 +110,7 @@ const getFiltered = <M extends RequestsAny>(resource: M) => {
 export const getMeta = <M extends RequestsAny>(
   resource: M
 ): { moduleName: ExtractModuleName<M>; middleware?: unknown } => {
-  const first = typedValuesOf(getFiltered(resource))[0]
+  const first = Record.values(getFiltered(resource))[0]
   if (first && "moduleName" in first) return { moduleName: first.moduleName, middleware: (first as any).middleware }
   throw new Error("No moduleName on requests!")
 }
@@ -125,7 +125,7 @@ export const makeRpcGroupFromRequestsAndModuleName = <M extends RequestsAny, con
   type newM = typeof filtered
   const baseRpcs = RpcGroup
     .make(
-      ...typedValuesOf(filtered).map((_) => {
+      ...Record.values(filtered).map((_) => {
         const r = _ as any
         const isStream = r.stream
         const isCommand = r.type === "command"
@@ -262,13 +262,14 @@ const makeApiClientFactory = Effect
 
       return {
         mr,
-        client: typedKeysOf(filtered)
+        client: Struct
+          .keys(filtered)
           .reduce((prev, cur) => {
             const h = filtered[cur]!
 
             const Request = h
 
-            const id = `${meta.moduleName}.${cur as string}`
+            const id = `${meta.moduleName}.${cur}`
               .replaceAll(".js", "")
 
             const requestMeta = {
@@ -281,7 +282,7 @@ const makeApiClientFactory = Effect
             }
 
             const requestNameLayer = Layer.succeed(RequestName, {
-              requestName: cur as string,
+              requestName: cur,
               moduleName: meta.moduleName
             })