@diphyx/harlemify 6.3.1 → 6.4.1

package/README.md

@@ -99,8 +99,6 @@ await execute();
 | Vue        | `^3.5.0`              |
 | Zod        | `^4.0.0`              |
 
-> **Note:** Early Nuxt 4 versions (e.g., 4.1.x) may have issues resolving the `#build` alias for module templates. If you encounter build errors related to `#build/harlemify.config`, upgrade to the latest Nuxt 4 release.
-
 ## Documentation
 
 [https://diphyx.github.io/harlemify/](https://diphyx.github.io/harlemify/)

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^3.14.0 || ^4.0.0"
   },
-  "version": "6.3.1",
+  "version": "6.4.1",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

package/dist/runtime/composables/action.d.ts

@@ -3,6 +3,13 @@ import { ActionStatus, type ActionCall, type ActionApiCall, type ActionHandlerCa
 export interface UseStoreActionOptions {
     isolated?: boolean;
 }
+type ResolveCallOptions<C> = C extends ActionHandlerCall<infer P, any> ? ActionHandlerCallOptions<P> : C extends ActionApiCall<any> ? ActionApiCallOptions : ActionCallOptions;
+export type IsolatedActionCall<C> = C extends ActionHandlerCall<infer P, any> ? {
+    payload: Readonly<Ref<P | undefined>>;
+} : C extends ActionApiCall<any> ? {
+    params: Readonly<Ref<Record<string, string | number> | undefined>>;
+    query: Readonly<Ref<Record<string, unknown> | undefined>>;
+} : object;
 export type UseStoreAction<T, O = ActionCallOptions> = {
     execute: (options?: Omit<O, "bind">) => Promise<T>;
     error: Readonly<Ref<Error | null>>;
@@ -14,4 +21,10 @@ export declare function useIsolatedActionError(): Ref<Error | null>;
 export declare function useIsolatedActionStatus(): Ref<ActionStatus>;
 export declare function useStoreAction<A extends Record<string, ActionCall<any>>, K extends keyof A & string, T = Awaited<ReturnType<A[K]>>>(store: {
     action: A;
-}, key: K, options?: UseStoreActionOptions): UseStoreAction<T, A[K] extends ActionHandlerCall<infer P, any> ? ActionHandlerCallOptions<P> : A[K] extends ActionApiCall<any> ? ActionApiCallOptions : ActionCallOptions>;
+}, key: K, options: UseStoreActionOptions & {
+    isolated: true;
+}): UseStoreAction<T, ResolveCallOptions<A[K]>> & IsolatedActionCall<A[K]>;
+export declare function useStoreAction<A extends Record<string, ActionCall<any>>, K extends keyof A & string, T = Awaited<ReturnType<A[K]>>>(store: {
+    action: A;
+}, key: K, options?: UseStoreActionOptions): UseStoreAction<T, ResolveCallOptions<A[K]>>;
+export {};

package/dist/runtime/composables/action.js

@@ -2,6 +2,7 @@ import { ref, computed } from "vue";
 import {
   ActionStatus
 } from "../core/types/action.js";
+import { snapshot } from "../core/utils/base.js";
 export function useIsolatedActionError() {
   return ref(null);
 }
@@ -13,6 +14,9 @@ export function useStoreAction(store, key, options) {
   if (!action) {
     throw new Error(`Action "${key}" not found in store`);
   }
+  const params = ref();
+  const query = ref();
+  const payload = ref();
   let error;
   let status;
   let loading;
@@ -28,6 +32,9 @@ export function useStoreAction(store, key, options) {
     reset = () => {
       isolatedStatus.value = ActionStatus.IDLE;
       isolatedError.value = null;
+      params.value = void 0;
+      query.value = void 0;
+      payload.value = void 0;
     };
   } else {
     error = action.error;
@@ -41,6 +48,12 @@ export function useStoreAction(store, key, options) {
         status,
         error
       };
+      if (!loading.value) {
+        const isolatedCall = callOptions;
+        params.value = snapshot(isolatedCall.params);
+        query.value = snapshot(isolatedCall.query);
+        payload.value = snapshot(isolatedCall.payload);
+      }
     }
     return action(callOptions);
   }
@@ -49,6 +62,9 @@ export function useStoreAction(store, key, options) {
     error,
     status,
     loading,
-    reset
+    reset,
+    params,
+    query,
+    payload
   };
 }

package/dist/runtime/composables/view.d.ts

