@effect-app/vue 4.0.0-beta.16 → 4.0.0-beta.160

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

@@ -1 +1 @@
-{"version":3,"file":"stubs.d.ts","sourceRoot":"","sources":["../stubs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,oCAAoC,CAAA;AAE9E,OAAO,EAAU,KAAK,EAA0B,CAAC,EAAE,MAAM,YAAY,CAAA;AACrE,OAAO,EAAE,gBAAgB,EAAiB,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAG9C,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAElD,OAAO,KAAK,KAAK,MAAM,8BAA8B,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAc,MAAM,sBAAsB,CAAA;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAA;AA8CxD,eAAO,MAAM,YAAY,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,KAepG,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAClD,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,oCACpC,CAAA;AAExE,eAAO,MAAM,eAAe,GAC1B,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE,6GASxG,CAAA;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAAyB;CAAG;AACnE,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;;;;;AACtE,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;;;;;;;;;;iBAML,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;;;;;AAJjE,qBAAa,6BAA8B,SAAQ,kCAMjD;CAAG;AAEL,eAAO,MAAM,SAAS;;;;;;CAA+F,CAAA;AAErH,eAAO,MAAM,SAAS,GACpB,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE;;;;;;;;;CAcxG,CAAA"}
+{"version":3,"file":"stubs.d.ts","sourceRoot":"","sources":["../stubs.ts"],"names":[],"mappings":"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"}

package/test/dist/stubs.js

@@ -4,12 +4,12 @@ import { ApiClientFactory, makeRpcClient } from "effect-app/client";
 import { RpcContextMap } from "effect-app/rpc";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import { ref } from "vue";
-import { Commander } from "../src/experimental/commander.js";
-import { I18n } from "../src/experimental/intl.js";
-import { makeUseCommand } from "../src/experimental/makeUseCommand.js";
-import * as Toast from "../src/experimental/toast.js";
-import { WithToast } from "../src/experimental/withToast.js";
-import { LegacyMutation, makeClient } from "../src/makeClient.js";
+import { Commander } from "../src/commander.js";
+import { I18n } from "../src/intl.js";
+import { makeClient } from "../src/makeClient.js";
+import { makeUseCommand } from "../src/makeUseCommand.js";
+import * as Toast from "../src/toast.js";
+import { WithToast } from "../src/withToast.js";
 const fakeToastLayer = (toasts = []) => Layer.effect(Toast.Toast, Effect.sync(() => {
     const dismiss = (id) => {
         const idx = toasts.findIndex((_) => _.id === id);
@@ -19,21 +19,21 @@ const fakeToastLayer = (toasts = []) => Layer.effect(Toast.Toast, Effect.sync(()
             toasts.splice(idx, 1);
         }
     };
-    const fakeToast = (message, options) => {
+    const fakeToast = (type) => (message, options) => {
         const id = options?.id ?? Math.random().toString(36).substring(2, 15);
-        console.log(`Toast [${id}]: ${message}`, options);
+        console.log(`Toast [${type}][${id}]: ${message}`, options);
         options = { ...options, id };
         const idx = toasts.findIndex((_) => _.id === id);
         if (idx > -1) {
             const toast = toasts[idx];
             clearTimeout(toast.timeoutId);
-            Object.assign(toast, { message, options });
+            Object.assign(toast, { type, message, options });
             toast.timeoutId = setTimeout(() => {
                 toasts.splice(idx, 1);
             }, options?.timeout ?? 3000);
         }
         else {
-            const toast = { id, message, options };
+            const toast = { id, type, message, options };
             toast.timeoutId = setTimeout(() => {
                 toasts.splice(idx, 1);
             }, options?.timeout ?? 3000);
@@ -42,10 +42,10 @@ const fakeToastLayer = (toasts = []) => Layer.effect(Toast.Toast, Effect.sync(()
         return id;
     };
     return Toast.Toast.of(Toast.wrap({
-        error: fakeToast,
-        warning: fakeToast,
-        success: fakeToast,
-        info: fakeToast,
+        error: fakeToast("error"),
+        warning: fakeToast("warning"),
+        success: fakeToast("success"),
+        info: fakeToast("info"),
         dismiss
     }));
 }));
@@ -76,29 +76,62 @@ export const useExperimental = (options) => {
 };
 export class RequestContextMap extends RpcContextMap.makeMap({}) {
 }
-export const { TaggedRequest: Req } = makeRpcClient(RequestContextMap);
-export class GetSomething2 extends Req()("GetSomething2", {
+export const { TaggedRequestFor } = makeRpcClient(RequestContextMap);
+export const SomethingReq = TaggedRequestFor("Something");
+const SomethingQuery = SomethingReq.Query;
+const SomethingCommand = SomethingReq.Command;
+class SomethingGetSomething2 extends SomethingQuery()("GetSomething2", {
     id: S.String
-}, { success: S.NumberFromString }) {
+}, { success: S.FiniteFromString }) {
 }
-export class GetSomething2WithDependencies extends Req()("GetSomething2", {
+class SomethingGetSomething2WithDependencies extends SomethingQuery()("GetSomething2", {
     id: S.String
 }, {
     // this is intentilally fake, to simulate a codec that requires a dependency
-    success: S.NumberFromString,
+    success: S.FiniteFromString,
     error: S.String
 }) {
 }
-export const Something = { GetSomething2, GetSomething2WithDependencies, meta: { moduleName: "Something" } };
+class SomethingDoSomething extends SomethingCommand()("DoSomething", {
+    id: S.String
+}, { success: S.FiniteFromString }) {
+}
+// success schema has encoded shape { a: string | null } — used to test projection constraints
+class SomethingGetStructNullable extends SomethingQuery()("GetStructNullable", {}, {
+    success: S.Struct({ a: S.NullOr(S.String) })
+}) {
+}
+export const Something = {
+    GetSomething2: SomethingGetSomething2,
+    GetSomething2WithDependencies: SomethingGetSomething2WithDependencies,
+    DoSomething: SomethingDoSomething,
+    GetStructNullable: SomethingGetStructNullable
+};
+export const SomethingElseReq = TaggedRequestFor("SomethingElse");
+const SomethingElseQuery = SomethingElseReq.Query;
+class SomethingElseGetSomething2 extends SomethingElseQuery()("GetSomething2", {
+    id: S.String
+}, { success: S.FiniteFromString }) {
+}
+class SomethingElseGetSomething2WithDependencies extends SomethingElseQuery()("GetSomething2", {
+    id: S.String
+}, {
+    success: S.FiniteFromString,
+    error: S.String
+}) {
+}
+export const SomethingElse = {
+    GetSomething2: SomethingElseGetSomething2,
+    GetSomething2WithDependencies: SomethingElseGetSomething2WithDependencies
+};
 export const useClient = (options) => {
     const FakeIntlLayer = fakeIntlLayer(options?.messages);
     const FakeToastLayer = fakeToastLayer(options?.toasts);
     const CommanderLayer = Commander.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]));
     const WithToastLayer = WithToast.Default.pipe(Layer.provide(FakeToastLayer));
     const api = ApiClientFactory.layer({ url: "bogus", headers: Option.none() }).pipe(Layer.provide(FetchHttpClient.layer));
-    const lm = LegacyMutation.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]));
-    const layers = Layer.mergeAll(CommanderLayer, WithToastLayer, FakeToastLayer, FakeIntlLayer, api, lm);
+    const layers = Layer.mergeAll(CommanderLayer, WithToastLayer, FakeToastLayer, FakeIntlLayer, api);
     const clientFor_ = ApiClientFactory.makeFor(Layer.empty);
     return makeClient(() => ManagedRuntime.make(layers), clientFor_, Layer.empty);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stubs.js","sourceRoot":"","sources":["../stubs.ts"],"names":[],"mappings":"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"}

package/test/form-validation-errors.test.ts

@@ -4,7 +4,7 @@ import { buildFieldInfoFromFieldsRoot, translate } from "../src/form.js"
 // test schema with integer field
 class TestSchema extends S.Class<TestSchema>("TestSchema")({
   integerField: S.Int,
-  numberField: S.Number,
+  numberField: S.Finite,
   stringField: S.String
 }) {}
 
@@ -137,22 +137,26 @@ it("validates integer field with valid integer", () =>
     .pipe(Effect.runPromise))
 
 it("error message format matches regex pattern", () => {
-  // test the actual error message format from Effect Schema
-  const errorMessage = `Int
-└─ From side refinement failure
-   └─ Int
-      └─ Predicate refinement failure
-         └─ Expected an integer, actual 59.5`
-
-  const integerMatch = errorMessage.match(/Expected.*integer.*actual\s+(.+)/i)
-  expect(integerMatch).toBeTruthy()
-  expect(integerMatch![1]).toBe("59.5")
-
-  const numberErrorMessage = `Number
-└─ Type side transformation failure
-   └─ Expected a number, actual "not-a-number"`
-
-  const numberMatch = numberErrorMessage.match(/Expected.*number.*actual\s+(.+)/i)
-  expect(numberMatch).toBeTruthy()
-  expect(numberMatch![1]).toBe("\"not-a-number\"")
+  // test the actual error message format from Effect Schema (both old "actual" and new "got" formats)
+  const errorMessageOld = `Expected an integer, actual 59.5`
+  const errorMessageNew = `SchemaError(Expected an integer, got 59.5)`
+
+  const oldMatch = errorMessageOld.match(/Expected.*integer.*(?:actual|got)\s+([^)]+)/i)
+  expect(oldMatch).toBeTruthy()
+  expect(oldMatch![1]).toBe("59.5")
+
+  const newMatch = errorMessageNew.match(/Expected.*integer.*(?:actual|got)\s+([^)]+)/i)
+  expect(newMatch).toBeTruthy()
+  expect(newMatch![1]).toBe("59.5")
+
+  const numberErrorOld = `Expected a number, actual "not-a-number"`
+  const numberErrorNew = `SchemaError(Expected a finite number, got "not-a-number")`
+
+  const numOldMatch = numberErrorOld.match(/Expected.*number.*(?:actual|got)\s+([^)]+)/i)
+  expect(numOldMatch).toBeTruthy()
+  expect(numOldMatch![1]).toBe("\"not-a-number\"")
+
+  const numNewMatch = numberErrorNew.match(/Expected.*number.*(?:actual|got)\s+([^)]+)/i)
+  expect(numNewMatch).toBeTruthy()
+  expect(numNewMatch![1]).toBe("\"not-a-number\"")
 })

