effect-app 4.0.0-beta.99 → 4.0.1

package/src/client.ts

@@ -1,6 +1,8 @@
 // codegen:start {preset: barrel, include: ./client/*.ts}
-export * from "./client/apiClientFactory.js"
-export * from "./client/clientFor.js"
-export * from "./client/errors.js"
-export * from "./client/makeClient.js"
+export * from "./client/apiClientFactory.ts"
+export * from "./client/clientFor.ts"
+export * from "./client/errors.ts"
+export * from "./client/InvalidationKeys.ts"
+export * from "./client/makeClient.ts"
 // codegen:end
+export * as DataDependencies from "./DataDependencies.ts"

package/src/http/Request.ts

@@ -1,7 +1,7 @@
-import { Option } from "effect"
-import type { HttpClientResponse } from "effect/unstable/http/HttpClientResponse"
-import * as Effect from "../Effect.js"
-import { HttpClient, HttpClientError, HttpClientRequest, HttpHeaders } from "./internal/lib.js"
+import type { HttpClientResponse } from "effect/http/HttpClientResponse"
+import * as Option from "effect/Option"
+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/internal/lib.ts

@@ -1,13 +1,13 @@
-export * as HttpHeaders from "effect/unstable/http/Headers"
-export * as HttpBody from "effect/unstable/http/HttpBody"
-export * as HttpClient from "effect/unstable/http/HttpClient"
-export * as HttpClientError from "effect/unstable/http/HttpClientError"
-export * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
-export * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
+export * as HttpHeaders from "effect/http/Headers"
+export * as HttpBody from "effect/http/HttpBody"
+export * as HttpClient from "effect/http/HttpClient"
+export * as HttpClientError from "effect/http/HttpClientError"
+export * as HttpClientRequest from "effect/http/HttpClientRequest"
+export * as HttpClientResponse from "effect/http/HttpClientResponse"
 // HttpLayerRouter removed in v4 — use HttpRouter instead
-export * as HttpMiddleware from "effect/unstable/http/HttpMiddleware"
-export * as HttpRouter from "effect/unstable/http/HttpRouter"
-export * as HttpServer from "effect/unstable/http/HttpServer"
-export * as HttpServerError from "effect/unstable/http/HttpServerError"
-export * as HttpServerRequest from "effect/unstable/http/HttpServerRequest"
-export * as HttpServerResponse from "effect/unstable/http/HttpServerResponse"
+export * as HttpMiddleware from "effect/http/HttpMiddleware"
+export * as HttpRouter from "effect/http/HttpRouter"
+export * as HttpServer from "effect/http/HttpServer"
+export * as HttpServerError from "effect/http/HttpServerError"
+export * as HttpServerRequest from "effect/http/HttpServerRequest"
+export * as HttpServerResponse from "effect/http/HttpServerResponse"

package/src/http.ts

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

package/src/ids.ts

@@ -1,29 +1,66 @@
-import { Effect } from "effect"
 import { brandedStringId, type Codec, NonEmptyString255, StringId, type StringIdBrand, withDefaultMake } from "effect-app/Schema"
 import type { B } from "effect-app/Schema/schema"
+import * as Effect from "effect/Effect"
 import type { Simplify } from "effect/Types"
-import { S } from "./index.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
 }
 
 export type RequestId = NonEmptyString255
