@diphyx/harlemify 4.0.0 → 5.0.0

package/README.md

@@ -4,12 +4,14 @@
 
 ## Features
 
-- **Shape-Driven** - Zod shapes define types and identifiers
-- **Three-Layer Architecture** - Model (state), View (computed), Action (async operations)
-- **Chainable Action Builders** - Fluent `api`, `handle`, `commit` chains
-- **Per-Action Status Tracking** - Built-in `loading`, `status`, `error`, `data` on every action
-- **Concurrency Control** - Block, skip, cancel, or allow concurrent calls
-- **SSR Support** - Server-side rendering with automatic hydration
+- **Single Factory** - Define shape, model, view, and action in one `createStore` call — fully typed end to end
+- **Zod Shapes** - Schema-first design with built-in validation, type inference, and identifier metadata
+- **Reactive Models** - `one()` and `many()` state containers with `set`, `patch`, `add`, `remove`, `reset` mutations
+- **Computed Views** - Derive read-only state from models with `from()` and `merge()` — auto-tracked by Vue
+- **API & Handler Actions** - Declarative HTTP actions with auto-commit, or custom handlers with full model/view access
+- **Action Metadata** - Every action exposes `loading`, `status`, `error`, `data`, and `reset()` out of the box
+- **Concurrency Control** - Block, skip, cancel, or allow parallel calls per action
+- **SSR Ready** - Server-side rendering with automatic state hydration
 
 ## Install
 
