@merkaly/nuxt 0.1.10 → 0.1.12

package/dist/module.d.mts

@@ -1,5 +1,7 @@
 import * as _nuxt_schema from '@nuxt/schema';
 import { ClientAuthorizationParams } from '@auth0/auth0-spa-js';
+export { AdapterArgs, AdapterOptions } from '../dist/runtime/utils/withAdapter.js';
+export { ApiOptions, HooksOptions, ParamsOptions, RefOptions } from '../dist/runtime/plugins/api.global.js';
 
 interface MerkalyModuleOptions {
     auth0: {

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "0.1.10",
+  "version": "0.1.12",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

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

@@ -1,18 +1,17 @@
+import type { Ref } from 'vue';
 import type { ApiOptions } from '../plugins/api.global.js';
-export interface ComposableOptions extends ApiOptions {
+export interface ComposableOptions<TData = unknown, TMeta = Record<string, unknown>> extends ApiOptions<TData, TMeta> {
     immediate?: boolean;
     uri: string;
 }
-export type CallbackArgs<T extends object> = (args: T) => ComposableOptions;
-declare function useApi<D extends object>(callback: CallbackArgs<D>): {
-    abort: {
-        (reason?: any): void;
-        (reason?: any): void;
-    };
-    data: import("vue").Ref<unknown, unknown>;
-    error: import("vue").Ref<Error | undefined, Error | undefined>;
-    execute: (args?: Partial<D>) => any;
-    loading: import("vue").Ref<boolean, boolean>;
-    meta: import("vue").Ref<{}, {}>;
-};
+export interface UseApiReturn<TData, TMeta, TParams> {
+    abort: () => void;
+    data: Ref<TData | undefined>;
+    error: Ref<Error | undefined>;
+    execute: (args?: Partial<TParams>) => Promise<void>;
+    loading: Ref<boolean>;
+    meta: Ref<TMeta>;
+    params: TParams;
+}
+declare function useApi<TData = unknown, TMeta = Record<string, unknown>, TParams extends object = object>(callback: (params: TParams) => ComposableOptions<TData, TMeta>): UseApiReturn<TData, TMeta, TParams>;
 export { useApi };

package/dist/runtime/composables/useApi.js

@@ -14,29 +14,33 @@ function useApi(callback) {
   const data = ref(initialOptions.default?.());
   const meta = ref({});
   const error = ref();
-  const execute = (args = {}) => {
-    Object.assign(params, args);
+  const execute = async (args = {}) => {
+    Object.keys(args).forEach((key) => {
+      params[key] = args[key];
+    });
     const currentOptions = getOptions(params);
-    return $api(currentOptions.uri, {
+    await $api(currentOptions.uri, {
       ...currentOptions,
       controller,
       data,
       default: currentOptions.default,
       error,
       loading,
-      meta
+      meta,
+      params
     });
   };
   if (initialOptions.immediate) {
     void execute();
   }
   return {
-    abort: controller.abort,
+    abort: () => controller.abort(),
     data,
     error,
     execute,
     loading,
-    meta
+    meta,
+    params
   };
 }
 export { useApi };

package/dist/runtime/plugins/api.global.d.ts

@@ -9,10 +9,11 @@ type OnResponseArgs = {
     response: FetchResponse<unknown>;
     request: RequestInfo;
 };
-type OnSuccessArgs = {
-    data: unknown;
-    meta: Record<string, unknown>;
+type OnSuccessArgs<TData = unknown, TMeta = Record<string, unknown>, TParams = object> = {
+    data: TData;
+    meta: TMeta;
     headers: FetchOptions['headers'];
+    params: TParams;
 };
 type OnCompleteArgs = {
     response?: FetchResponse<unknown>;
@@ -24,13 +25,13 @@ export interface RefOptions {
     loading?: Ref<boolean>;
     meta?: Ref<Record<string, unknown>>;
 }
-export interface HooksOptions {
+export interface HooksOptions<TData = unknown, TMeta = Record<string, unknown>, TParams = object> {
     onBeforeSend?(args: OnBeforeSendArgs): Promise<unknown> | unknown;
     onComplete?(args: OnCompleteArgs): Promise<unknown> | unknown;
     onError?(reason: Error): Promise<unknown> | unknown;
     onFatal?(reason: Error): Promise<unknown> | unknown;
     onResponse?(args: OnResponseArgs): Promise<unknown> | unknown;
-    onSuccess?(args: OnSuccessArgs): Promise<unknown> | unknown;
+    onSuccess?(args: OnSuccessArgs<TData, TMeta, TParams>): Promise<unknown> | unknown;
 }
 export interface ParamsOptions {
     body?: FetchOptions['body'];
@@ -42,6 +43,8 @@ export interface ParamsOptions {
     query?: FetchOptions['query'];
     timeout?: FetchOptions['timeout'];
 }
-export type ApiOptions = ParamsOptions & HooksOptions & RefOptions;
+export type ApiOptions<TData = unknown, TMeta = Record<string, unknown>, TParams = object> = ParamsOptions & HooksOptions<TData, TMeta, TParams> & RefOptions & {
+    params?: TParams;
+};
 declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugins/api.global.js

@@ -34,7 +34,7 @@ export default defineNuxtPlugin(({ provide }) => provide("api", async (url, opti
       const { data, meta } = _data || {};
       await options?.onResponse?.({ response, request });
       if (status >= 400) return;
-      await options?.onSuccess?.({ data, meta, headers });
+      await options?.onSuccess?.({ data, meta, headers, params: options.params });
       if (options.data) options.data.value = data;
       if (options.meta) options.meta.value = meta;
       await options?.onComplete?.({ response, request });

package/dist/runtime/types/nuxt.d.ts

@@ -4,13 +4,13 @@ import type { ApiOptions } from '../plugins/api.global';
 declare module '#app' {
   interface NuxtApp {
     $auth0: Auth0Client;
-    $api: (url: string, options?: ApiOptions) => Promise<unknown>;
+    $api: (url: string, options?: ApiOptions) => Promise<void>;
   }
 }
 
 declare module 'vue' {
   interface ComponentCustomProperties {
     $auth0: Auth0Client;
-    $api: (url: string, options?: ApiOptions) => Promise<unknown>;
+    $api: (url: string, options?: ApiOptions) => Promise<void>;
   }
 }

package/dist/runtime/utils/withAdapter.d.ts

@@ -1,22 +1,13 @@
-import type { ComposableOptions } from '../composables/useApi.js';
+import type { ComposableOptions, UseApiReturn } from '../composables/useApi.js';
 import type { HooksOptions } from '../plugins/api.global.js';
-type ReturnParams<T extends AdapterOptions> = () => {
-    params?: T['params'];
-} & HooksOptions;
 export interface AdapterOptions {
     data: unknown;
-    meta: Record<string, object>;
+    meta: Record<string, unknown>;
     params: object;
 }
-export declare const withAdapter: <T extends AdapterOptions>(callback: (params: T["params"]) => ComposableOptions) => (args?: ReturnParams<T>) => {
-    abort: {
-        (reason?: any): void;
-        (reason?: any): void;
-    };
-    data: import("vue").Ref<unknown, unknown>;
-    error: import("vue").Ref<Error | undefined, Error | undefined>;
-    execute: (args?: Partial<T["params"]>) => any;
-    loading: import("vue").Ref<boolean, boolean>;
-    meta: import("vue").Ref<{}, {}>;
-};
+export interface AdapterArgs<TData, TMeta, TParams> extends HooksOptions<TData, TMeta, TParams> {
+    params?: Partial<TParams>;
+}
+type AdapterCallback<T extends AdapterOptions> = (args: T['params']) => AdapterArgs<T['data'], T['meta'], T['params']>;
+export declare const withAdapter: <T extends AdapterOptions>(callback: (params: T["params"]) => ComposableOptions<T["data"], T["meta"]>) => (args?: AdapterCallback<T>) => UseApiReturn<T["data"], T["meta"], T["params"]>;
 export {};

package/dist/runtime/utils/withAdapter.js

@@ -1,9 +1,11 @@
 import { useApi } from "../composables/useApi.js";
 import { defu } from "defu";
-export const withAdapter = (callback) => (args) => useApi((executionParams) => {
-  const initialConfig = args?.() || {};
-  const { params: initialParams = {}, ...hooks } = initialConfig;
-  const mergedParams = defu(executionParams, initialParams);
-  const adapterResult = callback(mergedParams);
-  return defu(hooks, adapterResult);
-});
+export const withAdapter = (callback) => (args) => {
+  return useApi((executionParams) => {
+    const config = args?.(executionParams) || {};
+    const { params: initialParams = {}, ...hooks } = config;
+    const mergedParams = defu(executionParams, initialParams);
+    const adapterResult = callback(mergedParams);
+    return defu(hooks, adapterResult);
+  });
+};

package/dist/types.d.mts

@@ -4,6 +4,10 @@ import type { default as Module } from './module.mjs'
 
 export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
+export { type AdapterArgs, type AdapterOptions } from '../dist/runtime/utils/withAdapter.js'
+
+export { type ApiOptions, type HooksOptions, type ParamsOptions, type RefOptions } from '../dist/runtime/plugins/api.global.js'
+
 export { default } from './module.mjs'
 
 export { type MerkalyModuleOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merkaly/nuxt",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/merkaly-io/nuxt.git"