npm - @ramathibodi/nuxt-commons - Versions diffs - 4.0.13 → 4.0.15 - Mend

@ramathibodi/nuxt-commons 4.0.13 → 4.0.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

package/dist/runtime/composables/api.d.ts CHANGED Viewed

@@ -64,6 +64,13 @@ export type CacheOption = boolean | number | {
  */
 export interface ApiIdempotencyOption {
     idempotent?: boolean;
+    /**
+     * Optional discriminator folded as a trailing component into the
+     * Idempotency-Key hash: SHA-256(`<second>|<username>|<body>|<salt>`).
+     * Lets legitimately-identical payloads (e.g. duplicate bulk-import rows)
+     * resolve to distinct keys without weakening dedup elsewhere.
+     */
+    idempotencySalt?: string | number;
 }
 export type ApiFetchOptions = UseFetchOptions<unknown> & ApiIdempotencyOption;
 export declare function _resetLegacyHeuristicWarning(): void;

package/dist/runtime/composables/api.js CHANGED Viewed

@@ -101,9 +101,10 @@ export function useApi() {
       const username = (typeof auth.getUsername === "function" ? auth.getUsername() : auth.userProfile?.username) ?? "";
       const second = Math.floor(Date.now() / 1e3).toString();
       const bodyJson = stableStringify(body ?? {});
-      headers[headerName] = await sha256(`${second}|${username}|${bodyJson}`);
+      const salt = options.idempotencySalt != null ? `|${String(options.idempotencySalt)}` : "";
+      headers[headerName] = await sha256(`${second}|${username}|${bodyJson}${salt}`);
     }
-    const { idempotent: _omitIdempotent, ...passThroughOptions } = options;
+    const { idempotent: _omitIdempotent, idempotencySalt: _omitSalt, ...passThroughOptions } = options;
     const baseOptions = {
       method,
       body,

package/dist/runtime/composables/apiModel.d.ts CHANGED Viewed

@@ -30,9 +30,9 @@ export declare function useApiModel<T extends ApiModelComposableProps>(props: T)
     canCreate: import("vue").ComputedRef<boolean>;
     canUpdate: import("vue").ComputedRef<boolean>;
     canDelete: import("vue").ComputedRef<boolean>;
-    createItem: (item: Record<string, any>, callback?: FormDialogCallback, importing?: boolean) => Promise<any>;
+    createItem: (item: Record<string, any>, callback?: FormDialogCallback, importing?: boolean, idempotencySalt?: string | number) => Promise<any>;
     importItems: (importData: Record<string, any>[], callback?: FormDialogCallback) => void;
-    updateItem: (item: Record<string, any>, callback?: FormDialogCallback) => Promise<any>;
+    updateItem: (item: Record<string, any>, callback?: FormDialogCallback, importing?: boolean, idempotencySalt?: string | number) => Promise<any>;
     deleteItem: (item: Record<string, any>, callback?: FormDialogCallback) => Promise<any>;
     loadItems: (options: any) => Promise<void>;
     reload: () => Promise<void>;
@@ -45,15 +45,24 @@ export declare function useApiModel<T extends ApiModelComposableProps>(props: T)
         failed: import("vue").Ref<number, number>;
         errors: import("vue").Ref<{
             index: number;
+            item: any;
+            errorType: import("./importProgress.js").ImportErrorType;
             message: string;
+            detail?: any;
         }[], import("./importProgress.js").ImportError[] | {
             index: number;
+            item: any;
+            errorType: import("./importProgress.js").ImportErrorType;
             message: string;
+            detail?: any;
         }[]>;
         percent: import("vue").ComputedRef<number>;
+        resultVisible: import("vue").Ref<boolean, boolean>;
         reset: () => void;
         run: <T_1 = any>(items: T_1[], worker: import("./importProgress.js").ImportWorker<T_1>, options?: {
             concurrency?: number;
         }) => Promise<import("./importProgress.js").ImportSummary>;
+        retry: (indices?: number[]) => Promise<import("./importProgress.js").ImportSummary>;
+        dismissResult: () => void;
     };
 };

package/dist/runtime/composables/apiModel.js CHANGED Viewed

