@diphyx/harlemify 1.0.4 → 3.0.0

package/dist/runtime/index.d.ts

@@ -1,9 +1,17 @@
-export { EndpointMethod, Endpoint, EndpointStatus } from "./utils/endpoint.js";
+export { defineApiAdapter } from "./utils/adapter.js";
+export { Endpoint, EndpointMethod, EndpointStatus, resolveEndpointUrl } from "./utils/endpoint.js";
+export { ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./utils/errors.js";
+export { Memory, createMemoryBuilder } from "./utils/memory.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 { createApi } from "./core/api.js";
+export { createStore } from "./core/store.js";
 export { useStoreAlias } from "./composables/use.js";
-export type { SharedConfig } from "./shared.js";
-export type { EndpointDefinition } from "./utils/endpoint.js";
+export type { ApiAdapter, ApiAdapterRequest, ApiAdapterResponse, ApiFetchAdapterOptions, DefineApiAdapter, } from "./utils/adapter.js";
+export type { EndpointBuilder, EndpointChain, EndpointDefinition, EndpointUrl } from "./utils/endpoint.js";
+export type { ApiErrorOptions } from "./utils/errors.js";
+export type { MemoryBuilder, MemoryDefinition, MemoryMutation, MemoryTarget, EditOptions, AddOptions, UnitMemoryBuilder, UnitsMemoryBuilder, } from "./utils/memory.js";
 export type { SchemaMeta } from "./utils/schema.js";
-export type { ApiRequestHeader, ApiRequestQuery, ApiRequestBody, ApiRequestOptions, ApiOptions, EndpointMethodOptions, ApiErrorOptions, } from "./core/api.js";
+export type { Api, ApiOptions, ApiRequestBody, ApiRequestHeader, ApiRequestOptions, ApiRequestQuery, EndpointMethodOptions, } from "./core/api.js";
+export type { ActionDefinition, ActionFunction, ActionOptions, ActionStatus, ActionsConfig, Store, StoreActions, StoreHooks, StoreMemory, StoreMonitor, StoreOptions, } from "./core/store.js";
+export type { StoreAlias } from "./composables/use.js";
+export type { SharedConfig } from "./shared.js";

package/dist/runtime/index.js

@@ -1,5 +1,8 @@
-export { EndpointMethod, Endpoint, EndpointStatus } from "./utils/endpoint.js";
+export { defineApiAdapter } from "./utils/adapter.js";
+export { Endpoint, EndpointMethod, EndpointStatus, resolveEndpointUrl } from "./utils/endpoint.js";
+export { ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./utils/errors.js";
+export { Memory, createMemoryBuilder } from "./utils/memory.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 { createApi } from "./core/api.js";
+export { createStore } from "./core/store.js";
 export { useStoreAlias } from "./composables/use.js";

package/dist/runtime/shared.d.ts

@@ -1,7 +1,9 @@
+import type { ApiFetchAdapterOptions } from "./utils/adapter.js";
 export type SharedConfig = {
     api?: {
-        url?: string;
-        timeout?: number;
+        headers?: Record<string, string>;
+        query?: Record<string, unknown>;
+        adapter?: ApiFetchAdapterOptions;
     };
 };
 export declare const sharedConfig: SharedConfig;

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

@@ -0,0 +1,24 @@
+import type { EndpointMethod } from "./endpoint.js";
+export interface ApiAdapterRequest {
+    method: EndpointMethod;
+    url: string;
+    body?: unknown;
+    query?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+export interface ApiAdapterResponse<T = unknown> {
+    data: T;
+    status?: number;
+}
+export type ApiAdapter<T = unknown> = (request: ApiAdapterRequest) => Promise<ApiAdapterResponse<T>>;
+export type DefineApiAdapter<T = unknown, O = unknown> = (options?: O) => ApiAdapter<T>;
+export interface ApiFetchAdapterOptions {
+    baseURL?: string;
+    timeout?: number;
+    retry?: number | false;
+    retryDelay?: number;
+    retryStatusCodes?: number[];
+    responseType?: "json" | "text" | "blob" | "arrayBuffer";
+}
+export declare function defineApiAdapter<T = unknown>(options?: ApiFetchAdapterOptions): ApiAdapter<T>;

package/dist/runtime/utils/adapter.js

@@ -0,0 +1,35 @@
+import { ApiRequestError, ApiResponseError } from "./errors.js";
+export function defineApiAdapter(options) {
+  return async (request) => {
+    const data = await $fetch(request.url, {
+      baseURL: options?.baseURL,
+      method: request.method,
+      headers: request.headers,
+      query: request.query,
+      body: request.body,
+      timeout: options?.timeout,
+      signal: request.signal,
+      retry: options?.retry,
+      retryDelay: options?.retryDelay,
+      retryStatusCodes: options?.retryStatusCodes,
+      responseType: options?.responseType,
+      onRequestError({ request: request2, options: options2, error }) {
+        throw new ApiRequestError({
+          method: options2.method,
+          url: request2.toString(),
+          message: error?.message
+        });
+      },
+      onResponseError({ request: request2, options: options2, error }) {
+        throw new ApiResponseError({
+          method: options2.method,
+          url: request2.toString(),
+          message: error?.message
+        });
+      }
+    });
+    return {
+      data
+    };
+  };
+}

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

@@ -0,0 +1,10 @@
+export interface Cache<K, V> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): boolean;
+    clear(): void;
+    size(): number;
+    has(key: K): boolean;
+    entries(): IterableIterator<[K, V]>;
+}
+export declare function createCache<K, V>(): Cache<K, V>;

package/dist/runtime/utils/cache.js

@@ -0,0 +1,26 @@
+export function createCache() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      return map.get(key);
+    },
+    set(key, value) {
+      map.set(key, value);
+    },
+    delete(key) {
+      return map.delete(key);
+    },
+    clear() {
+      map.clear();
+    },
+    size() {
+      return map.size;
+    },
+    has(key) {
+      return map.has(key);
+    },
+    entries() {
+      return map.entries();
+    }
+  };
+}

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

