effect-app 4.0.0-beta.267 → 4.0.0-beta.269

package/src/Store.ts

@@ -2,17 +2,17 @@
 import * as Data from "effect/Data"
 import type * as Redacted from "effect/Redacted"
 import * as Semaphore from "effect/Semaphore"
-import type { NonEmptyReadonlyArray } from "./Array.js"
-import type { DatabaseError, OptimisticConcurrencyException } from "./client/errors.js"
-import * as Context from "./Context.js"
-import * as Effect from "./Effect.js"
-import * as Layer from "./Layer.js"
-import type { FilterResult } from "./Model/filter/filterApi.js"
-import type { FieldValues } from "./Model/filter/types.js"
-import type { FieldPath } from "./Model/filter/types/path/index.js"
-import type { AggregateIrExpression, ComputedProjectionIrExpression, RawQuery } from "./Model/query.js"
-import type * as Option from "./Option.js"
-import { NonEmptyString255 } from "./Schema.js"
+import type { NonEmptyReadonlyArray } from "./Array.ts"
+import type { DatabaseError, OptimisticConcurrencyException } from "./client/errors.ts"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+import type { FilterResult } from "./Model/filter/filterApi.ts"
+import type { FieldValues } from "./Model/filter/types.ts"
+import type { FieldPath } from "./Model/filter/types/path/index.ts"
+import type { AggregateIrExpression, ComputedProjectionIrExpression, RawQuery } from "./Model/query.ts"
+import type * as Option from "./Option.ts"
+import { NonEmptyString255 } from "./Schema.ts"
 
 /**
  * Adapter-neutral unique-key definition for stores that support unique indexes,

package/src/_ext/Array.ts

@@ -1,7 +1,7 @@
 import * as Chunk from "effect-app/Chunk"
 import * as Effect from "effect-app/Effect"
 import * as Equal from "effect/Equal"
-import { NotFoundError } from "../client/errors.js"
+import { NotFoundError } from "../client/errors.ts"
 
 function getFirstBy<A, Type extends string>(
   a: Iterable<A>,

package/src/client/InvalidationKeys.ts

@@ -1,7 +1,7 @@
 import * as Ref from "effect/Ref"
-import * as Context from "../Context.js"
-import * as Effect from "../Effect.js"
-import type { InvalidationKey } from "../rpc/Invalidation.js"
+import * as Context from "../Context.ts"
+import * as Effect from "../Effect.ts"
+import type { InvalidationKey } from "../rpc/Invalidation.ts"
 
 export type { InvalidationKey }
 /** Shape of the per-mutation service that accumulates server-provided invalidation keys. */

package/src/client/apiClientFactory.ts

@@ -8,15 +8,15 @@ import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import * as Struct from "effect/Struct"
 import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/unstable/rpc"
