@diphyx/harlemify 0.0.1 → 0.0.2

package/README.md

@@ -9,6 +9,7 @@ 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
 
 ## Installation
@@ -40,19 +41,29 @@ const UserSchema = z.object({
         indicator: true,
     }),
     name: z.string().meta({
-        actions: [ApiAction.POST, ApiAction.PUT],
+        actions: [ApiAction.POST, ApiAction.PATCH],
     }),
 });
 
+export type User = z.infer<typeof UserSchema>;
+
 export const userStore = createStore("user", UserSchema, {
     [Endpoint.GET_UNITS]: {
         action: ApiAction.GET,
         url: "/users",
     },
-    [Endpoint.POST_UNIT]: {
+    [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}`,
+    },
 });
 ```
 

package/dist/module.json

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

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

@@ -1,12 +1,16 @@
 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 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?: {
     api?: ApiOptions;
     extensions?: Extension<BaseState>[];
 }): {
-    api: {
+    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>;
@@ -22,9 +26,7 @@ export declare function createStore<T extends z.ZodRawShape>(name: string, schem
     }>, 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>;
+    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>;
@@ -69,57 +71,36 @@ export declare function createStore<T extends z.ZodRawShape>(name: string, schem
     };
     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, {}>, options?: 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,27 @@ 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 function createStore(name, schema, endpoints, options) {
-  const config = useRuntimeConfig();
-  const api = createApi({
-    ...config.public.harlemify.api,
-    ...options?.api
-  });
   const { indicator } = resolveSchema(schema);
+  let apiClient;
+  function api() {
+    if (!apiClient) {
+      const config = useRuntimeConfig();
+      apiClient = createApi({
+        ...config.public.harlemify?.api,
+        ...options?.api
+      });
+    }
+    return apiClient;
+  }
   const store = createHarlemStore(
     name,
     {
@@ -144,10 +155,10 @@ export function createStore(name, schema, endpoints, options) {
       status: EndpointStatus.PENDING
     });
     try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
-      });
-      const response = await api.get(resolvedUrl, options2);
+      const response = await api().get(
+        resolveEndpointUrl(endpoint, unit),
+        options2
+      );
       setMemorizedUnit(response);
       patchEndpointMemoryTo(Endpoint.GET_UNIT, {
         status: EndpointStatus.SUCCESS
@@ -166,8 +177,10 @@ export function createStore(name, schema, endpoints, options) {
       status: EndpointStatus.PENDING
     });
     try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url);
-      const response = await api.get(resolvedUrl, options2);
+      const response = await api().get(
+        resolveEndpointUrl(endpoint),
+        options2
+      );
       setMemorizedUnits(response);
       patchEndpointMemoryTo(Endpoint.GET_UNITS, {
         status: EndpointStatus.SUCCESS
@@ -190,14 +203,17 @@ export function createStore(name, schema, endpoints, options) {
       status: EndpointStatus.PENDING
     });
     try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
-      });
-      const response = await api.post(resolvedUrl, {
-        ...options2,
-        body: options2?.body ?? resolvedSchema.values
+      const response = await api().post(
+        resolveEndpointUrl(endpoint, unit),
+        {
+          ...options2,
+          body: options2?.body ?? resolvedSchema.values
+        }
+      );
+      setMemorizedUnit({
+        ...unit,
+        ...response
       });
-      setMemorizedUnit(response);
       patchEndpointMemoryTo(Endpoint.POST_UNIT, {
         status: EndpointStatus.SUCCESS
       });
@@ -211,30 +227,46 @@ export function createStore(name, schema, endpoints, options) {
   }
   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 resolvedSchema.values;
-    });
     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
-      ]);
+      const responses = [];
+      for (const unit of units) {
+        const resolvedSchema = resolveSchema(
+          schema,
+          endpoint.action,
+          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);
+      }
       patchEndpointMemoryTo(Endpoint.POST_UNITS, {
         status: EndpointStatus.SUCCESS
       });
-      return response;
+      return responses;
     } catch (error) {
       patchEndpointMemoryTo(Endpoint.POST_UNITS, {
         status: EndpointStatus.FAILED
@@ -252,14 +284,17 @@ export function createStore(name, schema, endpoints, options) {
       status: EndpointStatus.PENDING
     });
     try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
-      });
-      const response = await api.put(resolvedUrl, {
-        ...options2,
-        body: options2?.body ?? resolvedSchema.values
+      const response = await api().put(
+        resolveEndpointUrl(endpoint, unit),
+        {
+          ...options2,
+          body: options2?.body ?? resolvedSchema.values
+        }
+      );
+      setMemorizedUnit({
+        ...unit,
+        ...response
       });
-      setMemorizedUnit(response);
       patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
         status: EndpointStatus.SUCCESS
       });
@@ -273,27 +308,39 @@ export function createStore(name, schema, endpoints, options) {
   }
   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 resolvedSchema.values;
-    });
     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);
+      const responses = [];
+      for (const unit of units) {
+        const resolvedSchema = resolveSchema(
+          schema,
+          endpoint.action,
+          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);
+      }
       patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
         status: EndpointStatus.SUCCESS
       });
-      return response;
+      return responses;
     } catch (error) {
       patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
         status: EndpointStatus.FAILED
@@ -311,17 +358,14 @@ export function createStore(name, schema, endpoints, options) {
       status: EndpointStatus.PENDING
     });
     try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
+      const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
+        ...options2,
+        body: options2?.body ?? resolvedSchema.values
+      });
+      editMemorizedUnit({
+        ...unit,
+        ...response
       });
-      const response = await api.patch(
-        resolvedUrl,
-        {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
-        }
-      );
-      editMemorizedUnit(response);
       patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
         status: EndpointStatus.SUCCESS
       });
@@ -335,27 +379,36 @@ export function createStore(name, schema, endpoints, options) {
   }
   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 resolvedSchema.values;
-    });
     patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
       status: EndpointStatus.PENDING
     });
     try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url);
-      const response = await api.patch(resolvedUrl, {
-        ...options2,
-        body: options2?.body ?? body
-      });
-      editMemorizedUnits(response);
+      const responses = [];
+      for (const unit of units) {
+        const resolvedSchema = resolveSchema(
+          schema,
+          endpoint.action,
+          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);
+      }
       patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
         status: EndpointStatus.SUCCESS
       });
-      return response;
+      return responses;
     } catch (error) {
       patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
         status: EndpointStatus.FAILED
@@ -369,11 +422,8 @@ export function createStore(name, schema, endpoints, options) {
       status: EndpointStatus.PENDING
     });
     try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
-        [indicator]: unit[indicator]
-      });
-      await api.del(
-        resolvedUrl,
+      await api().del(
+        resolveEndpointUrl(endpoint, unit),
         options2
       );
       dropMemorizedUnit(unit);
@@ -394,12 +444,13 @@ export function createStore(name, schema, endpoints, options) {
       status: EndpointStatus.PENDING
     });
     try {
-      const resolvedUrl = resolveEndpointUrl(endpoint.url);
-      await api.del(
-        resolvedUrl,
-        options2
-      );
-      dropMemorizedUnits(units);
+      for (const unit of units) {
+        await api().del(
+          resolveEndpointUrl(endpoint, unit),
+          options2
+        );
+        dropMemorizedUnits([unit]);
+      }
       patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
         status: EndpointStatus.SUCCESS
       });

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,16 +18,18 @@ 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 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;

package/dist/runtime/utils/endpoint.js

@@ -28,11 +28,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diphyx/harlemify",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "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",
@@ -56,9 +55,9 @@
     "vitest": "^2.0.0"
   },
   "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"
   }