@@ -1,3 +1,4 @@
+import type { ApiAdapter } from "./adapter.js";
 import type { Capitalize } from "./transform.js";
 export declare enum EndpointMethod {
     GET = "get",
@@ -6,33 +7,32 @@ export declare enum EndpointMethod {
     PATCH = "patch",
     DELETE = "delete"
 }
-export declare enum Endpoint {
-    GET_UNIT = "getUnit",
-    GET_UNITS = "getUnits",
-    POST_UNIT = "postUnit",
-    POST_UNITS = "postUnits",
-    PUT_UNIT = "putUnit",
-    PUT_UNITS = "putUnits",
-    PATCH_UNIT = "patchUnit",
-    PATCH_UNITS = "patchUnits",
-    DELETE_UNIT = "deleteUnit",
-    DELETE_UNITS = "deleteUnits"
-}
 export declare enum EndpointStatus {
     IDLE = "idle",
     PENDING = "pending",
     SUCCESS = "success",
     FAILED = "failed"
 }
-export interface EndpointDefinition<T = Record<string, unknown>> {
-    method: EndpointMethod;
-    url: string | ((params: T) => string);
+export type EndpointUrl<S> = string | ((params: Partial<S>) => string);
+export interface EndpointDefinition<S = Record<string, unknown>> {
+    readonly method: EndpointMethod;
+    readonly url: EndpointUrl<S>;
+    readonly adapter?: ApiAdapter<any>;
+}
+export interface EndpointChain<S> {
+    readonly method: EndpointMethod;
+    readonly url: EndpointUrl<S>;
+    readonly adapter?: ApiAdapter<any>;
+    withAdapter(adapter: ApiAdapter<any>): EndpointDefinition<S>;
+}
+export interface EndpointBuilder {
+    get<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
+    post<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
+    put<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
+    patch<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
+    delete<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
 }
+export declare const Endpoint: EndpointBuilder;
 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 declare function resolveEndpointUrl<S>(endpoint: EndpointDefinition<S>, params?: Partial<S>): string;

package/dist/runtime/utils/endpoint.js

@@ -7,19 +7,6 @@ export var EndpointMethod = /* @__PURE__ */ ((EndpointMethod2) => {
   EndpointMethod2["DELETE"] = "delete";
   return EndpointMethod2;
 })(EndpointMethod || {});
-export var Endpoint = /* @__PURE__ */ ((Endpoint2) => {
-  Endpoint2["GET_UNIT"] = "getUnit";
-  Endpoint2["GET_UNITS"] = "getUnits";
-  Endpoint2["POST_UNIT"] = "postUnit";
-  Endpoint2["POST_UNITS"] = "postUnits";
-  Endpoint2["PUT_UNIT"] = "putUnit";
-  Endpoint2["PUT_UNITS"] = "putUnits";
-  Endpoint2["PATCH_UNIT"] = "patchUnit";
-  Endpoint2["PATCH_UNITS"] = "patchUnits";
-  Endpoint2["DELETE_UNIT"] = "deleteUnit";
-  Endpoint2["DELETE_UNITS"] = "deleteUnits";
-  return Endpoint2;
-})(Endpoint || {});
 export var EndpointStatus = /* @__PURE__ */ ((EndpointStatus2) => {
   EndpointStatus2["IDLE"] = "idle";
   EndpointStatus2["PENDING"] = "pending";
@@ -27,21 +14,43 @@ export var EndpointStatus = /* @__PURE__ */ ((EndpointStatus2) => {
   EndpointStatus2["FAILED"] = "failed";
   return EndpointStatus2;
 })(EndpointStatus || {});
-export function makeEndpointStatusFlag(status) {
-  return `Is${capitalize(status)}`;
-}
-export function makeEndpointStatusName(key, status) {
-  return `${key}${makeEndpointStatusFlag(status)}`;
+function createEndpointChain(method, url) {
+  return {
+    method,
+    url,
+    adapter: void 0,
+    withAdapter(adapter) {
+      return {
+        method,
+        url,
+        adapter
+      };
+    }
+  };
 }
-export function getEndpoint(endpoints, endpoint) {
-  if (!endpoints || !(endpoint in endpoints)) {
-    throw new Error(`Endpoint "${endpoint}" is not configured`);
+export const Endpoint = {
+  get(url) {
+    return createEndpointChain("get" /* GET */, url);
+  },
+  post(url) {
+    return createEndpointChain("post" /* POST */, url);
+  },
+  put(url) {
+    return createEndpointChain("put" /* PUT */, url);
+  },
+  patch(url) {
+    return createEndpointChain("patch" /* PATCH */, url);
+  },
+  delete(url) {
+    return createEndpointChain("delete" /* DELETE */, url);
   }
-  return endpoints[endpoint];
+};
+export function makeEndpointStatusFlag(status) {
+  return `Is${capitalize(status)}`;
 }
 export function resolveEndpointUrl(endpoint, params) {
   if (typeof endpoint.url === "function") {
-    return endpoint.url(params);
+    return endpoint.url(params ?? {});
   }
   return endpoint.url;
 }

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

@@ -0,0 +1,22 @@
+export declare enum ApiErrorSource {
+    REQUEST = "request",
+    RESPONSE = "response"
+}
+export interface ApiErrorOptions {
+    source: ApiErrorSource;
+    method: string;
+    url: string;
+    message?: string;
+}
+export declare class ApiError extends Error {
+    source: ApiErrorSource;
+    method: string;
+    url: string;
+    constructor(options: ApiErrorOptions);
+}
+export declare class ApiRequestError extends ApiError {
+    constructor(options: Omit<ApiErrorOptions, "source">);
+}
+export declare class ApiResponseError extends ApiError {
+    constructor(options: Omit<ApiErrorOptions, "source">);
+}

package/dist/runtime/utils/errors.js

@@ -0,0 +1,33 @@
+export var ApiErrorSource = /* @__PURE__ */ ((ApiErrorSource2) => {
+  ApiErrorSource2["REQUEST"] = "request";
+  ApiErrorSource2["RESPONSE"] = "response";
+  return ApiErrorSource2;
+})(ApiErrorSource || {});
+export class ApiError extends Error {
+  source;
+  method;
+  url;
+  constructor(options) {
+    super(options.message ?? "Unknown error");
+    this.name = "ApiError";
+    this.source = options.source;
+    this.method = options.method;
+    this.url = options.url;
+  }
+}
+export class ApiRequestError extends ApiError {
+  constructor(options) {
+    super({
+      ...options,
+      source: "request" /* REQUEST */
+    });
+  }
+}
+export class ApiResponseError extends ApiError {
+  constructor(options) {
+    super({
+      ...options,
+      source: "response" /* RESPONSE */
+    });
+  }
+}

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

@@ -0,0 +1,40 @@
+export type MemoryTarget = "unit" | "units";
+export type MemoryMutation = "set" | "edit" | "drop" | "add";
+export interface EditOptions {
+    deep?: boolean;
+}
+export interface AddOptions {
+    prepend?: boolean;
+}
+export interface MemoryDefinition {
+    readonly on: MemoryTarget;
+    readonly path: string[];
+    readonly mutation?: MemoryMutation;
+    readonly prepend?: boolean;
+    readonly deep?: boolean;
+}
+export interface UnitMemoryBuilder<_S = unknown> extends MemoryDefinition {
+    set(): MemoryDefinition;
+    edit(options?: EditOptions): MemoryDefinition;
+    drop(): MemoryDefinition;
+}
+export interface UnitsMemoryBuilder<_S = unknown> extends MemoryDefinition {
+    set(): MemoryDefinition;
+    edit(options?: EditOptions): MemoryDefinition;
+    drop(): MemoryDefinition;
+    add(options?: AddOptions): MemoryDefinition;
+}
+export interface UnitFunction<S> {
+    (): UnitMemoryBuilder<S>;
+    <K extends keyof S & string>(key: K): UnitMemoryBuilder<S[K]>;
+    <K extends keyof S & string, K2 extends keyof S[K] & string>(key: K, nested: K2): UnitMemoryBuilder<S[K][K2]>;
+}
+export interface UnitsFunction<S> {
+    (): UnitsMemoryBuilder<S>;
+}
+export interface MemoryBuilder<S = unknown> {
+    unit: UnitFunction<S>;
+    units: UnitsFunction<S>;
+}
+export declare function createMemoryBuilder<S>(): MemoryBuilder<S>;
+export declare const Memory: MemoryBuilder<any>;

package/dist/runtime/utils/memory.js

@@ -0,0 +1,87 @@
+function createUnitMemoryBuilder(path = []) {
+  const definition = {
+    on: "unit",
+    path
+  };
+  return {
+    ...definition,
+    set() {
+      return {
+        on: "unit",
+        path,
+        mutation: "set"
+      };
+    },
+    edit(options) {
+      return {
+        on: "unit",
+        path,
+        mutation: "edit",
+        deep: options?.deep
+      };
+    },
+    drop() {
+      return {
+        on: "unit",
+        path,
+        mutation: "drop"
+      };
+    }
+  };
+}
+function createUnitsMemoryBuilder() {
+  const definition = {
+    on: "units",
+    path: []
+  };
+  return {
+    ...definition,
+    set() {
+      return {
+        on: "units",
+        path: [],
+        mutation: "set"
+      };
+    },
+    edit(options) {
+      return {
+        on: "units",
+        path: [],
+        mutation: "edit",
+        deep: options?.deep
+      };
+    },
+    drop() {
+      return {
+        on: "units",
+        path: [],
+        mutation: "drop"
+      };
+    },
+    add(options) {
+      return {
+        on: "units",
+        path: [],
+        mutation: "add",
+        prepend: options?.prepend
+      };
+    }
+  };
+}
+function createUnitFunction() {
+  return function unit(...keys) {
+    return createUnitMemoryBuilder(keys);
+  };
+}
+function createUnitsFunction() {
+  return function units() {
+    return createUnitsMemoryBuilder();
+  };
+}
+export function createMemoryBuilder() {
+  return {
+    unit: createUnitFunction(),
+    units: createUnitsFunction()
+  };
+}
+export const Memory = createMemoryBuilder();

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

@@ -1,13 +1,19 @@
 import type { z } from "zod";
-import type { EndpointDefinition, EndpointMethod } from "./endpoint.js";
-export interface SchemaMeta {
+export interface SchemaMeta<A extends string = string> {
     indicator?: boolean;
-    methods?: EndpointMethod[];
+    actions?: A[];
 }
 export declare function getMeta(field: any): SchemaMeta | undefined;
+export interface SchemaFieldInfo<A extends string = string> {
+    name: string;
+    indicator: boolean;
+    actions: A[];
+}
+export declare function getSchemaFields<T extends z.ZodRawShape, A extends string = string>(schema: z.ZodObject<T>): SchemaFieldInfo<A>[];
+export declare function getFieldsForAction<T extends z.ZodRawShape, A extends string = string>(schema: z.ZodObject<T>, action: A): string[];
 export interface ResolveSchemaOptions<S> {
     indicator?: keyof S;
-    endpoint?: EndpointDefinition<Partial<S>>;
+    action?: string;
     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>): {

package/dist/runtime/utils/schema.js

@@ -1,21 +1,53 @@
 export function getMeta(field) {
   return field.meta();
 }
+const schemaFieldsCache = /* @__PURE__ */ new WeakMap();
+export function getSchemaFields(schema) {
+  const cached = schemaFieldsCache.get(schema);
+  if (cached) {
+    return cached;
+  }
+  const fields = [];
+  for (const key in schema.shape) {
+    const meta = getMeta(schema.shape[key]);
+    fields.push({
+      name: key,
+      indicator: meta?.indicator ?? false,
+      actions: meta?.actions ?? []
+    });
+  }
+  schemaFieldsCache.set(schema, fields);
+  return fields;
+}
+export function getFieldsForAction(schema, action) {
+  const fields = [];
+  for (const key in schema.shape) {
+    const meta = getMeta(schema.shape[key]);
+    if (meta?.actions) {
+      const actionsSet = new Set(meta.actions);
+      if (actionsSet.has(action)) {
+        fields.push(key);
+      }
+    }
+  }
+  return fields;
+}
 export function resolveSchema(schema, options) {
   const output = {
     indicator: options?.indicator ?? "id",
     keys: {},
     values: {}
   };
-  for (const key of Object.keys(schema.shape)) {
+  for (const key in schema.shape) {
     const meta = getMeta(schema.shape[key]);
     if (meta?.indicator) {
       output.indicator = key;
     }
-    if (!options?.endpoint?.method || !meta?.methods) {
+    if (!options?.action || !meta?.actions) {
       continue;
     }
-    if (meta?.methods.includes(options.endpoint.method)) {
+    const actionsSet = new Set(meta.actions);
+    if (actionsSet.has(options.action)) {
       output.keys[key] = true;
       if (options?.unit && key in options.unit) {
         output.values[key] = options.unit[key];

package/dist/runtime/utils/transform.js

@@ -1,16 +1,18 @@
+const VOWELS = /* @__PURE__ */ new Set(["a", "e", "i", "o", "u"]);
+const SIBILANTS = /* @__PURE__ */ new Set(["s", "x", "z"]);
+const SIBILANT_PAIRS = /* @__PURE__ */ new Set(["ch", "sh"]);
 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)) {
+  if (lastChar === "y" && !VOWELS.has(beforeLast)) {
     return word.slice(0, -1) + "ies";
   }
-  if (["s", "x", "z"].includes(lastChar)) {
+  if (SIBILANTS.has(lastChar)) {
     return word + "es";
   }
-  if (["ch", "sh"].includes(lastTwo)) {
+  if (SIBILANT_PAIRS.has(lastTwo)) {
     return word + "es";
   }
   return word + "s";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diphyx/harlemify",
-  "version": "1.0.4",
+  "version": "3.0.0",
   "description": "API state management for Nuxt powered by Harlem",
   "keywords": [
     "nuxt",
@@ -52,6 +52,7 @@
     "@nuxt/module-builder": "^0.8.0",
     "@nuxt/schema": "^3.14.0",
     "@nuxt/test-utils": "^3.14.0",
+    "@playwright/test": "^1.50.0",
     "@types/node": "^22.0.0",
     "eslint": "^9.0.0",
     "nuxt": "^3.14.0",
@@ -64,6 +65,7 @@
     "dev": "pnpm nuxt dev playground",
     "build": "nuxt-module-build build",
     "lint": "eslint . --fix",
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:e2e": "playwright test"
   }
 }