-import * as Config from "../Config.js"
-import * as Context from "../Context.js"
-import * as Effect from "../Effect.js"
-import { HttpClient, HttpClientRequest } from "../http.js"
-import { Invalidation } from "../rpc.js"
-import type * as S from "../Schema.js"
-import { typedKeysOf, typedValuesOf } from "../utils.js"
-import type { Client, ClientForOptions, ExtractModuleName, RequestsAny } from "./clientFor.js"
-import { InvalidationKeysFromServer } from "./InvalidationKeys.js"
+import * as Config from "../Config.ts"
+import * as Context from "../Context.ts"
+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"
 
 export interface ApiConfig {
   url: string

package/src/client/clientFor.ts

@@ -5,9 +5,9 @@ import * as Record from "effect/Record"
 import type * as Stream from "effect/Stream"
 import type { Path } from "path-parser"
 import qs from "query-string"
-import type * as Effect from "../Effect.js"
-import type * as S from "../Schema.js"
-import { type Req } from "./apiClientFactory.js"
+import type * as Effect from "../Effect.ts"
+import type * as S from "../Schema.ts"
+import { type Req } from "./apiClientFactory.ts"
 
 export function makePathWithQuery(
   path: Path,

package/src/client/errors.ts

@@ -1,7 +1,7 @@
 /** @effect-diagnostics overriddenSchemaConstructor:skip-file */
 import { TaggedErrorClass } from "effect-app/Schema"
 import * as Cause from "effect/Cause"
-import * as S from "../Schema.js"
+import * as S from "../Schema.ts"
 
 export const tryToJson = (error: unknown) => {
   try {
@@ -243,11 +243,16 @@ export const silenceError = (e: Record<PropertyKey, any>) => {
 }
 
 export class CauseException<E> extends Error {
-  constructor(readonly originalCause: Cause.Cause<E>, readonly _tag: string) {
+  readonly originalCause: Cause.Cause<E>
+  readonly _tag: string
+
+  constructor(originalCause: Cause.Cause<E>, _tag: string) {
     const limit = Error.stackTraceLimit
     Error.stackTraceLimit = 0
     super()
     Error.stackTraceLimit = limit
+    this.originalCause = originalCause
+    this._tag = _tag
     this.cause = Cause.squash(originalCause)
     // v4: makeFiberFailure removed — use Cause.prettyErrors instead
     const errors = Cause.prettyErrors(originalCause)

package/src/client/makeClient.ts

@@ -1,9 +1,9 @@
 import type * as Exit from "effect/Exit"
 import * as SchemaTransformation from "effect/SchemaTransformation"
-import { type GetContextConfig, type RpcContextMap } from "../rpc/RpcContextMap.js"
-import * as S from "../Schema.js"
-import { AST } from "../Schema.js"
-import type { ClientForOptions } from "./clientFor.js"
+import { type GetContextConfig, type RpcContextMap } from "../rpc/RpcContextMap.ts"
+import * as S from "../Schema.ts"
+import { AST } from "../Schema.ts"
+import type { ClientForOptions } from "./clientFor.ts"
 
 /**
  * Minimal structural shape for an rpc-client middleware tag.

package/src/http/Request.ts

@@ -1,7 +1,7 @@
 import * as Option from "effect/Option"
 import type { HttpClientResponse } from "effect/unstable/http/HttpClientResponse"
-import * as Effect from "../Effect.js"
-import { HttpClient, HttpClientError, HttpClientRequest, HttpHeaders } from "./internal/lib.js"
+import * as Effect from "../Effect.ts"
+import { HttpClient, HttpClientError, HttpClientRequest, HttpHeaders } from "./internal/lib.ts"
 
 export interface ResponseWithBody<A> extends Pick<HttpClientResponse, "headers" | "status" | "remoteAddress"> {
   readonly body: A

package/src/http.ts

@@ -1 +1 @@
-export * from "./http/internal/lib.js"
+export * from "./http/internal/lib.ts"

package/src/ids.ts

@@ -2,8 +2,8 @@ import { brandedStringId, type Codec, NonEmptyString255, StringId, type StringId
 import type { B } from "effect-app/Schema/schema"
 import * as Effect from "effect/Effect"
 import type { Simplify } from "effect/Types"
-import * as S from "./Schema.js"
-import { extendM } from "./utils.js"
+import * as S from "./Schema.ts"
+import { extendM } from "./utils.ts"
 
 export interface RequestIdBrand extends StringIdBrand {
   readonly RequestId: unique symbol

package/src/index.ts

@@ -1,27 +1,27 @@
 // eslint-disable-next-line import/no-unassigned-import
-import "./builtin.js"
+import "./builtin.ts"
 
-export * as Fnc from "./Function.js"
-export * as Utils from "./utils.js"
+export * as Fnc from "./Function.ts"
+export * as Utils from "./utils.ts"
 
-export * as Array from "./Array.js"
-export * as Config from "./Config.js"
-export * as ConfigProvider from "./ConfigProvider.js"
-export * as Context from "./Context.js"
-export * as Effect from "./Effect.js"
-export * as Layer from "./Layer.js"
-export * as Model from "./Model.js"
-export * as NonEmptySet from "./NonEmptySet.js"
-export * as Set from "./Set.js"
-export * as Store from "./Store.js"
+export * as Array from "./Array.ts"
+export * as Config from "./Config.ts"
+export * as ConfigProvider from "./ConfigProvider.ts"
+export * as Context from "./Context.ts"
+export * as Effect from "./Effect.ts"
+export * as Layer from "./Layer.ts"
+export * as Model from "./Model.ts"
+export * as NonEmptySet from "./NonEmptySet.ts"
+export * as Set from "./Set.ts"
+export * as Store from "./Store.ts"
 
-export { type NonEmptyArray, type NonEmptyReadonlyArray } from "./Array.js"
+export { type NonEmptyArray, type NonEmptyReadonlyArray } from "./Array.ts"
 
 export * from "effect"
 
-export type * as Types from "./Types.js"
+export type * as Types from "./Types.ts"
 
-export * as SecretURL from "./Config/SecretURL.js"
-export * as RpcX from "./rpc.js"
-export * as S from "./Schema.js"
-export { copy } from "./utils.js"
+export * as SecretURL from "./Config/SecretURL.ts"
+export * as RpcX from "./rpc.ts"
+export * as S from "./Schema.ts"
+export { copy } from "./utils.ts"

package/src/middleware.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as Context from "effect-app/Context"
-import { RpcMiddleware } from "./rpc.js"
+import { RpcMiddleware } from "./rpc.ts"
 
 export class DevMode extends Context.Reference("DevMode", { defaultValue: () => false }) {}
 

package/src/rpc/Invalidation.ts

@@ -1,9 +1,9 @@
 import * as Ref from "effect/Ref"
 import { Rpc } from "effect/unstable/rpc"
-import { type ClientForOptions, makeQueryKey } from "../client/clientFor.js"
-import * as Context from "../Context.js"
-import * as Effect from "../Effect.js"
-import * as S from "../Schema.js"
+import { type ClientForOptions, makeQueryKey } from "../client/clientFor.ts"
+import * as Context from "../Context.ts"
+import * as Effect from "../Effect.ts"
+import * as S from "../Schema.ts"
 
 /**
  * Shorthand for a handler-derived invalidation key.
@@ -111,7 +111,7 @@ export type StreamFailureChunk<E> = { readonly _tag: "error"; readonly error: E;
  * ```ts
  * import { makeQueryKey } from "effect-app/client"
  * import { Invalidation } from "effect-app/rpc"
- * import * as UserRsc from "../User/index.js"  // separate module to avoid circular deps
+ * import * as UserRsc from "../User/index.ts"  // separate module to avoid circular deps
  *
  * class UpdateProfile extends Rpc.make("UpdateProfile", { ... })
  *   .annotate(Invalidation.Invalidates, [makeQueryKey(UserRsc.GetMe), makeQueryKey(UserRsc.GetProfile)]) {}
@@ -160,8 +160,8 @@ export interface InvalidationSetService {
  * ```ts
  * import * as Effect from "effect/Effect"
  * import { Invalidation } from "effect-app/rpc"
- * import * as CartRsc from "../Cart/queries.js"
- * import * as UserRsc from "../User/queries.js"
+ * import * as CartRsc from "../Cart/queries.ts"
+ * import * as UserRsc from "../User/queries.ts"
  *
  * const handler = Effect.fnUntraced(function*(req: UpdateCartRequest) {
  *   const cart = yield* CartRepo.save(req.cart)

package/src/rpc/MiddlewareMaker.ts

@@ -7,12 +7,12 @@ import type * as Scope from "effect/Scope"
 import { type Simplify } from "effect/Types"
 import { Rpc, type RpcGroup, type RpcSchema } from "effect/unstable/rpc"
 import { type HandlersFrom } from "effect/unstable/rpc/RpcGroup"
-import * as Context from "../Context.js"
-import { PreludeLogger } from "../logger.js"
-import { type TypeTestId } from "../TypeTest.js"
-import { type GetContextConfig, type RequestContextMapTagAny, type RpcContextMap } from "./RpcContextMap.js"
-import { type AddMiddleware, type AnyDynamic, type RpcDynamic, type RpcMiddlewareV4, type TagClassAny } from "./RpcMiddleware.js"
-import * as RpcMiddlewareX from "./RpcMiddleware.js"
+import * as Context from "../Context.ts"
+import { PreludeLogger } from "../logger.ts"
+import { type TypeTestId } from "../TypeTest.ts"
+import { type GetContextConfig, type RequestContextMapTagAny, type RpcContextMap } from "./RpcContextMap.ts"
+import { type AddMiddleware, type AnyDynamic, type RpcDynamic, type RpcMiddlewareV4, type TagClassAny } from "./RpcMiddleware.ts"
+import * as RpcMiddlewareX from "./RpcMiddleware.ts"
 
 // adapter for effect/rpc v3 middleware provides. (in effect-smol (v4), it's just a Service Identifier, no tags.)
 // hm?

package/src/rpc/RpcContextMap.ts

@@ -4,8 +4,8 @@
 
 import type * as S from "effect/Schema"
 import { type AnyWithProps } from "effect/unstable/rpc/Rpc"
-import * as Context from "../Context.js"
-import { type RpcDynamic } from "./RpcMiddleware.js"
+import * as Context from "../Context.ts"
+import { type RpcDynamic } from "./RpcMiddleware.ts"
 
 type Values<T extends Record<any, any>> = T[keyof T]
 

package/src/rpc/RpcMiddleware.ts

@@ -8,8 +8,8 @@ import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import { type Rpc, RpcMiddleware } from "effect/unstable/rpc"
 import { type TypeId } from "effect/unstable/rpc/RpcMiddleware"
-import type * as Context from "../Context.js"
-import { type GetEffectContext, type RpcContextMap } from "./RpcContextMap.js"
+import type * as Context from "../Context.ts"
+import { type GetEffectContext, type RpcContextMap } from "./RpcContextMap.ts"
 
 export type RpcMiddlewareV4<Provides, E, Requires> = RpcMiddleware.RpcMiddleware<Provides, E, Requires>
 

package/src/rpc.ts

@@ -1,4 +1,4 @@
-export * as Invalidation from "./rpc/Invalidation.js"
-export * as MiddlewareMaker from "./rpc/MiddlewareMaker.js"
-export * as RpcContextMap from "./rpc/RpcContextMap.js"
-export * as RpcMiddleware from "./rpc/RpcMiddleware.js"
+export * as Invalidation from "./rpc/Invalidation.ts"
+export * as MiddlewareMaker from "./rpc/MiddlewareMaker.ts"
+export * as RpcContextMap from "./rpc/RpcContextMap.ts"
+export * as RpcMiddleware from "./rpc/RpcMiddleware.ts"

package/src/runtime.ts

@@ -2,10 +2,10 @@ import * as Exit from "effect/Exit"
 import { flow } from "effect/Function"
 import * as Logger from "effect/Logger"
 import * as ManagedRuntime from "effect/ManagedRuntime"
-import { CauseException } from "./client/errors.js"
-import { type Context } from "./Context.js"
-import * as Effect from "./Effect.js"
-import * as Layer from "./Layer.js"
+import { CauseException } from "./client/errors.ts"
+import { type Context } from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
 
 export const makeAppRuntime = Effect.fnUntraced(function*<A, E>(layer: Layer.Layer<A, E>) {
   const l = layer.pipe(

package/src/setupRequest.ts

@@ -1,11 +1,11 @@
 import * as Tracer from "effect/Tracer"
 import { SqlClient } from "effect/unstable/sql"
-import * as Effect from "./Effect.js"
-import * as Layer from "./Layer.js"
-import * as Option from "./Option.js"
-import { LocaleRef, RequestContext, spanAttributes } from "./RequestContext.js"
-import { NonEmptyString255 } from "./Schema.js"
-import { ContextMapContainer, storeId } from "./Store.js"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+import * as Option from "./Option.ts"
+import { LocaleRef, RequestContext, spanAttributes } from "./RequestContext.ts"
+import { NonEmptyString255 } from "./Schema.ts"
+import { ContextMapContainer, storeId } from "./Store.ts"
 
 const withSqlTransaction = <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.serviceOption(SqlClient.SqlClient).pipe(

package/src/toast.ts

@@ -1,7 +1,7 @@
-import * as Context from "./Context.js"
-import { accessEffectFn } from "./Context.js"
-import * as Effect from "./Effect.js"
-import * as Option from "./Option.js"
+import * as Context from "./Context.ts"
+import { accessEffectFn } from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Option from "./Option.ts"
 
 export type ToastId = string | number
 export type ToastOpts = { id?: ToastId; timeout?: number; groupId?: string; requestId?: string }

package/src/transform.ts

@@ -2,7 +2,7 @@
 import type { NonEmptyReadonlyArray } from "effect/Array"
 import * as Option from "effect/Option"
 import type { Misc, Union } from "ts-toolbelt"
-import type * as SET from "./Set.js"
+import type * as SET from "./Set.ts"
 
 // type SomeObject = {
 //   0: Option.Option<string>

package/src/utils/logger.ts

@@ -3,7 +3,7 @@
 
 import * as Effect from "effect/Effect"
 import type * as LogLevel from "effect/LogLevel"
-import * as Context from "../Context.js"
+import * as Context from "../Context.ts"
 
 type Levels = "info" | "debug" | "warn" | "error"
 

package/src/utils.ts

@@ -10,8 +10,8 @@ import * as Option from "effect/Option"
 import { isFunction } from "effect/Predicate"
 import * as Record from "effect/Record"
 import * as Result from "effect/Result"
-import { identity, pipe } from "./Function.js"
-import type { DeepMutable, Equals, Mutable } from "./Types.js"
+import { identity, pipe } from "./Function.ts"
+import type { DeepMutable, Equals, Mutable } from "./Types.ts"
 
 // codegen:start {preset: barrel, include: ./utils/*.ts, nodir: false }
 export * from "./utils/effectify.ts"
@@ -228,7 +228,7 @@ function decorateNew(
 function decorateLegacy(
   target: any,
   key: PropertyKey,
-  descriptor: PropertyDescriptor,
+  descriptor: PropertyDescriptor | undefined,
   setProto: boolean,
   makeNonConfigurable: boolean,
   // tslint:enable:bool-param-default
@@ -236,11 +236,12 @@ function decorateLegacy(
 ): PropertyDescriptor {
   /* istanbul ignore if */
   if (!descriptor) {
-    descriptor = <any> Object.getOwnPropertyDescriptor(target, key)
+    descriptor = Object.getOwnPropertyDescriptor(target, key)
     if (!descriptor) {
-      const e = new Error("@LazyGetter is unable to determine the property descriptor")
-      ;(<any> e).$target = target
-      ;(<any> e).$key = key
+      const e = Object.assign(new Error("@LazyGetter is unable to determine the property descriptor"), {
+        $key: key,
+        $target: target
+      })
       throw e
     }
   }
@@ -295,7 +296,7 @@ function defaultFilter(): boolean {
 
 function validateAndExtractMethodFromDescriptor(desc: PropertyDescriptor): Function {
   // eslint-disable-next-line @typescript-eslint/unbound-method
-  const originalMethod = <Function> desc.get
+  const originalMethod = desc.get
 
   if (!originalMethod) {
     throw new Error("@LazyGetter can only decorate getters!")
@@ -318,7 +319,7 @@ function getterCommon( // tslint:disable-line:parameters-max-number
   makeNonConfigurable: boolean,
   resultSelector: ResultSelectorFn
 ): any {
-  const value = originalMethod.apply(thisArg, <any> args)
+  const value = originalMethod.apply(thisArg, args)
 
   if (resultSelector(value)) {
     const newDescriptor: PropertyDescriptor = {
@@ -353,23 +354,23 @@ export function LazyGetter(
 ): MethodDecorator & ResettableDescriptor {
   let desc: PropertyDescriptor
   let prop: PropertyKey
-  let args: IArguments = <any> null
+  let args: [targetOrDesc: any, key: PropertyKey | undefined, descriptor: PropertyDescriptor | undefined] | undefined
   let isLegacy: boolean
 
   function decorator(
     targetOrDesc: any,
-    key: PropertyKey,
-    descriptor: PropertyDescriptor
+    key: PropertyKey | undefined,
+    descriptor: PropertyDescriptor | undefined
   ): DecoratorReturn {
-    // eslint-disable-next-line prefer-rest-params
-    args = arguments
+    args = [targetOrDesc, key, descriptor]
     if (key === undefined) {
       if (typeof desc === "undefined") {
+        const newDescriptor = targetOrDesc as NewDescriptor
         isLegacy = false
-        prop = (<NewDescriptor> targetOrDesc).key
+        prop = newDescriptor.key
         desc = Object.assign(
           {},
-          (<NewDescriptor> targetOrDesc).descriptor
+          newDescriptor.descriptor
             /* istanbul ignore next */ || targetOrDesc
         )
       }
@@ -411,11 +412,14 @@ export function LazyGetter(
           "Unable to restore descriptor. Did you remember to apply your decorator to a method?"
         )
       }
+      if (!args) {
+        throw new Error("Unable to restore descriptor before applying the decorator.")
+      }
       // Restore descriptor to its original state
       Object.defineProperty(on, prop, desc)
-      // eslint-disable-next-line prefer-spread
-      const ret: any = decorator.apply(null, <any> args)
-      Object.defineProperty(on, prop, isLegacy ? ret : ret.descriptor || ret)
+      const ret = decorator.apply(null, args)
+      const restoredDescriptor = isLegacy ? ret : "descriptor" in ret && ret.descriptor ? ret.descriptor : ret
+      Object.defineProperty(on, prop, restoredDescriptor)
     }
 
   return decorator

package/src/validation.ts

@@ -1,4 +1,4 @@
-import type { Predicate } from "./Function.js"
+import type { Predicate } from "./Function.ts"
 
 export const all_ = <T>(v: T, ...a: Predicate<T>[]) => !a.some((x) => !x(v))
 export const all = <T>(...a: Predicate<T>[]) => (v: T) => all_(v, ...a)
@@ -15,4 +15,4 @@ export const min = (min: number) => {
   return (v: { length: number }) => f(v.length)
 }
 
-export * from "./validation/validators.js"
+export * from "./validation/validators.ts"

package/src/withToast.ts

@@ -1,12 +1,12 @@
 import * as Cause from "effect/Cause"
 import * as Fiber from "effect/Fiber"
-import * as Context from "./Context.js"
-import * as Effect from "./Effect.js"
-import * as Layer from "./Layer.js"
-import type * as Option from "./Option.js"
-import * as S from "./Schema.js"
-import { CurrentToastId, Toast, type ToastId } from "./toast.js"
-import { wrapEffect } from "./utils.js"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+import type * as Option from "./Option.ts"
+import * as S from "./Schema.ts"
+import { CurrentToastId, Toast, type ToastId } from "./toast.ts"
+import { wrapEffect } from "./utils.ts"
 
 export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
   stableToastId?: undefined | string | ((...args: Args) => string | undefined)

package/tsconfig.json

@@ -34,6 +34,7 @@
     "moduleResolution": "Node16",
     "noErrorTruncation": true,
     "forceConsistentCasingInFileNames": true,
+    "erasableSyntaxOnly": true,
     "rewriteRelativeImportExtensions": true,
     "allowImportingTsExtensions": true,
     "types": [