@diphyx/harlemify 4.0.1 → 5.0.0

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

@@ -3,263 +3,279 @@ 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;
+}
+function resolveApiHeaders(definition, view, options) {
+  const initial = resolveValue(definition.request.headers, view, {});
+  const custom = options?.headers ?? {};
+  return defu(custom, initial);
 }
-class ConcurrentError extends Error {
-  name = "ActionConcurrentError";
-  constructor() {
-    super("Action is already pending");
+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;
+  let globalData = 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);
-        }
-        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 = await executeHandler(definition, model, view);
         }
-        data = result;
+        globalData = data;
         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;
@@ -282,12 +298,12 @@ export function createAction(definition, mutations, view, key) {
       return readonly(globalStatus);
     },
     get data() {
-      return data;
+      return globalData;
     },
     reset() {
       globalError.value = null;
       globalStatus.value = ActionStatus.IDLE;
-      data = null;
+      globalData = null;
     }
   });
   return action;

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

@@ -0,0 +1,4 @@
+export declare function trimStart(value: string, char: string): string;
+export declare function trimEnd(value: string, char: string): string;
+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

@@ -0,0 +1,24 @@
+export function trimStart(value, char) {
+  return value.replace(new RegExp(`^${char}+`), "");
+}
+export function trimEnd(value, char) {
+  return value.replace(new RegExp(`${char}+$`), "");
+}
+export function isPlainObject(value) {
+  if (!value || typeof value !== "object") {
+    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;
+}

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;

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

@@ -0,0 +1,36 @@
+export class ActionApiError extends Error {
+  name = "ActionApiError";
+  constructor(source) {
+    super(source.message || "API request failed");
+    this.status = source?.status ?? source?.response?.status ?? 500;
+    this.statusText = source?.statusText ?? source?.response?.statusText ?? "Internal Server Error";
+    this.data = source?.data ?? source?.response?._data ?? null;
+  }
+}
+export class ActionHandlerError extends Error {
+  name = "ActionHandlerError";
+  constructor(source) {
+    super(source.message || "Action handler failed");
+  }
+}
+export class ActionCommitError extends Error {
+  name = "ActionCommitError";
+  constructor(source) {
+    super(source.message || "Action commit failed");
+  }
+}
+export class ActionConcurrentError extends Error {
+  name = "ActionConcurrentError";
+  constructor() {
+    super("Action is already pending");
+  }
+}
+export function isError(error, ...types) {
+  return types.some((ErrorType) => error instanceof ErrorType);
+}
+export function toError(error, ErrorType) {
+  if (ErrorType) {
+    return new ErrorType(error);
+  }
+  return error instanceof Error ? error : new Error(String(error));
+}

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

@@ -1,12 +1,4 @@
 import type { Store as SourceStore, BaseState } from "@harlem/core";
-import { type Model, type ModelStateOf, type MutationsOneOptions, type MutationsManyOptions, type Mutations } from "../types/model.js";
-import { type ActionCommitter, ActionOneMode, ActionManyMode } from "../types/action.js";
-export declare function initializeState<M extends Model>(model: M): ModelStateOf<M>;
-export declare function createMutations<M extends Model>(source: SourceStore<BaseState>, model: M): Mutations<M>;
-export declare function executeCommit<M extends Model>(definition: {
-    model: keyof M;
-    mode: ActionOneMode | ActionManyMode;
-    value?: unknown;
-    options?: MutationsOneOptions | MutationsManyOptions;
-}, mutations: Mutations<M>, result?: unknown): void;
-export declare function createCommitter<M extends Model>(mutations: Mutations<M>): ActionCommitter<M>;
+import type { Shape } from "../types/shape.js";
+import { type ModelDefinition, type ModelCall } from "../types/model.js";
+export declare function createModel<S extends Shape>(definition: ModelDefinition<S>, source: SourceStore<BaseState>): ModelCall<S>;