@diphyx/harlemify 6.3.0 → 6.4.0

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.0",
+  "version": "6.4.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

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>> {
@@ -54,6 +55,7 @@ export interface ActionApiCommitContext<MD extends ModelDefinitions, VD extends
         query: Readonly<Record<string, unknown>>;
         body: unknown;
     }>;
+    params: Readonly<Record<string, string | number>>;
     view: DeepReadonly<StoreView<MD, VD>>;
 }
 export interface ActionApiCommit<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, K extends keyof MD = keyof MD> {
@@ -128,15 +130,35 @@ 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>;
+    params?: Record<string, string | number>;
     headers?: Record<string, string>;
     query?: Record<string, unknown>;
     body?: unknown;

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", {
@@ -297,6 +354,7 @@ export function createAction(definition, model, view) {
           );
           const context = {
             request: { url, method, headers, query, body },
+            params: options?.params ?? {},
             view
           };
           data = executeCommit(definition, model, response, context, options);

package/dist/runtime/index.d.ts

@@ -7,7 +7,7 @@ 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";

package/package.json

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