@diphyx/harlemify 1.0.4 → 3.0.0

package/dist/runtime/core/store.js

@@ -2,30 +2,95 @@ import { defu } from "defu";
 import { createStore as createHarlemStore } from "@harlem/core";
 import { createApi } from "./api.js";
 import { sharedConfig } from "../shared.js";
-import { resolveSchema } from "../utils/schema.js";
+import { createCache } from "../utils/cache.js";
+import { defineApiAdapter } from "../utils/adapter.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 || {});
-export function createStore(entity, schema, endpoints, options) {
-  const { indicator } = resolveSchema(schema, {
+import { resolveSchema } from "../utils/schema.js";
+import { EndpointMethod, EndpointStatus, resolveEndpointUrl } from "../utils/endpoint.js";
+function getDefaultMutation(method, target) {
+  const defaults = {
+    [EndpointMethod.GET]: {
+      unit: "set",
+      units: "set"
+    },
+    [EndpointMethod.POST]: {
+      unit: "set",
+      units: "add"
+    },
+    [EndpointMethod.PUT]: {
+      unit: "set",
+      units: "edit"
+    },
+    [EndpointMethod.PATCH]: {
+      unit: "edit",
+      units: "edit"
+    },
+    [EndpointMethod.DELETE]: {
+      unit: "drop",
+      units: "drop"
+    }
+  };
+  return defaults[method][target];
+}
+function setNestedValue(object, path, value) {
+  if (path.length === 0) {
+    return;
+  }
+  let current = object;
+  for (let index = 0; index < path.length - 1; index++) {
+    if (current[path[index]] === void 0) {
+      current[path[index]] = {};
+    }
+    current = current[path[index]];
+  }
+  current[path[path.length - 1]] = value;
+}
+function editNestedValue(object, path, value, deep) {
+  if (path.length === 0) {
+    return;
+  }
+  let current = object;
+  for (let index = 0; index < path.length - 1; index++) {
+    if (current[path[index]] === void 0) {
+      return;
+    }
+    current = current[path[index]];
+  }
+  const key = path[path.length - 1];
+  if (current[key] === void 0) {
+    current[key] = value;
+    return;
+  }
+  if (deep) {
+    current[key] = defu(value, current[key]);
+    return;
+  }
+  Object.assign(current[key], value);
+}
+export function createStore(entity, schema, actions, options) {
+  const resolvedSchema = resolveSchema(schema, {
     indicator: options?.indicator
   });
+  const indicator = resolvedSchema.indicator;
+  const indexCache = createCache();
+  const schemaCache = createCache();
+  for (const actionName in actions) {
+    const actionSchema = resolveSchema(schema, {
+      indicator,
+      action: actionName
+    });
+    schemaCache.set(actionName, {
+      keys: actionSchema.keys,
+      fields: Object.keys(actionSchema.keys)
+    });
+  }
   let apiClient;
   function api() {
     if (!apiClient) {
       apiClient = createApi({
-        ...sharedConfig.api ?? {},
-        ...options?.api
+        headers: sharedConfig.api?.headers,
+        query: sharedConfig.api?.query,
+        adapter: options?.adapter ?? defineApiAdapter(sharedConfig.api?.adapter)
       });
     }
     return apiClient;
@@ -35,8 +100,11 @@ export function createStore(entity, schema, endpoints, options) {
       unit: null,
       units: []
     },
-    endpoints: {}
+    status: {}
   };
+  for (const actionName in actions) {
+    state.status[actionName] = EndpointStatus.IDLE;
+  }
   const store = createHarlemStore(entity, state, {
     extensions: options?.extensions ?? []
   });
@@ -55,246 +123,459 @@ export function createStore(entity, schema, endpoints, options) {
   });
   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);
+    indexCache.clear();
+    if (units && Array.isArray(units)) {
+      for (let index = 0; index < units.length; index++) {
+        if (units[index]) {
+          indexCache.set(units[index][indicator], index);
+        }
+      }
     }
   });
