@diphyx/harlemify 5.1.0 → 5.2.0

package/dist/module.d.mts

@@ -4,13 +4,13 @@ interface RuntimeModelConfig {
     identifier?: string;
 }
 
+interface RuntimeViewConfig {
+    clone?: ViewClone;
+}
 declare enum ViewClone {
     SHALLOW = "shallow",
     DEEP = "deep"
 }
-interface RuntimeViewConfig {
-    clone?: ViewClone;
-}
 
 interface RuntimeActionConfig {
     endpoint?: string;

package/dist/module.d.ts

@@ -4,13 +4,13 @@ interface RuntimeModelConfig {
     identifier?: string;
 }
 
+interface RuntimeViewConfig {
+    clone?: ViewClone;
+}
 declare enum ViewClone {
     SHALLOW = "shallow",
     DEEP = "deep"
 }
-interface RuntimeViewConfig {
-    clone?: ViewClone;
-}
 
 interface RuntimeActionConfig {
     endpoint?: string;

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0 || >=4.0.0"
   },
-  "version": "5.1.0",
+  "version": "5.2.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

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

@@ -12,6 +12,6 @@ export type UseStoreAction<T> = {
 };
 export declare function useIsolatedActionError(): Ref<Error | null>;
 export declare function useIsolatedActionStatus(): Ref<ActionStatus>;
-export declare function useStoreAction<A extends Record<string, ActionCall>, K extends keyof A & string, T = Awaited<ReturnType<A[K]>>>(store: {
+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>;

package/dist/runtime/composables/action.js

@@ -1,5 +1,7 @@
 import { ref, computed } from "vue";
-import { ActionStatus } from "../core/types/action.js";
+import {
+  ActionStatus
+} from "../core/types/action.js";
 export function useIsolatedActionError() {
   return ref(null);
 }

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

@@ -1,46 +1,69 @@
+import { wrapBaseDefinition } from "../utils/base.js";
 import {
   ActionApiMethod
 } from "../types/action.js";
 export function createActionFactory(config, logger) {
   function apiCall(request, commit) {
-    const mergedRequest = {
-      endpoint: config?.endpoint,
-      headers: config?.headers,
-      query: config?.query,
-      timeout: config?.timeout,
-      concurrent: config?.concurrent,
-      ...request
-    };
-    let key = "";
-    return {
-      get key() {
-        return key;
+    return wrapBaseDefinition({
+      request: {
+        endpoint: config?.endpoint,
+        headers: config?.headers,
+        query: config?.query,
+        timeout: config?.timeout,
+        concurrent: config?.concurrent,
+        ...request
       },
-      setKey(value) {
-        key = value;
-      },
-      request: mergedRequest,
       commit,
       logger
-    };
+    });
   }
   function apiGet(request, commit) {
     return apiCall({ ...request, method: ActionApiMethod.GET }, commit);
   }
   function apiHead(request, commit) {
-    return apiCall({ ...request, method: ActionApiMethod.HEAD }, commit);
+    return apiCall(
+      {
+        ...request,
+        method: ActionApiMethod.HEAD
+      },
+      commit
+    );
   }
   function apiPost(request, commit) {
-    return apiCall({ ...request, method: ActionApiMethod.POST }, commit);
+    return apiCall(
+      {
+        ...request,
+        method: ActionApiMethod.POST
+      },
+      commit
+    );
   }
   function apiPut(request, commit) {
-    return apiCall({ ...request, method: ActionApiMethod.PUT }, commit);
+    return apiCall(
+      {
+        ...request,
+        method: ActionApiMethod.PUT
+      },
+      commit
+    );
   }
   function apiPatch(request, commit) {
-    return apiCall({ ...request, method: ActionApiMethod.PATCH }, commit);
+    return apiCall(
+      {
+        ...request,
+        method: ActionApiMethod.PATCH
+      },
+      commit
+    );
   }
   function apiDelete(request, commit) {
-    return apiCall({ ...request, method: ActionApiMethod.DELETE }, commit);
+    return apiCall(
+      {
+        ...request,
+        method: ActionApiMethod.DELETE
+      },
+      commit
+    );
   }
   const api = Object.assign(apiCall, {
     get: apiGet,
@@ -50,18 +73,15 @@ export function createActionFactory(config, logger) {
     patch: apiPatch,
     delete: apiDelete
   });
-  function handler(callback) {
-    let key = "";
-    return {
-      get key() {
-        return key;
-      },
-      setKey(value) {
-        key = value;
-      },
+  function handler(callback, options) {
+    return wrapBaseDefinition({
       callback,
+      options: {
+        concurrent: config?.concurrent,
+        ...options
+      },
       logger
-    };
+    });
   }
   return {
     api,

package/dist/runtime/core/layers/model.js

@@ -1,16 +1,10 @@
+import { wrapBaseDefinition } from "../utils/base.js";
 import {
   ModelKind
 } from "../types/model.js";
 export function createModelFactory(config, logger) {
   function one(shape, options) {
-    let key = "";
-    return {
-      get key() {
-        return key;
-      },
-      setKey(value) {
-        key = value;
-      },
+    return wrapBaseDefinition({
       shape,
       kind: ModelKind.OBJECT,
       options: {
@@ -18,17 +12,10 @@ export function createModelFactory(config, logger) {
         ...options
       },
       logger
-    };
+    });
   }
   function many(shape, options) {
-    let key = "";
-    return {
-      get key() {
-        return key;
-      },
-      setKey(value) {
-        key = value;
-      },
+    return wrapBaseDefinition({
       shape,
       kind: ModelKind.ARRAY,
       options: {
@@ -36,7 +23,7 @@ export function createModelFactory(config, logger) {
         ...options
       },
       logger
-    };
+    });
   }
   return {
     one,

package/dist/runtime/core/layers/view.js

@@ -1,13 +1,7 @@
+import { wrapBaseDefinition } from "../utils/base.js";
 export function createViewFactory(config, logger) {
   function from(model, resolver, options) {
-    let key = "";
-    const definition = {
-      get key() {
-        return key;
-      },
-      setKey(value) {
-        key = value;
-      },
+    return wrapBaseDefinition({
       model: [model],
       resolver,
       options: {
@@ -15,18 +9,10 @@ export function createViewFactory(config, logger) {
         ...options
       },
       logger
-    };
-    return definition;
+    });
   }
   function merge(models, resolver, options) {
-    let key = "";
-    return {
-      get key() {
-        return key;
-      },
-      setKey(value) {
-        key = value;
-      },
+    return wrapBaseDefinition({
       models,
       resolver,
       options: {
@@ -34,7 +20,7 @@ export function createViewFactory(config, logger) {
         ...options
       },
       logger
-    };
+    });
   }
   return {
     from,

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

@@ -52,18 +52,21 @@ export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends Vie
     request: ActionApiRequest<MD, VD>;
     commit?: ActionApiCommit<MD>;
 }
+export interface ActionHandlerOptions {
+    payload?: unknown;
+    concurrent?: ActionConcurrent;
+}
 export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> = (context: {
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
+    payload: unknown;
 }) => Promise<R>;
 export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> extends BaseDefinition {
     callback: ActionHandlerCallback<MD, VD, R>;
+    options?: ActionHandlerOptions;
 }
 export type ActionDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = ActionApiDefinition<MD, VD> | ActionHandlerDefinition<MD, VD, unknown>;
 export type ActionDefinitions<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Record<string, ActionDefinition<MD, VD>>;
-export type StoreAction<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> = {
-    [K in keyof AD]: ActionCall;
-};
 export interface ActionApiFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
     (request: ActionApiRequest<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
     get(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
@@ -74,7 +77,7 @@ export interface ActionApiFactory<MD extends ModelDefinitions, VD extends ViewDe
     delete(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
 }
 export interface ActionHandlerFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
-    <R>(callback: ActionHandlerCallback<MD, VD, R>): ActionHandlerDefinition<MD, VD, R>;
+    <R>(callback: ActionHandlerCallback<MD, VD, R>, options?: ActionHandlerOptions): ActionHandlerDefinition<MD, VD, R>;
 }
 export interface ActionFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
     api: ActionApiFactory<MD, VD>;
@@ -84,8 +87,9 @@ export interface ActionCallBindOptions {
     status?: Ref<ActionStatus>;
     error?: Ref<Error | null>;
 }
-export interface ActionCallCommitOptions {
-    mode?: ModelOneMode | ModelManyMode;
+export interface ActionCallBaseOptions {
+    concurrent?: ActionConcurrent;
+    bind?: ActionCallBindOptions;
 }
 export interface ActionResolvedApi {
     url: string;
@@ -100,7 +104,10 @@ export interface ActionCallTransformerOptions {
     request?: (api: ActionResolvedApi) => ActionResolvedApi;
     response?: (data: unknown) => unknown;
 }
-export interface ActionCallOptions {
+export interface ActionCallCommitOptions {
+    mode?: ModelOneMode | ModelManyMode;
+}
+export interface ActionApiCallOptions extends ActionCallBaseOptions {
     params?: Record<string, string>;
     headers?: Record<string, string>;
     query?: Record<string, unknown>;
@@ -108,14 +115,30 @@ export interface ActionCallOptions {
     timeout?: number;
     signal?: AbortSignal;
     transformer?: ActionCallTransformerOptions;
-    concurrent?: ActionConcurrent;
-    bind?: ActionCallBindOptions;
     commit?: ActionCallCommitOptions;
 }
-export interface ActionCall<T = void> {
-    (options?: ActionCallOptions): Promise<T>;
+export interface ActionResolvedHandler<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
+    model: StoreModel<MD>;
+    view: StoreView<MD, VD>;
+    payload: unknown;
+}
+export interface ActionHandlerCallOptions extends ActionCallBaseOptions {
+    payload?: unknown;
+}
+export type ActionCallOptions = ActionApiCallOptions | ActionHandlerCallOptions;
+export interface ActionCallBase {
     readonly error: Readonly<Ref<Error | null>>;
     readonly status: Readonly<Ref<ActionStatus>>;
     readonly loading: ComputedRef<boolean>;
     reset: () => void;
 }
+export interface ActionApiCall<T = void> extends ActionCallBase {
+    (options?: ActionApiCallOptions): Promise<T>;
+}
+export interface ActionHandlerCall<T = void> extends ActionCallBase {
+    (options?: ActionHandlerCallOptions): Promise<T>;
+}
+export type ActionCall<T = void> = ActionApiCall<T> | ActionHandlerCall<T>;
+export type StoreAction<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> = {
+    [K in keyof AD]: AD[K] extends ActionApiDefinition<MD, VD> ? ActionApiCall : AD[K] extends ActionHandlerDefinition<MD, VD, infer R> ? ActionHandlerCall<R> : never;
+};

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

@@ -1,11 +1,11 @@
 import type { ModelDefinitions, ModelFactory, StoreModel } from "./model.js";
 import type { ViewDefinitions, ViewFactory, StoreView } from "./view.js";
-import type { ActionDefinition, ActionDefinitions, ActionFactory, StoreAction } from "./action.js";
-export interface StoreConfig<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, _AD extends ActionDefinitions<MD, VD>> {
+import type { ActionDefinitions, ActionFactory, StoreAction } from "./action.js";
+export interface StoreConfig<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
     name: string;
     model: (factory: ModelFactory) => MD;
     view: (factory: ViewFactory<MD>) => VD;
-    action: (factory: ActionFactory<MD, VD>) => Record<string, ActionDefinition<MD, VD>>;
+    action: (factory: ActionFactory<MD, VD>) => AD;
 }
 export interface Store<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
     model: StoreModel<MD>;

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

@@ -1,13 +1,13 @@
 import type { ComputedRef } from "vue";
 import type { BaseDefinition } from "./base.js";
 import type { ModelDefinitions, ModelDefinitionInfer, ModelDefinitionInferTuple } from "./model.js";
+export interface RuntimeViewConfig {
+    clone?: ViewClone;
+}
 export declare enum ViewClone {
     SHALLOW = "shallow",
     DEEP = "deep"
 }
-export interface RuntimeViewConfig {
-    clone?: ViewClone;
-}
 export interface ViewDefinitionOptions {
     clone?: ViewClone;
 }

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

@@ -77,13 +77,22 @@ function resolveApiSignal(options, abortController) {
   }
   return abortController.signal;
 }
-function resolveCommitTarget(commit, model) {
+function resolveHandlerPayload(definition, options) {
+  if (options?.payload !== void 0) {
+    return options.payload;
+  }
+  if (definition.options?.payload !== void 0) {
+    return definition.options.payload;
+  }
+  return void 0;
+}
+function resolveApiCommitTarget(commit, model) {
   if (commit) {
     return model[commit.model];
   }
   return void 0;
 }
-function resolveCommitMode(commit, options) {
+function resolveApiCommitMode(commit, options) {
   if (commit) {
     if (options?.commit?.mode) {
       return options.commit.mode;
@@ -92,14 +101,17 @@ function resolveCommitMode(commit, options) {
   }
   return void 0;
 }
-function resolveCommitValue(commit, data) {
+function resolveApiCommitValue(commit, data) {
   if (typeof commit.value === "function") {
     return commit.value(data);
   }
   return data;
 }
 function isApiDefinition(definition) {
-  return "request" in definition;
+  return !("callback" in definition);
+}
+function isHandlerDefinition(definition) {
+  return "callback" in definition;
 }
 function resolveConcurrent(definition, options) {
   if (options?.concurrent) {
@@ -108,6 +120,9 @@ function resolveConcurrent(definition, options) {
   if (isApiDefinition(definition) && definition.request.concurrent) {
     return definition.request.concurrent;
   }
+  if (isHandlerDefinition(definition) && definition.options?.concurrent) {
+    return definition.options.concurrent;
+  }
   return ActionConcurrent.BLOCK;
 }
 async function executeApi(definition, api, options) {
@@ -147,15 +162,13 @@ async function executeApi(definition, api, options) {
     throw fetchError;
   }
 }
-async function executeHandler(definition, model, view) {
+async function executeHandler(definition, handler) {
   try {
     definition.logger?.debug("Action handler phase", {
       action: definition.key
     });
-    return await definition.callback({
-      model,
-      view
-    });
+    const data = await definition.callback(handler);
+    return data;
   } catch (error) {
     if (isError(error, ActionApiError, ActionHandlerError)) {
       throw error;
@@ -186,7 +199,7 @@ function executeCommit(definition, target, mode, data) {
     if (!isEmptyRecord(target.aliases())) {
       data = resolveAliasInbound(data, target.aliases());
     }
-    const value = resolveCommitValue(definition.commit, data);
+    const value = resolveApiCommitValue(definition.commit, data);
     target.commit(mode, value, definition.commit.options);
   } catch (error) {
     const commitError = toError(error, ActionCommitError);
@@ -241,10 +254,10 @@ export function createAction(definition, model, view) {
     activeError.value = null;
     currentController = (async () => {
       try {
-        let data;
+        let data = void 0;
         if (isApiDefinition(definition)) {
-          const target = resolveCommitTarget(definition.commit, model);
-          const mode = resolveCommitMode(definition.commit, options);
+          const target = resolveApiCommitTarget(definition.commit, model);
+          const mode = resolveApiCommitMode(definition.commit, options);
           const url = resolveApiUrl(definition, view, options);
           const method = resolveApiMethod(definition, view);
           const headers = resolveApiHeaders(definition, view, options);
@@ -266,8 +279,13 @@ export function createAction(definition, model, view) {
             options
           );
           executeCommit(definition, target, mode, data);
-        } else {
-          data = await executeHandler(definition, model, view);
+        } else if (isHandlerDefinition(definition)) {
+          const payload = resolveHandlerPayload(definition, options);
+          data = await executeHandler(definition, {
+            model,
+            view,
+            payload
+          });
         }
         activeStatus.value = ActionStatus.SUCCESS;
         definition.logger?.debug("Action success", {

package/dist/runtime/core/utils/base.d.ts

@@ -1,3 +1,5 @@
+import type { BaseDefinition } from "../types/base.js";
+export declare function wrapBaseDefinition<T extends Omit<BaseDefinition, "key" | "setKey">>(definition: T): T & BaseDefinition;
 export declare function trimStart(value: string, char: string): string;
 export declare function trimEnd(value: string, char: string): string;
 export declare function isObject(value: unknown): value is object;

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

@@ -1,3 +1,22 @@
+export function wrapBaseDefinition(definition) {
+  let key = "";
+  return Object.defineProperties(definition, {
+    key: {
+      get() {
+        return key;
+      },
+      enumerable: true,
+      configurable: true
+    },
+    setKey: {
+      value(value) {
+        key = value;
+      },
+      enumerable: true,
+      configurable: true
+    }
+  });
+}
 export function trimStart(value, char) {
   return value.replace(new RegExp(`^${char}+`), "");
 }

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, ActionApiMethod } from "./core/types/action.js";
-export type { ActionCall, ActionCallOptions, ActionCallTransformerOptions, ActionCallBindOptions, ActionCallCommitOptions, ActionResolvedApi, } from "./core/types/action.js";
+export type { ActionCall, ActionApiCall, ActionHandlerCall, ActionCallOptions, ActionCallBaseOptions, ActionApiCallOptions, ActionHandlerCallOptions, ActionCallTransformerOptions, ActionCallBindOptions, ActionCallCommitOptions, ActionHandlerOptions, ActionResolvedApi, } from "./core/types/action.js";
 export { ActionApiError, ActionHandlerError, ActionCommitError, ActionConcurrentError } from "./core/utils/error.js";
 export { useIsolatedActionStatus, useIsolatedActionError, useStoreAction } from "./composables/action.js";
 export type { UseStoreActionOptions, UseStoreAction } from "./composables/action.js";

package/package.json

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