@@ -35,7 +37,7 @@ export default defineNuxtConfig({
 
 ```typescript
 // stores/user.ts
-import { createStore, shape, ActionOneMode, ActionManyMode, type ShapeInfer } from "@diphyx/harlemify";
+import { createStore, shape, ModelManyMode, type ShapeInfer } from "@diphyx/harlemify";
 
 const userShape = shape((factory) => {
     return {
@@ -63,19 +65,13 @@ export const userStore = createStore({
             users: from("list"),
         };
     },
-    action({ api, commit }) {
+    action({ api, handler }) {
         return {
-            list: api
-                .get({
-                    url: "/users",
-                })
-                .commit("list", ActionManyMode.SET),
-            create: api
-                .post({
-                    url: "/users",
-                })
-                .commit("list", ActionManyMode.ADD),
-            clear: commit("list", ActionManyMode.RESET),
+            list: api.get({ url: "/users" }, { model: "list", mode: ModelManyMode.SET }),
+            create: api.post({ url: "/users" }, { model: "list", mode: ModelManyMode.ADD }),
+            clear: handler(async ({ model }) => {
+                model.list.reset();
+            }),
         };
     },
 });

package/dist/module.d.mts

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

package/dist/module.d.ts

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

package/dist/module.json

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

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

@@ -1,4 +1,4 @@
 import { type Ref } from "vue";
-import { type ActionError, ActionStatus } from "../core/types/action.js";
+import { ActionStatus } from "../core/types/action.js";
 export declare function useIsolatedActionStatus(): Ref<ActionStatus>;
-export declare function useIsolatedActionError(): Ref<ActionError | null>;
+export declare function useIsolatedActionError(): Ref<Error | null>;

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

@@ -1,4 +1,5 @@
 import type { ConsolaInstance } from "consola";
-import type { Model } from "../types/model.js";
+import type { ModelDefinitions } from "../types/model.js";
+import type { ViewDefinitions } from "../types/view.js";
 import { type RuntimeActionConfig, type ActionFactory } from "../types/action.js";
-export declare function createActionFactory<M extends Model, V>(config?: RuntimeActionConfig, logger?: ConsolaInstance, _model?: M, _view?: V): ActionFactory<M, V>;
+export declare function createActionFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>>(config?: RuntimeActionConfig, logger?: ConsolaInstance): ActionFactory<MD, VD>;

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

@@ -1,77 +1,46 @@
-import { buildCommitMethod } from "../utils/action.js";
 import {
-  ActionApiMethod,
-  DEFINITION
+  ActionApiMethod
 } from "../types/action.js";
-export function createActionFactory(config, logger, _model, _view) {
-  function apiCall(apiDefinition) {
-    apiDefinition = {
+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,
-      ...apiDefinition
-    };
-    const actionDefinition = {
-      api: apiDefinition,
-      logger
+      ...request
     };
+    let key = "";
     return {
-      handle(callback) {
-        const handleDefinition = {
-          api: apiDefinition,
-          handle: callback,
-          logger
-        };
-        return {
-          commit: buildCommitMethod(handleDefinition),
-          get [DEFINITION]() {
-            return handleDefinition;
-          }
-        };
+      get key() {
+        return key;
+      },
+      setKey(value) {
+        key = value;
       },
-      commit: buildCommitMethod(actionDefinition),
-      get [DEFINITION]() {
-        return actionDefinition;
-      }
+      request: mergedRequest,
+      commit,
+      logger
     };
   }
-  function apiGet(definition) {
-    return apiCall({
-      ...definition,
-      method: ActionApiMethod.GET
-    });
+  function apiGet(request, commit) {
+    return apiCall({ ...request, method: ActionApiMethod.GET }, commit);
   }
-  function apiHead(definition) {
-    return apiCall({
-      ...definition,
-      method: ActionApiMethod.HEAD
-    });
+  function apiHead(request, commit) {
+    return apiCall({ ...request, method: ActionApiMethod.HEAD }, commit);
   }
-  function apiPost(definition) {
-    return apiCall({
-      ...definition,
-      method: ActionApiMethod.POST
-    });
+  function apiPost(request, commit) {
+    return apiCall({ ...request, method: ActionApiMethod.POST }, commit);
   }
-  function apiPut(definition) {
-    return apiCall({
-      ...definition,
-      method: ActionApiMethod.PUT
-    });
+  function apiPut(request, commit) {
+    return apiCall({ ...request, method: ActionApiMethod.PUT }, commit);
   }
-  function apiPatch(definition) {
-    return apiCall({
-      ...definition,
-      method: ActionApiMethod.PATCH
-    });
+  function apiPatch(request, commit) {
+    return apiCall({ ...request, method: ActionApiMethod.PATCH }, commit);
   }
-  function apiDelete(definition) {
-    return apiCall({
-      ...definition,
-      method: ActionApiMethod.DELETE
-    });
+  function apiDelete(request, commit) {
+    return apiCall({ ...request, method: ActionApiMethod.DELETE }, commit);
   }
   const api = Object.assign(apiCall, {
     get: apiGet,
@@ -81,22 +50,21 @@ export function createActionFactory(config, logger, _model, _view) {
     patch: apiPatch,
     delete: apiDelete
   });
-  function handle(callback) {
-    const definition = {
-      handle: callback,
-      logger
-    };
+  function handler(callback) {
+    let key = "";
     return {
-      commit: buildCommitMethod(definition),
-      get [DEFINITION]() {
-        return definition;
-      }
+      get key() {
+        return key;
+      },
+      setKey(value) {
+        key = value;
+      },
+      callback,
+      logger
     };
   }
-  const commit = buildCommitMethod({ logger });
   return {
     api,
-    handle,
-    commit
+    handler
   };
 }

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

@@ -3,7 +3,14 @@ import {
 } from "../types/model.js";
 export function createModelFactory(config, logger) {
   function one(shape, options) {
+    let key = "";
     return {
+      get key() {
+        return key;
+      },
+      setKey(value) {
+        key = value;
+      },
       shape,
       kind: ModelKind.OBJECT,
       options: {
@@ -14,7 +21,14 @@ export function createModelFactory(config, logger) {
     };
   }
   function many(shape, options) {
+    let key = "";
     return {
+      get key() {
+        return key;
+      },
+      setKey(value) {
+        key = value;
+      },
       shape,
       kind: ModelKind.ARRAY,
       options: {

package/dist/runtime/core/layers/shape.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { ShapeFactory } from "../types/shape.js";
+import type { ShapeFactory, ShapeRawDefinition } from "../types/shape.js";
 export declare const primitiveField: {
     string: typeof z.string;
     number: typeof z.number;
@@ -42,4 +42,4 @@ export declare const specialField: {
     nullable: typeof z.nullable;
     optional: typeof z.optional;
 };
-export declare function shape<T extends z.ZodRawShape>(definition: T | ((factory: ShapeFactory) => T)): z.ZodObject<T>;
+export declare function shape<T extends ShapeRawDefinition>(definition: T | ((factory: ShapeFactory) => T)): import("../types/shape").ShapeCall<T>;

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

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { createShape } from "../utils/shape.js";
 export const primitiveField = {
   string: z.string,
   number: z.number,
@@ -43,7 +44,7 @@ export const specialField = {
 };
 export function shape(definition) {
   if (typeof definition === "function") {
-    return z.object(
+    return createShape(
       definition({
         ...primitiveField,
         ...structureField,
@@ -52,5 +53,5 @@ export function shape(definition) {
       })
     );
   }
-  return z.object(definition);
+  return createShape(definition);
 }

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

@@ -1,4 +1,4 @@
 import type { ConsolaInstance } from "consola";
-import type { Model } from "../types/model.js";
+import type { ModelDefinitions } from "../types/model.js";
 import type { RuntimeViewConfig, ViewFactory } from "../types/view.js";
-export declare function createViewFactory<M extends Model>(config?: RuntimeViewConfig, logger?: ConsolaInstance, _model?: M): ViewFactory<M>;
+export declare function createViewFactory<MD extends ModelDefinitions>(config?: RuntimeViewConfig, logger?: ConsolaInstance): ViewFactory<MD>;

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

@@ -1,16 +1,38 @@
-export function createViewFactory(config, logger, _model) {
-  function from(source, resolver) {
+export function createViewFactory(config, logger) {
+  function from(model, resolver, options) {
+    let key = "";
     const definition = {
-      sources: [source],
+      get key() {
+        return key;
+      },
+      setKey(value) {
+        key = value;
+      },
+      model: [model],
       resolver,
+      options: {
+        clone: config?.clone,
+        ...options
+      },
       logger
     };
     return definition;
   }
-  function merge(sources, resolver) {
+  function merge(models, resolver, options) {
+    let key = "";
     return {
-      sources,
+      get key() {
+        return key;
+      },
+      setKey(value) {
+        key = value;
+      },
+      models,
       resolver,
+      options: {
+        clone: config?.clone,
+        ...options
+      },
       logger
     };
   }

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

@@ -1,23 +1,5 @@
-import type { ComputedRef } from "vue";
-import type { Model, ModelFactory } from "./types/model.js";
-import type { ViewDefinitions, ViewResult, ViewFactory } from "./types/view.js";
-import { type Action, type ActionApiChain, type ActionCommitChain, type ActionCommitter, type ActionDefinition, type ActionDefinitions, type ActionFactory, type ActionHandleChain } from "./types/action.js";
-export type StoreModel<M extends Model> = ActionCommitter<M>;
-export type StoreView<M extends Model, VD extends ViewDefinitions<M>> = {
-    readonly [K in keyof VD]: ComputedRef<ViewResult<M, VD[K]>>;
-};
-export type StoreAction<M extends Model, V, AD extends Record<string, ActionDefinition<M, V, unknown>>> = {
-    [K in keyof AD]: Action<V>;
-};
-export interface StoreConfig<M extends Model, VD extends ViewDefinitions<M>, _AD extends ActionDefinitions<M, StoreView<M, VD>>> {
-    name: string;
-    model: (factory: ModelFactory) => M;
-    view: (factory: ViewFactory<M>) => VD;
-    action: (factory: ActionFactory<M, StoreView<M, VD>>) => Record<string, ActionApiChain<M, StoreView<M, VD>, unknown> | ActionHandleChain<M, StoreView<M, VD>, unknown> | ActionCommitChain<M, StoreView<M, VD>, unknown>>;
-}
-export interface Store<M extends Model, VD extends ViewDefinitions<M>, AD extends ActionDefinitions<M, StoreView<M, VD>>> {
-    model: StoreModel<M>;
-    view: StoreView<M, VD>;
-    action: StoreAction<M, StoreView<M, VD>, AD>;
-}
-export declare function createStore<M extends Model, VD extends ViewDefinitions<M>, AD extends ActionDefinitions<M, StoreView<M, VD>>>(config: StoreConfig<M, VD, AD>): Store<M, VD, AD>;
+import type { ModelDefinitions } from "./types/model.js";
+import type { ViewDefinitions } from "./types/view.js";
+import type { ActionDefinitions } from "./types/action.js";
+import type { Store, StoreConfig } from "./types/store.js";
+export declare function createStore<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>>(config: StoreConfig<MD, VD, AD>): Store<MD, VD, AD>;

package/dist/runtime/core/store.js

@@ -1,28 +1,10 @@
 import { createConsola } from "consola";
-import { createStore as createSourceStore } from "@harlem/core";
+import { createStore as createStoreSource } from "@harlem/core";
 import { runtimeConfig } from "../config.js";
 import { createModelFactory } from "./layers/model.js";
 import { createViewFactory } from "./layers/view.js";
 import { createActionFactory } from "./layers/action.js";
-import { initializeState, createMutations, createCommitter } from "./utils/model.js";
-import { createView } from "./utils/view.js";
-import { createAction } from "./utils/action.js";
-import {
-  DEFINITION
-} from "./types/action.js";
-function createStoreModel(mutations) {
-  return createCommitter(mutations);
-}
-function createStoreView(source, viewDefinitions) {
-  return createView(source, viewDefinitions);
-}
-function createStoreAction(actionDefinitions, view, mutations) {
-  const actions = {};
-  for (const [key, chain] of Object.entries(actionDefinitions)) {
-    actions[key] = createAction(chain[DEFINITION], mutations, view, key);
-  }
-  return actions;
-}
+import { createStoreState, createStoreModel, createStoreView, createStoreAction } from "./utils/store.js";
 export function createStore(config) {
   const logger = createConsola({
     level: runtimeConfig.logger,
@@ -30,20 +12,18 @@ export function createStore(config) {
       tag: `harlemify:${config.name}`
     }
   });
+  logger.info("Creating store");
   const modelFactory = createModelFactory(runtimeConfig.model, logger);
   const viewFactory = createViewFactory(runtimeConfig.view, logger);
   const actionFactory = createActionFactory(runtimeConfig.action, logger);
-  logger.info("Creating store");
   const modelDefinitions = config.model(modelFactory);
   const viewDefinitions = config.view(viewFactory);
   const actionDefinitions = config.action(actionFactory);
-  logger.debug("Initializing store");
-  const state = initializeState(modelDefinitions);
-  const source = createSourceStore(config.name, state);
-  const mutations = createMutations(source, modelDefinitions);
-  const model = createStoreModel(mutations);
-  const view = createStoreView(source, viewDefinitions);
-  const action = createStoreAction(actionDefinitions, view, mutations);
+  const state = createStoreState(modelDefinitions);
+  const source = createStoreSource(config.name, state);
+  const model = createStoreModel(modelDefinitions, source);
+  const view = createStoreView(viewDefinitions, source);
+  const action = createStoreAction(actionDefinitions, model, view);
   logger.info("Store created");
   return {
     model,