effect-app 1.32.0 → 2.0.0

package/src/Struct.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Types } from "effect"
+import * as Struct from "effect/Struct"
+
+export * from "effect/Struct"
+
+/**
+ * Create a new object by picking properties of an existing object.
+ *
+ * @example
+ * import { pick } from "effect/Struct"
+ * import { pipe } from "effect/Function"
+ *
+ * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, pick("a", "b")), { a: "a", b: 1 })
+ * assert.deepStrictEqual(pick({ a: "a", b: 1, c: true }, "a", "b"), { a: "a", b: 1 })
+ *
+ * @since 2.0.0
+ */
+export const pick: {
+  <Keys extends Array<PropertyKey>>(
+    ...keys: Keys
+  ): <S extends { [K in Keys[number]]?: any }>(
+    s: S
+  ) => Types.MatchRecord<S, { [K in Keys[number]]?: S[K] }, Pick<S, Keys[number]>>
+  <S extends object, Keys extends Array<keyof S>>(
+    s: S,
+    ...keys: Keys
+  ): Types.MatchRecord<S, { [K in Keys[number]]?: S[K] }, Pick<S, Keys[number]>>
+} = Struct.pick
+
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K>
+  : never
+
+/**
+ * Create a new object by omitting properties of an existing object.
+ *
+ * @example
+ * import { omit } from "effect/Struct"
+ * import { pipe } from "effect/Function"
+ *
+ * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, omit("c")), { a: "a", b: 1 })
+ * assert.deepStrictEqual(omit({ a: "a", b: 1, c: true }, "c"), { a: "a", b: 1 })
+ *
+ * @since 2.0.0
+ */
+export const omit: {
+  <Keys extends Array<PropertyKey>>(
+    ...keys: Keys
+  ): <S extends { [K in Keys[number]]?: any }>(s: S) => DistributiveOmit<S, Keys[number]>
+  <S extends object, Keys extends Array<keyof S>>(
+    s: S,
+    ...keys: Keys
+  ): DistributiveOmit<S, Keys[number]>
+} = Struct.omit as any

package/src/Tag.ts

@@ -0,0 +1,20 @@
+// /**
+//  * @tsplus fluent effect/data/Context/Tag withEffect_
+//  */
+// export function accessM_<T, I, R, E, A>(self: Tag<T, I>, f: (x: T) => Effect<R, E, A>) {
+//   return Effect.serviceWithEffect(self)(f)
+// }
+
+import { Layer } from "effect"
+
+// /**
+//  * @tsplus fluent effect/data/Context/Tag with_
+//  */
+// export function access_<T, I, B>(self: Tag<T, I>, f: (x: T) => B) {
+//   return Effect.serviceWith(self)(f)
+// }
+
+/**
+ * @tsplus fluent effect/data/Context/Tag makeLayer
+ */
+export const makeLayer = Layer.succeed

package/src/Unify.ts

@@ -0,0 +1,56 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// TODO: Add effect cause/exit etc
+
+import type { Chunk, Either, Option } from "effect"
+import type { Effect, EffectTypeId } from "effect/Effect"
+
+/**
+ * @tsplus unify effect/io/Effect
+ */
+export function unifyEffect<X extends { readonly [EffectTypeId]: Effect.VarianceStruct<any, any, any> }>(
+  self: X
+): Effect<
+  [X] extends [{ readonly [EffectTypeId]: { _A: (_: never) => infer A } }] ? A : never,
+  [X] extends [{ readonly [EffectTypeId]: { _E: (_: never) => infer E } }] ? E : never,
+  [X] extends [{ readonly [EffectTypeId]: { _R: (_: never) => infer R } }] ? R : never
+> {
+  return self as any
+}
+
+/**
+ * @tsplus unify effect/data/Chunk
+ */
+export function unifyChunk<X extends Chunk.Chunk<any>>(
+  self: X
+): Chunk.Chunk<[X] extends [Chunk.Chunk<infer A>] ? A : never> {
+  return self
+}
+
+/**
+ * @tsplus unify effect/data/Either
+ * @tsplus unify effect/data/Either.Left
+ * @tsplus unify effect/data/Either.Right
+ */
+export function unifyEither<X extends Either.Either<any, any>>(
+  self: X
+): Either.Either<
+  X extends Either.Right<any, infer AX> ? AX : X extends Either.Left<any, infer AX> ? AX : never,
+  X extends Either.Left<infer EX, any> ? EX : X extends Either.Right<infer EX, any> ? EX : never
+> {
+  return self
+}
+
+/**
+ * @tsplus unify effect/data/Option
+ * @tsplus unify effect/data/Option.Some
+ * @tsplus unify effect/data/Option.None
+ */
+export function unifyOption<X extends Option.Option<any>>(
+  self: X
+): Option.Option<
+  X extends Option.Some<infer A> ? A
+    : X extends Option.None<infer A> ? A
+    : never
+> {
+  return self
+}

