@diphyx/harlemify 5.1.0 → 5.3.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.3.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

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

@@ -1,10 +1,10 @@
 import { type ComputedRef, type Ref } from "vue";
-import { ActionStatus, type ActionCall, type ActionCallOptions } from "../core/types/action.js";
+import { ActionStatus, type ActionCall, type ActionApiCall, type ActionHandlerCall, type ActionCallOptions, type ActionApiCallOptions, type ActionHandlerCallOptions } from "../core/types/action.js";
 export interface UseStoreActionOptions {
     isolated?: boolean;
 }
-export type UseStoreAction<T> = {
-    execute: (options?: ActionCallOptions) => Promise<T>;
+export type UseStoreAction<T, O = ActionCallOptions> = {
+    execute: (options?: Omit<O, "bind">) => Promise<T>;
     error: Readonly<Ref<Error | null>>;
     status: Readonly<Ref<ActionStatus>>;
     loading: ComputedRef<boolean>;
@@ -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>;
+}, key: K, options?: UseStoreActionOptions): UseStoreAction<T, A[K] extends ActionHandlerCall<infer P, any> ? ActionHandlerCallOptions<P> : A[K] extends ActionApiCall<any> ? ActionApiCallOptions : ActionCallOptions>;

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/composables/model.d.ts

