effect-app 4.0.0-beta.280 → 4.0.0-beta.282

package/src/QueueMaker.ts

@@ -1,19 +1,11 @@
-import type * as Scope from "effect/Scope"
-import type { NonEmptyReadonlyArray } from "./Array.ts"
-import type * as Effect from "./Effect.ts"
 import { RequestContext } from "./RequestContext.ts"
 
-export interface QueueBase<Evt, DrainEvt> {
-  drain: <DrainE, DrainR>(
-    makeHandleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-    sessionId?: string
-  ) => Effect.Effect<never, never, Scope.Scope | DrainR>
-  publish: (
-    ...messages: NonEmptyReadonlyArray<Evt>
-  ) => Effect.Effect<void>
-}
-
-export interface QueueMakerOps {}
-export const QueueMaker: QueueMakerOps = {}
-
+/**
+ * Per-message context envelope (tenant/store id, request metadata) carried
+ * alongside message-schema payloads. Alias of {@link RequestContext}.
+ *
+ * All that remains of the former queue machinery (SB/SQLite/mem `QueueMaker`
+ * implementations and the `QueueBase` interface) after the move to cluster
+ * entities — the message schemas that embed it still reference this envelope.
+ */
 export const QueueMeta = RequestContext

package/src/Schema/Class.ts

@@ -3,7 +3,7 @@ import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as S from "effect/Schema"
-import * as SchemaAST from "effect/SchemaAST"
+import * as SchemaAST from "../SchemaAST.ts"
 import * as SchemaGetter from "effect/SchemaGetter"
 import * as SchemaIssue from "effect/SchemaIssue"
 import * as SchemaTransformation from "effect/SchemaTransformation"

package/src/Schema/ext.ts

@@ -37,7 +37,7 @@ import * as Function from "effect/Function"
 import * as Option from "effect/Option"
 import * as S from "effect/Schema"
 import { isDateValid } from "effect/Schema"
-import type * as SchemaAST from "effect/SchemaAST"
+import type * as SchemaAST from "../SchemaAST.ts"
 import * as SchemaIssue from "effect/SchemaIssue"
 import * as SchemaTransformation from "effect/SchemaTransformation"
 import { type NonEmptyReadonlyArray } from "../Array.ts"

package/src/Schema/moreStrings.ts

@@ -14,7 +14,7 @@ import type * as B from "effect/Brand"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as S from "effect/Schema"
-import type * as SchemaAST from "effect/SchemaAST"
+import type * as SchemaAST from "../SchemaAST.ts"
 import type { Simplify } from "effect/Types"
 import { customRandom, nanoid, urlAlphabet } from "nanoid"
 import validator from "validator"

package/src/Schema/numbers.ts

@@ -11,7 +11,7 @@
 import { extendM } from "effect-app/utils"
 import * as Effect from "effect/Effect"
 import * as S from "effect/Schema"
-import type * as SchemaAST from "effect/SchemaAST"
+import type * as SchemaAST from "../SchemaAST.ts"
 import type { Simplify } from "effect/Types"
 import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
 import { withDefaultMake } from "./ext.ts"

package/src/Schema/schema.ts

@@ -1,5 +1,5 @@
 import * as B from "effect/Brand"
-import * as AST from "effect/SchemaAST"
+import * as AST from "../SchemaAST.ts"
 import * as P from "effect/SchemaParser"
 
 export { AST, B, P }

package/src/Schema/strings.ts

@@ -1,6 +1,6 @@
 import type * as B from "effect/Brand"
 import * as S from "effect/Schema"
-import type * as SchemaAST from "effect/SchemaAST"
+import type * as SchemaAST from "../SchemaAST.ts"
 import type { Simplify } from "effect/Types"
 import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
 import { withDefaultMake } from "./ext.ts"

package/src/Schema.ts

@@ -1,5 +1,5 @@
 import * as S from "effect/Schema"
-import * as SchemaAST from "effect/SchemaAST"
+import * as SchemaAST from "./SchemaAST.ts"
 import { type Simplify } from "effect/Struct"
 import type * as Tracer from "effect/Tracer"
 import type { RequiredKeys } from "effect/Types"
@@ -137,6 +137,19 @@ export * as SchemaParser from "./Schema/SchemaParser.ts"
 
 export { Void as Void_ } from "effect/Schema"
 
