@diphyx/harlemify 0.0.3 → 1.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Amir Reza Dalir
+Copyright (c) 2026 DiPhyx
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,19 +1,18 @@
 # Harlemify
 
-API state management for Nuxt powered by [Harlem](https://harlemjs.com/)
+> Schema-driven state management for Nuxt powered by [Harlem](https://harlemjs.com/)
 
 ![Harlemify](https://raw.githubusercontent.com/diphyx/harlemify/main/docs/_media/icon.svg)
 
+Define your data schema once with Zod, and Harlemify handles the rest: type-safe API calls, reactive state, request monitoring, and automatic memory management. Your schema becomes the single source of truth for types, validation, and API payloads.
+
 ## Features
 
-- 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
+- **Schema-Driven** - Zod schema defines types, validation, and API payloads
+- **Automatic API Client** - Built-in HTTP client with runtime configuration
+- **Reactive Memory** - Unit and collection caching with Vue reactivity
+- **Request Monitoring** - Track pending, success, and failed states
+- **SSR Support** - Server-side rendering via Harlem SSR plugin
 
 ## Installation
 
@@ -37,58 +36,35 @@ export default defineNuxtConfig({
 
 ```typescript
 // stores/user.ts
-import { z, createStore, Endpoint, ApiAction } from "@diphyx/harlemify";
+import { z } from "zod";
+import { createStore, Endpoint, EndpointMethod } from "@diphyx/harlemify";
 
 const UserSchema = z.object({
-    id: z.number().meta({
-        indicator: true,
-    }),
+    id: z.number().meta({ indicator: true }),
     name: z.string().meta({
-        actions: [ApiAction.POST, ApiAction.PATCH],
+        methods: [EndpointMethod.POST, EndpointMethod.PATCH],
     }),
 });
 
 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}`,
-        },
-    },
-    {
-        indicator: "id",
-        hooks: {
-            before() {
-                console.log("Request starting...");
-            },
-            after(error) {
-                if (error) {
-                    console.error("Request failed:", error);
-                } else {
-                    console.log("Request completed");
-                }
-            },
-        },
-    },
-);
+export const userStore = createStore("user", UserSchema, {
+    [Endpoint.GET_UNITS]: { method: EndpointMethod.GET, url: "/users" },
+    [Endpoint.POST_UNITS]: { method: EndpointMethod.POST, url: "/users" },
+    [Endpoint.PATCH_UNITS]: { method: EndpointMethod.PATCH, url: (p) => `/users/${p.id}` },
+    [Endpoint.DELETE_UNITS]: { method: EndpointMethod.DELETE, url: (p) => `/users/${p.id}` },
+});
 ```
 
+## Why Harlemify?
+
+|                 |                                                   |
+| --------------- | ------------------------------------------------- |
+| **Type-Safe**   | Full TypeScript support with Zod schema inference |
+| **Declarative** | Define schema once, derive everything else        |
+| **Reactive**    | Powered by Vue's reactivity through Harlem        |
+| **Simple**      | Minimal boilerplate, maximum productivity         |
+
 ## Documentation
 
 Full documentation available at [https://diphyx.github.io/harlemify/](https://diphyx.github.io/harlemify/)

package/dist/module.json

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

package/dist/module.mjs

@@ -15,6 +15,8 @@ const module = defineNuxtModule({
     const { resolve } = createResolver(import.meta.url);
     addPlugin(resolve("./runtime", "plugin"));
     addImportsDir(resolve("./runtime", "core"));
+    addImportsDir(resolve("./runtime", "composables"));
+    addImportsDir(resolve("./runtime", "utils"));
     updateRuntimeConfig({
       public: {
         harlemify: options

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

@@ -0,0 +1,30 @@
+import type { ComputedRef } from "vue";
+import { EndpointMethod } from "../utils/endpoint.js";
+import type { Store } from "../core/store.js";
+import type { Pluralize, Capitalize } from "../utils/transform.js";
+import type { EndpointStatusFlag } from "../utils/endpoint.js";
+type Indicator<T, I extends keyof T> = Required<Pick<T, I>>;
+type PartialWithIndicator<T, I extends keyof T> = Indicator<T, I> & Partial<T>;
+type MemoryState<E extends string, T> = {
+    [P in E]: ComputedRef<T | null>;
+} & {
+    [P in Pluralize<E>]: ComputedRef<T[]>;
+};
+type MemoryAction<A extends string, E extends string, U> = {
+    [K in `${A}${Capitalize<E>}`]: (unit: U) => void;
+} & {
+    [K in `${A}${Capitalize<Pluralize<E>>}`]: (units: U[]) => void;
+};
+type EndpointAction<E extends string, T> = {
+    [M in EndpointMethod as `${M}${Capitalize<E>}`]: (unit?: Partial<T>) => Promise<T>;
+} & {
+    [M in EndpointMethod as `${M}${Capitalize<Pluralize<E>>}`]: (units?: Partial<T>[]) => Promise<T[]>;
+};
+type EndpointMonitor<E extends string> = {
+    [M in EndpointMethod as `${M}${Capitalize<E>}${EndpointStatusFlag}`]: ComputedRef<boolean>;
+} & {
+    [M in EndpointMethod as `${M}${Capitalize<Pluralize<E>>}${EndpointStatusFlag}`]: ComputedRef<boolean>;
+};
+type StoreAlias<E extends string, T, I extends keyof T = keyof T> = MemoryState<E, T> & MemoryAction<"set", E, T | null> & MemoryAction<"edit", E, PartialWithIndicator<T, I>> & MemoryAction<"drop", E, PartialWithIndicator<T, I>> & EndpointAction<E, T> & EndpointMonitor<E>;
+export declare function useStoreAlias<E extends string, T, I extends keyof T = keyof T>(store: Store<E, T, I>): StoreAlias<E, T, I>;
+export {};

package/dist/runtime/composables/use.js

@@ -0,0 +1,25 @@
+import { capitalize } from "../utils/transform.js";
+import { EndpointMethod, EndpointStatus, makeEndpointStatusFlag } from "../utils/endpoint.js";
+import { StoreMemoryAction } from "../core/store.js";
+export function useStoreAlias(store) {
+  const capitalizedUnit = capitalize(store.alias.unit);
+  const capitalizedUnits = capitalize(store.alias.units);
+  const output = {
+    [store.alias.unit]: store.unit,
+    [store.alias.units]: store.units
+  };
+  for (const action of Object.values(StoreMemoryAction)) {
+    output[`${action}${capitalizedUnit}`] = store.memory[`${action}Unit`];
+    output[`${action}${capitalizedUnits}`] = store.memory[`${action}Units`];
+  }
+  for (const method of Object.values(EndpointMethod)) {
+    output[`${method}${capitalizedUnit}`] = store.endpoint[`${method}Unit`];
+    output[`${method}${capitalizedUnits}`] = store.endpoint[`${method}Units`];
+    for (const status of Object.values(EndpointStatus)) {
+      const statusFlag = makeEndpointStatusFlag(status);
+      output[`${method}${capitalizedUnit}${statusFlag}`] = store.monitor[`${method}Unit${statusFlag}`];
+      output[`${method}${capitalizedUnits}${statusFlag}`] = store.monitor[`${method}Units${statusFlag}`];
+    }
+  }
+  return output;
+}

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

@@ -1,11 +1,5 @@
-import { type MaybeRefOrGetter } from "vue";
-export declare enum ApiAction {
-    GET = "get",
-    POST = "post",
-    PUT = "put",
-    PATCH = "patch",
-    DELETE = "delete"
-}
+import type { MaybeRefOrGetter } from "vue";
+import { EndpointMethod } from "../utils/endpoint.js";
 export declare enum ApiResponseType {
     JSON = "json",
     TEXT = "text",
@@ -19,7 +13,7 @@ export declare enum ApiErrorSource {
 export type ApiRequestHeader = MaybeRefOrGetter<Record<string, unknown>>;
 export type ApiRequestQuery = MaybeRefOrGetter<Record<string, unknown>>;
 export type ApiRequestBody = MaybeRefOrGetter<string | number | ArrayBuffer | FormData | Blob | Record<string, any>>;
-export interface ApiRequestOptions<A extends ApiAction = ApiAction, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> {
+export interface ApiRequestOptions<A extends EndpointMethod = EndpointMethod, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> {
     action?: A;
     headers?: H;
     query?: Q;
@@ -37,7 +31,7 @@ export interface ApiOptions {
     query?: ApiRequestQuery;
     timeout?: number;
 }
-export type ApiActionOptions<A extends ApiAction, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> = Omit<ApiRequestOptions<A, H, Q, B>, "action">;
+export type EndpointMethodOptions<A extends EndpointMethod, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> = Omit<ApiRequestOptions<A, H, Q, B>, "action">;
 export interface ApiErrorOptions {
     source: ApiErrorSource;
     method: string;
@@ -56,10 +50,11 @@ export declare class ApiRequestError extends ApiError {
 export declare class ApiResponseError extends ApiError {
     constructor(options: Omit<ApiErrorOptions, "source">);
 }
-export declare function createApi(options?: ApiOptions): {
-    get: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.GET, H, Q, never>) => Promise<T>;
-    post: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.POST, H, Q, B>) => Promise<T>;
-    put: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PUT, H, Q, B>) => Promise<T>;
-    patch: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PATCH, H, Q, B>) => Promise<T>;
-    del: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.DELETE, H, Q, never>) => Promise<T>;
-};
+export interface Api {
+    get: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.GET, H, Q, never>) => Promise<T>;
+    post: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.POST, H, Q, B>) => Promise<T>;
+    put: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.PUT, H, Q, B>) => Promise<T>;
+    patch: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.PATCH, H, Q, B>) => Promise<T>;
+    del: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.DELETE, H, Q, never>) => Promise<T>;
+}
+export declare function createApi(options?: ApiOptions): Api;

package/dist/runtime/core/api.js

@@ -1,12 +1,5 @@
 import { toValue } from "vue";
-export var ApiAction = /* @__PURE__ */ ((ApiAction2) => {
-  ApiAction2["GET"] = "get";
-  ApiAction2["POST"] = "post";
-  ApiAction2["PUT"] = "put";
-  ApiAction2["PATCH"] = "patch";
-  ApiAction2["DELETE"] = "delete";
-  return ApiAction2;
-})(ApiAction || {});
+import { EndpointMethod } from "../utils/endpoint.js";
 export var ApiResponseType = /* @__PURE__ */ ((ApiResponseType2) => {
   ApiResponseType2["JSON"] = "json";
   ApiResponseType2["TEXT"] = "text";
@@ -24,7 +17,7 @@ export class ApiError extends Error {
   method;
   url;
   constructor(options) {
-    super(options.message || "Unknown error");
+    super(options.message ?? "Unknown error");
     this.name = "ApiError";
     this.source = options.source;
     this.method = options.method;
@@ -51,7 +44,7 @@ export function createApi(options) {
   async function request(url, requestOptions) {
     return $fetch(url, {
       baseURL: options?.url,
-      method: requestOptions?.action ?? "get" /* GET */,
+      method: requestOptions?.action ?? EndpointMethod.GET,
       headers: {
         ...toValue(options?.headers),
         ...toValue(requestOptions?.headers)
@@ -86,31 +79,31 @@ export function createApi(options) {
   async function get(url, options2) {
     return request(url, {
       ...options2,
-      action: "get" /* GET */
+      action: EndpointMethod.GET
     });
   }
   async function post(url, options2) {
     return request(url, {
       ...options2,
-      action: "post" /* POST */
+      action: EndpointMethod.POST
     });
   }
   async function put(url, options2) {
     return request(url, {
       ...options2,
-      action: "put" /* PUT */
+      action: EndpointMethod.PUT
     });
   }
   async function patch(url, options2) {
     return request(url, {
       ...options2,
-      action: "patch" /* PATCH */
+      action: EndpointMethod.PATCH
     });
   }
   async function del(url, options2) {
     return request(url, {
       ...options2,
-      action: "delete" /* DELETE */
+      action: EndpointMethod.DELETE
     });
   }
   return {

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

@@ -1,14 +1,19 @@
-import { z } from "zod";
-import { type Extension, type BaseState } from "@harlem/core";
-import { Endpoint, type EndpointDefinition, type EndpointMemory } from "../utils/endpoint.js";
+import type { z } from "zod";
+import type { ComputedRef } from "vue";
+import type { Extension, BaseState } from "@harlem/core";
+import { Endpoint, EndpointStatus } from "../utils/endpoint.js";
+import type { EndpointMethodOptions, ApiOptions } from "./api.js";
+import type { EndpointDefinition, EndpointStatusName } from "../utils/endpoint.js";
+import type { Pluralize } from "../utils/transform.js";
+export declare enum StoreMemoryAction {
+    SET = "set",
+    EDIT = "edit",
+    DROP = "drop"
+}
 export declare enum StoreMemoryPosition {
     FIRST = "first",
     LAST = "last"
 }
-import { ApiAction, type ApiActionOptions, type ApiOptions } from "./api.js";
-export declare class StoreConfigurationError extends Error {
-    constructor(message: string);
-}
 export interface StoreHooks {
     before?: () => Promise<void> | void;
     after?: (error?: Error) => Promise<void> | void;
@@ -19,57 +24,51 @@ export interface StoreOptions {
     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>;
-        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>;
-        patch: <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.PATCH, H, Q, B>) => Promise<T_1>;
-        del: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.DELETE, H, Q, never>) => Promise<T_1>;
+type Indicator<T, I extends keyof T> = Required<Pick<T, I>>;
+type WithIndicator<T, I extends keyof T> = Indicator<T, I> & T;
+type PartialWithIndicator<T, I extends keyof T> = Indicator<T, I> & Partial<T>;
+type StoreEndpointReadOptions = Omit<EndpointMethodOptions<any>, "body">;
+type StoreEndpointWriteOptions = EndpointMethodOptions<any> & {
+    validate?: boolean;
+};
+type StoreEndpointWriteMultipleOptions = StoreEndpointWriteOptions & {
+    position?: StoreMemoryPosition;
+};
+type StoreMemory<T = unknown, I extends keyof T = keyof T> = {
+    setUnit: (unit: T | null) => void;
+    setUnits: (units: T[]) => void;
+    editUnit: (unit: PartialWithIndicator<T, I>) => void;
+    editUnits: (units: PartialWithIndicator<T, I>[]) => void;
+    dropUnit: (unit: PartialWithIndicator<T, I>) => void;
+    dropUnits: (units: PartialWithIndicator<T, I>[]) => void;
+};
+type StoreEndpoint<T = unknown, I extends keyof T = keyof T> = {
+    getUnit: (unit?: PartialWithIndicator<T, I>, options?: StoreEndpointReadOptions) => Promise<T>;
+    getUnits: (options?: StoreEndpointReadOptions) => Promise<T[]>;
+    postUnit: (unit: WithIndicator<T, I>, options?: StoreEndpointWriteOptions) => Promise<T>;
+    postUnits: (units: WithIndicator<T, I>[], options?: StoreEndpointWriteMultipleOptions) => Promise<T[]>;
+    putUnit: (unit: WithIndicator<T, I>, options?: StoreEndpointWriteOptions) => Promise<T>;
+    putUnits: (units: WithIndicator<T, I>[], options?: StoreEndpointWriteOptions) => Promise<T[]>;
+    patchUnit: (unit: PartialWithIndicator<T, I>, options?: StoreEndpointWriteOptions) => Promise<Partial<T>>;
+    patchUnits: (units: PartialWithIndicator<T, I>[], options?: StoreEndpointWriteOptions) => Promise<Partial<T>[]>;
+    deleteUnit: (unit: PartialWithIndicator<T, I>, options?: StoreEndpointReadOptions) => Promise<boolean>;
+    deleteUnits: (units: PartialWithIndicator<T, I>[], options?: StoreEndpointReadOptions) => Promise<boolean>;
+};
+type StoreMonitor = {
+    [K in Endpoint as EndpointStatusName<K, EndpointStatus>]: ComputedRef<boolean>;
+};
+export type Store<E extends string = string, T = unknown, I extends keyof T = keyof T> = {
+    store: any;
+    alias: {
+        unit: E;
+        units: Pluralize<E>;
     };
-    store: Omit<import("@harlem/core").Store<{
-        memory: {
-            unit: z.core.$InferObjectOutput<T, {}> | null;
-            units: z.core.$InferObjectOutput<T, {}>[];
-        };
-        endpoints: Record<Endpoint, EndpointMemory>;
-    }>, never>;
-    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<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?: 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, {}>, 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> & {
-        validate?: boolean;
-        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<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<(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<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<(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>;
+    indicator: I;
+    unit: ComputedRef<T | null>;
+    units: ComputedRef<T[]>;
+    memory: StoreMemory<T, I>;
+    endpoint: StoreEndpoint<T, I>;
+    monitor: StoreMonitor;
 };
+export declare function createStore<E extends string, T extends z.ZodRawShape, S extends z.infer<z.ZodObject<T>> = z.infer<z.ZodObject<T>>, I extends keyof S = "id" & keyof S>(entity: E, schema: z.ZodObject<T>, endpoints?: Partial<Record<Endpoint, EndpointDefinition<Partial<S>>>>, options?: StoreOptions): Store<E, S, I>;
+export {};

package/dist/runtime/core/store.js

@@ -1,277 +1,181 @@
 import { defu } from "defu";
-import {
-  createStore as createHarlemStore
-} from "@harlem/core";
+import { createStore as createHarlemStore } from "@harlem/core";
+import { createApi } from "./api.js";
 import { resolveSchema } from "../utils/schema.js";
-import {
-  makeEndpointStatusKey,
-  getEndpoint,
-  resolveEndpointUrl,
-  makeEndpointsStatus,
-  Endpoint,
-  EndpointStatus
-} from "../utils/endpoint.js";
+import { pluralize } from "../utils/transform.js";
+import { Endpoint, EndpointStatus, getEndpoint, makeEndpointStatusName, resolveEndpointUrl } from "../utils/endpoint.js";
+export var StoreMemoryAction = /* @__PURE__ */ ((StoreMemoryAction2) => {
+  StoreMemoryAction2["SET"] = "set";
+  StoreMemoryAction2["EDIT"] = "edit";
+  StoreMemoryAction2["DROP"] = "drop";
+  return StoreMemoryAction2;
+})(StoreMemoryAction || {});
 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) {
+export function createStore(entity, schema, endpoints, options) {
   const { indicator } = resolveSchema(schema, {
     indicator: options?.indicator
   });
-  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;
-      }
+      const config = useRuntimeConfig();
+      apiClient = createApi({
+        ...config.public.harlemify?.api ?? {},
+        ...options?.api
+      });
     }
     return apiClient;
   }
-  const store = createHarlemStore(
-    name,
-    {
-      memory: {
-        unit: null,
-        units: []
-      },
-      endpoints: {}
+  const state = {
+    memory: {
+      unit: null,
+      units: []
     },
-    {
-      extensions: options?.extensions ?? []
-    }
-  );
-  const memorizedUnit = store.getter("memorizedUnit", (state) => {
-    return state.memory.unit;
+    endpoints: {}
+  };
+  const store = createHarlemStore(entity, state, {
+    extensions: options?.extensions ?? []
+  });
+  const alias = {
+    unit: entity,
+    units: pluralize(entity)
+  };
+  const memorizedUnit = store.getter("memorizedUnit", (state2) => {
+    return state2.memory.unit;
+  });
+  const memorizedUnits = store.getter("memorizedUnits", (state2) => {
+    return state2.memory.units;
   });
-  const memorizedUnits = store.getter("memorizedUnits", (state) => {
-    return state.memory.units;
+  const setMemorizedUnit = store.mutation("setMemorizedUnit", (state2, unit = null) => {
+    state2.memory.unit = unit;
   });
-  function hasMemorizedUnits(...units) {
-    const output = {};
+  const setMemorizedUnits = store.mutation("setMemorizedUnits", (state2, units = []) => {
+    state2.memory.units = units;
+  });
+  const editMemorizedUnit = store.mutation("editMemorizedUnit", (state2, unit) => {
+    if (state2.memory.unit?.[indicator] === unit[indicator]) {
+      state2.memory.unit = defu(unit, state2.memory.unit);
+    }
+  });
+  const editMemorizedUnits = store.mutation("editMemorizedUnits", (state2, units) => {
     for (const unit of units) {
-      const exists = memorizedUnits.value.some((memorizedUnit2) => {
+      const index = state2.memory.units.findIndex((memorizedUnit2) => {
         return memorizedUnit2[indicator] === unit[indicator];
       });
-      output[unit[indicator]] = exists;
-    }
-    return output;
-  }
-  const setMemorizedUnit = store.mutation(
-    "setMemorizedUnit",
-    (state, unit = null) => {
-      state.memory.unit = unit;
-    }
-  );
-  const setMemorizedUnits = store.mutation(
-    "setMemorizedUnits",
-    (state, units = []) => {
-      state.memory.units = units;
-    }
-  );
-  const editMemorizedUnit = store.mutation(
-    "editMemorizedUnit",
-    (state, unit) => {
-      if (state.memory.unit?.[indicator] === unit[indicator]) {
-        state.memory.unit = defu(unit, state.memory.unit);
+      if (index !== -1) {
+        state2.memory.units[index] = defu(unit, state2.memory.units[index]);
       }
     }
-  );
-  const editMemorizedUnits = store.mutation(
-    "editMemorizedUnits",
-    (state, units) => {
+  });
+  const dropMemorizedUnit = store.mutation("dropMemorizedUnit", (state2, unit) => {
+    if (state2.memory.unit?.[indicator] === unit[indicator]) {
+      state2.memory.unit = null;
+    }
+  });
+  const dropMemorizedUnits = store.mutation("dropMemorizedUnits", (state2, units) => {
+    state2.memory.units = state2.memory.units.filter((memorizedUnit2) => {
       for (const unit of units) {
-        const index = state.memory.units.findIndex((memorizedUnit2) => {
-          return memorizedUnit2[indicator] === unit[indicator];
-        });
-        if (index !== -1) {
-          state.memory.units[index] = defu(
-            unit,
-            state.memory.units[index]
-          );
+        if (memorizedUnit2[indicator] === unit[indicator]) {
+          return false;
         }
       }
-    }
-  );
-  const dropMemorizedUnit = store.mutation(
-    "dropMemorizedUnit",
-    (state, unit) => {
-      if (state.memory.unit?.[indicator] === unit[indicator]) {
-        state.memory.unit = null;
-      }
-    }
-  );
-  const dropMemorizedUnits = store.mutation(
-    "dropMemorizedUnits",
-    (state, units) => {
-      state.memory.units = state.memory.units.filter((memorizedUnit2) => {
-        for (const unit of units) {
-          if (memorizedUnit2[indicator] === unit[indicator]) {
-            return false;
-          }
-        }
-        return true;
+      return true;
+    });
+  });
+  const monitor = {};
+  for (const endpoint of Object.values(Endpoint)) {
+    for (const endpointStatus of Object.values(EndpointStatus)) {
+      const statusKey = makeEndpointStatusName(endpoint, endpointStatus);
+      monitor[statusKey] = store.getter(statusKey, (state2) => {
+        return state2.endpoints[endpoint] === endpointStatus;
       });
     }
-  );
-  const endpointsStatus = makeEndpointsStatus(store.getter);
-  const patchEndpointMemory = store.mutation(
-    "patchEndpointMemory",
-    (state, {
-      key,
-      memory
-    }) => {
-      state.endpoints[key] = memory;
-    }
-  );
-  const purgeEndpointMemory = store.mutation(
-    "purgeEndpointMemory",
-    (state) => {
-      state.endpoints = {};
+  }
+  const patchMonitor = store.mutation(
+    "patchMonitor",
+    (state2, payload) => {
+      state2.endpoints[payload.endpoint] = payload.status;
     }
   );
-  function patchEndpointMemoryTo(key, memory) {
-    if (memory.status === EndpointStatus.PENDING) {
-      const statusKey = makeEndpointStatusKey(
-        key,
-        EndpointStatus.PENDING
-      );
-      if (endpointsStatus[statusKey].value) {
-        throw new Error(`Endpoint "${key}" is already pending`);
+  function patchMonitorTo(endpoint, status) {
+    if (status === EndpointStatus.PENDING) {
+      const statusKey = makeEndpointStatusName(endpoint, EndpointStatus.PENDING);
+      if (monitor[statusKey].value) {
+        throw new Error(`Endpoint "${endpoint}" is already pending`);
       }
     }
-    patchEndpointMemory({
-      key,
-      memory
+    patchMonitor({
+      endpoint,
+      status
     });
   }
-  async function withEndpointStatus(key, operation) {
-    await hooks?.before?.();
-    patchEndpointMemoryTo(key, {
-      status: EndpointStatus.PENDING
-    });
+  async function withStatus(key, operation) {
+    await options?.hooks?.before?.();
+    patchMonitorTo(key, EndpointStatus.PENDING);
     try {
       const result = await operation();
-      patchEndpointMemoryTo(key, {
-        status: EndpointStatus.SUCCESS
-      });
-      await hooks?.after?.();
+      patchMonitorTo(key, EndpointStatus.SUCCESS);
+      await options?.hooks?.after?.();
       return result;
     } catch (error) {
-      patchEndpointMemoryTo(key, {
-        status: EndpointStatus.FAILED
-      });
-      await hooks?.after?.(error);
+      patchMonitorTo(key, EndpointStatus.FAILED);
+      await options?.hooks?.after?.(error);
       throw error;
     }
   }
-  async function getUnit(unit, options2) {
+  async function getUnitEndpoint(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.GET_UNIT);
-    return withEndpointStatus(Endpoint.GET_UNIT, async () => {
-      const response = await api().get(
-        resolveEndpointUrl(endpoint, unit),
-        options2
-      );
+    return withStatus(Endpoint.GET_UNIT, async () => {
+      const response = await api().get(resolveEndpointUrl(endpoint, unit), options2);
       setMemorizedUnit(response);
       return response;
     });
   }
-  async function getUnits(options2) {
+  async function getUnitsEndpoint(options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.GET_UNITS);
-    return withEndpointStatus(Endpoint.GET_UNITS, async () => {
-      const response = await api().get(
-        resolveEndpointUrl(endpoint),
-        options2
-      );
+    return withStatus(Endpoint.GET_UNITS, async () => {
+      const response = await api().get(resolveEndpointUrl(endpoint), options2);
       setMemorizedUnits(response);
       return response;
     });
   }
-  async function postUnit(unit, actionOptions) {
+  async function postUnitEndpoint(unit, actionOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.POST_UNIT);
-    const resolvedSchema = resolveSchema(schema, {
-      indicator,
-      endpoint,
-      unit
-    });
+    const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
     if (actionOptions?.validate) {
       schema.pick(resolvedSchema.keys).parse(unit);
     }
-    return withEndpointStatus(Endpoint.POST_UNIT, async () => {
-      const response = await api().post(
-        resolveEndpointUrl(endpoint, unit),
-        {
-          ...actionOptions,
-          body: actionOptions?.body ?? resolvedSchema.values
-        }
-      );
-      setMemorizedUnit({
-        ...unit,
-        ...response
+    return withStatus(Endpoint.POST_UNIT, async () => {
+      const response = await api().post(resolveEndpointUrl(endpoint, unit), {
+        ...actionOptions,
+        body: actionOptions?.body ?? resolvedSchema.values
       });
+      setMemorizedUnit({ ...unit, ...response });
       return response;
     });
   }
-  async function postUnits(units, options2) {
+  async function postUnitsEndpoint(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.POST_UNITS);
-    return withEndpointStatus(Endpoint.POST_UNITS, async () => {
+    return withStatus(Endpoint.POST_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
-        const resolvedSchema = resolveSchema(schema, {
-          indicator,
-          endpoint,
-          unit
-        });
+        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 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
-          });
+          clonedUnits.push({ ...unit, ...response });
         } else {
-          clonedUnits.unshift({
-            ...unit,
-            ...response
-          });
+          clonedUnits.unshift({ ...unit, ...response });
         }
         setMemorizedUnits(clonedUnits);
         responses.push(response);
@@ -279,94 +183,61 @@ export function createStore(name, schema, endpoints, options) {
       return responses;
     });
   }
-  async function putUnit(unit, options2) {
+  async function putUnitEndpoint(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNIT);
-    const resolvedSchema = resolveSchema(schema, {
-      indicator,
-      endpoint,
-      unit
-    });
+    const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
     if (options2?.validate) {
       schema.pick(resolvedSchema.keys).parse(unit);
     }
-    return withEndpointStatus(Endpoint.PUT_UNIT, async () => {
-      const response = await api().put(
-        resolveEndpointUrl(endpoint, unit),
-        {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
-        }
-      );
-      setMemorizedUnit({
-        ...unit,
-        ...response
+    return withStatus(Endpoint.PUT_UNIT, async () => {
+      const response = await api().put(resolveEndpointUrl(endpoint, unit), {
+        ...options2,
+        body: options2?.body ?? resolvedSchema.values
       });
+      setMemorizedUnit({ ...unit, ...response });
       return response;
     });
   }
-  async function putUnits(units, options2) {
+  async function putUnitsEndpoint(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNITS);
-    return withEndpointStatus(Endpoint.PUT_UNITS, async () => {
+    return withStatus(Endpoint.PUT_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
-        const resolvedSchema = resolveSchema(schema, {
-          indicator,
-          endpoint,
-          unit
-        });
+        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
-          }
-        ]);
+        const response = await api().put(resolveEndpointUrl(endpoint, unit), {
+          ...options2,
+          body: options2?.body ?? resolvedSchema.values
+        });
+        editMemorizedUnits([{ ...unit, ...response }]);
         responses.push(response);
       }
       return responses;
     });
   }
-  async function patchUnit(unit, options2) {
+  async function patchUnitEndpoint(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNIT);
-    const resolvedSchema = resolveSchema(schema, {
-      indicator,
-      endpoint,
-      unit
-    });
+    const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
     if (options2?.validate) {
       schema.pick(resolvedSchema.keys).partial().parse(unit);
     }
-    return withEndpointStatus(Endpoint.PATCH_UNIT, async () => {
+    return withStatus(Endpoint.PATCH_UNIT, async () => {
       const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
         ...options2,
         body: options2?.body ?? resolvedSchema.values
       });
-      editMemorizedUnit({
-        ...unit,
-        ...response
-      });
+      editMemorizedUnit({ ...unit, ...response });
       return response;
     });
   }
-  async function patchUnits(units, options2) {
+  async function patchUnitsEndpoint(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNITS);
-    return withEndpointStatus(Endpoint.PATCH_UNITS, async () => {
+    return withStatus(Endpoint.PATCH_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
-        const resolvedSchema = resolveSchema(schema, {
-          indicator,
-          endpoint,
-          unit
-        });
+        const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
         if (options2?.validate) {
           schema.pick(resolvedSchema.keys).partial().parse(unit);
         }
@@ -374,65 +245,56 @@ export function createStore(name, schema, endpoints, options) {
           ...options2,
           body: options2?.body ?? resolvedSchema.values
         });
-        editMemorizedUnits([
-          {
-            ...unit,
-            ...response
-          }
-        ]);
+        editMemorizedUnits([{ ...unit, ...response }]);
         responses.push(response);
       }
       return responses;
     });
   }
-  async function deleteUnit(unit, options2) {
+  async function deleteUnitEndpoint(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNIT);
-    return withEndpointStatus(Endpoint.DELETE_UNIT, async () => {
-      await api().del(
-        resolveEndpointUrl(endpoint, unit),
-        options2
-      );
+    return withStatus(Endpoint.DELETE_UNIT, async () => {
+      await api().del(resolveEndpointUrl(endpoint, unit), options2);
       dropMemorizedUnit(unit);
       return true;
     });
   }
-  async function deleteUnits(units, options2) {
+  async function deleteUnitsEndpoint(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNITS);
-    return withEndpointStatus(Endpoint.DELETE_UNITS, async () => {
+    return withStatus(Endpoint.DELETE_UNITS, async () => {
       for (const unit of units) {
-        await api().del(
-          resolveEndpointUrl(endpoint, unit),
-          options2
-        );
+        await api().del(resolveEndpointUrl(endpoint, unit), options2);
         dropMemorizedUnits([unit]);
       }
       return true;
     });
   }
   return {
-    api,
     store,
-    memorizedUnit,
-    memorizedUnits,
-    hasMemorizedUnits,
-    endpointsStatus,
-    setMemorizedUnit,
-    setMemorizedUnits,
-    editMemorizedUnit,
-    editMemorizedUnits,
-    dropMemorizedUnit,
-    dropMemorizedUnits,
-    patchEndpointMemory,
-    purgeEndpointMemory,
-    getUnit,
-    getUnits,
-    postUnit,
-    postUnits,
-    putUnit,
-    putUnits,
-    patchUnit,
-    patchUnits,
-    deleteUnit,
-    deleteUnits
+    alias,
+    indicator,
+    unit: memorizedUnit,
+    units: memorizedUnits,
+    memory: {
+      setUnit: setMemorizedUnit,
+      setUnits: setMemorizedUnits,
+      editUnit: editMemorizedUnit,
+      editUnits: editMemorizedUnits,
+      dropUnit: dropMemorizedUnit,
+      dropUnits: dropMemorizedUnits
+    },
+    endpoint: {
+      getUnit: getUnitEndpoint,
+      getUnits: getUnitsEndpoint,
+      postUnit: postUnitEndpoint,
+      postUnits: postUnitsEndpoint,
+      putUnit: putUnitEndpoint,
+      putUnits: putUnitsEndpoint,
+      patchUnit: patchUnitEndpoint,
+      patchUnits: patchUnitsEndpoint,
+      deleteUnit: deleteUnitEndpoint,
+      deleteUnits: deleteUnitsEndpoint
+    },
+    monitor
   };
 }

package/dist/runtime/index.d.ts

@@ -1,5 +1,8 @@
-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 { EndpointMethod, Endpoint, EndpointStatus } from "./utils/endpoint.js";
+export { getMeta, resolveSchema } from "./utils/schema.js";
+export { createApi, ApiResponseType, ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./core/api.js";
 export { createStore, StoreMemoryPosition } from "./core/store.js";
+export { useStoreAlias } from "./composables/use.js";
+export type { EndpointDefinition } from "./utils/endpoint.js";
+export type { SchemaMeta } from "./utils/schema.js";
+export type { ApiRequestHeader, ApiRequestQuery, ApiRequestBody, ApiRequestOptions, ApiOptions, EndpointMethodOptions, ApiErrorOptions, } from "./core/api.js";

package/dist/runtime/index.js

@@ -1,16 +1,5 @@
-export { z } from "zod";
-export {
-  ApiAction,
-  ApiResponseType,
-  ApiErrorSource,
-  createApi,
-  ApiError,
-  ApiRequestError,
-  ApiResponseError
-} from "./core/api.js";
-export {
-  Endpoint,
-  EndpointStatus
-} from "./utils/endpoint.js";
+export { EndpointMethod, Endpoint, EndpointStatus } from "./utils/endpoint.js";
 export { getMeta, resolveSchema } from "./utils/schema.js";
+export { createApi, ApiResponseType, ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./core/api.js";
 export { createStore, StoreMemoryPosition } from "./core/store.js";
+export { useStoreAlias } from "./composables/use.js";

package/dist/runtime/plugin.js

@@ -1,9 +1,5 @@
 import { createVuePlugin } from "@harlem/core";
-import {
-  createServerSSRPlugin,
-  createClientSSRPlugin,
-  getBridgingScript
-} from "@harlem/plugin-ssr";
+import { createServerSSRPlugin, createClientSSRPlugin, getBridgingScript } from "@harlem/plugin-ssr";
 export default defineNuxtPlugin((nuxtApp) => {
   const plugins = [];
   if (import.meta.server) {

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

@@ -1,5 +1,11 @@
-import type { BaseState } from "@harlem/core";
-import type { ApiAction } from "../core/api.js";
+import type { Capitalize } from "./transform.js";
+export declare enum EndpointMethod {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    PATCH = "patch",
+    DELETE = "delete"
+}
 export declare enum Endpoint {
     GET_UNIT = "getUnit",
     GET_UNITS = "getUnits",
@@ -19,21 +25,14 @@ export declare enum EndpointStatus {
     FAILED = "failed"
 }
 export interface EndpointDefinition<T = Record<string, unknown>> {
-    action: ApiAction;
+    method: EndpointMethod;
     url: string | ((params: T) => string);
 }
-export interface EndpointMemory {
-    status: EndpointStatus;
-}
-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 type EndpointStatusFlag<S extends EndpointStatus = EndpointStatus> = `Is${Capitalize<S>}`;
+export type EndpointStatusName<K extends Endpoint = Endpoint, S extends EndpointStatus = EndpointStatus> = `${K}${EndpointStatusFlag<S>}`;
+export declare function makeEndpointStatusFlag<S extends EndpointStatus>(status: S): EndpointStatusFlag<S>;
+export declare function makeEndpointStatusName<K extends Endpoint, S extends EndpointStatus>(key: K, status: S): EndpointStatusName<K, S>;
+export declare function getEndpoint<T = Record<string, unknown>>(endpoints: Partial<Record<Endpoint, EndpointDefinition<T>>> | undefined, endpoint: 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

@@ -1,3 +1,12 @@
+import { capitalize } from "./transform.js";
+export var EndpointMethod = /* @__PURE__ */ ((EndpointMethod2) => {
+  EndpointMethod2["GET"] = "get";
+  EndpointMethod2["POST"] = "post";
+  EndpointMethod2["PUT"] = "put";
+  EndpointMethod2["PATCH"] = "patch";
+  EndpointMethod2["DELETE"] = "delete";
+  return EndpointMethod2;
+})(EndpointMethod || {});
 export var Endpoint = /* @__PURE__ */ ((Endpoint2) => {
   Endpoint2["GET_UNIT"] = "getUnit";
   Endpoint2["GET_UNITS"] = "getUnits";
@@ -18,16 +27,17 @@ export var EndpointStatus = /* @__PURE__ */ ((EndpointStatus2) => {
   EndpointStatus2["FAILED"] = "failed";
   return EndpointStatus2;
 })(EndpointStatus || {});
-export function makeEndpointStatusKey(key, status) {
-  const capitalizedStatus = status.charAt(0).toUpperCase() + status.slice(1);
-  return `${key}Is${capitalizedStatus}`;
+export function makeEndpointStatusFlag(status) {
+  return `Is${capitalize(status)}`;
 }
-export function getEndpoint(endpoints, key) {
-  const endpoint = endpoints?.[key];
-  if (!endpoint) {
-    throw new Error(`Endpoint "${key}" is not configured`);
+export function makeEndpointStatusName(key, status) {
+  return `${key}${makeEndpointStatusFlag(status)}`;
+}
+export function getEndpoint(endpoints, endpoint) {
+  if (!endpoints || !(endpoint in endpoints)) {
+    throw new Error(`Endpoint "${endpoint}" is not configured`);
   }
-  return endpoint;
+  return endpoints[endpoint];
 }
 export function resolveEndpointUrl(endpoint, params) {
   if (typeof endpoint.url === "function") {
@@ -35,15 +45,3 @@ export function resolveEndpointUrl(endpoint, params) {
   }
   return endpoint.url;
 }
-export function makeEndpointsStatus(getter) {
-  const output = {};
-  for (const key of Object.values(Endpoint)) {
-    for (const status of Object.values(EndpointStatus)) {
-      const statusKey = makeEndpointStatusKey(key, status);
-      output[statusKey] = getter(statusKey, (state) => {
-        return state.endpoints[key]?.status === status;
-      });
-    }
-  }
-  return output;
-}

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

@@ -1,9 +1,8 @@
-import { z } from "zod";
-import type { ApiAction } from "../core/api.js";
-import type { EndpointDefinition } from "./endpoint.js";
+import type { z } from "zod";
+import type { EndpointDefinition, EndpointMethod } from "./endpoint.js";
 export interface SchemaMeta {
     indicator?: boolean;
-    actions?: ApiAction[];
+    methods?: EndpointMethod[];
 }
 export declare function getMeta(field: any): SchemaMeta | undefined;
 export interface ResolveSchemaOptions<S> {

package/dist/runtime/utils/schema.js

@@ -12,10 +12,10 @@ export function resolveSchema(schema, options) {
     if (meta?.indicator) {
       output.indicator = key;
     }
-    if (!options?.endpoint?.action || !meta?.actions) {
+    if (!options?.endpoint?.method || !meta?.methods) {
       continue;
     }
-    if (meta?.actions.includes(options.endpoint.action)) {
+    if (meta?.methods.includes(options.endpoint.method)) {
       output.keys[key] = true;
       if (options?.unit && key in options.unit) {
         output.values[key] = options.unit[key];

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

@@ -0,0 +1,6 @@
+type IsVowel<C extends string> = C extends "a" | "e" | "i" | "o" | "u" ? true : false;
+export type Pluralize<S extends string> = S extends `${infer Base}y` ? Base extends `${infer _Rest}${infer Last}` ? IsVowel<Last> extends true ? `${S}s` : `${Base}ies` : `${S}s` : S extends `${string}${"s" | "x" | "z"}` ? `${S}es` : S extends `${string}${"ch" | "sh"}` ? `${S}es` : `${S}s`;
+export declare function pluralize<S extends string>(word: S): Pluralize<S>;
+export type Capitalize<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+export declare function capitalize<S extends string>(str: S): Capitalize<S>;
+export {};

package/dist/runtime/utils/transform.js

@@ -0,0 +1,20 @@
+export function pluralize(word) {
+  if (!word) return word;
+  const vowels = ["a", "e", "i", "o", "u"];
+  const lastChar = word.slice(-1).toLowerCase();
+  const lastTwo = word.slice(-2).toLowerCase();
+  const beforeLast = word.slice(-2, -1).toLowerCase();
+  if (lastChar === "y" && !vowels.includes(beforeLast)) {
+    return word.slice(0, -1) + "ies";
+  }
+  if (["s", "x", "z"].includes(lastChar)) {
+    return word + "es";
+  }
+  if (["ch", "sh"].includes(lastTwo)) {
+    return word + "es";
+  }
+  return word + "s";
+}
+export function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diphyx/harlemify",
-  "version": "0.0.3",
+  "version": "1.0.0",
   "description": "API state management for Nuxt powered by Harlem",
   "keywords": [
     "nuxt",