@@ -50,9 +50,9 @@ export function useApiModel(props) {
     }
     return [.../* @__PURE__ */ new Set([...fieldsProps, ...tmpFields])];
   });
-  function createItem(item, callback, importing = false) {
+  function createItem(item, callback, importing = false, idempotencySalt) {
     isLoading.value = true;
-    return ops.value.create(item, fields.value).then((result) => {
+    return ops.value.create(item, fields.value, idempotencySalt != null ? { idempotencySalt } : void 0).then((result) => {
       if (canServerPageable.value) {
         if (!importing) loadItems(currentOptions.value);
       } else {
@@ -75,15 +75,15 @@ export function useApiModel(props) {
       return;
     }
     isLoading.value = true;
-    const worker = (item) => {
-      const createAsNew = () => createItem(Object.assign({}, props.initialData, item), void 0, true);
-      return item[props.modelKey || "id"] ? updateItem(item, void 0).then((result) => {
+    const worker = (item, _index, salt) => {
+      const createAsNew = () => createItem(Object.assign({}, props.initialData, item), void 0, true, salt);
+      return item[props.modelKey || "id"] ? updateItem(item, void 0, true, salt).then((result) => {
         if (!result) return createAsNew();
       }) : createAsNew();
     };
     importProgress.run(importData, worker, { concurrency: props.importConcurrency }).then(({ succeeded, failed }) => {
       if (failed > 0) {
-        alert?.addAlert({ alertType: "warning", message: `\u0E19\u0E33\u0E40\u0E02\u0E49\u0E32\u0E2A\u0E33\u0E40\u0E23\u0E47\u0E08 ${succeeded} \u0E23\u0E32\u0E22\u0E01\u0E32\u0E23, \u0E25\u0E49\u0E21\u0E40\u0E2B\u0E25\u0E27 ${failed} \u0E23\u0E32\u0E22\u0E01\u0E32\u0E23` });
+        importProgress.resultVisible.value = true;
       } else {
         alert?.addAlert({ alertType: "success", message: `\u0E19\u0E33\u0E40\u0E02\u0E49\u0E32\u0E2A\u0E33\u0E40\u0E23\u0E47\u0E08 ${succeeded} \u0E23\u0E32\u0E22\u0E01\u0E32\u0E23` });
       }
@@ -93,9 +93,9 @@ export function useApiModel(props) {
       if (callback) callback.done();
     });
   }
-  function updateItem(item, callback) {
+  function updateItem(item, callback, importing = false, idempotencySalt) {
     isLoading.value = true;
-    return ops.value.update(item, fields.value).then((result) => {
+    return ops.value.update(item, fields.value, idempotencySalt != null ? { idempotencySalt } : void 0).then((result) => {
       if (canServerPageable.value) {
         loadItems(currentOptions.value);
       } else {
@@ -107,9 +107,10 @@ export function useApiModel(props) {
       if (callback && callback.setData) callback.setData(result);
       return result;
     }).catch((error) => {
+      if (importing) throw error;
       alert?.addAlert({ alertType: "error", message: error?.message || String(error) });
     }).finally(() => {
-      isLoading.value = false;
+      if (!importing) isLoading.value = false;
       if (callback) callback.done();
     });
   }

package/dist/runtime/composables/apiModelOperation.d.ts CHANGED Viewed

@@ -1,3 +1,17 @@
+/**
+ * useApiModelOperation provides a single runtime layer that owns every
+ * URL- and body-building rule for API mode (the REST counterpart to
+ * useGraphQlOperation). Reads preserve the full modelName; mutations
+ * strip the `By<Qualifier>` suffix.
+ *
+ * When the GraphQL bridge has a `graphqlType[modelName]` entry, fields
+ * are expanded via the existing buildFields() helper exactly the way
+ * useGraphQlOperation does for GraphQL queries. Otherwise, fields and
+ * variables pass through verbatim.
+ *
+ * This doc block is consumed by vue-docgen for generated API documentation.
+ */
+import { type ApiIdempotencyOption } from './api.js';
 export interface ApiModelPageable {
     page?: number;
     perPage?: number;
@@ -12,8 +26,8 @@ export interface ApiModelOperationCallables<TItem = any, TInput = any> {
         };
     }>;
     search: <T = TItem>(fields?: Array<string | object>, variables?: Record<string, any>, search?: any) => Promise<T[]>;
-    create: <T = TItem>(input: TInput | Record<string, any>, fields?: Array<string | object>) => Promise<T>;
-    update: <T = TItem>(input: TInput | Record<string, any>, fields?: Array<string | object>) => Promise<T>;
-    delete: <T = any>(input: TInput | Record<string, any>, fields?: Array<string | object>) => Promise<T>;
+    create: <T = TItem>(input: TInput | Record<string, any>, fields?: Array<string | object>, options?: ApiIdempotencyOption) => Promise<T>;
+    update: <T = TItem>(input: TInput | Record<string, any>, fields?: Array<string | object>, options?: ApiIdempotencyOption) => Promise<T>;
+    delete: <T = any>(input: TInput | Record<string, any>, fields?: Array<string | object>, options?: ApiIdempotencyOption) => Promise<T>;
 }
 export declare function useApiModelOperation<TItem = any, TInput = any>(modelName: string): ApiModelOperationCallables<TItem, TInput>;

package/dist/runtime/composables/apiModelOperation.js CHANGED Viewed

@@ -40,17 +40,17 @@ export function useApiModelOperation(modelName) {
         search
       });
     },
-    create: (input, fields) => {
+    create: (input, fields, options) => {
       const endpoint = buildApiEndpoint(stripModelByQualifier(modelName), "create");
-      return api.postPromise(endpoint, { input, fields: prepFields(fields) });
+      return api.postPromise(endpoint, { input, fields: prepFields(fields) }, void 0, options);
     },
-    update: (input, fields) => {
+    update: (input, fields, options) => {
       const endpoint = buildApiEndpoint(stripModelByQualifier(modelName), "update");
-      return api.postPromise(endpoint, { input, fields: prepFields(fields) });
+      return api.postPromise(endpoint, { input, fields: prepFields(fields) }, void 0, options);
     },
-    delete: (input, fields) => {
+    delete: (input, fields, options) => {
       const endpoint = buildApiEndpoint(stripModelByQualifier(modelName), "delete");
-      return api.postPromise(endpoint, { input, fields: prepFields(fields) });
+      return api.postPromise(endpoint, { input, fields: prepFields(fields) }, void 0, options);
     }
   };
 }

package/dist/runtime/composables/graphql.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { type UseMutationReturn } from '@vue/apollo-composable';
 import { type ClassConstructor } from '../utils/object.js';
-import { type CacheOption } from './api.js';
+import { type CacheOption, type ApiIdempotencyOption } from './api.js';
 declare type VariableOptions = {
     type?: string;
     name?: string;
@@ -12,8 +12,8 @@ declare type VariableOptions = {
 };
 export declare function useGraphQl(): {
     query: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions, cache?: boolean) => import("@vue/apollo-composable").UseQueryReturn<T, Record<string, never>>;
-    queryPromise: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions, cache?: CacheOption) => Promise<T>;
+    queryPromise: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions, cache?: CacheOption, options?: ApiIdempotencyOption) => Promise<T>;
     mutation: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions) => UseMutationReturn<any, any>;
-    mutationPromise: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions) => Promise<T>;
+    mutationPromise: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions, options?: ApiIdempotencyOption) => Promise<T>;
 };
 export {};

package/dist/runtime/composables/graphql.js CHANGED Viewed

@@ -5,12 +5,12 @@ import { classAttributes, isClassConstructor } from "../utils/object.js";
 import { useApi } from "./api.js";
 import { useRuntimeConfig } from "#imports";
 export function useGraphQl() {
-  function simplePromiseCall(operation, query2, variables, cache = false) {
+  function simplePromiseCall(operation, query2, variables, cache = false, options) {
     return new Promise((resolve, reject) => {
       useApi().postPromise(useRuntimeConfig().public.WS_GRAPHQL, {
         query: query2,
         variables
-      }, void 0, void 0, cache).then((result) => {
+      }, void 0, options, cache).then((result) => {
         if (result.errors) reject(result.errors.map((error) => {
           return error.message;
         }).join("\n"));
@@ -35,20 +35,20 @@ export function useGraphQl() {
     };
     return useQuery(gql(builder.query), builder.variables, options);
   }
-  function queryPromise(operation, fields, variables, cache = false) {
+  function queryPromise(operation, fields, variables, cache = false, options) {
     if (isClassConstructor(fields)) fields = classAttributes(fields);
     const builder = gqlQuery({ operation, fields, variables });
-    return simplePromiseCall(operation, builder.query, builder.variables, cache);
+    return simplePromiseCall(operation, builder.query, builder.variables, cache, options);
   }
   function mutation(operation, fields, variables) {
     if (isClassConstructor(fields)) fields = classAttributes(fields);
     const builder = gqlMutation({ operation, fields, variables });
     return useMutation(gql(builder.query), { variables: builder.variables });
   }
-  function mutationPromise(operation, fields, variables) {
+  function mutationPromise(operation, fields, variables, options) {
     if (isClassConstructor(fields)) fields = classAttributes(fields);
     const builder = gqlMutation({ operation, fields, variables });
-    return simplePromiseCall(operation, builder.query, builder.variables);
+    return simplePromiseCall(operation, builder.query, builder.variables, false, options);
   }
   return { query, queryPromise, mutation, mutationPromise };
 }

package/dist/runtime/composables/graphqlModel.d.ts CHANGED Viewed

@@ -25,9 +25,9 @@ export declare function useGraphqlModel<T extends GraphqlModelProps>(props: T):
     canCreate: import("vue").ComputedRef<boolean>;
     canUpdate: import("vue").ComputedRef<boolean>;
     canDelete: import("vue").ComputedRef<boolean>;
-    createItem: (item: Record<string, any>, callback?: FormDialogCallback, importing?: boolean) => Promise<void>;
+    createItem: (item: Record<string, any>, callback?: FormDialogCallback, importing?: boolean, idempotencySalt?: string | number) => Promise<void>;
     importItems: (importData: Record<string, any>[], callback?: FormDialogCallback) => void;
-    updateItem: (item: Record<string, any>, callback?: FormDialogCallback) => Promise<void>;
+    updateItem: (item: Record<string, any>, callback?: FormDialogCallback, idempotencySalt?: string | number) => Promise<void>;
     deleteItem: (item: Record<string, any>, callback?: FormDialogCallback) => Promise<any>;
     loadItems: (options: any) => Promise<void> | undefined;
     reload: () => Promise<void> | undefined;
@@ -40,15 +40,24 @@ export declare function useGraphqlModel<T extends GraphqlModelProps>(props: T):
         failed: import("vue").Ref<number, number>;
         errors: import("vue").Ref<{
             index: number;
+            item: any;
+            errorType: import("./importProgress.js").ImportErrorType;
             message: string;
+            detail?: any;
         }[], import("./importProgress.js").ImportError[] | {
             index: number;
+            item: any;
+            errorType: import("./importProgress.js").ImportErrorType;
             message: string;
+            detail?: any;
         }[]>;
         percent: import("vue").ComputedRef<number>;
+        resultVisible: import("vue").Ref<boolean, boolean>;
         reset: () => void;
         run: <T_1 = any>(items: T_1[], worker: import("./importProgress.js").ImportWorker<T_1>, options?: {
             concurrency?: number;
         }) => Promise<import("./importProgress.js").ImportSummary>;
+        retry: (indices?: number[]) => Promise<import("./importProgress.js").ImportSummary>;
+        dismissResult: () => void;
     };
 };

package/dist/runtime/composables/graphqlModel.js CHANGED Viewed

@@ -57,9 +57,9 @@ export function useGraphqlModel(props) {
   const canDelete = computed(() => {
     return !!operationDelete.value;
   });
-  function createItem(item, callback, importing = false) {
+  function createItem(item, callback, importing = false, idempotencySalt) {
     isLoading.value = true;
-    return operationCreate.value?.call(fields.value, { input: item }).then((result) => {
+    return operationCreate.value?.call(fields.value, { input: item }, void 0, idempotencySalt != null ? { idempotencySalt } : void 0).then((result) => {
       if (canServerPageable.value) {
         if (!importing) loadItems(currentOptions.value);
       } else items.value.push(result);
@@ -79,15 +79,15 @@ export function useGraphqlModel(props) {
       return;
     }
     isLoading.value = true;
-    const worker = (item) => {
-      const createAsNew = () => createItem(Object.assign({}, props.initialData, item), void 0, true);
-      return item[props.modelKey || "id"] ? operationUpdate.value?.call(fields.value, { input: item }).then((result) => {
+    const worker = (item, _index, salt) => {
+      const createAsNew = () => createItem(Object.assign({}, props.initialData, item), void 0, true, salt);
+      return item[props.modelKey || "id"] ? operationUpdate.value?.call(fields.value, { input: item }, void 0, salt != null ? { idempotencySalt: salt } : void 0).then((result) => {
         if (!result) return createAsNew();
       }) : createAsNew();
     };
     importProgress.run(importData, worker, { concurrency: props.importConcurrency }).then(({ succeeded, failed }) => {
       if (failed > 0) {
-        alert?.addAlert({ alertType: "warning", message: `\u0E19\u0E33\u0E40\u0E02\u0E49\u0E32\u0E2A\u0E33\u0E40\u0E23\u0E47\u0E08 ${succeeded} \u0E23\u0E32\u0E22\u0E01\u0E32\u0E23, \u0E25\u0E49\u0E21\u0E40\u0E2B\u0E25\u0E27 ${failed} \u0E23\u0E32\u0E22\u0E01\u0E32\u0E23` });
+        importProgress.resultVisible.value = true;
       } else {
         alert?.addAlert({ alertType: "success", message: `\u0E19\u0E33\u0E40\u0E02\u0E49\u0E32\u0E2A\u0E33\u0E40\u0E23\u0E47\u0E08 ${succeeded} \u0E23\u0E32\u0E22\u0E01\u0E32\u0E23` });
       }
@@ -97,9 +97,9 @@ export function useGraphqlModel(props) {
       if (callback) callback.done();
     });
   }
-  function updateItem(item, callback) {
+  function updateItem(item, callback, idempotencySalt) {
     isLoading.value = true;
-    return operationUpdate.value?.call(fields.value, { input: item }).then((result) => {
+    return operationUpdate.value?.call(fields.value, { input: item }, void 0, idempotencySalt != null ? { idempotencySalt } : void 0).then((result) => {
       if (canServerPageable.value) loadItems(currentOptions.value);
       else {
         const index = items.value.findIndex((item2) => item2[props.modelKey || "id"] === result[props.modelKey || "id"]);

package/dist/runtime/composables/graphqlOperation.d.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import { type ClassConstructor } from '../utils/object.js';
 import type { graphqlTypeObject, graphqlVariable } from '../types/graphqlOperation.js';
+import type { ApiIdempotencyOption } from './api.js';
 export declare function buildFields(operationFields: graphqlTypeObject, fields?: Array<string | Object> | ClassConstructor<any>, depth?: number): Array<string | Object>;
 export declare function buildVariables(outputVariables?: graphqlVariable[], inputVariables?: {
     [p: string]: any;
@@ -7,4 +8,4 @@ export declare function buildVariables(outputVariables?: graphqlVariable[], inpu
 export declare function buildRequiredInputFields(variables: graphqlVariable[] | undefined, inputField?: string): string[];
 export declare function useGraphQlOperation<T>(operationType: string, operation: string, fields?: Array<string | Object> | ClassConstructor<any>, variables?: {
     [p: string]: any;
-}, cache?: boolean | number): Promise<T>;
+}, cache?: boolean | number, options?: ApiIdempotencyOption): Promise<T>;

package/dist/runtime/composables/graphqlOperation.js CHANGED Viewed

@@ -93,7 +93,7 @@ export function buildRequiredInputFields(variables, inputField = "input") {
     return [];
   }
 }
-export function useGraphQlOperation(operationType, operation, fields, variables, cache = false) {
+export function useGraphQlOperation(operationType, operation, fields, variables, cache = false, options) {
   const { graphqlOperation } = useGraphqlBridge();
   return new Promise((resolve, reject) => {
     let rejectReason = void 0;
@@ -107,8 +107,8 @@ export function useGraphQlOperation(operationType, operation, fields, variables,
     }
     if (graphqlOperation[operation]?.fields) {
       fields = buildFields(graphqlOperation[operation]?.fields, fields, 0);
-      if (operationType == "Query") useGraphQl().queryPromise(operation, fields, variables, cache).then((result) => resolve(result)).catch((error) => reject(error));
-      else if (operationType == "Mutation") useGraphQl().mutationPromise(operation, fields, variables).then((result) => resolve(result)).catch((error) => reject(error));
+      if (operationType == "Query") useGraphQl().queryPromise(operation, fields, variables, cache, options).then((result) => resolve(result)).catch((error) => reject(error));
+      else if (operationType == "Mutation") useGraphQl().mutationPromise(operation, fields, variables, options).then((result) => resolve(result)).catch((error) => reject(error));
       else reject("Invalid Operation Type");
     } else {
       reject("No schema of return data available");

package/dist/runtime/composables/importProgress.d.ts CHANGED Viewed

@@ -1,13 +1,28 @@
+export type ImportErrorType = 'network' | 'timeout' | 'server' | 'unknown';
 export interface ImportError {
     index: number;
+    item: any;
+    errorType: ImportErrorType;
     message: string;
+    detail?: any;
 }
 export interface ImportSummary {
     succeeded: number;
     failed: number;
     errors: ImportError[];
 }
-export type ImportWorker<T = any> = (item: T, index: number) => Promise<any>;
+export type ImportWorker<T = any> = (item: T, index: number, salt: string) => Promise<any>;
+/**
+ * classifyImportError buckets a thrown import error into a coarse type and
+ * extracts a short message + raw detail, normalising ofetch FetchError and
+ * Apollo error shapes so callers can separate connection failures from
+ * server-returned errors.
+ */
+export declare function classifyImportError(error: any): {
+    errorType: ImportErrorType;
+    message: string;
+    detail?: any;
+};
 /**
  * useImportProgress drives a concurrency-limited bulk import while exposing
  * reactive progress. The runner continues on per-row errors and never rejects;
@@ -21,14 +36,23 @@ export declare function useImportProgress(): {
     failed: import("vue").Ref<number, number>;
     errors: import("vue").Ref<{
         index: number;
+        item: any;
+        errorType: ImportErrorType;
         message: string;
+        detail?: any;
     }[], ImportError[] | {
         index: number;
+        item: any;
+        errorType: ImportErrorType;
         message: string;
+        detail?: any;
     }[]>;
     percent: import("vue").ComputedRef<number>;
+    resultVisible: import("vue").Ref<boolean, boolean>;
     reset: () => void;
     run: <T = any>(items: T[], worker: ImportWorker<T>, options?: {
         concurrency?: number;
     }) => Promise<ImportSummary>;
+    retry: (indices?: number[]) => Promise<ImportSummary>;
+    dismissResult: () => void;
 };

package/dist/runtime/composables/importProgress.js CHANGED Viewed

@@ -1,5 +1,26 @@
 import { computed, ref } from "vue";
 import pLimit from "p-limit";
+export function classifyImportError(error) {
+  const isString = typeof error === "string";
+  const rawMessage = error?.message || (isString ? error : String(error));
+  const name = error?.name;
+  const status = error?.status ?? error?.statusCode ?? error?.response?.status;
+  const graphQLErrors = error?.graphQLErrors;
+  const networkError = error?.networkError;
+  if (name === "AbortError" || name === "TimeoutError" || /timeout|timed out|aborted/i.test(rawMessage)) {
+    return { errorType: "timeout", message: rawMessage, detail: error?.data };
+  }
+  if (networkError || /failed to fetch|fetch failed|network ?error|load failed/i.test(rawMessage)) {
+    return { errorType: "network", message: rawMessage, detail: networkError ?? error?.data };
+  }
+  if (status || Array.isArray(graphQLErrors) && graphQLErrors.length > 0 || isString) {
+    const detail = error?.data ?? (graphQLErrors?.length ? graphQLErrors : isString ? error : error?.response?._data);
+    const message = error?.data?.message || graphQLErrors?.[0]?.message || rawMessage || `Server error ${status ?? ""}`.trim();
+    return { errorType: "server", message, detail };
+  }
+  return { errorType: "unknown", message: rawMessage, detail: error?.data };
+}
+let _importRunSeq = 0;
 export function useImportProgress() {
   const isImporting = ref(false);
   const total = ref(0);
@@ -7,6 +28,11 @@ export function useImportProgress() {
   const succeeded = ref(0);
   const failed = ref(0);
   const errors = ref([]);
+  const resultVisible = ref(false);
+  let _items = [];
+  let _worker = null;
+  let _concurrency = 3;
+  let _runId = 0;
   const percent = computed(
     () => total.value ? Math.round(processed.value / total.value * 100) : 0
   );
@@ -16,6 +42,7 @@ export function useImportProgress() {
     succeeded.value = 0;
     failed.value = 0;
     errors.value = [];
+    resultVisible.value = false;
   }
   async function run(items, worker, options = {}) {
     if (isImporting.value) {
@@ -24,17 +51,23 @@ export function useImportProgress() {
     reset();
     total.value = items.length;
     isImporting.value = true;
-    const limit = pLimit(options.concurrency && options.concurrency > 0 ? options.concurrency : 3);
+    _items = items;
+    _worker = worker;
+    _concurrency = options.concurrency && options.concurrency > 0 ? options.concurrency : 3;
+    _runId = ++_importRunSeq;
+    const limit = pLimit(_concurrency);
     try {
       await Promise.all(
         items.map(
           (item, index) => limit(async () => {
             try {
-              await worker(item, index);
+              await worker(item, index, `import:${_runId}:${index}`);
               succeeded.value++;
             } catch (error) {
+              const info = classifyImportError(error);
+              console.error("[import] row failed", { index, errorType: info.errorType, item, message: info.message, detail: info.detail });
               failed.value++;
-              errors.value.push({ index, message: error?.message || String(error) });
+              errors.value.push({ index, item, ...info });
             } finally {
               processed.value++;
             }
@@ -46,5 +79,52 @@ export function useImportProgress() {
     }
     return { succeeded: succeeded.value, failed: failed.value, errors: [...errors.value] };
   }
-  return { isImporting, total, processed, succeeded, failed, errors, percent, reset, run };
+  function dismissResult() {
+    resultVisible.value = false;
+  }
+  async function retry(indices) {
+    if (isImporting.value || !_worker) {
+      return { succeeded: succeeded.value, failed: failed.value, errors: [...errors.value] };
+    }
+    const requested = indices && indices.length ? indices : errors.value.map((e) => e.index);
+    const targets = requested.filter((i) => errors.value.some((e) => e.index === i));
+    if (targets.length === 0) {
+      return { succeeded: succeeded.value, failed: failed.value, errors: [...errors.value] };
+    }
+    isImporting.value = true;
+    const limit = pLimit(_concurrency);
+    try {
+      await Promise.all(
+        targets.map(
+          (index) => limit(async () => {
+            const item = _items[index];
+            try {
+              await _worker(item, index, `import:${_runId}:${index}`);
+              const pos = errors.value.findIndex((e) => e.index === index);
+              if (pos !== -1) {
+                errors.value.splice(pos, 1);
+                failed.value = Math.max(0, failed.value - 1);
+                succeeded.value++;
+              }
+            } catch (error) {
+              const info = classifyImportError(error);
+              console.error("[import] row failed", { index, errorType: info.errorType, item, message: info.message, detail: info.detail });
+              const next = { index, item, ...info };
+              const pos = errors.value.findIndex((e) => e.index === index);
+              if (pos !== -1) errors.value[pos] = next;
+              else {
+                errors.value.push(next);
+                failed.value++;
+              }
+            }
+          })
+        )
+      );
+    } finally {
+      processed.value = succeeded.value + failed.value;
+      isImporting.value = false;
+    }
+    return { succeeded: succeeded.value, failed: failed.value, errors: [...errors.value] };
+  }
+  return { isImporting, total, processed, succeeded, failed, errors, percent, resultVisible, reset, run, retry, dismissResult };
 }

package/dist/runtime/types/graphqlOperation.d.ts CHANGED Viewed

@@ -12,7 +12,18 @@ export interface graphqlOperationObject<T, U> {
   fields?: graphqlTypeObject
   operationType: 'Query' | 'Mutation'
   name: string
-  call: (fields?: Array<string | Object>, variables?: U, cache?: boolean | number) => Promise<T>
+  /**
+   * Execute this operation.
+   *
+   * The signature is shared by Query and Mutation operations:
+   * - `cache` applies to **Query** operations only (localStorage TTL / fetch policy).
+   *   It is **ignored for Mutation** operations — mutations are never cached, so a
+   *   value passed here has no effect.
+   * - `options.idempotencySalt` applies to **both** kinds: it is folded into the
+   *   request's `Idempotency-Key` (`SHA-256(<second>|<username>|<body>|<salt>)`).
+   *   Pass `options.idempotent: false` to skip the header for this call.
+   */
+  call: (fields?: Array<string | Object>, variables?: U, cache?: boolean | number, options?: { idempotent?: boolean, idempotencySalt?: string | number }) => Promise<T>
 }
 export interface graphqlTypeObject {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ramathibodi/nuxt-commons",
-  "version": "4.0.13",
+  "version": "4.0.15",
   "description": "Ramathibodi Nuxt modules for common components",
   "repository": {
     "type": "git",

package/templates/.codegen/plugin-schema-object.cjs CHANGED Viewed

@@ -104,19 +104,22 @@ module.exports = {
     return `
         import * as graphQlClass from "~/types/graphql"
         import { useGraphQlOperation } from "#imports";
+        import type { ApiIdempotencyOption } from "#imports";
         import type {
             graphqlInputObject,
             graphqlOperationObject,
             graphqlTypeObject,
             graphqlVariable
           } from "#build/types/graphqlOperation";
         export const scalarType = ${JSON.stringify(scalarType)}
-        function operationCall${'<' + 'T,U>'}(operationType:string, operation: string,fields?: ${'Array' + '<string | Object>'},variables?: U,cache: boolean | number = false) {
-            return useGraphQlOperation${'<' + 'T>'}(operationType,operation,fields,variables as {[p: string] : any} | undefined,cache)
+        function operationCall${'<' + 'T,U>'}(operationType:string, operation: string,fields?: ${'Array' + '<string | Object>'},variables?: U,cache: boolean | number = false,
+        options?: ApiIdempotencyOption) {
+            return useGraphQlOperation${'<' + 'T>'}(operationType,operation,fields,variables as {[p: string] : any} | undefined,cache,
+            options)
         }
         function createGraphQLOperation${'<' + 'T,U>'}(operationType: "Query" | "Mutation",name: string,variables?: graphqlVariable[],fields?: graphqlTypeObject): graphqlOperationObject${'<' + 'T,U>'} {
             let returnGraphqlOperation : ${'Record' + '<string,any>'} = {
                 operationType,
@@ -124,14 +127,8 @@ module.exports = {
                 variables,
                 fields,
             }
-            if (operationType === "Mutation") {
-              returnGraphqlOperation['call'] = async function(fields?: ${'Array' + '<string | Object>'}, variables?: U): Promise${'<' + 'T>'} {
-                  return operationCall(operationType,name, fields, variables);
-              }
-            } else {
-              returnGraphqlOperation['call'] = async function(fields?: ${'Array' + '<string | Object>'}, variables?: U,cache: boolean | number = false): Promise${'<' + 'T>'} {
-                  return operationCall(operationType,name, fields, variables,cache);
-              }
+            returnGraphqlOperation['call'] = async function(fields?: ${'Array' + '<string | Object>'}, variables?: U, cache: boolean | number = false, options?: ApiIdempotencyOption): Promise${'<' + 'T>'} {
+                return operationCall(operationType,name, fields, variables, cache, options);
             }
             return returnGraphqlOperation as graphqlOperationObject${'<' + 'T,U>'}
         }