@@ -13,3 +13,6 @@ export type UseStoreView<T> = {
 export declare function useStoreView<V extends Record<string, ViewCall>, K extends keyof V & string, T = V[K] extends ComputedRef<infer R> ? R : unknown>(store: {
     view: V;
 }, key: K): UseStoreView<T>;
+export declare function useStoreView<V extends Record<string, ViewCall>, K extends keyof V & string, R, T = V[K] extends ComputedRef<infer U> ? U : unknown>(store: {
+    view: V;
+}, key: K, resolver: (value: T) => R): UseStoreView<R>;

package/dist/runtime/composables/view.js

@@ -1,11 +1,11 @@
-import { watch } from "vue";
+import { computed, watch } from "vue";
 import { debounce, throttle } from "../core/utils/base.js";
-export function useStoreView(store, key) {
+export function useStoreView(store, key, resolver) {
   if (!store.view[key]) {
     throw new Error(`View "${key}" not found in store`);
   }
   const source = store.view[key];
-  const data = source;
+  const data = resolver ? computed(() => resolver(source.value)) : source;
   function resolveCallback(callback, callbackOptions) {
     if (callbackOptions?.debounce) {
       return debounce(callback, callbackOptions.debounce);
@@ -18,7 +18,7 @@ export function useStoreView(store, key) {
   function track(handler, trackOptions) {
     const callback = resolveCallback(handler, trackOptions);
     const stop = watch(
-      source,
+      data,
       (value) => {
         callback(value);
       },

package/dist/runtime/core/types/action.d.ts

@@ -44,6 +44,7 @@ export interface ActionApiRequest<MD extends ModelDefinitions, VD extends ViewDe
     body?: ActionApiRequestValue<MD, VD, unknown>;
     timeout?: ActionApiRequestValue<MD, VD, number>;
     concurrent?: ActionConcurrent;
+    hooks?: ActionHooks;
 }
 export type ActionApiRequestShortcut<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Omit<ActionApiRequest<MD, VD>, "method">;
 export interface ActionApiCommitContext<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
@@ -129,12 +130,32 @@ export interface ActionResolvedApi {
     timeout?: number;
     signal: AbortSignal;
 }
+export interface ActionHookRequest extends ActionResolvedApi {
+    error?: Error;
+}
+export interface ActionHookResponse {
+    status: number;
+    headers: Record<string, string>;
+    data: unknown;
+}
+export interface ActionHookPreContext {
+    request: Readonly<ActionResolvedApi>;
+}
+export interface ActionHookPostContext {
+    request: Readonly<ActionHookRequest>;
+    response?: Readonly<ActionHookResponse>;
+}
+export interface ActionHooks {
+    pre?: (context: ActionHookPreContext) => void | Promise<void>;
+    post?: (context: ActionHookPostContext) => void | Promise<void>;
+}
 export interface ActionCallTransformerOptions {
     request?: (api: ActionResolvedApi) => ActionResolvedApi;
     response?: (data: unknown) => unknown;
 }
 export interface ActionCallCommitOptions {
     mode?: ModelOneMode | ModelManyMode | Record<string, ModelOneMode | ModelManyMode>;
+    options?: ModelOneCommitOptions | ModelManyCommitOptions | Record<string, ModelOneCommitOptions | ModelManyCommitOptions>;
 }
 export interface ActionApiCallOptions extends ActionCallBaseOptions {
     params?: Record<string, string | number>;

package/dist/runtime/core/utils/action.js

@@ -96,6 +96,19 @@ function resolveCommitMode(commit, options) {
   }
   return commit.mode;
 }
+function resolveCommitOptions(commit, options) {
+  const override = options?.commit?.options;
+  if (!override) {
+    return commit.options;
+  }
+  const values = Object.values(override);
+  const perModel = values.length > 0 && values.every((value) => isPlainObject(value));
+  const resolved = perModel ? override[commit.model] : override;
+  if (!resolved) {
+    return commit.options;
+  }
+  return merge(resolved, commit.options);
+}
 function resolveCommitTransform(commit, data, context) {
   if (typeof commit.transform === "function") {
     return commit.transform(data, context);
@@ -120,6 +133,25 @@ function resolveConcurrent(definition, options) {
   }
   return ActionConcurrent.BLOCK;
 }
+async function executeHook(definition, hooks, key, context) {
+  const hook = hooks?.[key];
+  if (!hook) {
+    return;
+  }
+  definition.logger?.debug("Action API hook", {
+    action: definition.key,
+    hook: key
+  });
+  try {
+    await hook(context);
+  } catch (error) {
+    definition.logger?.error("Action API hook error", {
+      action: definition.key,
+      hook: key,
+      error
+    });
+  }
+}
 async function executeApi(definition, api, options) {
   try {
     definition.logger?.debug("Action API request", {
@@ -137,7 +169,31 @@ async function executeApi(definition, api, options) {
       body: api.body,
       timeout: api.timeout,
       signal: api.signal,
-      responseType: "json"
+      responseType: "json",
+      async onRequest() {
+        await executeHook(definition, definition.request.hooks, "pre", {
+          request: api
+        });
+      },
+      async onResponse({ response: response2 }) {
+        await executeHook(definition, definition.request.hooks, "post", {
+          request: api,
+          response: {
+            status: response2.status,
+            headers: Object.fromEntries(response2.headers),
+            data: response2._data
+          }
+        });
+      },
+      async onRequestError({ error }) {
+        await executeHook(definition, definition.request.hooks, "post", {
+          request: {
+            ...api,
+            error
+          }
+        });
+        throw error;
+      }
     });
     definition.logger?.debug("Action API response received", {
       action: definition.key,
@@ -191,11 +247,12 @@ function executeCommit(definition, model, data, context, options) {
         });
       }
       const mode = resolveCommitMode(commit, options);
+      const commitOptions = resolveCommitOptions(commit, options);
       let value = resolveCommitTransform(commit, data, context);
       if (!isEmptyRecord(target.aliases())) {
         value = resolveAliasInbound(value, target.aliases());
       }
-      plan.push({ commit, target, mode, value });
+      plan.push({ commit, target, mode, options: commitOptions, value });
     }
   } catch (error) {
     const commitError = toError(error, ActionCommitError);
@@ -213,7 +270,7 @@ function executeCommit(definition, model, data, context, options) {
       mode: entry.mode
     });
     try {
-      entry.target.commit(entry.mode, entry.value, entry.commit.options);
+      entry.target.commit(entry.mode, entry.value, entry.options);
     } catch (error) {
       const commitError = toError(error, ActionCommitError);
       definition.logger?.error("Action commit error", {

package/dist/runtime/index.d.ts

@@ -7,13 +7,13 @@ export type { ModelOneCommitOptions, ModelManyCommitOptions } from "./core/types
 export { ViewClone } from "./core/types/view.js";
 export type { ViewDefinitionOptions } from "./core/types/view.js";
 export { ActionStatus, ActionConcurrent, ActionType, ActionApiMethod } from "./core/types/action.js";
-export type { ActionCall, ActionApiCall, ActionApiCommitContext, ActionHandlerCall, ActionCallOptions, ActionCallBaseOptions, ActionApiCallOptions, ActionHandlerCallOptions, ActionCallTransformerOptions, ActionCallBindOptions, ActionCallCommitOptions, ActionHandlerOptions, ActionResolvedApi, } from "./core/types/action.js";
+export type { ActionCall, ActionApiCall, ActionApiCommitContext, ActionHandlerCall, ActionCallOptions, ActionCallBaseOptions, ActionApiCallOptions, ActionHandlerCallOptions, ActionCallTransformerOptions, ActionCallBindOptions, ActionCallCommitOptions, ActionHandlerOptions, ActionResolvedApi, ActionHooks, ActionHookPreContext, ActionHookPostContext, ActionHookRequest, ActionHookResponse, } from "./core/types/action.js";
 export { ActionApiError, ActionHandlerError, ActionCommitError, ActionConcurrentError, isError, toError, } from "./core/utils/error.js";
 export type { ComposeCallback, ComposeCall, ComposeDefinitions, ComposeContext, StoreCompose, } from "./core/types/compose.js";
 export { useStoreCompose } from "./composables/compose.js";
 export type { UseStoreCompose } from "./composables/compose.js";
 export { useIsolatedActionStatus, useIsolatedActionError, useStoreAction } from "./composables/action.js";
-export type { UseStoreActionOptions, UseStoreAction } from "./composables/action.js";
+export type { UseStoreActionOptions, UseStoreAction, IsolatedActionCall } from "./composables/action.js";
 export { useStoreModel } from "./composables/model.js";
 export type { UseStoreModelOptions, UseStoreModel } from "./composables/model.js";
 export { useStoreView } from "./composables/view.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@diphyx/harlemify",
-    "version": "6.3.1",
+    "version": "6.4.1",
     "description": "API state management for Nuxt powered by Harlem",
     "keywords": [
         "nuxt",