-// a request id may be made from a span id, which does not comply with StringId schema.
+/**
+ * Schema for a request id.
+ *
+ * A request id may be made from a span id, which does not comply with the
+ * `StringId` schema (hence the looser `NonEmptyString255` base).
+ *
+ * `.withConstructorDefault` => fresh `StringId` (construction-only; not
+ * applied during decode — cannot be used to JIT-migrate database fields).
+ * See `./Schema/ext.ts` for the full policy note.
+ */
+const requestIdSamples = S.makeFilter<string>(() => undefined, {
+  arbitraryConstraint: {
+    minLength: 21,
+    maxLength: 21,
+    patterns: [{ source: "^[A-Za-z0-9_-]{21}$", flags: "" }]
+  }
+})
+
 export const RequestId = extendM(
   Object
-    .assign(Object.create(NonEmptyString255) as {}, NonEmptyString255 as unknown as Codec<NonEmptyString255, string>),
+    .assign(
+      Object.create(NonEmptyString255) as {},
+      NonEmptyString255.pipe(S.check(requestIdSamples)) as unknown as Codec<NonEmptyString255, string>
+    ),
   (s) => {
-    const make = StringId.make as () => NonEmptyString255
+    function make(): NonEmptyString255
+    function make(input: string, options?: S.MakeOptions): NonEmptyString255
+    function make(input?: string, options?: S.MakeOptions): NonEmptyString255 {
+      const id = input === undefined ? StringId.make() : StringId.make(input, options)
+      return id
+    }
     return ({
       make,
-      withDefault: S.withConstructorDefault(Effect.sync(make))(s as typeof s & S.WithoutConstructorDefault)
+      /**
+       * Construction-only default: fresh `StringId`. Applied only when the
+       * field is omitted from `.make(...)` input. NOT applied during decode —
+       * cannot be used to JIT-migrate database fields. See `./Schema/ext.ts`
+       * file-level note.
+       */
+      withConstructorDefault: S.withConstructorDefault(Effect.sync(make))(s as typeof s & S.WithoutConstructorDefault)
     })
   }
 )
   .pipe(withDefaultMake)
 
 export interface UserProfileIdBrand extends Simplify<B.Brand<"UserProfileId"> & StringIdBrand> {}
-export type UserProfileId = StringId & UserProfileIdBrand
+export type UserProfileId = string & UserProfileIdBrand
+/**
+ * Branded `StringId` for user profiles.
+ *
+ * Exposes `.withConstructorDefault` (fresh id) — construction-only; not
+ * applied during decode. See `./Schema/ext.ts` for the full policy note.
+ */
 export const UserProfileId = brandedStringId<UserProfileId>()

package/src/index.ts

@@ -1,23 +1,27 @@
-import "./builtin.js"
+// eslint-disable-next-line import/no-unassigned-import
+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 NonEmptySet from "./NonEmptySet.js"
-export * as Set from "./Set.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 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,21 +1,25 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context } from "effect-app"
-import { RpcX } from "./rpc.js"
+import * as Context from "effect-app/Context"
+import { RpcMiddleware } from "./rpc.ts"
 
 export class DevMode extends Context.Reference("DevMode", { defaultValue: () => false }) {}
 
-export class RequestCacheMiddleware
-  extends RpcX.RpcMiddleware.Tag<RequestCacheMiddleware>()("RequestCacheMiddleware")
-{}
+export class RequestCacheMiddleware extends RpcMiddleware.Tag<RequestCacheMiddleware>()("RequestCacheMiddleware") {}
 
 export class ConfigureInterruptibilityMiddleware
-  extends RpcX.RpcMiddleware.Tag<ConfigureInterruptibilityMiddleware>()("ConfigureInterruptibilityMiddleware")
+  extends RpcMiddleware.Tag<ConfigureInterruptibilityMiddleware>()("ConfigureInterruptibilityMiddleware")
 {}
 
-export class LoggerMiddleware extends RpcX.RpcMiddleware.Tag<LoggerMiddleware>()("LoggerMiddleware") {}
+export class LoggerMiddleware extends RpcMiddleware.Tag<LoggerMiddleware>()("LoggerMiddleware") {}
 
-export class DevModeMiddleware extends RpcX.RpcMiddleware.Tag<DevModeMiddleware>()("DevModeMiddleware") {}
+export class DevModeMiddleware extends RpcMiddleware.Tag<DevModeMiddleware>()("DevModeMiddleware") {}
 
+/**
+ * Generic middlewares attached by `makeRouter` to every request.
+ *
+ * Invalidation key wrap/unwrap is handled by the routing layer (server) and the
+ * api client factory (client) directly — there is no middleware tag for it.
+ */
 export const DefaultGenericMiddlewares = [
   RequestCacheMiddleware,
   ConfigureInterruptibilityMiddleware,