+/**
+ * Schema for a TypeScript `void` return value — the single canonical `Void`
+ * used across the app, including RPC success schemas.
+ *
+ * Built from our overridden {@link SchemaAST.Void} AST node: accepts **any
+ * present value** at runtime and discards it to `undefined`, while keeping the
+ * decoded/encoded type as `void` (effect-smol PR #2475). Use {@link Void_}
+ * (effect's original) or `S.Undefined` when the input must be exactly
+ * `undefined`.
+ */
+export interface Void extends S.Void {}
+export const Void: Void = S.make<S.Void>(new SchemaAST.Void())
+
 // ---------------------------------------------------------------------------
 // Struct / NonEmptyArray / Record
 // ---------------------------------------------------------------------------

package/src/SchemaAST.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect"
+import type * as Option from "effect/Option"
+import { Void as BaseVoid } from "effect/SchemaAST"
+
+export * from "effect/SchemaAST"
+
+/**
+ * AST node for a TypeScript `void` return value — overrides effect's
+ * `SchemaAST.Void` parser with TypeScript `void` semantics (the effect-smol
+ * PR #2475 / `b7d46ab` implementation).
+ *
+ * Runtime parsing accepts **any present value** and discards it, producing
+ * `undefined` — matching a `void` return whose result callers never observe.
+ * The decoded/encoded TypeScript representation stays `void`.
+ *
+ * @see {@link void_} for the singleton instance.
+ */
+export class Void extends BaseVoid {
+  /** @internal — mirrors the PR's `fromAnyToConst(undefined)`. */
+  getParser() {
+    const succeed = Effect.succeedSome(undefined)
+    return (oinput: Option.Option<unknown>) => oinput._tag === "None" ? Effect.succeedNone : succeed
+  }
+}
+
+const voidNode: Void = new Void()
+
+/** Singleton {@link Void} AST node — overrides effect's `void` singleton. */
+export { voidNode as void }

package/src/client/makeClient.ts

@@ -1,5 +1,4 @@
 import type * as Exit from "effect/Exit"
-import * as SchemaTransformation from "effect/SchemaTransformation"
 import { type GetContextConfig, type RpcContextMap } from "../rpc/RpcContextMap.ts"
 import * as S from "../Schema.ts"
 import { AST } from "../Schema.ts"
@@ -20,15 +19,6 @@ export interface ClientMiddleware<RequestContextMap extends Record<string, RpcCo
 const merge = (a: any, b: Array<any>) =>
   a !== undefined && b.length ? S.Union([a, ...b]) : a !== undefined ? a : b.length ? S.Union(b) : S.Never
 
-/**
- * Whatever the input, we will only decode or encode to void
- */
-export const ForceVoid = S
-  .declare((_: unknown): _ is unknown => true)
-  .pipe(
-    S.decodeTo(S.Any, SchemaTransformation.transform<unknown, unknown>({ decode: () => void 0, encode: () => void 0 }))
-  )
-
 type SchemaOrFields<T> = T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void
 
 type TaggedRequestSchema<Tag extends string, Payload extends S.Struct.Fields> = S.Struct<
@@ -46,7 +36,7 @@ type QueryOnlyResources<Resources> = {
 type InputFromPayload<Payload extends S.Struct.Fields> = keyof Payload extends never ? void
   : S.Struct<Payload>["Type"]
 
-type OutputFromSuccess<Success extends S.Top> = Success extends typeof ForceVoid ? void : Success["Type"]
+type OutputFromSuccess<Success extends S.Top> = Success extends typeof S.Void ? void : Success["Type"]
 
 type InvalidationResources = Record<string, Record<string, unknown>>
 
@@ -176,9 +166,9 @@ export const makeRpcClient = <
     )
     const successSchema = config?.success
       ? S.isSchema(config.success)
-        ? AST.isVoid(config.success.ast) ? ForceVoid : config.success
+        ? AST.isVoid(config.success.ast) ? S.Void : config.success
         : S.Struct(config.success)
-      : ForceVoid
+      : S.Void
 
     const finalConfig = (config as any)?.final
     const finalSchema = finalConfig && S.isSchema(finalConfig) ? finalConfig : undefined
@@ -327,7 +317,7 @@ export const makeRpcClient = <
         Self,
         Tag,
         Payload,
-        typeof ForceVoid,
+        typeof S.Void,
         ErrorResult<C & { error: Error }>,
         Omit<
           & Omit<C, "invalidatesQueries">
@@ -336,7 +326,7 @@ export const makeRpcClient = <
             InvalidationConfigForCommand<
               Resources,
               Payload,
