@diphyx/harlemify 4.0.1 → 5.1.0

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

@@ -1,4 +1,4 @@
-import { type Action, type ActionCommitMethod, type ActionDefinition } from "../types/action.js";
-import type { Model, Mutations } from "../types/model.js";
-export declare function buildCommitMethod<M extends Model, V, R>(definition: ActionDefinition<M, V, R>): ActionCommitMethod<M, V, R>;
-export declare function createAction<M extends Model, V, R>(definition: ActionDefinition<M, V, R>, mutations: Mutations<M>, view: V, key: string): Action<V, R>;
+import { type StoreModel, type ModelDefinitions } from "../types/model.js";
+import type { StoreView, ViewDefinitions } from "../types/view.js";
+import { type ActionCall, type ActionDefinition } from "../types/action.js";
+export declare function createAction<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R>(definition: ActionDefinition<MD, VD>, model: StoreModel<MD>, view: StoreView<MD, VD>): ActionCall<R>;

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

@@ -3,263 +3,277 @@ import { ref, computed, readonly, toValue, nextTick } from "vue";
 import {
   ActionApiMethod,
   ActionStatus,
-  ActionConcurrent,
-  DEFINITION
+  ActionConcurrent
 } from "../types/action.js";
-import { createCommitter, executeCommit } from "./model.js";
-class ApiError extends Error {
-  name = "ActionApiError";
-  constructor(message, options) {
-    super(message);
-    this.status = options?.status;
-    this.statusText = options?.statusText;
-    this.data = options?.data;
+import { trimStart, trimEnd, isEmptyRecord, isPlainObject } from "./base.js";
+import {
+  ActionApiError,
+  ActionHandlerError,
+  ActionCommitError,
+  ActionConcurrentError,
+  isError,
+  toError
+} from "./error.js";
+import { resolveAliasInbound, resolveAliasOutbound } from "./shape.js";
+function resolveValue(value, view, fallback) {
+  if (typeof value === "function") {
+    return value(view) || fallback;
   }
+  return toValue(value) || fallback;
 }
-class HandleError extends Error {
-  name = "ActionHandleError";
-  constructor(cause) {
-    super(cause.message);
-    this.cause = cause;
+function resolveApiUrl(definition, view, options) {
+  const endpoint = trimEnd(definition.request.endpoint ?? "", "/");
+  let path = resolveValue(definition.request.url, view);
+  if (options?.params) {
+    for (const [key, value] of Object.entries(options.params)) {
+      path = path.replace(`:${key}`, encodeURIComponent(value));
+    }
   }
-}
-class CommitError extends Error {
-  name = "ActionCommitError";
-  constructor(cause) {
-    super(cause.message);
-    this.cause = cause;
+  if (endpoint) {
+    return `${endpoint}/${trimStart(path, "/")}`;
   }
+  return path;
 }
-class ConcurrentError extends Error {
-  name = "ActionConcurrentError";
-  constructor() {
-    super("Action is already pending");
+function resolveApiHeaders(definition, view, options) {
+  const initial = resolveValue(definition.request.headers, view, {});
+  const custom = options?.headers ?? {};
+  return defu(custom, initial);
+}
+function resolveApiQuery(definition, view, options) {
+  const initial = resolveValue(definition.request.query, view, {});
+  const custom = options?.query ?? {};
+  return defu(custom, initial);
+}
+function resolveApiBody(definition, view, target, options) {
+  if (definition.request.method === ActionApiMethod.GET || definition.request.method === ActionApiMethod.HEAD) {
+    return void 0;
+  }
+  const initial = resolveValue(definition.request.body, view, {});
+  const custom = options?.body ?? {};
+  const body = defu(custom, initial);
+  if (!isPlainObject(body)) {
+    return body;
   }
+  if (!isEmptyRecord(target?.aliases())) {
+    return resolveAliasOutbound(body, target.aliases());
+  }
+  return body;
 }
-function createApiError(message, options) {
-  return new ApiError(message, options);
+function resolveApiMethod(definition, view) {
+  return resolveValue(definition.request.method, view, ActionApiMethod.GET);
 }
-function createHandleError(cause) {
-  return new HandleError(cause);
+function resolveApiTimeout(definition, view, options) {
+  if (options?.timeout) {
+    return options.timeout;
+  }
+  if (definition.request.timeout) {
+    return resolveValue(definition.request.timeout, view);
+  }
+  return void 0;
 }
-function createCommitError(cause) {
-  return new CommitError(cause);
+function resolveApiSignal(options, abortController) {
+  if (options?.signal) {
+    return options.signal;
+  }
+  return abortController.signal;
 }
-function createConcurrentError() {
-  return new ConcurrentError();
+function resolveCommitTarget(commit, model) {
+  if (commit) {
+    return model[commit.model];
+  }
+  return void 0;
 }
-export function buildCommitMethod(definition) {
-  function commit(model, mode, value, options) {
-    return {
-      [DEFINITION]: {
-        ...definition,
-        commit: {
-          model,
-          mode,
-          value,
-          options
-        }
-      }
-    };
+function resolveCommitMode(commit, options) {
+  if (commit) {
+    if (options?.commit?.mode) {
+      return options.commit.mode;
+    }
+    return commit.mode;
   }
-  return commit;
+  return void 0;
 }
-function resolveApiValue(value, view, fallback) {
-  if (typeof value === "function") {
-    const handler = value;
-    return handler(view) || fallback;
+function resolveCommitValue(commit, data) {
+  if (typeof commit.value === "function") {
+    return commit.value(data);
   }
-  return toValue(value) || fallback;
+  return data;
 }
-function resolveApiUrl(definition, view) {
-  const endpoint = (definition.endpoint ?? "").replace(/\/+$/, "");
-  const path = resolveApiValue(definition.url, view);
-  if (endpoint) {
-    return `${endpoint}/${path.replace(/^\/+/, "")}`;
+function isApiDefinition(definition) {
+  return "request" in definition;
+}
+function resolveConcurrent(definition, options) {
+  if (options?.concurrent) {
+    return options.concurrent;
   }
-  return path;
+  if (isApiDefinition(definition) && definition.request.concurrent) {
+    return definition.request.concurrent;
+  }
+  return ActionConcurrent.BLOCK;
 }
-function resolveApiHeaders(definition, view, payload) {
-  const initial = resolveApiValue(definition.headers, view, {});
-  const custom = resolveApiValue(payload?.headers, view, {});
-  return defu(custom, initial);
+async function executeApi(definition, api, options) {
+  try {
+    definition.logger?.debug("Action API request", {
+      action: definition.key,
+      method: api.method,
+      url: api.url
+    });
+    if (options?.transformer?.request) {
+      api = options.transformer.request(api);
+    }
+    const response = await $fetch(api.url, {
+      method: api.method,
+      headers: api.headers,
+      query: api.query,
+      body: api.body,
+      timeout: api.timeout,
+      signal: api.signal,
+      responseType: "json"
+    });
+    definition.logger?.debug("Action API response received", {
+      action: definition.key,
+      method: api.method,
+      url: api.url
+    });
+    if (options?.transformer?.response) {
+      return options.transformer.response(response);
+    }
+    return response;
+  } catch (error) {
+    const fetchError = toError(error, ActionApiError);
+    definition.logger?.error("Action API error", {
+      action: definition.key,
+      error: fetchError.message
+    });
+    throw fetchError;
+  }
 }
-function resolveApiQuery(definition, view, payload) {
-  const initial = resolveApiValue(definition.query, view, {});
-  const custom = resolveApiValue(payload?.query, view, {});
-  return defu(custom, initial);
+async function executeHandler(definition, model, view) {
+  try {
+    definition.logger?.debug("Action handler phase", {
+      action: definition.key
+    });
+    return await definition.callback({
+      model,
+      view
+    });
+  } catch (error) {
+    if (isError(error, ActionApiError, ActionHandlerError)) {
+      throw error;
+    }
+    const handlerError = toError(error, ActionHandlerError);
+    definition.logger?.error("Action handler error", {
+      action: definition.key,
+      error: handlerError.message
+    });
+    throw handlerError;
+  }
 }
-function resolveApiBody(definition, view, payload) {
-  if (definition.method === ActionApiMethod.GET || definition.method === ActionApiMethod.HEAD) {
-    return void 0;
+function executeCommit(definition, target, mode, data) {
+  if (!definition.commit) {
+    return;
+  }
+  if (!target || !mode) {
+    throw new ActionCommitError({
+      message: `Model "${definition.commit.model}" is not defined`
+    });
+  }
+  try {
+    definition.logger?.debug("Action commit phase", {
+      action: definition.key,
+      target,
+      mode
+    });
+    if (!isEmptyRecord(target.aliases())) {
+      data = resolveAliasInbound(data, target.aliases());
+    }
+    const value = resolveCommitValue(definition.commit, data);
+    target.commit(mode, value, definition.commit.options);
+  } catch (error) {
+    const commitError = toError(error, ActionCommitError);
+    definition.logger?.error("Action commit error", {
+      action: definition.key,
+      error: commitError.message
+    });
+    throw commitError;
   }
-  const initial = resolveApiValue(definition.body, view, {});
-  const custom = resolveApiValue(payload?.body, view, {});
-  return defu(custom, initial);
 }
-export function createAction(definition, mutations, view, key) {
+export function createAction(definition, model, view) {
+  definition.logger?.debug("Registering action", {
+    action: definition.key,
+    type: isApiDefinition(definition) ? "api" : "handler"
+  });
+  let currentController = null;
+  let abortController = null;
   const globalError = ref(null);
   const globalStatus = ref(ActionStatus.IDLE);
   const loading = computed(() => {
     return globalStatus.value === ActionStatus.PENDING;
   });
-  let data = null;
-  let currentController = null;
-  let abortController = null;
-  async function execute(payload) {
+  async function execute(options) {
     await nextTick();
+    const concurrent = resolveConcurrent(definition, options);
     if (loading.value) {
-      const concurrent = payload?.concurrent ?? definition.api?.concurrent ?? ActionConcurrent.BLOCK;
       switch (concurrent) {
         case ActionConcurrent.BLOCK: {
           definition.logger?.error("Action blocked by concurrent guard", {
-            action: key
+            action: definition.key
           });
-          throw createConcurrentError();
+          throw new ActionConcurrentError();
         }
         case ActionConcurrent.SKIP: {
           definition.logger?.warn("Action skipped by concurrent guard", {
-            action: key
+            action: definition.key
           });
           return currentController;
         }
         case ActionConcurrent.CANCEL: {
           definition.logger?.warn("Action cancelling previous execution", {
-            action: key
+            action: definition.key
           });
           abortController?.abort();
         }
       }
     }
     abortController = new AbortController();
-    const activeStatus = payload?.bind?.status ?? globalStatus;
-    const activeError = payload?.bind?.error ?? globalError;
+    const activeStatus = options?.bind?.status ?? globalStatus;
+    const activeError = options?.bind?.error ?? globalError;
     activeStatus.value = ActionStatus.PENDING;
     activeError.value = null;
     currentController = (async () => {
       try {
-        let result;
-        const committer = createCommitter(mutations);
-        if (definition.api) {
-          let response;
-          try {
-            const apiPayload = {
-              ...payload,
-              signal: payload?.signal ?? abortController.signal
-            };
-            const url = resolveApiUrl(definition.api, view);
-            definition.logger?.debug("Action API request", {
-              action: key,
-              method: definition.api.method,
-              url
-            });
-            response = await $fetch(url, {
-              method: definition.api.method,
-              headers: resolveApiHeaders(definition.api, view, apiPayload),
-              query: resolveApiQuery(definition.api, view, apiPayload),
-              body: resolveApiBody(definition.api, view, apiPayload),
-              timeout: apiPayload?.timeout ?? definition.api.timeout,
-              signal: apiPayload?.signal
-            });
-            definition.logger?.debug("Action API response received", {
-              action: key,
-              method: definition.api.method,
-              url
-            });
-          } catch (error) {
-            const errorMessage = error?.message ?? "API request failed";
-            const errorOptions = {
-              status: error?.status ?? error?.response?.status,
-              statusText: error?.statusText ?? error?.response?.statusText,
-              data: error?.data ?? error?.response?._data
-            };
-            definition.logger?.error("Action API error", {
-              action: key,
-              error: errorMessage
-            });
-            throw createApiError(errorMessage, errorOptions);
-          }
-          if (definition.handle) {
-            const handler = definition.handle;
-            try {
-              definition.logger?.debug("Action handle phase", {
-                action: key
-              });
-              result = await handler({
-                view,
-                commit: committer,
-                async api() {
-                  return response;
-                }
-              });
-            } catch (handleError) {
-              if (handleError instanceof ApiError || handleError instanceof HandleError) {
-                throw handleError;
-              }
-              definition.logger?.error("Action handle error", {
-                action: key,
-                error: handleError?.message
-              });
-              throw createHandleError(handleError);
-            }
-          } else {
-            result = response;
-          }
-        } else if (definition.handle) {
-          const handler = definition.handle;
-          try {
-            definition.logger?.debug("Action handle phase", {
-              action: key
-            });
-            result = await handler({
-              view,
-              commit: committer
-            });
-          } catch (handleError) {
-            if (handleError instanceof HandleError) {
-              throw handleError;
-            }
-            definition.logger?.error("Action handle error", {
-              action: key,
-              error: handleError?.message
-            });
-            throw createHandleError(handleError);
-          }
+        let data;
+        if (isApiDefinition(definition)) {
+          const target = resolveCommitTarget(definition.commit, model);
+          const mode = resolveCommitMode(definition.commit, options);
+          const url = resolveApiUrl(definition, view, options);
+          const method = resolveApiMethod(definition, view);
+          const headers = resolveApiHeaders(definition, view, options);
+          const query = resolveApiQuery(definition, view, options);
+          const body = resolveApiBody(definition, view, target, options);
+          const timeout = resolveApiTimeout(definition, view, options);
+          const signal = resolveApiSignal(options, abortController);
+          data = await executeApi(
+            definition,
+            {
+              url,
+              method,
+              headers,
+              query,
+              body,
+              timeout,
+              signal
+            },
+            options
+          );
+          executeCommit(definition, target, mode, data);
         } else {
-          result = void 0;
-        }
-        if (payload?.transformer) {
-          result = payload.transformer(result);
+          data = await executeHandler(definition, model, view);
         }
-        if (definition.commit) {
-          try {
-            definition.logger?.debug("Action commit phase", {
-              action: key,
-              model: definition.commit.model,
-              mode: definition.commit.mode
-            });
-            executeCommit(
-              {
-                ...definition.commit,
-                mode: payload?.commit?.mode ?? definition.commit.mode
-              },
-              mutations,
-              result
-            );
-          } catch (commitError) {
-            definition.logger?.error("Action commit error", {
-              action: key,
-              error: commitError?.message
-            });
-            throw createCommitError(commitError);
-          }
-        }
-        data = result;
         activeStatus.value = ActionStatus.SUCCESS;
         definition.logger?.debug("Action success", {
-          action: key
+          action: definition.key
         });
-        return result;
+        return data;
       } catch (actionError) {
         activeError.value = actionError;
         activeStatus.value = ActionStatus.ERROR;
@@ -272,22 +286,18 @@ export function createAction(definition, mutations, view, key) {
     return currentController;
   }
   const action = Object.assign(execute, {
-    get loading() {
-      return loading;
-    },
     get error() {
       return readonly(globalError);
     },
     get status() {
       return readonly(globalStatus);
     },
-    get data() {
-      return data;
+    get loading() {
+      return loading;
     },
     reset() {
       globalError.value = null;
       globalStatus.value = ActionStatus.IDLE;
-      data = null;
     }
   });
   return action;

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

@@ -0,0 +1,14 @@
+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;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isEmptyRecord(record: Record<string, unknown> | undefined): record is undefined;
+type ReferenceProxy<T> = {
+    value: T;
+} & Record<string | symbol, unknown>;
+export declare function toReactiveProxy<T>(reference: {
+    value: T;
+}): ReferenceProxy<T>;
+export declare function debounce<T extends (...args: any[]) => any>(callback: T, delay: number): T;
+export declare function throttle<T extends (...args: any[]) => any>(callback: T, delay: number): T;
+export {};

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

@@ -0,0 +1,109 @@
+export function trimStart(value, char) {
+  return value.replace(new RegExp(`^${char}+`), "");
+}
+export function trimEnd(value, char) {
+  return value.replace(new RegExp(`${char}+$`), "");
+}
+export function isObject(value) {
+  return value != null && typeof value === "object";
+}
+export function isPlainObject(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  return true;
+}
+export function isEmptyRecord(record) {
+  if (!record) {
+    return true;
+  }
+  if (Object.keys(record).length === 0) {
+    return true;
+  }
+  return false;
+}
+export function toReactiveProxy(reference) {
+  function get(_target, prop) {
+    if (prop === "value") {
+      return reference.value;
+    }
+    if (!isObject(reference.value)) {
+      return void 0;
+    }
+    return reference.value[prop];
+  }
+  function has(_target, prop) {
+    if (prop === "value") {
+      return true;
+    }
+    if (!isObject(reference.value)) {
+      return false;
+    }
+    return prop in reference.value;
+  }
+  function ownKeys() {
+    if (!isObject(reference.value)) {
+      return [];
+    }
+    return Reflect.ownKeys(reference.value);
+  }
+  function getOwnPropertyDescriptor(_target, prop) {
+    if (!isObject(reference.value) || !(prop in reference.value)) {
+      return void 0;
+    }
+    return {
+      configurable: true,
+      enumerable: true,
+      value: reference.value[prop]
+    };
+  }
+  return new Proxy(
+    {},
+    {
+      get,
+      has,
+      ownKeys,
+      getOwnPropertyDescriptor
+    }
+  );
+}
+export function debounce(callback, delay) {
+  let timer = null;
+  return (...args) => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      callback(...args);
+    }, delay);
+  };
+}
+export function throttle(callback, delay) {
+  let lastCall = 0;
+  let timer = null;
+  return (...args) => {
+    const now = Date.now();
+    const remaining = delay - (now - lastCall);
+    if (remaining <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      lastCall = now;
+      callback(...args);
+      return;
+    }
+    if (timer) {
+      return;
+    }
+    timer = setTimeout(() => {
+      lastCall = Date.now();
+      timer = null;
+      callback(...args);
+    }, remaining);
+  };
+}

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

@@ -0,0 +1,21 @@
+export declare class ActionApiError extends Error {
+    name: "ActionApiError";
+    status: number;
+    statusText: string;
+    data: unknown;
+    constructor(source: any);
+}
+export declare class ActionHandlerError extends Error {
+    name: "ActionHandlerError";
+    constructor(source: any);
+}
+export declare class ActionCommitError extends Error {
+    name: "ActionCommitError";
+    constructor(source: any);
+}
+export declare class ActionConcurrentError extends Error {
+    name: "ActionConcurrentError";
+    constructor();
+}
+export declare function isError(error: unknown, ...types: (abstract new (...args: never[]) => Error)[]): error is Error;
+export declare function toError<T extends Error = Error>(error: unknown, ErrorType?: new (source: unknown) => T): T;