@diphyx/harlemify 0.0.1 → 0.0.3

package/README.md

@@ -9,7 +9,11 @@ API state management for Nuxt powered by [Harlem](https://harlemjs.com/)
 - Zod schema validation with field metadata
 - Automatic API client with runtime config
 - 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
 
@@ -40,20 +44,49 @@ const UserSchema = z.object({
         indicator: true,
     }),
     name: z.string().meta({
-        actions: [ApiAction.POST, ApiAction.PUT],
+        actions: [ApiAction.POST, ApiAction.PATCH],
     }),
 });
 
-export const userStore = createStore("user", UserSchema, {
-    [Endpoint.GET_UNITS]: {
-        action: ApiAction.GET,
-        url: "/users",
+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}`,
+        },
+        [Endpoint.DELETE_UNITS]: {
+            action: ApiAction.DELETE,
+            url: (params) => `/users/${params.id}`,
+        },
     },
-    [Endpoint.POST_UNIT]: {
-        action: ApiAction.POST,
-        url: "/users",
+    {
+        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.1",
+  "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

@@ -1,12 +1,26 @@
 import { z } from "zod";
 import { type Extension, type BaseState } from "@harlem/core";
 import { Endpoint, type EndpointDefinition, type EndpointMemory } from "../utils/endpoint.js";
+export declare enum StoreMemoryPosition {
+    FIRST = "first",
+    LAST = "last"
+}
 import { ApiAction, type ApiActionOptions, type ApiOptions } from "./api.js";
-export declare function createStore<T extends z.ZodRawShape>(name: string, schema: z.ZodObject<T>, endpoints?: Partial<Record<Endpoint, EndpointDefinition>>, 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>[];
-}): {
-    api: {
+}
+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>;
         put: <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.PUT, H, Q, B>) => Promise<T_1>;
@@ -20,106 +34,42 @@ export declare function createStore<T extends z.ZodRawShape>(name: string, schem
         };
         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, {}>>[]>;
-    hasMemorizedUnits: (...units: ({
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => Record<keyof z.core.$InferObjectOutput<T, {}>, 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>;
-    };
+    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: 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<{
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>, void>;
-    editMemorizedUnits: (payload: ({
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => void;
-    dropMemorizedUnit: import("@harlem/core").Mutation<{
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>, void>;
-    dropMemorizedUnits: (payload: ({
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => void;
+    editMemorizedUnit: import("@harlem/core").Mutation<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, void>;
+    editMemorizedUnits: (payload: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => void;
+    dropMemorizedUnit: import("@harlem/core").Mutation<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, void>;
+    dropMemorizedUnits: (payload: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => void;
     patchEndpointMemory: (payload: {
         key: Endpoint;
         memory: EndpointMemory;
     }) => void;
     purgeEndpointMemory: (payload?: unknown) => void;
-    getUnit: (unit: {
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>, options?: Omit<ApiActionOptions<ApiAction.GET>, "body">) => Promise<z.core.$InferObjectOutput<T, {}>>;
+    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: 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<z.core.$InferObjectOutput<T, {}>>;
-    postUnits: (units: z.core.$InferObjectOutput<T, {}>[], options?: ApiActionOptions<ApiAction.POST> & {
+    }) => 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> & {
         validate?: boolean;
-    }) => Promise<z.core.$InferObjectOutput<T, {}>[]>;
-    putUnit: (unit: z.core.$InferObjectOutput<T, {}>, options?: ApiActionOptions<ApiAction.PUT> & {
+        position?: StoreMemoryPosition;
+    }) => Promise<(Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>)[]>;
+    putUnit: (unit: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>, options?: ApiActionOptions<ApiAction.PUT> & {
         validate?: boolean;
-    }) => Promise<z.core.$InferObjectOutput<T, {}>>;
-    putUnits: (units: z.core.$InferObjectOutput<T, {}>[], options?: ApiActionOptions<ApiAction.PUT> & {
+    }) => Promise<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>>;
+    putUnits: (units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>)[], options?: ApiActionOptions<ApiAction.PUT> & {
         validate?: boolean;
-    }) => Promise<z.core.$InferObjectOutput<T, {}>[]>;
-    patchUnit: (unit: {
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>, options?: ApiActionOptions<ApiAction.PATCH> & {
+    }) => Promise<(Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>)[]>;
+    patchUnit: (unit: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, options?: ApiActionOptions<ApiAction.PATCH> & {
         validate?: boolean;
-    }) => Promise<{
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>>;
-    patchUnits: (units: ({
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>)[], options?: ApiActionOptions<ApiAction.PATCH> & {
+    }) => Promise<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>>;
+    patchUnits: (units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[], options?: ApiActionOptions<ApiAction.PATCH> & {
         validate?: boolean;
-    }) => Promise<({
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>)[]>;
-    deleteUnit: (unit: {
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>, options?: Omit<ApiActionOptions<ApiAction.DELETE>, "body">) => Promise<boolean>;
-    deleteUnits: (units: ({
-        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
-    } & Partial<z.core.$InferObjectOutput<T, {}>>)[], options?: Omit<ApiActionOptions<ApiAction.DELETE>, "body">) => Promise<boolean>;
+    }) => Promise<(Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[]>;
+    deleteUnit: (unit: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, options?: Omit<ApiActionOptions<ApiAction.DELETE>, "body">) => Promise<boolean>;
+    deleteUnits: (units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[], options?: Omit<ApiActionOptions<ApiAction.DELETE>, "body">) => Promise<boolean>;
 };

package/dist/runtime/core/store.js

@@ -11,16 +11,52 @@ import {
   Endpoint,
   EndpointStatus
 } from "../utils/endpoint.js";
+export var StoreMemoryPosition = /* @__PURE__ */ ((StoreMemoryPosition2) => {
+  StoreMemoryPosition2["FIRST"] = "first";
+  StoreMemoryPosition2["LAST"] = "last";
+  return StoreMemoryPosition2;
+})(StoreMemoryPosition || {});
 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 config = useRuntimeConfig();
-  const api = createApi({
-    ...config.public.harlemify.api,
-    ...options?.api
+  const { indicator } = resolveSchema(schema, {
+    indicator: options?.indicator
   });
-  const { indicator } = resolveSchema(schema);
+  const hooks = options?.hooks;
+  let apiClient;
+  let apiInitError = null;
+  function api() {
+    if (apiInitError) {
+      throw apiInitError;
+    }
+    if (!apiClient) {
+      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;
+  }
   const store = createHarlemStore(
     name,
     {
@@ -138,278 +174,240 @@ 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 resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
-      });
-      const response = await api.get(resolvedUrl, 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 {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url);
-      const response = await api.get(resolvedUrl, options2);
+    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 {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
-      });
-      const response = await api.post(resolvedUrl, {
-        ...options2,
-        body: options2?.body ?? resolvedSchema.values
-      });
-      setMemorizedUnit(response);
-      patchEndpointMemoryTo(Endpoint.POST_UNIT, {
-        status: EndpointStatus.SUCCESS
+    return withEndpointStatus(Endpoint.POST_UNIT, async () => {
+      const response = await api().post(
+        resolveEndpointUrl(endpoint, unit),
+        {
+          ...actionOptions,
+          body: actionOptions?.body ?? resolvedSchema.values
+        }
+      );
+      setMemorizedUnit({
+        ...unit,
+        ...response
       });
       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);
-    const body = units.map((unit) => {
-      const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
-      if (options2?.validate) {
-        schema.pick(resolvedSchema.keys).parse(unit);
+    return withEndpointStatus(Endpoint.POST_UNITS, async () => {
+      const responses = [];
+      for (const unit of units) {
+        const resolvedSchema = resolveSchema(schema, {
+          indicator,
+          endpoint,
+          unit
+        });
+        if (options2?.validate) {
+          schema.pick(resolvedSchema.keys).parse(unit);
+        }
+        const response = await api().post(
+          resolveEndpointUrl(endpoint, unit),
+          {
+            ...options2,
+            body: options2?.body ?? resolvedSchema.values
+          }
+        );
+        const clonedUnits = [...memorizedUnits.value];
+        if (options2?.position === "last" /* LAST */) {
+          clonedUnits.push({
+            ...unit,
+            ...response
+          });
+        } else {
+          clonedUnits.unshift({
+            ...unit,
+            ...response
+          });
+        }
+        setMemorizedUnits(clonedUnits);
+        responses.push(response);
       }
-      return resolvedSchema.values;
+      return responses;
     });
-    patchEndpointMemoryTo(Endpoint.POST_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url);
-      const response = await api.post(resolvedUrl, {
-        ...options2,
-        body: options2?.body ?? body
-      });
-      setMemorizedUnits([
-        ...memorizedUnits.value,
-        ...response
-      ]);
-      patchEndpointMemoryTo(Endpoint.POST_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
-      return response;
-    } 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 {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
-      });
-      const response = await api.put(resolvedUrl, {
-        ...options2,
-        body: options2?.body ?? resolvedSchema.values
-      });
-      setMemorizedUnit(response);
-      patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
-        status: EndpointStatus.SUCCESS
+    return withEndpointStatus(Endpoint.PUT_UNIT, async () => {
+      const response = await api().put(
+        resolveEndpointUrl(endpoint, unit),
+        {
+          ...options2,
+          body: options2?.body ?? resolvedSchema.values
+        }
+      );
+      setMemorizedUnit({
+        ...unit,
+        ...response
       });
       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);
-    const body = units.map((unit) => {
-      const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
-      if (options2?.validate) {
-        schema.pick(resolvedSchema.keys).parse(unit);
+    return withEndpointStatus(Endpoint.PUT_UNITS, async () => {
+      const responses = [];
+      for (const unit of units) {
+        const resolvedSchema = resolveSchema(schema, {
+          indicator,
+          endpoint,
+          unit
+        });
+        if (options2?.validate) {
+          schema.pick(resolvedSchema.keys).parse(unit);
+        }
+        const response = await api().put(
+          resolveEndpointUrl(endpoint, unit),
+          {
+            ...options2,
+            body: options2?.body ?? resolvedSchema.values
+          }
+        );
+        editMemorizedUnits([
+          {
+            ...unit,
+            ...response
+          }
+        ]);
+        responses.push(response);
       }
-      return resolvedSchema.values;
+      return responses;
     });
-    patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url);
-      const response = await api.put(resolvedUrl, {
-        ...options2,
-        body: options2?.body ?? body
-      });
-      setMemorizedUnits(response);
-      patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
-      return response;
-    } 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 {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
+    return withEndpointStatus(Endpoint.PATCH_UNIT, async () => {
+      const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
+        ...options2,
+        body: options2?.body ?? resolvedSchema.values
       });
-      const response = await api.patch(
-        resolvedUrl,
-        {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
-        }
-      );
-      editMemorizedUnit(response);
-      patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
-        status: EndpointStatus.SUCCESS
+      editMemorizedUnit({
+        ...unit,
+        ...response
       });
       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);
-    const body = units.map((unit) => {
-      const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
-      if (options2?.validate) {
-        schema.pick(resolvedSchema.keys).partial().parse(unit);
+    return withEndpointStatus(Endpoint.PATCH_UNITS, async () => {
+      const responses = [];
+      for (const unit of units) {
+        const resolvedSchema = resolveSchema(schema, {
+          indicator,
+          endpoint,
+          unit
+        });
+        if (options2?.validate) {
+          schema.pick(resolvedSchema.keys).partial().parse(unit);
+        }
+        const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
+          ...options2,
+          body: options2?.body ?? resolvedSchema.values
+        });
+        editMemorizedUnits([
+          {
+            ...unit,
+            ...response
+          }
+        ]);
+        responses.push(response);
       }
-      return resolvedSchema.values;
-    });
-    patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
-      status: EndpointStatus.PENDING
+      return responses;
     });
-    try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url);
-      const response = await api.patch(resolvedUrl, {
-        ...options2,
-        body: options2?.body ?? body
-      });
-      editMemorizedUnits(response);
-      patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
-      return response;
-    } 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 {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
-      });
-      await api.del(
-        resolvedUrl,
+    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 {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url);
-      await api.del(
-        resolvedUrl,
-        options2
-      );
-      dropMemorizedUnits(units);
-      patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
+    return withEndpointStatus(Endpoint.DELETE_UNITS, async () => {
+      for (const unit of units) {
+        await api().del(
+          resolveEndpointUrl(endpoint, unit),
+          options2
+        );
+        dropMemorizedUnits([unit]);
+      }
       return true;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   return {
     api,

package/dist/runtime/index.d.ts

@@ -2,4 +2,4 @@ export { z } from "zod";
 export { ApiAction, ApiResponseType, ApiErrorSource, type ApiRequestHeader, type ApiRequestQuery, type ApiRequestBody, type ApiRequestOptions, type ApiOptions, type ApiActionOptions, type ApiErrorOptions, createApi, ApiError, ApiRequestError, ApiResponseError, } from "./core/api.js";
 export { Endpoint, EndpointStatus, type EndpointDefinition, type EndpointMemory, } from "./utils/endpoint.js";
 export { type SchemaMeta, getMeta, resolveSchema } from "./utils/schema.js";
-export { createStore } from "./core/store.js";
+export { createStore, StoreMemoryPosition } from "./core/store.js";

package/dist/runtime/index.js

@@ -13,4 +13,4 @@ export {
   EndpointStatus
 } from "./utils/endpoint.js";
 export { getMeta, resolveSchema } from "./utils/schema.js";
-export { createStore } from "./core/store.js";
+export { createStore, StoreMemoryPosition } from "./core/store.js";

package/dist/runtime/plugin.js

@@ -1,20 +1,26 @@
 import { createVuePlugin } from "@harlem/core";
 import {
+  createServerSSRPlugin,
   createClientSSRPlugin,
-  createServerSSRPlugin
+  getBridgingScript
 } from "@harlem/plugin-ssr";
 export default defineNuxtPlugin((nuxtApp) => {
   const plugins = [];
-  if (nuxtApp.payload.serverRendered) {
-    if (import.meta.server) {
-      plugins.push(createServerSSRPlugin());
-    }
-    if (import.meta.client) {
-      plugins.push(createClientSSRPlugin());
-    }
+  if (import.meta.server) {
+    plugins.push(createServerSSRPlugin());
+  }
+  if (import.meta.client) {
+    plugins.push(createClientSSRPlugin());
   }
   const harlem = createVuePlugin({
     plugins
   });
   nuxtApp.vueApp.use(harlem);
+  useHead({
+    script: [
+      {
+        innerHTML: getBridgingScript()
+      }
+    ]
+  });
 });

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

@@ -18,55 +18,22 @@ export declare enum EndpointStatus {
     SUCCESS = "success",
     FAILED = "failed"
 }
-export interface EndpointDefinition {
+export interface EndpointDefinition<T = Record<string, unknown>> {
     action: ApiAction;
-    url: string | ((keys: Record<PropertyKey, unknown>) => string);
+    url: string | ((params: T) => string);
 }
 export interface EndpointMemory {
     status: EndpointStatus;
 }
-export declare function makeEndpointStatusKey<K extends Endpoint, S extends EndpointStatus>(key: K, status: S): `${K}Is${Capitalize<S>}`;
-export declare function getEndpoint(endpoints: Partial<Record<Endpoint, EndpointDefinition>> | undefined, key: Endpoint): EndpointDefinition;
-export declare function resolveEndpointUrl<T extends Record<PropertyKey, unknown>>(url: string | ((parameters: T) => string), parameters?: T): 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;
+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 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];
@@ -28,11 +29,11 @@ export function getEndpoint(endpoints, key) {
   }
   return endpoint;
 }
-export function resolveEndpointUrl(url, parameters = {}) {
-  if (typeof url === "function") {
-    return url(parameters);
+export function resolveEndpointUrl(endpoint, params) {
+  if (typeof endpoint.url === "function") {
+    return endpoint.url(params);
   }
-  return url;
+  return endpoint.url;
 }
 export function makeEndpointsStatus(getter) {
   const output = {};

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.1",
+  "version": "0.0.3",
   "description": "API state management for Nuxt powered by Harlem",
   "keywords": [
     "nuxt",
@@ -37,14 +37,13 @@
     "dist"
   ],
   "dependencies": {
-    "@nuxt/kit": "^3.14.0",
     "@harlem/core": "^3.0.0",
     "@harlem/plugin-ssr": "^3.0.0",
+    "@nuxt/kit": "^3.14.0",
     "defu": "^6.0.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {
-    "@nuxt/devtools": "^1.6.0",
     "@nuxt/eslint-config": "^0.6.0",
     "@nuxt/module-builder": "^0.8.0",
     "@nuxt/schema": "^3.14.0",
@@ -53,12 +52,13 @@
     "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": {
-    "postinstall": "nuxi prepare playground",
+    "cleanup": "pnpm nuxt cleanup && pnpm nuxt cleanup playground",
+    "dev": "pnpm nuxt dev playground",
     "build": "nuxt-module-build build",
-    "dev": "nuxi dev playground",
     "lint": "eslint . --fix",
     "test": "vitest run"
   }