package/src/Widen.type.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { BuiltInObject } from "@effect-app/core/utils"
+import type { BuiltInObject } from "effect-app/utils"
 
 type AllKeys<T> = T extends any ? keyof T : never
 

package/src/_ext/misc.ts

@@ -1,13 +1,13 @@
-import { Effect, Either, Option, type Scope } from "@effect-app/core"
-import type { LazyArg } from "@effect-app/core/Function"
+import { Effect, Either, Option, type Scope } from "effect"
+import type { LazyArg } from "effect-app/Function"
 
-export type _R<T extends Effect<any, any, any>> = [T] extends [
-  Effect<any, any, infer R>
+export type _R<T extends Effect.Effect<any, any, any>> = [T] extends [
+  Effect.Effect<any, any, infer R>
 ] ? R
   : never
 
-export type _E<T extends Effect<any, any, any>> = [T] extends [
-  Effect<any, infer E, any>
+export type _E<T extends Effect.Effect<any, any, any>> = [T] extends [
+  Effect.Effect<any, infer E, any>
 ] ? E
   : never
 
@@ -15,9 +15,9 @@ export type _E<T extends Effect<any, any, any>> = [T] extends [
  * @tsplus fluent effect/data/Option encaseInEffect
  */
 export function encaseMaybeInEffect_<E, A>(
-  o: Option<A>,
+  o: Option.Option<A>,
   onError: LazyArg<E>
-): Effect<A, E> {
+): Effect.Effect<A, E> {
   return Option.match(o, { onNone: () => Effect.fail(onError()), onSome: Effect.succeed })
 }
 
@@ -25,7 +25,7 @@ export function encaseMaybeInEffect_<E, A>(
  * @tsplus fluent effect/data/Option encaseInEither
  */
 export function encaseMaybeEither_<E, A>(
-  o: Option<A>,
+  o: Option.Option<A>,
   onError: LazyArg<E>
 ): Either.Either<A, E> {
   return Option.match(o, { onNone: () => Either.left(onError()), onSome: Either.right })
@@ -35,7 +35,7 @@ export function encaseMaybeEither_<E, A>(
  * @tsplus getter effect/io/Effect toNullable
  */
 export function toNullable<R, E, A>(
-  self: Effect<Option<A>, E, R>
+  self: Effect.Effect<Option.Option<A>, E, R>
 ) {
   return Effect.map(self, (_) => Option.getOrNull(_))
 }
@@ -44,9 +44,9 @@ export function toNullable<R, E, A>(
  * @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>> {
+  scopedEffect: Effect.Effect<A, E, R | Scope.Scope>,
+  effect: Effect.Effect<A2, E2, R2>
+): Effect.Effect<A2, E | E2, Exclude<R | R2, Scope.Scope>> {
   return Effect.zipRight(scopedEffect, effect).pipe(Effect.scoped)
 }
 
@@ -54,9 +54,9 @@ export function scope<R, E, A, R2, E2, A2>(
  * @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>> {
+  scopedEffect: Effect.Effect<A, E, R | Scope.Scope>,
+  effect: (a: A) => Effect.Effect<A2, E2, R2>
+): Effect.Effect<A2, E | E2, Exclude<R | R2, Scope.Scope>> {
   return scopedEffect.pipe(Effect.flatMap(effect), Effect.scoped)
 }
 
@@ -64,9 +64,9 @@ export function flatMapScoped<R, E, A, R2, E2, A2>(
 //  * @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> {
+//   effect: Effect.Effect<R2, E2, A2>,
+//   scopedEffect: Effect.Effect<R | Scope.Scope, E, A>
+// ): Effect.Effect<Exclude<R | R2, Scope.Scope>, E | E2, A2> {
 //   return scopedEffect.zipRight(effect).scoped
 // }
 
@@ -74,8 +74,8 @@ export function flatMapScoped<R, E, A, R2, E2, A2>(
 //  * @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> {
+//   effect: (a: A) => Effect.Effect<R2, E2, A2>,
+//   scopedEffect: Effect.Effect<R | Scope.Scope, E, A>
+// ): Effect.Effect<Exclude<R | R2, Scope.Scope>, E | E2, A2> {
 //   return scopedEffect.flatMap(effect).scoped
 // }

package/src/_ext/ord.ext.ts

@@ -0,0 +1,49 @@
+import { Chunk } from "effect"
+import type { Equivalence } from "effect"
+
+/**
+ * @tsplus getter Generator toArray
+ */
+export function toArray<A>(
+  gen: Generator<A, void, unknown>
+) {
+  return Array.from(gen)
+}
+
+/**
+ * Remove duplicates from an array, keeping the first occurrence of an element.
+ *
+ * @tsplus static effect/data/Chunk.Ops uniq
+ * @tsplus pipeable effect/data/Chunk uniq
+ */
+export function uniq<A>(E: Equivalence.Equivalence<A>) {
+  return (self: Chunk.Chunk<A>): Chunk.Chunk<A> => {
+    let out = Chunk.fromIterable<A>([])
+    for (let i = 0; i < self.length; i++) {
+      const a = Chunk.unsafeGet(self, i)
+      if (!elem(E, a)(out)) {
+        out = Chunk.append(out, a)
+      }
+    }
+    return self.length === out.length ? self : out
+  }
+}
+
+/**
+ * Test if a value is a member of an array. Takes a `Equivalence.Equivalence<A>` as a single
+ * argument which returns the function to use to search for a value of type `A`
+ * in an array of type `Chunk.Chunk<A>`.
+ *
+ * @tsplus static effect/data/Chunk.Ops elem2
+ * @tsplus pipeable effect/data/Chunk elem2
+ */
+export function elem<A>(E: Equivalence.Equivalence<A>, value: A) {
+  return (self: Chunk.Chunk<A>): boolean => {
+    for (let i = 0; i < self.length; i++) {
+      if (E(Chunk.unsafeGet(self, i), value)) {
+        return true
+      }
+    }
+    return false
+  }
+}

package/src/builtin.ts

@@ -0,0 +1,64 @@
+import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect/Array"
+
+declare global {
+  interface String {
+    /**
+     * Split a string into substrings using the specified separator and return them as an array.
+     * @param splitter An object that can split a string.
+     * @param limit A value used to limit the number of elements returned in the array.
+     */
+    split(splitter: { [Symbol.split](string: string, limit?: number): string[] }, limit?: number): [string, ...string[]]
+
+    /**
+     * Split a string into substrings using the specified separator and return them as an array.
+     * @param separator A string that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned.
+     * @param limit A value used to limit the number of elements returned in the array.
+     */
+    split(separator: string | RegExp, limit?: number): [string, ...string[]]
+  }
+
+  interface JSON {
+    /**
+     * Converts a JavaScript Object Notation (JSON) string into an object.
+     * @param text A valid JSON string.
+     * @param reviver A function that transforms the results. This function is called for each member of the object.
+     * If a member contains nested objects, the nested objects are transformed before the parent object is.
+     */
+    parse(text: string, reviver?: (this: any, key: string, value: any) => any): unknown
+  }
+
+  interface Body {
+    json(): Promise<unknown>
+  }
+
+  interface Array<T> {
+    map<A, B>(
+      this: NonEmptyArray<A>,
+      map: (a: A, index: number) => B
+    ): NonEmptyArray<B>
+  }
+  interface ReadonlyArray<T> {
+    // Subsequent property declarations must have the same type.  Property 'length' must be of type 'number', but here has type 'NonNegativeInt'.
+    // readonly length: NonNegativeInt
+
+    map<A, B>(
+      this: NonEmptyReadonlyArray<A>,
+      map: (a: A, index: number) => B
+    ): NonEmptyReadonlyArray<B>
+  }
+}
+
+declare module "effect/Option" {
+  export interface None<out A> {
+    get value(): A | undefined
+  }
+}
+
+declare module "effect/Either" {
+  export interface Left<out L, out R> {
+    get right(): R | undefined
+  }
+  export interface Right<out L, out R> {
+    get left(): L | undefined
+  }
+}

package/src/client/clientFor.ts

@@ -5,7 +5,6 @@ import { RpcResolver } from "@effect/rpc"
 import { HttpRpcResolver } from "@effect/rpc-http"
 import type { RpcRouter } from "@effect/rpc/RpcRouter"
 import { Record } from "effect"
-import { S } from "effect-app"
 import { ApiConfig } from "effect-app/client"
 import { HttpClient, HttpClientRequest } from "effect-app/http"
 import { typedKeysOf } from "effect-app/utils"
@@ -14,6 +13,7 @@ import type { Path } from "path-parser"
 import qs from "query-string"
 import type { Schema } from "../lib.js"
 import { Effect, flow, HashMap, Layer, Option, Predicate, Struct } from "../lib.js"
+import * as S from "../Schema.js"
 
 export function makePathWithQuery(
   path: Path,

package/src/client/config.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, type HashMap, Layer, type Option } from "@effect-app/core"
+import { Context, Effect, type HashMap, Layer, type Option } from "../lib.js"
 
 export interface ApiConfig {
   apiUrl: string

package/src/client/errors.ts

@@ -1,4 +1,4 @@
-import { TaggedError } from "effect-app/schema"
+import { TaggedError } from "effect-app/Schema"
 import { makeFiberFailure } from "effect/Runtime"
 import { Cause, S } from "../lib.js"
 

package/src/http/http-client.ts

@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type { Option } from "../Option.js"
+
+export const Method = {
+  GET: null,
+  POST: null,
+  PUT: null,
+  DELETE: null,
+  PATCH: null
+}
+export type Method = keyof typeof Method
+
+/** @deprecated use @effect/platform */
+export type Headers = Record<string, string>
+
+/** @deprecated use @effect/platform */
+export interface Response<Body> {
+  body: Option<Body>
+  headers: Headers
+  status: number
+}
+
+/** @deprecated use @effect/platform */
+export const HttpErrorReason = {
+  Request: "HttpErrorRequest",
+  Response: "HttpErrorResponse"
+} as const
+
+/** @deprecated use @effect/platform */
+export type HttpErrorReason = typeof HttpErrorReason
+
+/** @deprecated use @effect/platform */
+export interface HttpResponseError<ErrorBody> {
+  _tag: HttpErrorReason["Response"]
+  response: Response<ErrorBody>
+}
+
+/** @deprecated use @effect/platform */
+export function isHttpResponseError(
+  u: unknown
+): u is HttpResponseError<unknown> {
+  return (
+    typeof u === "object"
+    && u !== null
+    && (u as any)["_tag"] === HttpErrorReason.Response
+  )
+}
+
+/** @deprecated use @effect/platform */
+export interface HttpRequestError {
+  _tag: HttpErrorReason["Request"]
+  error: Error
+}
+
+/** @deprecated use @effect/platform */
+export function isHttpRequestError(u: unknown): u is HttpRequestError {
+  return (
+    typeof u === "object"
+    && u !== null
+    && (u as any)["_tag"] === HttpErrorReason.Request
+  )
+}
+
+/** @deprecated use @effect/platform */
+export function isHttpError(u: unknown): u is HttpError<unknown> {
+  return isHttpRequestError(u) || isHttpResponseError(u)
+}
+
+/** @deprecated use @effect/platform */
+export type HttpError<ErrorBody> =
+  | HttpRequestError
+  | HttpResponseError<ErrorBody>

package/src/ids.ts

@@ -1,6 +1,6 @@
-import type { B } from "@effect-app/core/Schema/schema"
-import { brandedStringId, NonEmptyString255, StringId, withDefaultMake } from "effect-app/schema"
-import type { Schema, StringIdBrand } from "effect-app/schema"
+import { brandedStringId, NonEmptyString255, StringId, withDefaultMake } from "effect-app/Schema"
+import type { Schema, StringIdBrand } from "effect-app/Schema"
+import type { B } from "effect-app/Schema/schema"
 import type { Simplify } from "effect/Types"
 import { S } from "./index.js"
 import { extendM } from "./utils.js"

package/src/index.ts

@@ -1,3 +1,3 @@
-import "@effect-app/core/builtin"
+import "./builtin.js"
 
 export * from "./lib.js"

package/src/lib.ts

@@ -1,4 +1,88 @@
-export * from "@effect-app/core"
-export { copy } from "@effect-app/core/utils"
-export * as SecretURL from "effect-app/Config/SecretURL"
-export * as S from "effect-app/schema"
+import type { YieldWrap } from "effect/Utils"
+import { Effect } from "./Prelude.js"
+
+export * as Fnc from "./Function.js"
+export * as Record from "./Object.js"
+export * as Utils from "./utils.js"
+
+export * from "effect"
+
+// we cannot export types colliding with namespaces from .ts files, only from .d.ts files with custom .js trick, applied in effect-app
+// for app land, it may make sense to create an app/prelude?
+export * from "./Prelude.js"
+
+export {
+  Array,
+  Cause,
+  Chunk,
+  Config,
+  Context,
+  Duration,
+  Effect,
+  Either,
+  Equal,
+  Equivalence,
+  Exit,
+  FiberRef,
+  HashMap,
+  Layer,
+  Option,
+  Order,
+  Ref,
+  Schema,
+  Scope
+} from "./Prelude.js"
+
+export * as Struct from "./Struct.js"
+
+export * as SecretURL from "./Config/SecretURL.js"
+export * as S from "./Schema.js"
+export { copy } from "./utils.js"
+
+// Simply Effect! https://github.com/kasperpeulen/simply-effect
+type InferE<Eff extends YieldWrap<Effect<any, any, any>>> = [
+  Eff
+] extends [never] ? never
+  : [Eff] extends [YieldWrap<Effect<infer _A, infer E, infer _R>>] ? E
+  : never
+type InferR<Eff extends YieldWrap<Effect<any, any, any>>> = [
+  Eff
+] extends [never] ? never
+  : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R
+  : never
+
+export function effect<
+  Eff extends YieldWrap<Effect<any, any, any>>,
+  AEff
+>(
+  f: () => Generator<Eff, AEff, never>
+): Effect<AEff, InferE<Eff>, InferR<Eff>>
+export function effect<
+  Eff extends YieldWrap<Effect<any, any, any>>,
+  AEff,
+  Args extends any[]
+>(
+  f: (...args: Args) => Generator<Eff, AEff, never>
+): (...args: Args) => Effect<AEff, InferE<Eff>, InferR<Eff>>
+export function effect<
+  Self,
+  Eff extends YieldWrap<Effect<any, any, any>>,
+  AEff
+>(
+  self: Self,
+  f: (this: Self) => Generator<Eff, AEff, never>
+): Effect<AEff, InferE<Eff>, InferR<Eff>>
+export function effect<
+  Eff extends YieldWrap<Effect<any, any, any>>,
+  AEff,
+  Args extends any[],
+  Self
+>(
+  self: Self,
+  f: (this: Self, ...args: Args) => Generator<Eff, AEff, never>
+): (...args: Args) => Effect<AEff, InferE<Eff>, InferR<Eff>>
+export function effect() {
+  const f = arguments.length === 1 ? arguments[0] : arguments[1].bind(arguments[0])
+  if (f.length === 0) return Effect.gen(f)
+  return (...args: any) => Effect.gen(() => f(...args))
+}

package/src/logger.ts

@@ -1,3 +1,3 @@
-import { makeLog } from "@effect-app/core/utils/logger"
+import { makeLog } from "effect-app/utils/logger"
 
 export const PreludeLogger = makeLog("effect-app", "info")

package/src/transform.ts

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Option } from "effect"
+import type { NonEmptyReadonlyArray } from "effect/Array"
+import type { Misc, Union } from "ts-toolbelt"
+import type * as SET from "./Set.js"
+
+// type SomeObject = {
+//   0: Option<string>
+//   a: {
+//     b: Option<string>
+//     g: Option<Option<string>>
+//     h: Option<{ i: Option<boolean> }>
+//   }
+//   c: { d: Array<Option<{ e: Option<boolean> }>> }
+// }
+// type test0 = Transform<SomeObject>
+// type test1 = Transform<SomeObject[]>
+
+type OptOf<A> = Union.Exclude<
+  A extends Option.Some<infer X> ? X | null : A,
+  Option.None<any>
+>
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+export type TransformRoot<O> = O extends Option.Option<any> ? Transform<OptOf<O>>
+  : Transform<O>
+export type Transform<O> = O extends Misc.BuiltIn | Misc.Primitive ? O
+  : {
+    [K in keyof O]: OptOf<O[K]> extends infer X ? X extends (infer Y)[] ? OptOf<Transform<Y>>[]
+      : X extends NonEmptyReadonlyArray<infer Y> ? NonEmptyReadonlyArray<OptOf<Transform<Y>>>
+      : X extends SET.Set<infer Y> ? SET.Set<OptOf<Transform<Y>>>
+      : X extends readonly (infer Y)[] ? readonly OptOf<Transform<Y>>[]
+      : Transform<X>
+      : never
+  }
+
+export const encodeOptsAsNullable = <T>(root: T): TransformRoot<T> => encodeOptsAsNullable_(root, new Map())
+
+const encodeOptsAsNullable_ = (value: any, cacheMap: Map<any, any>): any => {
+  const cacheEntry = cacheMap.get(value)
+  if (cacheEntry) {
+    return cacheEntry
+  }
+
+  if (Array.isArray(value)) {
+    const newAr: typeof value = []
+    cacheMap.set(value, newAr)
+    value.forEach((x) => newAr.push(encodeOptsAsNullable_(x, cacheMap)))
+    return newAr
+  }
+
+  if (
+    value instanceof Date
+    || value instanceof Function
+    || value instanceof Promise
+  ) {
+    return value
+  }
+
+  if (value instanceof Set) {
+    const newValue = [...value]
+    cacheMap.set(value, newValue)
+    return newValue
+  }
+
+  if (value instanceof Object) {
+    if (value._tag === "Some" || value._tag === "None") {
+      const v = value as Option.Option<unknown>
+      return encodeOptsAsNullable_(Option.getOrNull(v), cacheMap)
+    }
+    const newObj = {} as Record<string, any>
+    cacheMap.set(value, newObj)
+
+    Object.keys(value).forEach((key) => {
+      newObj[key] = encodeOptsAsNullable_(value[key], cacheMap)
+    })
+    return newObj
+  }
+  return value
+}