@diphyx/harlemify 0.0.2 → 1.0.0

package/dist/runtime/core/store.js

@@ -1,395 +1,243 @@
 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 function createStore(name, schema, endpoints, options) {
-  const { indicator } = resolveSchema(schema);
+export function createStore(entity, schema, endpoints, options) {
+  const { indicator } = resolveSchema(schema, {
+    indicator: options?.indicator
+  });
   let apiClient;
   function api() {
     if (!apiClient) {
       const config = useRuntimeConfig();
       apiClient = createApi({
-        ...config.public.harlemify?.api,
+        ...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 memorizedUnits = store.getter("memorizedUnits", (state) => {
-    return state.memory.units;
+  const alias = {
+    unit: entity,
+    units: pluralize(entity)
+  };
+  const memorizedUnit = store.getter("memorizedUnit", (state2) => {
+    return state2.memory.unit;
   });
-  function hasMemorizedUnits(...units) {
-    const output = {};
+  const memorizedUnits = store.getter("memorizedUnits", (state2) => {
+    return state2.memory.units;
+  });
+  const setMemorizedUnit = store.mutation("setMemorizedUnit", (state2, unit = null) => {
+    state2.memory.unit = unit;
+  });
+  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 getUnit(unit, options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.GET_UNIT);
-    patchEndpointMemoryTo(Endpoint.GET_UNIT, {
-      status: EndpointStatus.PENDING
-    });
+  async function withStatus(key, operation) {
+    await options?.hooks?.before?.();
+    patchMonitorTo(key, EndpointStatus.PENDING);
     try {
-      const response = await api().get(
-        resolveEndpointUrl(endpoint, unit),
-        options2
-      );
-      setMemorizedUnit(response);
-      patchEndpointMemoryTo(Endpoint.GET_UNIT, {
-        status: EndpointStatus.SUCCESS
-      });
-      return response;
+      const result = await operation();
+      patchMonitorTo(key, EndpointStatus.SUCCESS);
+      await options?.hooks?.after?.();
+      return result;
     } catch (error) {
-      patchEndpointMemoryTo(Endpoint.GET_UNIT, {
-        status: EndpointStatus.FAILED
-      });
+      patchMonitorTo(key, EndpointStatus.FAILED);
+      await options?.hooks?.after?.(error);
       throw error;
     }
   }
-  async function getUnits(options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.GET_UNITS);
-    patchEndpointMemoryTo(Endpoint.GET_UNITS, {
-      status: EndpointStatus.PENDING
+  async function getUnitEndpoint(unit, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.GET_UNIT);
+    return withStatus(Endpoint.GET_UNIT, async () => {
+      const response = await api().get(resolveEndpointUrl(endpoint, unit), options2);
+      setMemorizedUnit(response);
+      return response;
     });
-    try {
-      const response = await api().get(
-        resolveEndpointUrl(endpoint),
-        options2
-      );
+  }
+  async function getUnitsEndpoint(options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.GET_UNITS);
+    return withStatus(Endpoint.GET_UNITS, async () => {
+      const response = await api().get(resolveEndpointUrl(endpoint), options2);
       setMemorizedUnits(response);
-      patchEndpointMemoryTo(Endpoint.GET_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return response;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.GET_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
-  async function postUnit(unit, options2) {
+  async function postUnitEndpoint(unit, actionOptions) {
     const endpoint = getEndpoint(endpoints, Endpoint.POST_UNIT);
-    const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
-    if (options2?.validate) {
+    const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
+    if (actionOptions?.validate) {
       schema.pick(resolvedSchema.keys).parse(unit);
     }
-    patchEndpointMemoryTo(Endpoint.POST_UNIT, {
-      status: EndpointStatus.PENDING
-    });
-    try {
-      const response = await api().post(
-        resolveEndpointUrl(endpoint, unit),
-        {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
-        }
-      );
-      setMemorizedUnit({
-        ...unit,
-        ...response
-      });
-      patchEndpointMemoryTo(Endpoint.POST_UNIT, {
-        status: EndpointStatus.SUCCESS
+    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;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.POST_UNIT, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
-  async function postUnits(units, options2) {
+  async function postUnitsEndpoint(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.POST_UNITS);
-    patchEndpointMemoryTo(Endpoint.POST_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withStatus(Endpoint.POST_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
-        const resolvedSchema = resolveSchema(
-          schema,
-          endpoint.action,
-          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);
       }
-      patchEndpointMemoryTo(Endpoint.POST_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return responses;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.POST_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
-  async function putUnit(unit, options2) {
+  async function putUnitEndpoint(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNIT);
-    const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+    const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
     if (options2?.validate) {
       schema.pick(resolvedSchema.keys).parse(unit);
     }
-    patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
-      status: EndpointStatus.PENDING
-    });
-    try {
-      const response = await api().put(
-        resolveEndpointUrl(endpoint, unit),
-        {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
-        }
-      );
-      setMemorizedUnit({
-        ...unit,
-        ...response
-      });
-      patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
-        status: EndpointStatus.SUCCESS
+    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;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
-  async function putUnits(units, options2) {
+  async function putUnitsEndpoint(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNITS);
-    patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withStatus(Endpoint.PUT_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
-        const resolvedSchema = resolveSchema(
-          schema,
-          endpoint.action,
-          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);
       }
-      patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return responses;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
-  async function patchUnit(unit, options2) {
+  async function patchUnitEndpoint(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNIT);
-    const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+    const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
     if (options2?.validate) {
       schema.pick(resolvedSchema.keys).partial().parse(unit);
     }
-    patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withStatus(Endpoint.PATCH_UNIT, async () => {
       const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
         ...options2,
         body: options2?.body ?? resolvedSchema.values
       });
-      editMemorizedUnit({
-        ...unit,
-        ...response
-      });
-      patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
-        status: EndpointStatus.SUCCESS
-      });
+      editMemorizedUnit({ ...unit, ...response });
       return response;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
-  async function patchUnits(units, options2) {
+  async function patchUnitsEndpoint(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNITS);
-    patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    return withStatus(Endpoint.PATCH_UNITS, async () => {
       const responses = [];
       for (const unit of units) {
-        const resolvedSchema = resolveSchema(
-          schema,
-          endpoint.action,
-          unit
-        );
+        const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
         if (options2?.validate) {
           schema.pick(resolvedSchema.keys).partial().parse(unit);
         }
@@ -397,95 +245,56 @@ export function createStore(name, schema, endpoints, options) {
           ...options2,
           body: options2?.body ?? resolvedSchema.values
         });
-        editMemorizedUnits([
-          {
-            ...unit,
-            ...response
-          }
-        ]);
+        editMemorizedUnits([{ ...unit, ...response }]);
         responses.push(response);
       }
-      patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return responses;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
-  async function deleteUnit(unit, options2) {
+  async function deleteUnitEndpoint(unit, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNIT);
-    patchEndpointMemoryTo(Endpoint.DELETE_UNIT, {
-      status: EndpointStatus.PENDING
-    });
-    try {
-      await api().del(
-        resolveEndpointUrl(endpoint, unit),
-        options2
-      );
+    return withStatus(Endpoint.DELETE_UNIT, async () => {
+      await api().del(resolveEndpointUrl(endpoint, unit), options2);
       dropMemorizedUnit(unit);
-      patchEndpointMemoryTo(Endpoint.DELETE_UNIT, {
-        status: EndpointStatus.SUCCESS
-      });
       return true;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.DELETE_UNIT, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
-  async function deleteUnits(units, options2) {
+  async function deleteUnitsEndpoint(units, options2) {
     const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNITS);
-    patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
-      status: EndpointStatus.PENDING
-    });
-    try {
+    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]);
       }
-      patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
-        status: EndpointStatus.SUCCESS
-      });
       return true;
-    } catch (error) {
-      patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
-        status: EndpointStatus.FAILED
-      });
-      throw error;
-    }
+    });
   }
   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";