-  const editMemorizedUnits = store.mutation("editMemorizedUnits", (state2, units) => {
-    for (const unit of units) {
-      const index = state2.memory.units.findIndex((memorizedUnit2) => {
-        return memorizedUnit2[indicator] === unit[indicator];
-      });
-      if (index !== -1) {
-        state2.memory.units[index] = defu(unit, state2.memory.units[index]);
+  const editMemorizedUnit = store.mutation(
+    "editMemorizedUnit",
+    (state2, payload) => {
+      if (state2.memory.unit?.[indicator] !== payload.unit[indicator]) {
+        return;
+      }
+      if (payload.deep) {
+        state2.memory.unit = defu(payload.unit, state2.memory.unit);
+        return;
       }
+      Object.assign(state2.memory.unit, payload.unit);
     }
-  });
+  );
+  const editMemorizedUnits = store.mutation(
+    "editMemorizedUnits",
+    (state2, payload) => {
+      const tempIndex = /* @__PURE__ */ new Map();
+      for (let index = 0; index < state2.memory.units.length; index++) {
+        tempIndex.set(state2.memory.units[index][indicator], index);
+      }
+      for (const unit of payload.units) {
+        let unitIndex = indexCache.get(unit[indicator]);
+        if (unitIndex === void 0 || unitIndex >= state2.memory.units.length || state2.memory.units[unitIndex]?.[indicator] !== unit[indicator]) {
+          const foundIndex = tempIndex.get(unit[indicator]);
+          if (foundIndex !== void 0) {
+            unitIndex = foundIndex;
+            indexCache.set(unit[indicator], foundIndex);
+          } else {
+            unitIndex = void 0;
+          }
+        }
+        if (unitIndex === void 0) {
+          continue;
+        }
+        if (payload.deep) {
+          state2.memory.units[unitIndex] = defu(unit, state2.memory.units[unitIndex]);
+          continue;
+        }
+        Object.assign(state2.memory.units[unitIndex], unit);
+      }
+    }
+  );
   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) => {
+  const dropMemorizedUnits = store.mutation(
+    "dropMemorizedUnits",
+    (state2, units) => {
+      const dropSet = new Set(
+        units.map((unit) => {
+          return unit[indicator];
+        })
+      );
       for (const unit of units) {
-        if (memorizedUnit2[indicator] === unit[indicator]) {
-          return false;
-        }
+        indexCache.delete(unit[indicator]);
       }
-      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;
+      state2.memory.units = state2.memory.units.filter((memorizedUnit2) => {
+        return !dropSet.has(memorizedUnit2[indicator]);
       });
     }
-  }
-  const patchMonitor = store.mutation(
-    "patchMonitor",
+  );
+  const addMemorizedUnits = store.mutation(
+    "addMemorizedUnits",
     (state2, payload) => {
-      state2.endpoints[payload.endpoint] = payload.status;
+      if (payload.prepend) {
+        indexCache.clear();
+        for (let index = 0; index < payload.units.length; index++) {
+          indexCache.set(payload.units[index][indicator], index);
+        }
+        for (let index = 0; index < state2.memory.units.length; index++) {
+          indexCache.set(state2.memory.units[index][indicator], index + payload.units.length);
+        }
+        state2.memory.units = [...payload.units, ...state2.memory.units];
+        return;
+      }
+      for (let index = 0; index < payload.units.length; index++) {
+        indexCache.set(payload.units[index][indicator], state2.memory.units.length + index);
+      }
+      state2.memory.units = [...state2.memory.units, ...payload.units];
     }
   );
-  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`);
+  const setNestedUnit = store.mutation("setNestedUnit", (state2, payload) => {
+    if (!state2.memory.unit) {
+      return;
+    }
+    setNestedValue(state2.memory.unit, payload.path, payload.value);
+  });
+  const editNestedUnit = store.mutation(
+    "editNestedUnit",
+    (state2, payload) => {
+      if (!state2.memory.unit) {
+        return;
       }
+      editNestedValue(state2.memory.unit, payload.path, payload.value, payload.deep);
     }
-    patchMonitor({
-      endpoint,
-      status
-    });
+  );
+  const dropNestedUnit = store.mutation("dropNestedUnit", (state2, payload) => {
+    if (!state2.memory.unit || payload.path.length === 0) {
+      return;
+    }
+    setNestedValue(state2.memory.unit, payload.path, null);
+  });
+  const patchStatus = store.mutation(
+    "patchStatus",
+    (state2, payload) => {
+      state2.status[payload.action] = payload.status;
+    }
+  );
+  function createActionStatus(actionName) {
+    const current = store.getter(
+      `${actionName}:current`,
+      (state2) => state2.status[actionName] ?? EndpointStatus.IDLE
+    );
+    const pending = store.getter(
+      `${actionName}:pending`,
+      (state2) => state2.status[actionName] === EndpointStatus.PENDING
+    );
+    const success = store.getter(
+      `${actionName}:success`,
+      (state2) => state2.status[actionName] === EndpointStatus.SUCCESS
+    );
+    const failed = store.getter(
+      `${actionName}:failed`,
+      (state2) => state2.status[actionName] === EndpointStatus.FAILED
+    );
+    const idle = store.getter(
+      `${actionName}:idle`,
+      (state2) => state2.status[actionName] === EndpointStatus.IDLE
+    );
+    return {
+      current() {
+        return current.value;
+      },
+      pending() {
+        return pending.value;
+      },
+      success() {
+        return success.value;
+      },
+      failed() {
+        return failed.value;
+      },
+      idle() {
+        return idle.value;
+      }
+    };
+  }
+  const monitor = {};
+  for (const actionName in actions) {
+    monitor[actionName] = createActionStatus(actionName);
   }
-  async function withStatus(key, operation) {
+  async function withStatus(actionName, operation) {
     await options?.hooks?.before?.();
-    patchMonitorTo(key, EndpointStatus.PENDING);
+    if (store.state.status[actionName] === EndpointStatus.PENDING) {
+      throw new Error(`Action "${actionName}" is already pending`);
+    }
+    patchStatus({
+      action: actionName,
+      status: EndpointStatus.PENDING
+    });
     try {
       const result = await operation();
-      patchMonitorTo(key, EndpointStatus.SUCCESS);
+      patchStatus({
+        action: actionName,
+        status: EndpointStatus.SUCCESS
+      });
       await options?.hooks?.after?.();
       return result;
     } catch (error) {
-      patchMonitorTo(key, EndpointStatus.FAILED);
+      patchStatus({
+        action: actionName,
+        status: EndpointStatus.FAILED
+      });
       await options?.hooks?.after?.(error);
       throw error;
     }
   }
-  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;
-    });
-  }
-  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);
-      return response;
-    });
-  }
-  async function postUnitEndpoint(unit, actionOptions) {
-    const endpoint = getEndpoint(endpoints, Endpoint.POST_UNIT);
-    const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-    if (actionOptions?.validate) {
-      schema.pick(resolvedSchema.keys).parse(unit);
+  function applyMemoryOperation(memoryDefinition, method, response, params) {
+    if (!memoryDefinition) {
+      return;
     }
-    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 postUnitsEndpoint(units, options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.POST_UNITS);
-    return withStatus(Endpoint.POST_UNITS, async () => {
-      const responses = [];
-      for (const unit of units) {
-        const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-        if (options2?.validate) {
-          schema.pick(resolvedSchema.keys).parse(unit);
+    const mutation = memoryDefinition.mutation ?? getDefaultMutation(method, memoryDefinition.on);
+    if (memoryDefinition.on === "unit") {
+      if (memoryDefinition.path.length > 0) {
+        switch (mutation) {
+          case "set": {
+            setNestedUnit({
+              path: memoryDefinition.path,
+              value: response
+            });
+            break;
+          }
+          case "edit": {
+            editNestedUnit({
+              path: memoryDefinition.path,
+              value: response,
+              deep: memoryDefinition.deep
+            });
+            break;
+          }
+          case "drop": {
+            dropNestedUnit({
+              path: memoryDefinition.path
+            });
+            break;
+          }
         }
-        const response = await api().post(resolveEndpointUrl(endpoint, unit), {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
-        });
-        const clonedUnits = [...memorizedUnits.value];
-        if (options2?.position === "last" /* LAST */) {
-          clonedUnits.push({ ...unit, ...response });
-        } else {
-          clonedUnits.unshift({ ...unit, ...response });
+        return;
+      }
+      switch (mutation) {
+        case "set": {
+          setMemorizedUnit(response);
+          break;
+        }
+        case "edit": {
+          const editData = {
+            ...params,
+            ...response
+          };
+          editMemorizedUnit({
+            unit: editData,
+            deep: memoryDefinition.deep
+          });
+          editMemorizedUnits({
+            units: [editData],
+            deep: memoryDefinition.deep
+          });
+          break;
+        }
+        case "drop": {
+          dropMemorizedUnit(params);
+          break;
         }
-        setMemorizedUnits(clonedUnits);
-        responses.push(response);
       }
-      return responses;
-    });
-  }
-  async function putUnitEndpoint(unit, options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNIT);
-    const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-    if (options2?.validate) {
-      schema.pick(resolvedSchema.keys).parse(unit);
+      return;
     }
-    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 putUnitsEndpoint(units, options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNITS);
-    return withStatus(Endpoint.PUT_UNITS, async () => {
-      const responses = [];
-      for (const unit of units) {
-        const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-        if (options2?.validate) {
-          schema.pick(resolvedSchema.keys).parse(unit);
+    if (Array.isArray(response)) {
+      switch (mutation) {
+        case "set": {
+          setMemorizedUnits(response);
+          break;
+        }
+        case "edit": {
+          editMemorizedUnits({
+            units: response.map((item) => {
+              return {
+                ...params,
+                ...item
+              };
+            }),
+            deep: memoryDefinition.deep
+          });
+          break;
+        }
+        case "drop": {
+          if (params) {
+            dropMemorizedUnits([params]);
+            break;
+          }
+          dropMemorizedUnits(response);
+          break;
         }
-        const response = await api().put(resolveEndpointUrl(endpoint, unit), {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
+        case "add": {
+          addMemorizedUnits({
+            units: response,
+            prepend: memoryDefinition.prepend
+          });
+          break;
+        }
+      }
+      return;
+    }
+    switch (mutation) {
+      case "set": {
+        setMemorizedUnits([response]);
+        break;
+      }
+      case "edit": {
+        editMemorizedUnits({
+          units: [
+            {
+              ...params,
+              ...response
+            }
+          ],
+          deep: memoryDefinition.deep
         });
-        editMemorizedUnits([{ ...unit, ...response }]);
-        responses.push(response);
+        break;
       }
-      return responses;
-    });
+      case "drop": {
+        if (params) {
+          dropMemorizedUnits([params]);
+          break;
+        }
+        dropMemorizedUnits([response]);
+        break;
+      }
+      case "add": {
+        addMemorizedUnits({
+          units: [response],
+          prepend: memoryDefinition.prepend
+        });
+        break;
+      }
+    }
   }
-  async function patchUnitEndpoint(unit, options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNIT);
-    const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-    if (options2?.validate) {
-      schema.pick(resolvedSchema.keys).partial().parse(unit);
+  function resolveRequestBody(actionName, params, actionOptions) {
+    if (actionOptions?.body) {
+      return actionOptions.body;
     }
-    return withStatus(Endpoint.PATCH_UNIT, async () => {
-      const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
-        ...options2,
-        body: options2?.body ?? resolvedSchema.values
-      });
-      editMemorizedUnit({ ...unit, ...response });
-      return response;
-    });
+    const cached = schemaCache.get(actionName);
+    if (cached && cached.fields.length > 0 && params) {
+      return cached.fields.reduce((accumulator, key) => {
+        if (key in params) {
+          accumulator[key] = params[key];
+        }
+        return accumulator;
+      }, {});
+    }
+    return params;
   }
-  async function patchUnitsEndpoint(units, options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNITS);
-    return withStatus(Endpoint.PATCH_UNITS, async () => {
-      const responses = [];
-      for (const unit of units) {
-        const resolvedSchema = resolveSchema(schema, { indicator, endpoint, unit });
-        if (options2?.validate) {
-          schema.pick(resolvedSchema.keys).partial().parse(unit);
+  function validateRequestBody(actionName, params, partial) {
+    const cached = schemaCache.get(actionName);
+    if (!cached || cached.fields.length === 0) {
+      return;
+    }
+    if (partial) {
+      schema.pick(cached.keys).partial().parse(params);
+      return;
+    }
+    schema.pick(cached.keys).parse(params);
+  }
+  function createActionFunction(actionName, actionDefinition) {
+    return async (params, actionOptions) => {
+      return withStatus(actionName, async () => {
+        const url = resolveEndpointUrl(actionDefinition.endpoint, params);
+        const body = resolveRequestBody(actionName, params, actionOptions);
+        const adapter = actionOptions?.adapter ?? actionDefinition.endpoint.adapter;
+        const baseOptions = {
+          query: actionOptions?.query,
+          headers: actionOptions?.headers,
+          signal: actionOptions?.signal,
+          ...adapter && { adapter }
+        };
+        let response;
+        switch (actionDefinition.endpoint.method) {
+          case EndpointMethod.GET: {
+            response = await api().get(url, baseOptions);
+            break;
+          }
+          case EndpointMethod.POST: {
+            if (actionOptions?.validate) {
+              validateRequestBody(actionName, params);
+            }
+            response = await api().post(url, {
+              ...baseOptions,
+              body
+            });
+            break;
+          }
+          case EndpointMethod.PUT: {
+            if (actionOptions?.validate) {
+              validateRequestBody(actionName, params);
+            }
+            response = await api().put(url, {
+              ...baseOptions,
+              body
+            });
+            break;
+          }
+          case EndpointMethod.PATCH: {
+            if (actionOptions?.validate) {
+              validateRequestBody(actionName, params, true);
+            }
+            response = await api().patch(url, {
+              ...baseOptions,
+              body
+            });
+            break;
+          }
+          case EndpointMethod.DELETE: {
+            await api().del(url, baseOptions);
+            response = true;
+            break;
+          }
         }
-        const response = await api().patch(resolveEndpointUrl(endpoint, unit), {
-          ...options2,
-          body: options2?.body ?? resolvedSchema.values
-        });
-        editMemorizedUnits([{ ...unit, ...response }]);
-        responses.push(response);
-      }
-      return responses;
-    });
+        applyMemoryOperation(actionDefinition.memory, actionDefinition.endpoint.method, response, params);
+        return response;
+      });
+    };
   }
-  async function deleteUnitEndpoint(unit, options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNIT);
-    return withStatus(Endpoint.DELETE_UNIT, async () => {
-      await api().del(resolveEndpointUrl(endpoint, unit), options2);
-      dropMemorizedUnit(unit);
-      return true;
-    });
+  const storeActions = {};
+  for (const actionName in actions) {
+    storeActions[actionName] = createActionFunction(actionName, actions[actionName]);
   }
-  async function deleteUnitsEndpoint(units, options2) {
-    const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNITS);
-    return withStatus(Endpoint.DELETE_UNITS, async () => {
-      for (const unit of units) {
-        await api().del(resolveEndpointUrl(endpoint, unit), options2);
-        dropMemorizedUnits([unit]);
+  const memory = {
+    set(data) {
+      if (Array.isArray(data)) {
+        setMemorizedUnits(data);
+        return;
       }
-      return true;
-    });
-  }
+      setMemorizedUnit(data);
+    },
+    edit(data, editOptions) {
+      if (Array.isArray(data)) {
+        editMemorizedUnit({
+          unit: data[0],
+          deep: editOptions?.deep
+        });
+        editMemorizedUnits({
+          units: data,
+          deep: editOptions?.deep
+        });
+        return;
+      }
+      editMemorizedUnit({
+        unit: data,
+        deep: editOptions?.deep
+      });
+      editMemorizedUnits({
+        units: [data],
+        deep: editOptions?.deep
+      });
+    },
+    drop(data) {
+      if (Array.isArray(data)) {
+        dropMemorizedUnit(data[0]);
+        dropMemorizedUnits(data);
+        return;
+      }
+      dropMemorizedUnit(data);
+      dropMemorizedUnits([data]);
+    }
+  };
   return {
     store,
     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
-    },
+    action: storeActions,
+    memory,
     monitor
   };
 }