@diphyx/harlemify 3.0.0 → 4.0.0

package/README.md

@@ -1,14 +1,14 @@
 # Harlemify
 
-> Schema-driven state management for Nuxt powered by [Harlem](https://harlemjs.com/)
+> Factory-driven state management for Nuxt powered by [Harlem](https://harlemjs.com/)
 
 ## Features
 
-- **Schema-Driven** - Zod schema defines types, validation, and API payloads
-- **Free-form Actions** - Define any action with custom naming
-- **Chainable Builders** - Fluent `Endpoint` and `Memory` APIs
-- **Function-based Monitor** - Track status with `pending()`, `success()`, `failed()`, `idle()`
-- **Custom Adapters** - Override HTTP at module, store, endpoint, or call-time
+- **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
 
 ## Install
@@ -24,10 +24,8 @@ npm install @diphyx/harlemify
 export default defineNuxtConfig({
     modules: ["@diphyx/harlemify"],
     harlemify: {
-        api: {
-            adapter: {
-                baseURL: "https://api.example.com",
-            },
+        action: {
+            endpoint: "https://api.example.com",
         },
     },
 });
@@ -37,42 +35,63 @@ export default defineNuxtConfig({
 
 ```typescript
 // stores/user.ts
-import { z } from "zod";
-
-enum UserAction {
-    LIST = "list",
-    CREATE = "create",
-}
-
-const userSchema = z.object({
-    id: z.number().meta({ indicator: true }),
-    name: z.string().meta({ actions: [UserAction.CREATE] }),
-    email: z.string().meta({ actions: [UserAction.CREATE] }),
+import { createStore, shape, ActionOneMode, ActionManyMode, type ShapeInfer } from "@diphyx/harlemify";
+
+const userShape = shape((factory) => {
+    return {
+        id: factory.number().meta({
+            identifier: true,
+        }),
+        name: factory.string(),
+        email: factory.email(),
+    };
 });
 
-export const userStore = createStore("user", userSchema, {
-    [UserAction.LIST]: {
-        endpoint: Endpoint.get("/users"),
-        memory: Memory.units(),
+export type User = ShapeInfer<typeof userShape>;
+
+export const userStore = createStore({
+    name: "users",
+    model({ one, many }) {
+        return {
+            current: one(userShape),
+            list: many(userShape),
+        };
+    },
+    view({ from }) {
+        return {
+            user: from("current"),
+            users: from("list"),
+        };
     },
-    [UserAction.CREATE]: {
-        endpoint: Endpoint.post("/users"),
-        memory: Memory.units().add(),
+    action({ api, commit }) {
+        return {
+            list: api
+                .get({
+                    url: "/users",
+                })
+                .commit("list", ActionManyMode.SET),
+            create: api
+                .post({
+                    url: "/users",
+                })
+                .commit("list", ActionManyMode.ADD),
+            clear: commit("list", ActionManyMode.RESET),
+        };
     },
 });
 ```
 
 ```vue
 <script setup>
-const { users, listUser, userMonitor } = useStoreAlias(userStore);
+const { view, action } = userStore;
 
-await listUser();
+await action.list();
 </script>
 
 <template>
-    <div v-if="userMonitor.list.pending()">Loading...</div>
+    <div v-if="action.list.loading.value">Loading...</div>
     <ul v-else>
-        <li v-for="user in users" :key="user.id">{{ user.name }}</li>
+        <li v-for="user in view.users.value" :key="user.id">{{ user.name }}</li>
     </ul>
 </template>
 ```

package/dist/module.d.mts

@@ -1,22 +1,33 @@
 import * as _nuxt_schema from '@nuxt/schema';
 
-interface ApiFetchAdapterOptions {
-    baseURL?: string;
+interface RuntimeModelConfig {
+    identifier?: string;
+}
+
+interface RuntimeViewConfig {
+}
+
+interface RuntimeActionConfig {
+    endpoint?: string;
+    headers?: Record<string, string>;
+    query?: Record<string, unknown>;
     timeout?: number;
-    retry?: number | false;
-    retryDelay?: number;
-    retryStatusCodes?: number[];
-    responseType?: "json" | "text" | "blob" | "arrayBuffer";
+    concurrent?: ActionConcurrent;
+}
+declare enum ActionConcurrent {
+    BLOCK = "block",
+    SKIP = "skip",
+    CANCEL = "cancel",
+    ALLOW = "allow"
 }
 
-type SharedConfig = {
-    api?: {
-        headers?: Record<string, string>;
-        query?: Record<string, unknown>;
-        adapter?: ApiFetchAdapterOptions;
-    };
+type RuntimeConfig = {
+    model?: RuntimeModelConfig;
+    view?: RuntimeViewConfig;
+    action?: RuntimeActionConfig;
+    logger?: number;
 };
 
-declare const _default: _nuxt_schema.NuxtModule<SharedConfig, SharedConfig, false>;
+declare const _default: _nuxt_schema.NuxtModule<RuntimeConfig, RuntimeConfig, false>;
 
 export { _default as default };

package/dist/module.d.ts

@@ -1,22 +1,33 @@
 import * as _nuxt_schema from '@nuxt/schema';
 
-interface ApiFetchAdapterOptions {
-    baseURL?: string;
+interface RuntimeModelConfig {
+    identifier?: string;
+}
+
+interface RuntimeViewConfig {
+}
+
+interface RuntimeActionConfig {
+    endpoint?: string;
+    headers?: Record<string, string>;
+    query?: Record<string, unknown>;
     timeout?: number;
-    retry?: number | false;
-    retryDelay?: number;
-    retryStatusCodes?: number[];
-    responseType?: "json" | "text" | "blob" | "arrayBuffer";
+    concurrent?: ActionConcurrent;
+}
+declare enum ActionConcurrent {
+    BLOCK = "block",
+    SKIP = "skip",
+    CANCEL = "cancel",
+    ALLOW = "allow"
 }
 
-type SharedConfig = {
-    api?: {
-        headers?: Record<string, string>;
-        query?: Record<string, unknown>;
-        adapter?: ApiFetchAdapterOptions;
-    };
+type RuntimeConfig = {
+    model?: RuntimeModelConfig;
+    view?: RuntimeViewConfig;
+    action?: RuntimeActionConfig;
+    logger?: number;
 };
 
-declare const _default: _nuxt_schema.NuxtModule<SharedConfig, SharedConfig, false>;
+declare const _default: _nuxt_schema.NuxtModule<RuntimeConfig, RuntimeConfig, false>;
 
 export { _default as default };

package/dist/module.json

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

package/dist/module.mjs

@@ -1,4 +1,4 @@
-import { defineNuxtModule, createResolver, addTemplate, addPlugin, addImportsDir } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addTemplate, addPlugin, addImportsDir, addImports } from '@nuxt/kit';
 
 const module = defineNuxtModule({
   meta: {
@@ -8,13 +8,7 @@ const module = defineNuxtModule({
       nuxt: ">=3.0.0 || >=4.0.0"
     }
   },
-  defaults: {
-    api: {
-      headers: {},
-      query: {},
-      adapter: {}
-    }
-  },
+  defaults: {},
   setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
     addTemplate({
@@ -25,9 +19,13 @@ const module = defineNuxtModule({
       }
     });
     addPlugin(resolve("./runtime", "plugin"));
-    addImportsDir(resolve("./runtime", "core"));
     addImportsDir(resolve("./runtime", "composables"));
-    addImportsDir(resolve("./runtime", "utils"));
+    addImports([
+      {
+        name: "createStore",
+        from: resolve("./runtime/core/store")
+      }
+    ]);
     nuxt.options.build.transpile.push(/@harlem\//);
   }
 });

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

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

package/dist/runtime/composables/action.js

@@ -0,0 +1,8 @@
+import { ref } from "vue";
+import { ActionStatus } from "../core/types/action.js";
+export function useIsolatedActionStatus() {
+  return ref(ActionStatus.IDLE);
+}
+export function useIsolatedActionError() {
+  return ref(null);
+}

package/dist/runtime/config.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeModelConfig } from "./core/types/model.js";
+import type { RuntimeViewConfig } from "./core/types/view.js";
+import type { RuntimeActionConfig } from "./core/types/action.js";
+export type RuntimeConfig = {
+    model?: RuntimeModelConfig;
+    view?: RuntimeViewConfig;
+    action?: RuntimeActionConfig;
+    logger?: number;
+};
+export declare const runtimeConfig: RuntimeConfig;

package/dist/runtime/config.js

@@ -0,0 +1,7 @@
+import config from "#build/harlemify.config";
+export const runtimeConfig = {
+  model: config.model ?? {},
+  view: config.view ?? {},
+  action: config.action ?? {},
+  logger: config.logger ?? -999
+};

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

@@ -0,0 +1,4 @@
+import type { ConsolaInstance } from "consola";
+import type { Model } from "../types/model.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>;

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

@@ -0,0 +1,102 @@
+import { buildCommitMethod } from "../utils/action.js";
+import {
+  ActionApiMethod,
+  DEFINITION
+} from "../types/action.js";
+export function createActionFactory(config, logger, _model, _view) {
+  function apiCall(apiDefinition) {
+    apiDefinition = {
+      endpoint: config?.endpoint,
+      headers: config?.headers,
+      query: config?.query,
+      timeout: config?.timeout,
+      concurrent: config?.concurrent,
+      ...apiDefinition
+    };
+    const actionDefinition = {
+      api: apiDefinition,
+      logger
+    };
+    return {
+      handle(callback) {
+        const handleDefinition = {
+          api: apiDefinition,
+          handle: callback,
+          logger
+        };
+        return {
+          commit: buildCommitMethod(handleDefinition),
+          get [DEFINITION]() {
+            return handleDefinition;
+          }
+        };
+      },
+      commit: buildCommitMethod(actionDefinition),
+      get [DEFINITION]() {
+        return actionDefinition;
+      }
+    };
+  }
+  function apiGet(definition) {
+    return apiCall({
+      ...definition,
+      method: ActionApiMethod.GET
+    });
+  }
+  function apiHead(definition) {
+    return apiCall({
+      ...definition,
+      method: ActionApiMethod.HEAD
+    });
+  }
+  function apiPost(definition) {
+    return apiCall({
+      ...definition,
+      method: ActionApiMethod.POST
+    });
+  }
+  function apiPut(definition) {
+    return apiCall({
+      ...definition,
+      method: ActionApiMethod.PUT
+    });
+  }
+  function apiPatch(definition) {
+    return apiCall({
+      ...definition,
+      method: ActionApiMethod.PATCH
+    });
+  }
+  function apiDelete(definition) {
+    return apiCall({
+      ...definition,
+      method: ActionApiMethod.DELETE
+    });
+  }
+  const api = Object.assign(apiCall, {
+    get: apiGet,
+    head: apiHead,
+    post: apiPost,
+    put: apiPut,
+    patch: apiPatch,
+    delete: apiDelete
+  });
+  function handle(callback) {
+    const definition = {
+      handle: callback,
+      logger
+    };
+    return {
+      commit: buildCommitMethod(definition),
+      get [DEFINITION]() {
+        return definition;
+      }
+    };
+  }
+  const commit = buildCommitMethod({ logger });
+  return {
+    api,
+    handle,
+    commit
+  };
+}

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

@@ -0,0 +1,3 @@
+import type { ConsolaInstance } from "consola";
+import { type RuntimeModelConfig, type ModelFactory } from "../types/model.js";
+export declare function createModelFactory(config?: RuntimeModelConfig, logger?: ConsolaInstance): ModelFactory;

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

@@ -0,0 +1,31 @@
+import {
+  ModelKind
+} from "../types/model.js";
+export function createModelFactory(config, logger) {
+  function one(shape, options) {
+    return {
+      shape,
+      kind: ModelKind.OBJECT,
+      options: {
+        identifier: config?.identifier,
+        ...options
+      },
+      logger
+    };
+  }
+  function many(shape, options) {
+    return {
+      shape,
+      kind: ModelKind.ARRAY,
+      options: {
+        identifier: config?.identifier,
+        ...options
+      },
+      logger
+    };
+  }
+  return {
+    one,
+    many
+  };
+}

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

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import type { ShapeFactory } from "../types/shape.js";
+export declare const primitiveField: {
+    string: typeof z.string;
+    number: typeof z.number;
+    boolean: typeof z.boolean;
+    bigint: typeof z.bigint;
+    date: typeof z.date;
+};
+export declare const structureField: {
+    object: typeof z.object;
+    array: typeof z.array;
+    tuple: typeof z.tuple;
+    record: typeof z.record;
+    map: typeof z.map;
+    set: typeof z.set;
+    enum: typeof z.enum;
+    union: typeof z.union;
+    literal: typeof z.literal;
+};
+export declare const formatField: {
+    email: typeof z.email;
+    url: typeof z.url;
+    uuid: typeof z.uuid;
+    cuid: typeof z.cuid;
+    cuid2: typeof z.cuid2;
+    ulid: typeof z.ulid;
+    nanoid: typeof z.nanoid;
+    jwt: typeof z.jwt;
+    emoji: typeof z.emoji;
+    ipv4: typeof z.ipv4;
+    ipv6: typeof z.ipv6;
+    mac: typeof z.mac;
+    base64: typeof z.base64;
+    base64url: typeof z.base64url;
+    hex: typeof z.hex;
+};
+export declare const specialField: {
+    any: typeof z.any;
+    unknown: typeof z.unknown;
+    never: typeof z.never;
+    nullable: typeof z.nullable;
+    optional: typeof z.optional;
+};
+export declare function shape<T extends z.ZodRawShape>(definition: T | ((factory: ShapeFactory) => T)): z.ZodObject<T>;

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

@@ -0,0 +1,56 @@
+import { z } from "zod";
+export const primitiveField = {
+  string: z.string,
+  number: z.number,
+  boolean: z.boolean,
+  bigint: z.bigint,
+  date: z.date
+};
+export const structureField = {
+  object: z.object,
+  array: z.array,
+  tuple: z.tuple,
+  record: z.record,
+  map: z.map,
+  set: z.set,
+  enum: z.enum,
+  union: z.union,
+  literal: z.literal
+};
+export const formatField = {
+  email: z.email,
+  url: z.url,
+  uuid: z.uuid,
+  cuid: z.cuid,
+  cuid2: z.cuid2,
+  ulid: z.ulid,
+  nanoid: z.nanoid,
+  jwt: z.jwt,
+  emoji: z.emoji,
+  ipv4: z.ipv4,
+  ipv6: z.ipv6,
+  mac: z.mac,
+  base64: z.base64,
+  base64url: z.base64url,
+  hex: z.hex
+};
+export const specialField = {
+  any: z.any,
+  unknown: z.unknown,
+  never: z.never,
+  nullable: z.nullable,
+  optional: z.optional
+};
+export function shape(definition) {
+  if (typeof definition === "function") {
+    return z.object(
+      definition({
+        ...primitiveField,
+        ...structureField,
+        ...formatField,
+        ...specialField
+      })
+    );
+  }
+  return z.object(definition);
+}

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

@@ -0,0 +1,4 @@
+import type { ConsolaInstance } from "consola";
+import type { Model } 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>;

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

@@ -0,0 +1,21 @@
+export function createViewFactory(config, logger, _model) {
+  function from(source, resolver) {
+    const definition = {
+      sources: [source],
+      resolver,
+      logger
+    };
+    return definition;
+  }
+  function merge(sources, resolver) {
+    return {
+      sources,
+      resolver,
+      logger
+    };
+  }
+  return {
+    from,
+    merge
+  };
+}

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

@@ -1,69 +1,23 @@
-import type { z } from "zod";
 import type { ComputedRef } from "vue";
-import type { Extension, BaseState } from "@harlem/core";
-import { EndpointStatus } from "../utils/endpoint.js";
-import type { ApiAdapter } from "../utils/adapter.js";
-import type { Pluralize } from "../utils/transform.js";
-import type { EndpointDefinition } from "../utils/endpoint.js";
-import type { MemoryDefinition } from "../utils/memory.js";
-export interface ActionDefinition<S = Record<string, unknown>> {
-    endpoint: EndpointDefinition<S>;
-    memory?: MemoryDefinition;
-}
-export interface ActionOptions {
-    query?: Record<string, unknown>;
-    headers?: Record<string, string>;
-    body?: unknown;
-    signal?: AbortSignal;
-    validate?: boolean;
-    adapter?: ApiAdapter<any>;
-}
-export interface ActionStatus {
-    current: () => EndpointStatus;
-    pending: () => boolean;
-    success: () => boolean;
-    failed: () => boolean;
-    idle: () => boolean;
-}
-export interface StoreHooks {
-    before?: () => Promise<void> | void;
-    after?: (error?: Error) => Promise<void> | void;
-}
-export interface StoreOptions<_A extends ActionsConfig<any> = ActionsConfig<any>> {
-    adapter?: ApiAdapter<any>;
-    indicator?: string;
-    hooks?: StoreHooks;
-    extensions?: Extension<BaseState>[];
-}
-export type ActionsConfig<S = Record<string, unknown>> = Record<string, ActionDefinition<S>>;
-export type ActionFunction<S> = (params?: Partial<S>, options?: ActionOptions) => Promise<S | S[] | boolean>;
-export type StoreActions<A extends ActionsConfig<S>, S> = {
-    [K in keyof A]: ActionFunction<S>;
+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 StoreMonitor<A extends ActionsConfig<any>> = {
-    [K in keyof A]: ActionStatus;
+export type StoreAction<M extends Model, V, AD extends Record<string, ActionDefinition<M, V, unknown>>> = {
+    [K in keyof AD]: Action<V>;
 };
-export type StoreMemory<T, I extends keyof T> = {
-    set: (data: T | T[] | null) => void;
-    edit: (data: PartialWithIndicator<T, I> | PartialWithIndicator<T, I>[], options?: {
-        deep?: boolean;
-    }) => void;
-    drop: (data: PartialWithIndicator<T, I> | PartialWithIndicator<T, I>[]) => void;
-};
-export type Store<E extends string = string, S = unknown, I extends keyof S = keyof S, A extends ActionsConfig<S> = ActionsConfig<S>> = {
-    store: any;
-    alias: {
-        unit: E;
-        units: Pluralize<E>;
-    };
-    indicator: I;
-    unit: ComputedRef<S | null>;
-    units: ComputedRef<S[]>;
-    action: StoreActions<A, S>;
-    memory: StoreMemory<S, I>;
-    monitor: StoreMonitor<A>;
-};
-type Indicator<T, I extends keyof T> = Required<Pick<T, I>>;
-type PartialWithIndicator<T, I extends keyof T> = Indicator<T, I> & Partial<T>;
-export declare function createStore<E extends string, T extends z.ZodRawShape, A extends ActionsConfig<z.infer<z.ZodObject<T>>>, S extends z.infer<z.ZodObject<T>> = z.infer<z.ZodObject<T>>, I extends keyof S = "id" & keyof S>(entity: E, schema: z.ZodObject<T>, actions: A, options?: StoreOptions<A>): Store<E, S, I, A>;
-export {};
+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>;