-              typeof ForceVoid,
+              typeof S.Void,
               ErrorResult<C & { error: Error }>
             >
           >,
@@ -372,11 +362,11 @@ export const makeRpcClient = <
         Self,
         Tag,
         Payload,
-        typeof ForceVoid,
+        typeof S.Void,
         ErrorResult<C>,
         Omit<
           & Omit<C, "invalidatesQueries">
-          & Partial<InvalidationConfigForCommand<Resources, Payload, typeof ForceVoid, ErrorResult<C>>>,
+          & Partial<InvalidationConfigForCommand<Resources, Payload, typeof S.Void, ErrorResult<C>>>,
           "success" | "error" | "stream"
         >,
         ModuleName,
@@ -507,7 +497,7 @@ export const makeRpcClient = <
         Self,
         Tag,
         Payload,
-        typeof ForceVoid,
+        typeof S.Void,
         ErrorResult<C & { error: Error }>,
         Omit<
           & Omit<C, "invalidatesQueries">
@@ -518,7 +508,7 @@ export const makeRpcClient = <
             InvalidationConfigForCommand<
               Resources,
               Payload,
-              typeof ForceVoid,
+              typeof S.Void,
               ErrorResult<C & { error: Error }>
             >
           >,
@@ -549,11 +539,11 @@ export const makeRpcClient = <
         Self,
         Tag,
         Payload,
-        typeof ForceVoid,
+        typeof S.Void,
         ErrorResult<C>,
         Omit<
           & Omit<C, "invalidatesQueries">
-          & Partial<InvalidationConfigForCommand<Resources, Payload, typeof ForceVoid, ErrorResult<C>>>,
+          & Partial<InvalidationConfigForCommand<Resources, Payload, typeof S.Void, ErrorResult<C>>>,
           "success" | "error" | "stream"
         >,
         ModuleName,
@@ -570,7 +560,7 @@ export const makeRpcClient = <
         Self,
         Tag,
         Payload,
-        typeof ForceVoid,
+        typeof S.Void,
         ErrorResult<{}>,
         Record<string, never>,
         ModuleName,

package/test/dist/rpc.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAErF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAI0B,KAAK;;;;AAKpC,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAI0B,KAAK;;;;AAKpC,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}

package/test/rpc.test.ts

@@ -2,7 +2,6 @@ import type * as Effect from "effect/Effect"
 import type * as Option from "effect/Option"
 import { expect, test } from "vitest"
 import { makeRpcClient, NotLoggedInError, UnauthorizedError } from "../src/client.js"
-import { ForceVoid } from "../src/client/makeClient.js"
 import { S } from "../src/index.js"
 import { RpcContextMap } from "../src/rpc.js"
 
@@ -34,17 +33,17 @@ declare const _statsSuccess: typeof Stats.success.Type
 declare const _statsError: typeof Stats.error.Type
 declare const _statsRequestType: typeof Stats.type
 
-test("ForceVoid decodes and encodes as void", () => {
+test("Void decodes and encodes as void", () => {
   const statsFromMake = Stats.make({})
   const statsFromMakeOption = Stats.makeOption({})
   const statsFromMakeEffect = Stats.makeEffect({})
 
-  expect(S.decodeUnknownSync(ForceVoid)(undefined)).toBe(undefined)
-  expect(S.is(ForceVoid)(undefined)).toBe(true)
-  expect(S.decodeUnknownSync(ForceVoid)("test")).toBe(undefined)
-  expect(S.is(ForceVoid)("test")).toBe(true)
-  expect(S.encodeUnknownSync(ForceVoid)("test")).toBe(undefined)
-  expect(S.encodeUnknownSync(S.toCodecJson(ForceVoid))("test")).toBe(null)
+  expect(S.decodeUnknownSync(S.Void)(undefined)).toBe(undefined)
+  expect(S.is(S.Void)(undefined)).toBe(true)
+  expect(S.decodeUnknownSync(S.Void)("test")).toBe(undefined)
+  expect(S.is(S.Void)("test")).toBe(true)
+  expect(S.encodeUnknownSync(S.Void)("test")).toBe(undefined)
+  expect(S.encodeUnknownSync(S.toCodecJson(S.Void))("test")).toBe(null)
   expectTypeOf<typeof _stats>().toEqualTypeOf<Stats>()
   expectTypeOf<typeof _statsSuccess>().toEqualTypeOf<{
     readonly usersActive24Hours: number