effect-app 4.0.0-beta.281 → 4.0.0-beta.283

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/src/client.ts

@@ -5,3 +5,4 @@ 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/rpc/Invalidation.ts

@@ -2,6 +2,7 @@ import * as Ref from "effect/Ref"
 import { Rpc } from "effect/unstable/rpc"
 import { type ClientForOptions, makeQueryKey } from "../client/clientFor.ts"
 import * as Context from "../Context.ts"
+import * as DataDependencies from "../DataDependencies.ts"
 import * as Effect from "../Effect.ts"
 import * as S from "../Schema.ts"
 
@@ -23,7 +24,7 @@ const normalizeKey = (input: InvalidationKeyInput): InvalidationKey => {
 const isBatch = (
   input: InvalidationKeyInput | ReadonlyArray<InvalidationKeyInput>
 ): input is ReadonlyArray<InvalidationKeyInput> =>
-  Array.isArray(input) && input.length > 0 && typeof input[0] !== "string"
+  Array.isArray(input) && input[0] !== undefined && typeof input[0] !== "string"
 
 const normalizeInputs = (
   input: InvalidationKeyInput | ReadonlyArray<InvalidationKeyInput>
@@ -46,9 +47,22 @@ export const InvalidationKeys = S.Array(InvalidationKey)
 export type InvalidationKeys = S.Schema.Type<typeof InvalidationKeys>
 
 /** Metadata included in every command response for server-driven cache invalidation. */
-export const CommandMetaData = S.Struct({ invalidateQueries: InvalidationKeys })
+export const CommandMetaData = S.Struct({
+  invalidateQueries: InvalidationKeys,
+  dataDependencies: DataDependencies.DataDependencySet
+})
 export type CommandMetaData = S.Schema.Type<typeof CommandMetaData>
 
+export const emptyDataDependencies: DataDependencies.DataDependencySet = { reads: [], writes: [] }
+
+export const makeMetaData = (
+  invalidateQueries: InvalidationKeys,
+  dataDependencies: DataDependencies.DataDependencySet = emptyDataDependencies
+): CommandMetaData => ({ invalidateQueries, dataDependencies })
+
+export const QueryResponseWithMetaData = <S extends S.Top>(success: S) =>
+  S.Struct({ payload: success, metadata: S.Struct({ dataDependencies: DataDependencies.DataDependencySet }) })
+
 /**
  * Wraps a command's success schema so that the wire format carries both the `payload`
  * (the handler's actual return value) and `metadata` (server-driven cache invalidation keys).

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