package/test/form.test.ts

@@ -1,5 +1,5 @@
 import { Effect, S } from "effect-app"
-import { buildFieldInfoFromFieldsRoot, type DiscriminatedUnionFieldInfo, type FieldInfo, type NestedFieldInfo, type UnionFieldInfo } from "../src/form.js"
+import { buildFieldInfoFromFieldsRoot, type DiscriminatedUnionFieldInfo, type FieldInfo, getMetadataFromSchema, type NestedFieldInfo, type UnionFieldInfo } from "../src/form.js"
 
 export class NestedSchema extends S.Class<NestedSchema>("NestedSchema")({
   shallow: S.String,
@@ -9,7 +9,11 @@ export class NestedSchema extends S.Class<NestedSchema>("NestedSchema")({
       deepest: S.Number
     })
   }),
-  age: S.Struct({ nfs: S.NumberFromString.pipe(S.decodeTo(S.PositiveInt)) })
+  age: S.Struct({ nfs: S.NumberFromString.pipe(S.decodeTo(S.PositiveInt)) }),
+  testNumber: S.Number,
+  testFinite: S.Finite,
+  testNullableNummber: S.NullOr(S.Number),
+  testOptionalNumber: S.optional(S.Number)
 }) {}
 
 export class SchemaContainsClass extends S.Class<SchemaContainsClass>("SchemaContainsClass")({
@@ -156,6 +160,15 @@ function testDiscriminatedUnionFieldInfo<T extends Record<PropertyKey, any>>(duf
   )
 }
 
+it("getMetadataFromSchema handles composed numeric schemas", () => {
+  expect(getMetadataFromSchema(S.Number.ast).type).toBe("float")
+  expect(getMetadataFromSchema(S.Finite.ast).type).toBe("float")
+  expect(getMetadataFromSchema(S.PositiveNumber.ast).type).toBe("float")
+  expect(getMetadataFromSchema(S.Int.ast).type).toBe("int")
+  expect(getMetadataFromSchema(S.PositiveInt.ast).type).toBe("int")
+  expect(getMetadataFromSchema(S.NullOr(S.Number).ast).type).toBe("float")
+})
+
 it("buildFieldInfo", () =>
   Effect
     .gen(function*() {
@@ -176,6 +189,11 @@ it("buildFieldInfo", () =>
       testNestedFieldInfo(nestedFieldinfo)
       testNestedFieldInfo(nestedFieldinfo.fields.nested)
       testNestedFieldInfo(nestedFieldinfo.fields.age)
+
+      expect(nestedFieldinfo.fields.testNumber.type).toBe("float")
+      expect(nestedFieldinfo.fields.testFinite.type).toBe("float")
+      expect(nestedFieldinfo.fields.testNullableNummber.type).toBe("float")
+      expect(nestedFieldinfo.fields.testOptionalNumber.type).toBe("float")
     })
     .pipe(Effect.runPromise))
 

package/test/makeClient.test.ts

@@ -1,95 +1,149 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Effect } from "effect-app"
-import { Something, useClient, useExperimental } from "./stubs.js"
-
-it.skip("works2", () => {
-  const { legacy } = useClient()
-  const n = legacy.useQuery({
-    Request: null as any,
-    handler: null as any as (a: string) => Effect.Effect<number>,
-    id: "id"
-  })
+import { S } from "effect-app"
+import { makeQueryKey } from "../src/lib.js"
+import { Something, SomethingElse, SomethingElseReq, SomethingReq, useClient, useExperimental } from "./stubs.js"
+
+it("TaggedRequestFor .moduleName and request .id / .moduleName", () => {
+  expectTypeOf(SomethingReq.moduleName).toEqualTypeOf<"Something">()
+  expectTypeOf(SomethingElseReq.moduleName).toEqualTypeOf<"SomethingElse">()
+
+  expectTypeOf(Something.GetSomething2.moduleName).toEqualTypeOf<"Something">()
+  expectTypeOf(Something.GetSomething2.id).toEqualTypeOf<"Something.GetSomething2">()
+  expectTypeOf(Something.GetSomething2.type).toEqualTypeOf<"query">()
+  expectTypeOf(Something.DoSomething.type).toEqualTypeOf<"command">()
+
+  expectTypeOf(SomethingElse.GetSomething2.moduleName).toEqualTypeOf<"SomethingElse">()
+  expectTypeOf(SomethingElse.GetSomething2.id).toEqualTypeOf<"SomethingElse.GetSomething2">()
+})
+
+it.skip("query type tests", () => {
+  const { clientFor } = useClient()
+  const client = clientFor(Something, () => ({
+    GetSomething2WithDependencies: (queryKey) => [
+      { filters: { queryKey } },
+      {
+        filters: {
+          queryKey: makeQueryKey(
+            SomethingElse
+              .GetSomething2
+          )
+        }
+      }
+    ]
+  }))
+
+  const q = client.GetSomething2.query
 
-  const [, z] = n("a")
+  const [, z] = q({ id: "a" })
   const valz = z.value
   expectTypeOf(valz).toEqualTypeOf<number | undefined>()
 
-  const [, a] = n("a", { placeholderData: () => 123 })
+  const [, a] = q({ id: "a" }, { placeholderData: () => 123 })
   const val1 = a.value
   expectTypeOf(val1).toEqualTypeOf<number>()
 
-  const [, bbbb] = n("a", { select: (data) => data.toString() })
+  const [, bbbb] = q({ id: "a" }, { select: (data) => data.toString() })
   const val = bbbb.value
   expectTypeOf(val).toEqualTypeOf<string | undefined>()
 
-  const [, ccc] = n("a", { placeholderData: () => 123, select: (data) => data.toString() })
+  const [, ccc] = q({ id: "a" }, { placeholderData: () => 123, select: (data) => data.toString() })
   const val2 = ccc.value
   expectTypeOf(val2).toEqualTypeOf<string>()
 
-  const [, ddd] = n("a", { initialData: 123, select: (data) => data.toString() })
+  const [, ddd] = q({ id: "a" }, { initialData: 123, select: (data) => data.toString() })
   const val3 = ddd.value
   expectTypeOf(val3).toEqualTypeOf<string>()
 
-  const [, eee] = n("a", { initialData: 123, placeholderData: () => 123, select: (data) => data.toString() })
+  const [, eee] = q({ id: "a" }, { initialData: 123, placeholderData: () => 123, select: (data) => data.toString() })
   const val4 = eee.value
   expectTypeOf(val4).toEqualTypeOf<string>()
 })
 
 it.skip("works", () => {
-  const { clientFor, legacy } = useClient()
+  const { clientFor } = useClient()
   const client = clientFor(Something)
   const Command = useExperimental()
 
   // just for jsdoc / type testing.
-  const a0 = client.GetSomething2(null as any)
-  const a00 = client.GetSomething2.mutate(null as any)
+  const a0 = client.GetSomething2.request(null as any)
+  const a00 = client.DoSomething.mutate(null as any)
   const a = client.GetSomething2.suspense(null as any)
   const b = client.GetSomething2.query(null as any)
 
-  const c0 = legacy.useSafeMutation(null as any)
-  const c = legacy.useQuery(null as any)
-  const d = legacy.useSuspenseQuery(null as any)
-
+  // @ts-expect-error query requests no longer expose command helpers
   const e = client.GetSomething2.wrap(null as any)
+  // @ts-expect-error query requests no longer expose command helpers
   const f = client.GetSomething2.fn(null as any)
 
-  // @ts-expect-error dependencies required that are not provided
-  const e0 = client.GetSomething2WithDependencies.wrap().handle // not available as we require dependencies not provided by the runtime
-  // @ts-expect-error dependencies required that are not provided
-  const e000 = Command.wrap(client.GetSomething2WithDependencies)().handle // not available as we require dependencies not provided by the runtime
-  const e00 = client.GetSomething2WithDependencies.wrap((_) => _ as Effect.Effect<number, never, never>).handle(
-    null as any
-  )
-  const e0000 =
-    Command.wrap(client.GetSomething2WithDependencies)((_) => _ as Effect.Effect<number, never, never>).handle
+  // @ts-expect-error query requests no longer expose command helpers
+  const e0 = client.GetSomething2WithDependencies.wrap
+  // @ts-expect-error query request does not match Command.wrap mutation signature
+  const e000 = Command.wrap(client.GetSomething2WithDependencies)
+  const e00 = client.GetSomething2WithDependencies.request(null as any)
   // @ts-expect-error dependencies required that are not provided
   const e1 = client.GetSomething2WithDependencies.suspense(null as any)
   // @ts-expect-error dependencies required that are not provided
   const e2 = client.GetSomething2WithDependencies.query(null as any)
+  // @ts-expect-error query requests no longer expose command helpers
   const f0 = client.GetSomething2WithDependencies.fn(null as any)
 
-  const g = client.GetSomething2.mutate.wrap(null as any)
-  const h = client.GetSomething2.mutate.fn(null as any)
+  const g0 = client.DoSomething.wrap(null as any)
+  const g = client.DoSomething.mutate.wrap(null as any)
+  const g1 = client.DoSomething.mutate.project(S.String)
+  const g2 = g1(null as any)
+  const g3 = g1.wrap(null as any)
+  const g4 = client.helpers.doSomethingMutation.project(S.String)
+  const g5 = g4(null as any)
+  const g6 = g4.wrap(null as any)
+  // @ts-expect-error mutate no longer exposes fn, use client.DoSomething.fn
+  const h = client.DoSomething.mutate.fn(null as any)
+
+  // projection
+  // GetSomething2 uses FiniteFromString, that means Codec is String -> Number
+  // when we project that to S.String, it should work as the encoded shapes are identical
+  // aka, when we project, we skip decoding with the original codec, and instead use the provided one
+  // we have to make sure the Encoded shape of the provided projection schema matches the Encoded Shape of the original codec.
+  const projected = client.GetSomething2.project(S.String)
+  // @ts-expect-error encoded type mismatch: original encodes to string, S.Number encodes to number
+  const _projectedBad = client.GetSomething2.project(S.Number)
+  const p0 = projected.request(null as any)
+
+  // struct example: success schema encodes to { a: string | null }
+  // good: projection schema also expects { a: string | null } on the encoded side
+  const projectedStruct = client.GetStructNullable.project(S.Struct({ a: S.NullOr(S.String) }))
+  // bad: { a: S.String } has encoded type { a: string } — does not accept null
+  // @ts-expect-error encoded type mismatch: original encodes to { a: string | null }, projection expects { a: string }
+  const _projectedStructBad = client.GetStructNullable.project(S.Struct({ a: S.String }))
+
+  const p00 = projected.query(null as any)
+  const p = projected.suspense(null as any)
 
   expect(true).toBe(true)
   console.log({
     a,
     a0,
     a00,
-    c0,
     b,
-    c,
-    d,
     e,
     e0,
     e00,
     e000,
-    e0000,
     e1,
     e2,
     f,
     f0,
+    g0,
     g,
-    h
+    g1,
+    g2,
+    g3,
+    g4,
+    g5,
+    g6,
+    h,
+    p0,
+    p00,
+    p,
+    projectedStruct
   })
 })

package/test/stubs.ts

@@ -6,13 +6,13 @@ import { ApiClientFactory, makeRpcClient } from "effect-app/client"
 import { RpcContextMap } from "effect-app/rpc"
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient"
 import { ref } from "vue"
-import { Commander } from "../src/experimental/commander.js"
-import { I18n } from "../src/experimental/intl.js"
-import { makeUseCommand } from "../src/experimental/makeUseCommand.js"
-import * as Toast from "../src/experimental/toast.js"
-import { WithToast } from "../src/experimental/withToast.js"
-import { LegacyMutation, makeClient } from "../src/makeClient.js"
+import { Commander } from "../src/commander.js"
+import { I18n } from "../src/intl.js"
+import { makeClient } from "../src/makeClient.js"
 import { type MakeIntlReturn } from "../src/makeIntl.js"
+import { makeUseCommand } from "../src/makeUseCommand.js"
+import * as Toast from "../src/toast.js"
+import { WithToast } from "../src/withToast.js"
 
 const fakeToastLayer = (toasts: any[] = []) =>
   Layer.effect(
@@ -26,33 +26,34 @@ const fakeToastLayer = (toasts: any[] = []) =>
           toasts.splice(idx, 1)
         }
       }
-      const fakeToast = (message: string, options?: Toast.ToastOpts) => {
-        const id = options?.id ?? Math.random().toString(36).substring(2, 15)
-        console.log(`Toast [${id}]: ${message}`, options)
+      const fakeToast =
+        (type: "error" | "warning" | "success" | "info") => (message: string, options?: Toast.ToastOpts) => {
+          const id = options?.id ?? Math.random().toString(36).substring(2, 15)
+          console.log(`Toast [${type}][${id}]: ${message}`, options)
 
-        options = { ...options, id }
-        const idx = toasts.findIndex((_) => _.id === id)
-        if (idx > -1) {
-          const toast = toasts[idx]
-          clearTimeout(toast.timeoutId)
-          Object.assign(toast, { message, options })
-          toast.timeoutId = setTimeout(() => {
-            toasts.splice(idx, 1)
-          }, options?.timeout ?? 3000)
-        } else {
-          const toast: any = { id, message, options }
-          toast.timeoutId = setTimeout(() => {
-            toasts.splice(idx, 1)
-          }, options?.timeout ?? 3000)
-          toasts.push(toast)
+          options = { ...options, id }
+          const idx = toasts.findIndex((_) => _.id === id)
+          if (idx > -1) {
+            const toast = toasts[idx]
+            clearTimeout(toast.timeoutId)
+            Object.assign(toast, { type, message, options })
+            toast.timeoutId = setTimeout(() => {
+              toasts.splice(idx, 1)
+            }, options?.timeout ?? 3000)
+          } else {
+            const toast: any = { id, type, message, options }
+            toast.timeoutId = setTimeout(() => {
+              toasts.splice(idx, 1)
+            }, options?.timeout ?? 3000)
+            toasts.push(toast)
+          }
+          return id
         }
-        return id
-      }
       return Toast.Toast.of(Toast.wrap({
-        error: fakeToast,
-        warning: fakeToast,
-        success: fakeToast,
-        info: fakeToast,
+        error: fakeToast("error"),
+        warning: fakeToast("warning"),
+        success: fakeToast("success"),
+        info: fakeToast("info"),
         dismiss
       })) as any
     })
@@ -92,20 +93,62 @@ export const useExperimental = (
 }
 
 export class RequestContextMap extends RpcContextMap.makeMap({}) {}
-export const { TaggedRequest: Req } = makeRpcClient(RequestContextMap)
-export class GetSomething2 extends Req<GetSomething2>()("GetSomething2", {
+export const { TaggedRequestFor } = makeRpcClient(RequestContextMap)
+
+export const SomethingReq = TaggedRequestFor("Something")
+const SomethingQuery = SomethingReq.Query
+const SomethingCommand = SomethingReq.Command
+
+class SomethingGetSomething2 extends SomethingQuery<SomethingGetSomething2>()("GetSomething2", {
   id: S.String
-}, { success: S.NumberFromString }) {}
+}, { success: S.FiniteFromString }) {}
+
+class SomethingGetSomething2WithDependencies
+  extends SomethingQuery<SomethingGetSomething2WithDependencies>()("GetSomething2", {
+    id: S.String
+  }, {
+    // this is intentilally fake, to simulate a codec that requires a dependency
+    success: S.FiniteFromString as S.Codec<number, string, "dep-a">,
+    error: S.String
+  })
+{}
 
-export class GetSomething2WithDependencies extends Req<GetSomething2WithDependencies>()("GetSomething2", {
+class SomethingDoSomething extends SomethingCommand<SomethingDoSomething>()("DoSomething", {
   id: S.String
-}, {
-  // this is intentilally fake, to simulate a codec that requires a dependency
-  success: S.NumberFromString as S.Codec<number, string, "dep-a">,
-  error: S.String
+}, { success: S.FiniteFromString }) {}
+
+// success schema has encoded shape { a: string | null } — used to test projection constraints
+class SomethingGetStructNullable extends SomethingQuery<SomethingGetStructNullable>()("GetStructNullable", {}, {
+  success: S.Struct({ a: S.NullOr(S.String) })
 }) {}
 
-export const Something = { GetSomething2, GetSomething2WithDependencies, meta: { moduleName: "Something" as const } }
+export const Something = {
+  GetSomething2: SomethingGetSomething2,
+  GetSomething2WithDependencies: SomethingGetSomething2WithDependencies,
+  DoSomething: SomethingDoSomething,
+  GetStructNullable: SomethingGetStructNullable
+}
+
+export const SomethingElseReq = TaggedRequestFor("SomethingElse")
+const SomethingElseQuery = SomethingElseReq.Query
+
+class SomethingElseGetSomething2 extends SomethingElseQuery<SomethingElseGetSomething2>()("GetSomething2", {
+  id: S.String
+}, { success: S.FiniteFromString }) {}
+
+class SomethingElseGetSomething2WithDependencies
+  extends SomethingElseQuery<SomethingElseGetSomething2WithDependencies>()("GetSomething2", {
+    id: S.String
+  }, {
+    success: S.FiniteFromString as S.Codec<number, string, "dep-a">,
+    error: S.String
+  })
+{}
+
+export const SomethingElse = {
+  GetSomething2: SomethingElseGetSomething2,
+  GetSomething2WithDependencies: SomethingElseGetSomething2WithDependencies
+}
 
 export const useClient = (
   options?: { messages?: Record<string, string> | Record<string, MessageFormatElement[]>; toasts: any[] }
@@ -117,8 +160,7 @@ export const useClient = (
   const api = ApiClientFactory.layer({ url: "bogus", headers: Option.none() }).pipe(
     Layer.provide(FetchHttpClient.layer)
   )
-  const lm = LegacyMutation.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]))
-  const layers = Layer.mergeAll(CommanderLayer, WithToastLayer, FakeToastLayer, FakeIntlLayer, api, lm)
+  const layers = Layer.mergeAll(CommanderLayer, WithToastLayer, FakeToastLayer, FakeIntlLayer, api)
 
   const clientFor_ = ApiClientFactory.makeFor(Layer.empty)
   return makeClient(() => ManagedRuntime.make(layers), clientFor_, Layer.empty)

package/tsconfig.json

@@ -32,7 +32,6 @@
     "outDir": "build/dist",
     "resolveJsonModule": true,
     "moduleResolution": "Node16",
-    "downlevelIteration": true,
     "noErrorTruncation": true,
     "forceConsistentCasingInFileNames": true,
     "types": [

package/tsconfig.json.bak

@@ -8,5 +8,5 @@
     {
       "path": "./tsconfig.test.json"
     }
-  ],
-}
+  ]
+}