@@ -1,4 +1,4 @@
-import type { ModelCall, ModelOneCall, ModelManyCall, ModelOneCommit, ModelManyCommit, StoreModel, ModelDefinitions } from "../core/types/model.js";
+import type { ModelCall, ModelOneCall, ModelManyCall, ModelOneCommit, ModelManyListCommit, ModelManyRecordCommit, ModelManyCommit, StoreModel, ModelDefinitions } from "../core/types/model.js";
 export interface UseStoreModelOptions {
     debounce?: number;
     throttle?: number;
@@ -8,14 +8,14 @@ type UseStoreModelOne<C extends ModelOneCommit<any>> = {
     reset: C["reset"];
     patch: C["patch"];
 };
-type UseStoreModelMany<C extends ModelManyCommit<any>> = {
+type UseStoreModelMany<C extends ModelManyListCommit<any, any> | ModelManyRecordCommit<any>> = {
     set: C["set"];
     reset: C["reset"];
     patch: C["patch"];
     add: C["add"];
     remove: C["remove"];
 };
-export type UseStoreModel<M extends ModelCall<any> = ModelCall<any>> = M extends ModelManyCall<infer S> ? UseStoreModelMany<ModelManyCommit<S>> : M extends ModelOneCall<infer S> ? UseStoreModelOne<ModelOneCommit<S>> : never;
+export type UseStoreModel<M extends ModelCall<any> = ModelCall<any>> = M extends ModelManyCall<infer S, infer I, infer T> ? UseStoreModelMany<ModelManyCommit<S, I, T>> : M extends ModelOneCall<infer S> ? UseStoreModelOne<ModelOneCommit<S>> : never;
 export declare function useStoreModel<M extends StoreModel<ModelDefinitions>, K extends keyof M & string>(store: {
     model: M;
 }, key: K, options?: UseStoreModelOptions): UseStoreModel<M[K]>;

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,42 +1,29 @@
+import { wrapBaseDefinition } from "../utils/base.js";
 import {
-  ModelKind
+  ModelType
 } 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,
+      type: ModelType.ONE,
       options: {
         identifier: config?.identifier,
         ...options
       },
       logger
-    };
+    });
   }
   function many(shape, options) {
-    let key = "";
-    return {
-      get key() {
-        return key;
-      },
-      setKey(value) {
-        key = value;
-      },
+    return wrapBaseDefinition({
       shape,
-      kind: ModelKind.ARRAY,
+      type: ModelType.MANY,
       options: {
         identifier: config?.identifier,
         ...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

@@ -1,6 +1,6 @@
 import type { ComputedRef, DeepReadonly, MaybeRefOrGetter, Ref } from "vue";
 import type { BaseDefinition } from "./base.js";
-import type { ModelDefinitions, ModelOneCommitOptions, ModelManyCommitOptions, StoreModel } from "./model.js";
+import type { ModelDefinitions, ModelDefinitionInfer, ModelOneCommitOptions, ModelManyCommitOptions, StoreModel } from "./model.js";
 import { ModelOneMode, ModelManyMode } from "./model.js";
 import type { ViewDefinitions, StoreView } from "./view.js";
 export interface RuntimeActionConfig {
@@ -22,6 +22,10 @@ export declare enum ActionConcurrent {
     CANCEL = "cancel",
     ALLOW = "allow"
 }
+export declare enum ActionType {
+    API = "api",
+    HANDLER = "handler"
+}
 export declare enum ActionApiMethod {
     GET = "GET",
     HEAD = "HEAD",
@@ -42,39 +46,49 @@ export interface ActionApiRequest<MD extends ModelDefinitions, VD extends ViewDe
     concurrent?: ActionConcurrent;
 }
 export type ActionApiRequestShortcut<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Omit<ActionApiRequest<MD, VD>, "method">;
-export interface ActionApiCommit<MD extends ModelDefinitions> {
-    model: keyof MD;
+export interface ActionApiCommit<MD extends ModelDefinitions, K extends keyof MD = keyof MD> {
+    model: K;
     mode: ModelOneMode | ModelManyMode;
     value?: (data: unknown) => unknown;
     options?: ModelOneCommitOptions | ModelManyCommitOptions;
 }
-export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> extends BaseDefinition {
+export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, K extends keyof MD = keyof MD> extends BaseDefinition {
     request: ActionApiRequest<MD, VD>;
-    commit?: ActionApiCommit<MD>;
+    commit?: ActionApiCommit<MD, K>;
+}
+export interface ActionHandlerOptions<P = unknown> {
+    payload?: P;
+    concurrent?: ActionConcurrent;
 }
-export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> = (context: {
+export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, P = unknown, R = void> = (context: {
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
+    payload: P;
 }) => Promise<R>;
-export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> extends BaseDefinition {
-    callback: ActionHandlerCallback<MD, VD, R>;
+export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, P = unknown, R = void> extends BaseDefinition {
+    callback: ActionHandlerCallback<MD, VD, P, R>;
+    options?: ActionHandlerOptions<P>;
 }
-export type ActionDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = ActionApiDefinition<MD, VD> | ActionHandlerDefinition<MD, VD, unknown>;
+export type ActionDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = ActionApiDefinition<MD, VD> | ActionHandlerDefinition<MD, VD, any, any>;
 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>;
-    head(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    post(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    put(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    patch(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    delete(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
+    <K extends keyof MD>(request: ActionApiRequest<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    (request: ActionApiRequest<MD, VD>): ActionApiDefinition<MD, VD>;
+    get<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    get(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    head<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    head(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    post<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    post(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    put<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    put(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    patch<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    patch(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    delete<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    delete(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
 }
 export interface ActionHandlerFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
-    <R>(callback: ActionHandlerCallback<MD, VD, R>): ActionHandlerDefinition<MD, VD, R>;
+    <P = unknown, R = void>(callback: ActionHandlerCallback<MD, VD, P, R>, options?: ActionHandlerOptions<P>): ActionHandlerDefinition<MD, VD, P, R>;
 }
 export interface ActionFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
     api: ActionApiFactory<MD, VD>;
@@ -84,8 +98,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 +115,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 +126,32 @@ 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>, P = unknown> {
+    model: StoreModel<MD>;
+    view: StoreView<MD, VD>;
+    payload: P;
+}
+export interface ActionHandlerCallOptions<P = unknown> extends ActionCallBaseOptions {
+    payload?: P;
+}
+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 {
+    readonly actionType: ActionType.API;
+    (options?: ActionApiCallOptions): Promise<T>;
+}
+export interface ActionHandlerCall<P = unknown, T = void> extends ActionCallBase {
+    readonly actionType: ActionType.HANDLER;
+    (options?: ActionHandlerCallOptions<P>): Promise<T>;
+}
+export type ActionCall<T = void> = ActionApiCall<T> | ActionHandlerCall<any, 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, infer MK> ? MK extends keyof MD ? ActionApiCall<ModelDefinitionInfer<MD, MK>> : ActionApiCall : AD[K] extends ActionHandlerDefinition<MD, VD, infer P, infer R> ? ActionHandlerCall<P, R> : never;
+};

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

@@ -12,6 +12,11 @@ export var ActionConcurrent = /* @__PURE__ */ ((ActionConcurrent2) => {
   ActionConcurrent2["ALLOW"] = "allow";
   return ActionConcurrent2;
 })(ActionConcurrent || {});
+export var ActionType = /* @__PURE__ */ ((ActionType2) => {
+  ActionType2["API"] = "api";
+  ActionType2["HANDLER"] = "handler";
+  return ActionType2;
+})(ActionType || {});
 export var ActionApiMethod = /* @__PURE__ */ ((ActionApiMethod2) => {
   ActionApiMethod2["GET"] = "GET";
   ActionApiMethod2["HEAD"] = "HEAD";

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

@@ -1,6 +1,5 @@
 import type { ConsolaInstance } from "consola";
 export interface BaseDefinition {
-    readonly key: string;
+    key: string;
     logger?: ConsolaInstance;
-    setKey(key: string): void;
 }

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

@@ -3,9 +3,13 @@ import type { Shape, ShapeType } from "./shape.js";
 export interface RuntimeModelConfig {
     identifier?: string;
 }
-export declare enum ModelKind {
-    OBJECT = "object",
-    ARRAY = "array"
+export declare enum ModelType {
+    ONE = "one",
+    MANY = "many"
+}
+export declare enum ModelManyKind {
+    LIST = "list",
+    RECORD = "record"
 }
 export declare enum ModelOneMode {
     SET = "set",
@@ -19,27 +23,33 @@ export declare enum ModelManyMode {
     REMOVE = "remove",
     ADD = "add"
 }
+export type ModelDefaultIdentifier<S extends Shape> = "id" extends keyof S ? "id" : keyof S;
+export type AtLeastOne<S extends Shape> = {
+    [K in keyof S]: Pick<S, K>;
+}[keyof S];
 export interface ModelOneDefinitionOptions<S extends Shape> {
     identifier?: keyof S;
     default?: S;
 }
-export interface ModelManyDefinitionOptions<S extends Shape> {
-    identifier?: keyof S;
-    default?: S[];
-}
+export type ModelManyDefinitionOptions<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> = {
+    kind?: T;
+    default?: [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>;
+} & ([T] extends [ModelManyKind.LIST] ? {
+    identifier?: I;
+} : {});
 export interface ModelOneDefinition<S extends Shape> extends BaseDefinition {
     shape: ShapeType<S>;
-    kind: ModelKind.OBJECT;
+    type: ModelType.ONE;
     options?: ModelOneDefinitionOptions<S>;
 }
-export interface ModelManyDefinition<S extends Shape> extends BaseDefinition {
+export interface ModelManyDefinition<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> extends BaseDefinition {
     shape: ShapeType<S>;
-    kind: ModelKind.ARRAY;
-    options?: ModelManyDefinitionOptions<S>;
+    type: ModelType.MANY;
+    options?: ModelManyDefinitionOptions<S, I, T>;
 }
-export type ModelDefinition<S extends Shape> = ModelOneDefinition<S> | ModelManyDefinition<S>;
+export type ModelDefinition<S extends Shape> = ModelOneDefinition<S> | ModelManyDefinition<S, any, any>;
 export type ModelDefinitions = Record<string, ModelDefinition<any>>;
-export type ModelDefinitionInfer<MD extends ModelDefinitions, K extends keyof MD> = MD[K] extends ModelOneDefinition<infer S> ? S | null : MD[K] extends ModelManyDefinition<infer S> ? S[] : never;
+export type ModelDefinitionInfer<MD extends ModelDefinitions, K extends keyof MD> = MD[K] extends ModelOneDefinition<infer S> ? S | null : MD[K] extends ModelManyDefinition<infer S, any, infer T> ? [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]> : never;
 export type ModelDefinitionInferTuple<MD extends ModelDefinitions, K extends readonly (keyof MD)[]> = {
     [I in keyof K]: K[I] extends keyof MD ? ModelDefinitionInfer<MD, K[I]> : never;
 };
@@ -48,7 +58,7 @@ export type ModelDefinitionsInfer<MD extends ModelDefinitions> = {
 };
 export interface ModelFactory {
     one<S extends Shape>(shape: ShapeType<S>, options?: ModelOneDefinitionOptions<S>): ModelOneDefinition<S>;
-    many<S extends Shape>(shape: ShapeType<S>, options?: ModelManyDefinitionOptions<S>): ModelManyDefinition<S>;
+    many<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST>(shape: ShapeType<S>, options?: ModelManyDefinitionOptions<S, I, T>): ModelManyDefinition<S, I, T>;
 }
 export interface ModelOneCommitOptions {
     deep?: boolean;
@@ -64,22 +74,30 @@ export interface ModelOneCommit<S extends Shape> {
     reset: () => void;
     patch: (value: Partial<S>, options?: ModelOneCommitOptions) => void;
 }
-export interface ModelManyCommit<S extends Shape> {
+export interface ModelManyListCommit<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>> {
     set: (value: S[]) => void;
     reset: () => void;
     patch: (value: Partial<S> | Partial<S>[], options?: ModelManyCommitOptions) => void;
-    remove: (value: S | S[], options?: ModelManyCommitOptions) => void;
+    remove: (value: Pick<S, I> | Pick<S, I>[] | AtLeastOne<S> | AtLeastOne<S>[]) => void;
     add: (value: S | S[], options?: ModelManyCommitOptions) => void;
 }
+export interface ModelManyRecordCommit<S extends Shape> {
+    set: (value: Record<string, S[]>) => void;
+    reset: () => void;
+    patch: (value: Record<string, S[]>, options?: ModelOneCommitOptions) => void;
+    remove: (key: string) => void;
+    add: (key: string, value: S[]) => void;
+}
+export type ModelManyCommit<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> = [T] extends [ModelManyKind.LIST] ? ModelManyListCommit<S, I> : ModelManyRecordCommit<S>;
 export type ModelOneCall<S extends Shape> = ModelOneCommit<S> & {
     commit(mode: string, value?: unknown, options?: unknown): void;
     aliases(): Record<string, string>;
 };
-export type ModelManyCall<S extends Shape> = ModelManyCommit<S> & {
+export type ModelManyCall<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> = ModelManyCommit<S, I, T> & {
     commit(mode: string, value?: unknown, options?: unknown): void;
     aliases(): Record<string, string>;
 };
-export type ModelCall<S extends Shape> = ModelOneCall<S> | ModelManyCall<S>;
+export type ModelCall<S extends Shape> = ModelOneCall<S> | ModelManyCall<S, any, any>;
 export type StoreModel<MD extends ModelDefinitions> = {
-    [K in keyof MD]: MD[K] extends ModelOneDefinition<infer S> ? ModelOneCall<S> : MD[K] extends ModelManyDefinition<infer S> ? ModelManyCall<S> : never;
+    [K in keyof MD]: MD[K] extends ModelOneDefinition<infer S> ? ModelOneCall<S> : MD[K] extends ModelManyDefinition<infer S, infer I, infer T> ? ModelManyCall<S, I, T> : never;
 };

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

@@ -1,8 +1,13 @@
-export var ModelKind = /* @__PURE__ */ ((ModelKind2) => {
-  ModelKind2["OBJECT"] = "object";
-  ModelKind2["ARRAY"] = "array";
-  return ModelKind2;
-})(ModelKind || {});
+export var ModelType = /* @__PURE__ */ ((ModelType2) => {
+  ModelType2["ONE"] = "one";
+  ModelType2["MANY"] = "many";
+  return ModelType2;
+})(ModelType || {});
+export var ModelManyKind = /* @__PURE__ */ ((ModelManyKind2) => {
+  ModelManyKind2["LIST"] = "list";
+  ModelManyKind2["RECORD"] = "record";
+  return ModelManyKind2;
+})(ModelManyKind || {});
 export var ModelOneMode = /* @__PURE__ */ ((ModelOneMode2) => {
   ModelOneMode2["SET"] = "set";
   ModelOneMode2["RESET"] = "reset";

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

@@ -2,6 +2,7 @@ import { defu } from "defu";
 import { ref, computed, readonly, toValue, nextTick } from "vue";
 import {
   ActionApiMethod,
+  ActionType,
   ActionStatus,
   ActionConcurrent
 } from "../types/action.js";
@@ -77,13 +78,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 +102,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 +121,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 +163,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 +200,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);
@@ -198,9 +212,10 @@ function executeCommit(definition, target, mode, data) {
   }
 }
 export function createAction(definition, model, view) {
+  const actionType = isApiDefinition(definition) ? ActionType.API : ActionType.HANDLER;
   definition.logger?.debug("Registering action", {
     action: definition.key,
-    type: isApiDefinition(definition) ? "api" : "handler"
+    type: actionType
   });
   let currentController = null;
   let abortController = null;
@@ -241,10 +256,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 +281,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", {
@@ -286,6 +306,7 @@ export function createAction(definition, model, view) {
     return currentController;
   }
   const action = Object.assign(execute, {
+    actionType,
     get error() {
       return readonly(globalError);
     },

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

@@ -1,5 +1,8 @@
+import type { BaseDefinition } from "../types/base.js";
+export declare function wrapBaseDefinition<T extends Omit<BaseDefinition, "key">>(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 ensureArray<T>(value: T | T[]): T[];
 export declare function isObject(value: unknown): value is object;
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 export declare function isEmptyRecord(record: Record<string, unknown> | undefined): record is undefined;

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

@@ -1,9 +1,27 @@
+export function wrapBaseDefinition(definition) {
+  let key = "";
+  return Object.defineProperties(definition, {
+    key: {
+      get() {
+        return key;
+      },
+      set(value) {
+        key = value;
+      },
+      enumerable: true,
+      configurable: true
+    }
+  });
+}
 export function trimStart(value, char) {
   return value.replace(new RegExp(`^${char}+`), "");
 }
 export function trimEnd(value, char) {
   return value.replace(new RegExp(`${char}+$`), "");
 }
+export function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
 export function isObject(value) {
   return value != null && typeof value === "object";
 }

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

@@ -1,7 +1,9 @@
 import { defu } from "defu";
+import { ensureArray } from "./base.js";
 import { resolveShape } from "./shape.js";
 import {
-  ModelKind,
+  ModelType,
+  ModelManyKind,
   ModelOneMode,
   ModelManyMode
 } from "../types/model.js";
@@ -64,7 +66,7 @@ function createOneCommit(definition, source) {
     patch
   };
 }
-function createManyCommit(definition, shape, source) {
+function createManyListCommit(definition, shape, source) {
   const identifier = resolveIdentifier(definition, shape);
   const setOperation = source.mutation(`${definition.key}:set`, (state, value) => {
     state[definition.key] = value;
@@ -75,11 +77,11 @@ function createManyCommit(definition, shape, source) {
   const patchOperation = source.mutation(
     `${definition.key}:patch`,
     (state, payload) => {
-      const items = Array.isArray(payload.value) ? payload.value : [payload.value];
+      const items = ensureArray(payload.value);
       const by = payload.options?.by ?? identifier;
       state[definition.key] = state[definition.key].map((item) => {
-        const found = items.find((p) => {
-          return p[by] === item[by];
+        const found = items.find((partial) => {
+          return partial[by] === item[by];
         });
         if (!found) {
           return item;
@@ -96,23 +98,25 @@ function createManyCommit(definition, shape, source) {
   );
   const removeOperation = source.mutation(
     `${definition.key}:remove`,
-    (state, payload) => {
-      const items = Array.isArray(payload.value) ? payload.value : [payload.value];
-      const by = payload.options?.by ?? identifier;
-      const ids = new Set(
-        items.map((item) => {
-          return item[by];
-        })
-      );
+    (state, value) => {
+      const items = ensureArray(value);
       state[definition.key] = state[definition.key].filter((item) => {
-        return !ids.has(item[by]);
+        return !items.some((match) => {
+          let keys = Object.keys(match);
+          if (identifier in match) {
+            keys = [identifier];
+          }
+          return keys.every((key) => {
+            return item[key] === match[key];
+          });
+        });
       });
     }
   );
   const addOperation = source.mutation(
     `${definition.key}:add`,
     (state, payload) => {
-      let items = Array.isArray(payload.value) ? payload.value : [payload.value];
+      let items = ensureArray(payload.value);
       if (payload.options?.unique) {
         const by = payload.options.by ?? identifier;
         const existingIds = new Set(
@@ -155,15 +159,12 @@ function createManyCommit(definition, shape, source) {
       options
     });
   }
-  function remove(value, options) {
+  function remove(value) {
     definition.logger?.debug("Model mutation", {
       model: definition.key,
       mutation: "remove"
     });
-    removeOperation({
-      value,
-      options
-    });
+    removeOperation(value);
   }
   function add(value, options) {
     definition.logger?.debug("Model mutation", {
@@ -183,19 +184,112 @@ function createManyCommit(definition, shape, source) {
     add
   };
 }
+function createManyRecordCommit(definition, source) {
+  const setOperation = source.mutation(
+    `${definition.key}:set`,
+    (state, value) => {
+      state[definition.key] = value;
+    }
+  );
+  const resetOperation = source.mutation(`${definition.key}:reset`, (state) => {
+    state[definition.key] = definition.options?.default ?? {};
+  });
+  const patchOperation = source.mutation(
+    `${definition.key}:patch`,
+    (state, payload) => {
+      if (payload.options?.deep) {
+        state[definition.key] = defu(payload.value, state[definition.key]);
+        return;
+      }
+      state[definition.key] = {
+        ...state[definition.key],
+        ...payload.value
+      };
+    }
+  );
+  const removeOperation = source.mutation(`${definition.key}:remove`, (state, key) => {
+    const record = {};
+    for (const entry of Object.keys(state[definition.key])) {
+      if (entry !== key) {
+        record[entry] = state[definition.key][entry];
+      }
+    }
+    state[definition.key] = record;
+  });
+  const addOperation = source.mutation(
+    `${definition.key}:add`,
+    (state, payload) => {
+      state[definition.key] = {
+        ...state[definition.key],
+        [payload.key]: payload.value
+      };
+    }
+  );
+  function set(value) {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "set"
+    });
+    setOperation(value);
+  }
+  function reset() {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "reset"
+    });
+    resetOperation();
+  }
+  function patch(value, options) {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "patch"
+    });
+    patchOperation({ value, options });
+  }
+  function remove(key) {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "remove"
+    });
+    removeOperation(key);
+  }
+  function add(key, value) {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "add"
+    });
+    addOperation({ key, value });
+  }
+  return {
+    set,
+    reset,
+    patch,
+    remove,
+    add
+  };
+}
 function isOneDefinition(definition) {
-  return definition.kind === ModelKind.OBJECT;
+  return definition.type === ModelType.ONE;
+}
+function isManyRecordDefinition(definition) {
+  return definition.options?.kind === ModelManyKind.RECORD;
+}
+function resolveManyCommit(definition, shape, source) {
+  if (isManyRecordDefinition(definition)) {
+    return createManyRecordCommit(definition, source);
+  }
+  return createManyListCommit(definition, shape, source);
 }
 function resolveCommit(definition, shape, source) {
   if (isOneDefinition(definition)) {
     return createOneCommit(definition, source);
   }
-  return createManyCommit(definition, shape, source);
+  return resolveManyCommit(definition, shape, source);
 }
 export function createModel(definition, source) {
   definition.logger?.debug("Registering model", {
     model: definition.key,
-    kind: definition.kind
+    type: definition.type
   });
   const shape = resolveShape(definition.shape);
   const commit = resolveCommit(definition, shape, source);

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

@@ -1,18 +1,26 @@
 import { createModel } from "./model.js";
 import { createView } from "./view.js";
 import { createAction } from "./action.js";
-import { ModelKind } from "../types/model.js";
+import {
+  ModelType,
+  ModelManyKind
+} from "../types/model.js";
 export function createStoreState(modelDefinitions) {
   const output = {};
-  for (const [key, { options, kind }] of Object.entries(modelDefinitions)) {
-    output[key] = options?.default ?? (kind === ModelKind.OBJECT ? null : []);
+  for (const [key, { options, type }] of Object.entries(modelDefinitions)) {
+    if (type === ModelType.ONE) {
+      output[key] = options?.default ?? null;
+    } else {
+      const manyDefault = options?.kind === ModelManyKind.RECORD ? {} : [];
+      output[key] = options?.default ?? manyDefault;
+    }
   }
   return output;
 }
 export function createStoreModel(modelDefinitions, source) {
   const output = {};
   for (const [key, definition] of Object.entries(modelDefinitions)) {
-    definition.setKey(key);
+    definition.key = key;
     output[key] = createModel(definition, source);
   }
   return output;
@@ -20,7 +28,7 @@ export function createStoreModel(modelDefinitions, source) {
 export function createStoreView(viewDefinitions, source) {
   const output = {};
   for (const [key, definition] of Object.entries(viewDefinitions)) {
-    definition.setKey(key);
+    definition.key = key;
     output[key] = createView(definition, source);
   }
   return output;
@@ -28,7 +36,7 @@ export function createStoreView(viewDefinitions, source) {
 export function createStoreAction(actionDefinitions, model, view) {
   const output = {};
   for (const [key, definition] of Object.entries(actionDefinitions)) {
-    definition.setKey(key);
+    definition.key = key;
     output[key] = createAction(definition, model, view);
   }
   return output;

package/dist/runtime/index.d.ts

@@ -2,12 +2,12 @@ export { createStore } from "./core/store.js";
 export type { Store, StoreConfig } from "./core/types/store.js";
 export { shape } from "./core/layers/shape.js";
 export type { ShapeInfer } from "./core/types/shape.js";
-export { ModelKind, ModelOneMode, ModelManyMode } from "./core/types/model.js";
+export { ModelType, ModelManyKind, ModelOneMode, ModelManyMode } from "./core/types/model.js";
 export type { ModelOneCommitOptions, ModelManyCommitOptions } from "./core/types/model.js";
 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 { ActionStatus, ActionConcurrent, ActionType, ActionApiMethod } 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/dist/runtime/index.js

@@ -1,8 +1,8 @@
 export { createStore } from "./core/store.js";
 export { shape } from "./core/layers/shape.js";
-export { ModelKind, ModelOneMode, ModelManyMode } from "./core/types/model.js";
+export { ModelType, ModelManyKind, ModelOneMode, ModelManyMode } from "./core/types/model.js";
 export { ViewClone } from "./core/types/view.js";
-export { ActionStatus, ActionConcurrent, ActionApiMethod } from "./core/types/action.js";
+export { ActionStatus, ActionConcurrent, ActionType, ActionApiMethod } from "./core/types/action.js";
 export { ActionApiError, ActionHandlerError, ActionCommitError, ActionConcurrentError } from "./core/utils/error.js";
 export { useIsolatedActionStatus, useIsolatedActionError, useStoreAction } from "./composables/action.js";
 export { useStoreModel } from "./composables/model.js";

package/package.json

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