@effect-app/vue 4.0.0-beta.15 → 4.0.0-beta.151

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,56 @@ 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 }) {
+}
+export const Something = {
+    GetSomething2: SomethingGetSomething2,
+    GetSomething2WithDependencies: SomethingGetSomething2WithDependencies,
+    DoSomething: SomethingDoSomething
+};
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R1YnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zdHVicy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssSUFBSSxNQUFNLGdCQUFnQixDQUFBO0FBQ3RDLE9BQU8sRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsQ0FBQyxFQUFFLE1BQU0sWUFBWSxDQUFBO0FBQ3JFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUNuRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFDOUMsT0FBTyxLQUFLLGVBQWUsTUFBTSxzQ0FBc0MsQ0FBQTtBQUN2RSxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sS0FBSyxDQUFBO0FBQ3pCLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQTtBQUM1RCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sNkJBQTZCLENBQUE7QUFDbEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHVDQUF1QyxDQUFBO0FBQ3RFLE9BQU8sS0FBSyxLQUFLLE1BQU0sOEJBQThCLENBQUE7QUFDckQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGtDQUFrQyxDQUFBO0FBQzVELE9BQU8sRUFBRSxjQUFjLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUE7QUFHakUsTUFBTSxjQUFjLEdBQUcsQ0FBQyxTQUFnQixFQUFFLEVBQUUsRUFBRSxDQUM1QyxLQUFLLENBQUMsTUFBTSxDQUNWLEtBQUssQ0FBQyxLQUFLLEVBQ1gsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUU7SUFDZixNQUFNLE9BQU8sR0FBRyxDQUFDLEVBQWlCLEVBQUUsRUFBRTtRQUNwQyxNQUFNLEdBQUcsR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFBO1FBQ2hELElBQUksR0FBRyxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDYixNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDekIsWUFBWSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQTtZQUM3QixNQUFNLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQTtRQUN2QixDQUFDO0lBQ0gsQ0FBQyxDQUFBO0lBQ0QsTUFBTSxTQUFTLEdBQUcsQ0FBQyxPQUFlLEVBQUUsT0FBeUIsRUFBRSxFQUFFO1FBQy9ELE1BQU0sRUFBRSxHQUFHLE9BQU8sRUFBRSxFQUFFLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFBO1FBQ3JFLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLE1BQU0sT0FBTyxFQUFFLEVBQUUsT0FBTyxDQUFDLENBQUE7UUFFakQsT0FBTyxHQUFHLEVBQUUsR0FBRyxPQUFPLEVBQUUsRUFBRSxFQUFFLENBQUE7UUFDNUIsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQTtRQUNoRCxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQ2IsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ3pCLFlBQVksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUE7WUFDN0IsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQTtZQUMxQyxLQUFLLENBQUMsU0FBUyxHQUFHLFVBQVUsQ0FBQyxHQUFHLEVBQUU7Z0JBQ2hDLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFBO1lBQ3ZCLENBQUMsRUFBRSxPQUFPLEVBQUUsT0FBTyxJQUFJLElBQUksQ0FBQyxDQUFBO1FBQzlCLENBQUM7YUFBTSxDQUFDO1lBQ04sTUFBTSxLQUFLLEdBQVEsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFBO1lBQzNDLEtBQUssQ0FBQyxTQUFTLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRTtnQkFDaEMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUE7WUFDdkIsQ0FBQyxFQUFFLE9BQU8sRUFBRSxPQUFPLElBQUksSUFBSSxDQUFDLENBQUE7WUFDNUIsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQTtRQUNwQixDQUFDO1FBQ0QsT0FBTyxFQUFFLENBQUE7SUFDWCxDQUFDLENBQUE7SUFDRCxPQUFPLEtBQUssQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUM7UUFDL0IsS0FBSyxFQUFFLFNBQVM7UUFDaEIsT0FBTyxFQUFFLFNBQVM7UUFDbEIsT0FBTyxFQUFFLFNBQVM7UUFDbEIsSUFBSSxFQUFFLFNBQVM7UUFDZixPQUFPO0tBQ1IsQ0FBQyxDQUFRLENBQUE7QUFDWixDQUFDLENBQUMsQ0FDSCxDQUFBO0FBRUgsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsV0FBNEUsRUFBRSxFQUFFLEVBQUU7SUFDN0csTUFBTSxNQUFNLEdBQUcsR0FBRyxDQUFDLElBQWEsQ0FBQyxDQUFBO0lBQ2pDLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQTtJQUN4QyxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFzQjtRQUNoRCxNQUFNLEVBQUUsTUFBTSxDQUFDLEtBQUs7UUFDcEIsUUFBUTtLQUNULEVBQUUsU0FBUyxDQUFDLENBQUE7SUFFYixPQUFPO1FBQ0wsTUFBTTtRQUNOLElBQUk7UUFDSixLQUFLLEVBQUUsQ0FBQyxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsTUFBTSxDQUFDO1FBQ3pELElBQUksYUFBYTtZQUNmLE9BQU8sSUFBSSxDQUFDLGFBQWEsQ0FBQTtRQUMzQixDQUFDO0tBQytDLENBQUE7QUFDcEQsQ0FBQyxDQUFBO0FBRUQsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLENBQUMsV0FBNEUsRUFBRSxFQUFFLEVBQUUsQ0FDOUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQUV4RSxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsQ0FDN0IsT0FBdUcsRUFDdkcsRUFBRTtJQUNGLE1BQU0sYUFBYSxHQUFHLGFBQWEsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUE7SUFDdEQsTUFBTSxjQUFjLEdBQUcsY0FBYyxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQTtJQUN0RCxNQUFNLGNBQWMsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsYUFBYSxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUM3RixNQUFNLGNBQWMsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUE7SUFDNUUsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQyxjQUFjLEVBQUUsY0FBYyxFQUFFLGNBQWMsRUFBRSxhQUFhLENBQUMsQ0FBQTtJQUU1RixPQUFPLE1BQU0sQ0FBQyxPQUFPLENBQUMsY0FBYyxDQUFpQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBQ2pILENBQUMsQ0FBQTtBQUVELE1BQU0sT0FBTyxpQkFBa0IsU0FBUSxhQUFhLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztDQUFHO0FBQ25FLE1BQU0sQ0FBQyxNQUFNLEVBQUUsYUFBYSxFQUFFLEdBQUcsRUFBRSxHQUFHLGFBQWEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFBO0FBQ3RFLE1BQU0sT0FBTyxhQUFjLFNBQVEsR0FBRyxFQUFpQixDQUFDLGVBQWUsRUFBRTtJQUN2RSxFQUFFLEVBQUUsQ0FBQyxDQUFDLE1BQU07Q0FDYixFQUFFLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0NBQUc7QUFFdEMsTUFBTSxPQUFPLDZCQUE4QixTQUFRLEdBQUcsRUFBaUMsQ0FBQyxlQUFlLEVBQUU7SUFDdkcsRUFBRSxFQUFFLENBQUMsQ0FBQyxNQUFNO0NBQ2IsRUFBRTtJQUNELDRFQUE0RTtJQUM1RSxPQUFPLEVBQUUsQ0FBQyxDQUFDLGdCQUFvRDtJQUMvRCxLQUFLLEVBQUUsQ0FBQyxDQUFDLE1BQU07Q0FDaEIsQ0FBQztDQUFHO0FBRUwsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLEVBQUUsYUFBYSxFQUFFLDZCQUE2QixFQUFFLElBQUksRUFBRSxFQUFFLFVBQVUsRUFBRSxXQUFvQixFQUFFLEVBQUUsQ0FBQTtBQUVySCxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsQ0FDdkIsT0FBdUcsRUFDdkcsRUFBRTtJQUNGLE1BQU0sYUFBYSxHQUFHLGFBQWEsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUE7SUFDdEQsTUFBTSxjQUFjLEdBQUcsY0FBYyxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQTtJQUN0RCxNQUFNLGNBQWMsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsYUFBYSxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUM3RixNQUFNLGNBQWMsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUE7SUFDNUUsTUFBTSxHQUFHLEdBQUcsZ0JBQWdCLENBQUMsS0FBSyxDQUFDLEVBQUUsR0FBRyxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQy9FLEtBQUssQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUNyQyxDQUFBO0lBQ0QsTUFBTSxFQUFFLEdBQUcsY0FBYyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLGFBQWEsRUFBRSxjQUFjLENBQUMsQ0FBQyxDQUFDLENBQUE7SUFDdEYsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQyxjQUFjLEVBQUUsY0FBYyxFQUFFLGNBQWMsRUFBRSxhQUFhLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFBO0lBRXJHLE1BQU0sVUFBVSxHQUFHLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDeEQsT0FBTyxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxVQUFVLEVBQUUsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFBO0FBQy9FLENBQUMsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,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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,94 +1,109 @@
 /* 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 { 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">()
+})
 
-  const [, z] = n("a")
+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] = 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)
   // @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)
+  // @ts-expect-error mutate no longer exposes fn, use client.DoSomething.fn
+  const h = client.DoSomething.mutate.fn(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
   })

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,21 +26,21 @@ const fakeToastLayer = (toasts: any[] = []) =>
           toasts.splice(idx, 1)
         }
       }
-      const fakeToast = (message: string, options?: Toast.ToastOpts) => {
+      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 [${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: any = { id, message, options }
+          const toast: any = { id, type, message, options }
           toast.timeoutId = setTimeout(() => {
             toasts.splice(idx, 1)
           }, options?.timeout ?? 3000)
@@ -49,10 +49,10 @@ const fakeToastLayer = (toasts: any[] = []) =>
         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 +92,56 @@ 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.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
+  })
+{}
+
+class SomethingDoSomething extends SomethingCommand<SomethingDoSomething>()("DoSomething", {
   id: S.String
-}, { success: S.NumberFromString }) {}
+}, { success: S.FiniteFromString }) {}
 
-export class GetSomething2WithDependencies extends Req<GetSomething2WithDependencies>()("GetSomething2", {
+export const Something = {
+  GetSomething2: SomethingGetSomething2,
+  GetSomething2WithDependencies: SomethingGetSomething2WithDependencies,
+  DoSomething: SomethingDoSomething
+}
+
+export const SomethingElseReq = TaggedRequestFor("SomethingElse")
+const SomethingElseQuery = SomethingElseReq.Query
+
+class SomethingElseGetSomething2 extends SomethingElseQuery<SomethingElseGetSomething2>()("GetSomething2", {
   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 }) {}
 
-export const Something = { GetSomething2, GetSomething2WithDependencies, meta: { moduleName: "Something" as const } }
+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 +153,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": [