@diphyx/harlemify 0.0.2 → 0.0.3

package/README.md

@@ -11,6 +11,9 @@ API state management for Nuxt powered by [Harlem](https://harlemjs.com/)
 - CRUD operations with endpoint status tracking
 - Type-safe endpoint URL parameters
 - SSR support via Harlem SSR plugin
+- Configurable primary key indicator
+- Lifecycle hooks (before/after) for API operations
+- Abort controller support for request cancellation
 
 ## Installation
 
@@ -47,24 +50,43 @@ const UserSchema = z.object({
 
 export type User = z.infer<typeof UserSchema>;
 
-export const userStore = createStore("user", UserSchema, {
-    [Endpoint.GET_UNITS]: {
-        action: ApiAction.GET,
-        url: "/users",
-    },
-    [Endpoint.POST_UNITS]: {
-        action: ApiAction.POST,
-        url: "/users",
-    },
-    [Endpoint.PATCH_UNITS]: {
-        action: ApiAction.PATCH,
-        url: (params) => `/users/${params.id}`,
+export const userStore = createStore(
+    "user",
+    UserSchema,
+    {
+        [Endpoint.GET_UNITS]: {
+            action: ApiAction.GET,
+            url: "/users",
+        },
+        [Endpoint.POST_UNITS]: {
+            action: ApiAction.POST,
+            url: "/users",
+        },
+        [Endpoint.PATCH_UNITS]: {
+            action: ApiAction.PATCH,
+            url: (params) => `/users/${params.id}`,
+        },
+        [Endpoint.DELETE_UNITS]: {
+            action: ApiAction.DELETE,
+            url: (params) => `/users/${params.id}`,
+        },
     },
-    [Endpoint.DELETE_UNITS]: {
-        action: ApiAction.DELETE,
-        url: (params) => `/users/${params.id}`,
+    {
+        indicator: "id",
+        hooks: {
+            before() {
+                console.log("Request starting...");
+            },
+            after(error) {
+                if (error) {
+                    console.error("Request failed:", error);
+                } else {
+                    console.log("Request completed");
+                }
+            },
+        },
     },
-});
+);
 ```
 
 ## Documentation

package/dist/module.json

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

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

@@ -24,10 +24,12 @@ export interface ApiRequestOptions<A extends ApiAction = ApiAction, H extends Ap
     headers?: H;
     query?: Q;
     body?: B;
+    timeout?: number;
     responseType?: ApiResponseType;
     retry?: number | false;
     retryDelay?: number;
     retryStatusCodes?: number[];
+    signal?: AbortSignal;
 }
 export interface ApiOptions {
     url?: string;

package/dist/runtime/core/api.js

@@ -66,6 +66,7 @@ export function createApi(options) {
       retry: requestOptions?.retry,
       retryDelay: requestOptions?.retryDelay,
       retryStatusCodes: requestOptions?.retryStatusCodes,
+      signal: requestOptions?.signal,
       onRequestError({ request: request2, options: options2, error }) {
         throw new ApiRequestError({
           method: options2.method,

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

@@ -6,10 +6,20 @@ export declare enum StoreMemoryPosition {
     LAST = "last"
 }
 import { ApiAction, type ApiActionOptions, type ApiOptions } from "./api.js";
-export declare function createStore<T extends z.ZodRawShape, K extends keyof z.infer<z.ZodObject<T>> = "id" & keyof z.infer<z.ZodObject<T>>>(name: string, schema: z.ZodObject<T>, endpoints?: Partial<Record<Endpoint, EndpointDefinition<Partial<z.infer<z.ZodObject<T>>>>>>, options?: {
+export declare class StoreConfigurationError extends Error {
+    constructor(message: string);
+}
+export interface StoreHooks {
+    before?: () => Promise<void> | void;
+    after?: (error?: Error) => Promise<void> | void;
+}
+export interface StoreOptions {
     api?: ApiOptions;
+    indicator?: string;
+    hooks?: StoreHooks;
     extensions?: Extension<BaseState>[];
-}): {
+}
+export declare function createStore<T extends z.ZodRawShape, K extends keyof z.infer<z.ZodObject<T>> = "id" & keyof z.infer<z.ZodObject<T>>>(name: string, schema: z.ZodObject<T>, endpoints?: Partial<Record<Endpoint, EndpointDefinition<Partial<z.infer<z.ZodObject<T>>>>>>, options?: StoreOptions): {
     api: () => {
         get: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.GET, H, Q, never>) => Promise<T_1>;
         post: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery, B extends import("./api").ApiRequestBody = import("./api").ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.POST, H, Q, B>) => Promise<T_1>;
@@ -24,51 +34,10 @@ export declare function createStore<T extends z.ZodRawShape, K extends keyof z.i
         };
         endpoints: Record<Endpoint, EndpointMemory>;
     }>, never>;
-    memorizedUnit: import("@vue/reactivity").ComputedRef<import("@vue/reactivity").DeepReadonly<z.core.$InferObjectOutput<T, {}>> | null>;
-    memorizedUnits: import("@vue/reactivity").ComputedRef<readonly import("@vue/reactivity").DeepReadonly<z.core.$InferObjectOutput<T, {}>>[]>;
+    memorizedUnit: import("vue").ComputedRef<import("vue").DeepReadonly<z.core.$InferObjectOutput<T, {}>> | null>;
+    memorizedUnits: import("vue").ComputedRef<readonly import("vue").DeepReadonly<z.core.$InferObjectOutput<T, {}>>[]>;
     hasMemorizedUnits: (...units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => Record<string | number, boolean>;
-    endpointsStatus: {
-        getUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-    };
+    endpointsStatus: import("../utils/endpoint").EndpointsStatusMap<import("vue").ComputedRef<boolean>>;
     setMemorizedUnit: import("@harlem/core").Mutation<z.core.$InferObjectOutput<T, {}> | null, void>;
     setMemorizedUnits: (payload: z.core.$InferObjectOutput<T, {}>[]) => void;
     editMemorizedUnit: import("@harlem/core").Mutation<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, void>;
@@ -82,7 +51,7 @@ export declare function createStore<T extends z.ZodRawShape, K extends keyof z.i
     purgeEndpointMemory: (payload?: unknown) => void;
     getUnit: (unit?: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, options?: Omit<ApiActionOptions<ApiAction.GET>, "body">) => Promise<z.core.$InferObjectOutput<T, {}>>;
     getUnits: (options?: Omit<ApiActionOptions<ApiAction.GET>, "body">) => Promise<z.core.$InferObjectOutput<T, {}>[]>;
-    postUnit: (unit: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>, options?: ApiActionOptions<ApiAction.POST> & {
+    postUnit: (unit: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>, actionOptions?: ApiActionOptions<ApiAction.POST> & {
         validate?: boolean;
     }) => Promise<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>>;
     postUnits: (units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>)[], options?: ApiActionOptions<ApiAction.POST> & {

package/dist/runtime/core/store.js

@@ -19,16 +19,41 @@ export var StoreMemoryPosition = /* @__PURE__ */ ((StoreMemoryPosition2) => {
 import {
   createApi
 } from "./api.js";
+export class StoreConfigurationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StoreConfigurationError";
+  }
+}
 export function createStore(name, schema, endpoints, options) {
-  const { indicator } = resolveSchema(schema);
+  const { indicator } = resolveSchema(schema, {
+    indicator: options?.indicator
+  });
+  const hooks = options?.hooks;
   let apiClient;
+  let apiInitError = null;
   function api() {
+    if (apiInitError) {
+      throw apiInitError;
+    }
     if (!apiClient) {
-      const config = useRuntimeConfig();
-      apiClient = createApi({
-        ...config.public.harlemify?.api,
-        ...options?.api
-      });
+      try {
+        const config = useRuntimeConfig();
+        if (!config) {
+          throw new StoreConfigurationError(
+            `Runtime config is not available. Ensure the store "${name}" is used within a Nuxt context.`
+          );
+        }
+        apiClient = createApi({
+          ...config.public.harlemify?.api,
+          ...options?.api
+        });
+      } catch (error) {
+        apiInitError = error instanceof Error ? error : new StoreConfigurationError(
+          `Failed to initialize API client for store "${name}": ${String(error)}`
+        );
+        throw apiInitError;
+      }
     }
     return apiClient;
   }
@@ -149,95 +174,83 @@ export function createStore(name, schema, endpoints, options) {
       memory
     });
   }
-  async function getUnit(unit, options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.GET_UNIT);
-    patchEndpointMemoryTo(Endpoint.GET_UNIT, {
+  async function withEndpointStatus(key, operation) {
+    await hooks?.before?.();
+    patchEndpointMemoryTo(key, {
       status: EndpointStatus.PENDING
     });
     try {
-      const response = await api().get(
-        resolveEndpointUrl(endpoint, unit),
-        options2
-      );
-      setMemorizedUnit(response);
-      patchEndpointMemoryTo(Endpoint.GET_UNIT, {
+      const result = await operation();
+      patchEndpointMemoryTo(key, {
         status: EndpointStatus.SUCCESS
       });
-      return response;
+      await hooks?.after?.();
+      return result;
     } catch (error) {
-      patchEndpointMemoryTo(Endpoint.GET_UNIT, {
+      patchEndpointMemoryTo(key, {
         status: EndpointStatus.FAILED
       });
+      await hooks?.after?.(error);
       throw error;
     }
   }
+  async function getUnit(unit, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.GET_UNIT);
+    return withEndpointStatus(Endpoint.GET_UNIT, async () => {
+      const response = await api().get(
+        resolveEndpointUrl(endpoint, unit),
+        options2
+      );
+      setMemorizedUnit(response);
+      return response;
+    });
+  }
   async function getUnits(options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.GET_UNITS);
-    patchEndpointMemoryTo(Endpoint.GET_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withEndpointStatus(Endpoint.GET_UNITS, async () => {
       const response = await api().get(
         resolveEndpointUrl(endpoint),
         options2
       );
       setMemorizedUnits(response);
-      patchEndpointMemoryTo(Endpoint.GET_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return response;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.GET_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
-  async function postUnit(unit, options2) {
+  async function postUnit(unit, actionOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.POST_UNIT);
-    const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
-    if (options2?.validate) {
+    const resolvedSchema = resolveSchema(schema, {
+      indicator,
+      endpoint,
+      unit
+    });
+    if (actionOptions?.validate) {
       schema.pick(resolvedSchema.keys).parse(unit);
     }
-    patchEndpointMemoryTo(Endpoint.POST_UNIT, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withEndpointStatus(Endpoint.POST_UNIT, async () => {
       const response = await api().post(
         resolveEndpointUrl(endpoint, unit),
         {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
+          ...actionOptions,
+          body: actionOptions?.body ?? resolvedSchema.values
         }
       );
       setMemorizedUnit({
         ...unit,
         ...response
       });
-      patchEndpointMemoryTo(Endpoint.POST_UNIT, {
-        status: EndpointStatus.SUCCESS
-      });
       return response;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.POST_UNIT, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   async function postUnits(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.POST_UNITS);
-    patchEndpointMemoryTo(Endpoint.POST_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withEndpointStatus(Endpoint.POST_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
-        const resolvedSchema = resolveSchema(
-          schema,
-          endpoint.action,
+        const resolvedSchema = resolveSchema(schema, {
+          indicator,
+          endpoint,
           unit
-        );
+        });
         if (options2?.validate) {
           schema.pick(resolvedSchema.keys).parse(unit);
         }
@@ -263,27 +276,20 @@ export function createStore(name, schema, endpoints, options) {
         setMemorizedUnits(clonedUnits);
         responses.push(response);
       }
-      patchEndpointMemoryTo(Endpoint.POST_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return responses;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.POST_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   async function putUnit(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNIT);
-    const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+    const resolvedSchema = resolveSchema(schema, {
+      indicator,
+      endpoint,
+      unit
+    });
     if (options2?.validate) {
       schema.pick(resolvedSchema.keys).parse(unit);
     }
-    patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withEndpointStatus(Endpoint.PUT_UNIT, async () => {
       const response = await api().put(
         resolveEndpointUrl(endpoint, unit),
         {
@@ -295,30 +301,19 @@ export function createStore(name, schema, endpoints, options) {
         ...unit,
         ...response
       });
-      patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
-        status: EndpointStatus.SUCCESS
-      });
       return response;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   async function putUnits(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNITS);
-    patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withEndpointStatus(Endpoint.PUT_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
-        const resolvedSchema = resolveSchema(
-          schema,
-          endpoint.action,
+        const resolvedSchema = resolveSchema(schema, {
+          indicator,
+          endpoint,
           unit
-        );
+        });
         if (options2?.validate) {
           schema.pick(resolvedSchema.keys).parse(unit);
         }
@@ -337,27 +332,20 @@ export function createStore(name, schema, endpoints, options) {
         ]);
         responses.push(response);
       }
-      patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return responses;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   async function patchUnit(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNIT);
-    const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+    const resolvedSchema = resolveSchema(schema, {
+      indicator,
+      endpoint,
+      unit
+    });
     if (options2?.validate) {
       schema.pick(resolvedSchema.keys).partial().parse(unit);
     }
-    patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withEndpointStatus(Endpoint.PATCH_UNIT, async () => {
       const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
         ...options2,
         body: options2?.body ?? resolvedSchema.values
@@ -366,30 +354,19 @@ export function createStore(name, schema, endpoints, options) {
         ...unit,
         ...response
       });
-      patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
-        status: EndpointStatus.SUCCESS
-      });
       return response;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   async function patchUnits(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNITS);
-    patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withEndpointStatus(Endpoint.PATCH_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
-        const resolvedSchema = resolveSchema(
-          schema,
-          endpoint.action,
+        const resolvedSchema = resolveSchema(schema, {
+          indicator,
+          endpoint,
           unit
-        );
+        });
         if (options2?.validate) {
           schema.pick(resolvedSchema.keys).partial().parse(unit);
         }
@@ -405,45 +382,23 @@ export function createStore(name, schema, endpoints, options) {
         ]);
         responses.push(response);
       }
-      patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return responses;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   async function deleteUnit(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNIT);
-    patchEndpointMemoryTo(Endpoint.DELETE_UNIT, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withEndpointStatus(Endpoint.DELETE_UNIT, async () => {
       await api().del(
         resolveEndpointUrl(endpoint, unit),
         options2
       );
       dropMemorizedUnit(unit);
-      patchEndpointMemoryTo(Endpoint.DELETE_UNIT, {
-        status: EndpointStatus.SUCCESS
-      });
       return true;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.DELETE_UNIT, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   async function deleteUnits(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNITS);
-    patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withEndpointStatus(Endpoint.DELETE_UNITS, async () => {
       for (const unit of units) {
         await api().del(
           resolveEndpointUrl(endpoint, unit),
@@ -451,16 +406,8 @@ export function createStore(name, schema, endpoints, options) {
         );
         dropMemorizedUnits([unit]);
       }
-      patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return true;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   return {
     api,

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

@@ -25,50 +25,15 @@ export interface EndpointDefinition<T = Record<string, unknown>> {
 export interface EndpointMemory {
     status: EndpointStatus;
 }
-export declare function makeEndpointStatusKey<K extends Endpoint, S extends EndpointStatus>(key: K, status: S): `${K}Is${Capitalize<S>}`;
+type CapitalizeString<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+export type EndpointStatusKey<K extends Endpoint = Endpoint, S extends EndpointStatus = EndpointStatus> = `${K}Is${CapitalizeString<S>}`;
+export declare function makeEndpointStatusKey<K extends Endpoint, S extends EndpointStatus>(key: K, status: S): EndpointStatusKey<K, S>;
 export declare function getEndpoint<T = Record<string, unknown>>(endpoints: Partial<Record<Endpoint, EndpointDefinition<T>>> | undefined, key: Endpoint): EndpointDefinition<T>;
 export declare function resolveEndpointUrl<T>(endpoint: EndpointDefinition<T>, params?: {
     [key: string]: unknown;
 }): string;
-export declare function makeEndpointsStatus<T>(getter: (name: string, fn: (state: BaseState) => boolean) => T): {
-    getUnitIsIdle: T;
-    getUnitIsPending: T;
-    getUnitIsSuccess: T;
-    getUnitIsFailed: T;
-    getUnitsIsIdle: T;
-    getUnitsIsPending: T;
-    getUnitsIsSuccess: T;
-    getUnitsIsFailed: T;
-    postUnitIsIdle: T;
-    postUnitIsPending: T;
-    postUnitIsSuccess: T;
-    postUnitIsFailed: T;
-    postUnitsIsIdle: T;
-    postUnitsIsPending: T;
-    postUnitsIsSuccess: T;
-    postUnitsIsFailed: T;
-    putUnitIsIdle: T;
-    putUnitIsPending: T;
-    putUnitIsSuccess: T;
-    putUnitIsFailed: T;
-    putUnitsIsIdle: T;
-    putUnitsIsPending: T;
-    putUnitsIsSuccess: T;
-    putUnitsIsFailed: T;
-    patchUnitIsIdle: T;
-    patchUnitIsPending: T;
-    patchUnitIsSuccess: T;
-    patchUnitIsFailed: T;
-    patchUnitsIsIdle: T;
-    patchUnitsIsPending: T;
-    patchUnitsIsSuccess: T;
-    patchUnitsIsFailed: T;
-    deleteUnitIsIdle: T;
-    deleteUnitIsPending: T;
-    deleteUnitIsSuccess: T;
-    deleteUnitIsFailed: T;
-    deleteUnitsIsIdle: T;
-    deleteUnitsIsPending: T;
-    deleteUnitsIsSuccess: T;
-    deleteUnitsIsFailed: T;
+export type EndpointsStatusMap<T> = {
+    [K in Endpoint as EndpointStatusKey<K, EndpointStatus>]: T;
 };
+export declare function makeEndpointsStatus<T>(getter: (name: string, fn: (state: BaseState) => boolean) => T): EndpointsStatusMap<T>;
+export {};

package/dist/runtime/utils/endpoint.js

@@ -19,7 +19,8 @@ export var EndpointStatus = /* @__PURE__ */ ((EndpointStatus2) => {
   return EndpointStatus2;
 })(EndpointStatus || {});
 export function makeEndpointStatusKey(key, status) {
-  return `${key}Is${status.charAt(0).toUpperCase() + status.slice(1)}`;
+  const capitalizedStatus = status.charAt(0).toUpperCase() + status.slice(1);
+  return `${key}Is${capitalizedStatus}`;
 }
 export function getEndpoint(endpoints, key) {
   const endpoint = endpoints?.[key];

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

@@ -1,11 +1,17 @@
 import { z } from "zod";
 import type { ApiAction } from "../core/api.js";
+import type { EndpointDefinition } from "./endpoint.js";
 export interface SchemaMeta {
     indicator?: boolean;
     actions?: ApiAction[];
 }
 export declare function getMeta(field: any): SchemaMeta | undefined;
-export declare function resolveSchema<T extends z.ZodRawShape, S extends z.infer<z.ZodObject<T>>>(schema: z.ZodObject<T>, action?: ApiAction, input?: Partial<S>): {
+export interface ResolveSchemaOptions<S> {
+    indicator?: keyof S;
+    endpoint?: EndpointDefinition<Partial<S>>;
+    unit?: Partial<S>;
+}
+export declare function resolveSchema<T extends z.ZodRawShape, S extends z.infer<z.ZodObject<T>>>(schema: z.ZodObject<T>, options?: ResolveSchemaOptions<S>): {
     indicator: keyof S;
     keys: Record<keyof S, true>;
     values: Partial<S>;

package/dist/runtime/utils/schema.js

@@ -1,9 +1,9 @@
 export function getMeta(field) {
   return field.meta();
 }
-export function resolveSchema(schema, action, input) {
+export function resolveSchema(schema, options) {
   const output = {
-    indicator: "id",
+    indicator: options?.indicator ?? "id",
     keys: {},
     values: {}
   };
@@ -12,13 +12,13 @@ export function resolveSchema(schema, action, input) {
     if (meta?.indicator) {
       output.indicator = key;
     }
-    if (!action || !meta?.actions) {
+    if (!options?.endpoint?.action || !meta?.actions) {
       continue;
     }
-    if (meta?.actions.includes(action)) {
+    if (meta?.actions.includes(options.endpoint.action)) {
       output.keys[key] = true;
-      if (input && key in input) {
-        output.values[key] = input[key];
+      if (options?.unit && key in options.unit) {
+        output.values[key] = options.unit[key];
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diphyx/harlemify",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "API state management for Nuxt powered by Harlem",
   "keywords": [
     "nuxt",
@@ -52,7 +52,8 @@
     "eslint": "^9.0.0",
     "nuxt": "^3.14.0",
     "typescript": "^5.6.0",
-    "vitest": "^2.0.0"
+    "vitest": "^2.0.0",
+    "vue": "^3.5.26"
   },
   "scripts": {
     "cleanup": "pnpm nuxt cleanup && pnpm nuxt cleanup playground",