@diphyx/harlemify 3.0.0 → 4.0.1

package/dist/runtime/core/store.js

@@ -1,581 +1,53 @@
-import { defu } from "defu";
-import { createStore as createHarlemStore } from "@harlem/core";
-import { createApi } from "./api.js";
-import { sharedConfig } from "../shared.js";
-import { createCache } from "../utils/cache.js";
-import { defineApiAdapter } from "../utils/adapter.js";
-import { pluralize } from "../utils/transform.js";
-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];
+import { createConsola } from "consola";
+import { createStore as createSourceStore } from "@harlem/core";
+import { runtimeConfig } from "../config.js";
+import { createModelFactory } from "./layers/model.js";
+import { createViewFactory } from "./layers/view.js";
+import { createActionFactory } from "./layers/action.js";
+import { initializeState, createMutations, createCommitter } from "./utils/model.js";
+import { createView } from "./utils/view.js";
+import { createAction } from "./utils/action.js";
+import {
+  DEFINITION
+} from "./types/action.js";
+function createStoreModel(mutations) {
+  return createCommitter(mutations);
 }
-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 createStoreView(source, viewDefinitions) {
+  return createView(source, viewDefinitions);
 }
-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]];
+function createStoreAction(actionDefinitions, view, mutations) {
+  const actions = {};
+  for (const [key, chain] of Object.entries(actionDefinitions)) {
+    actions[key] = createAction(chain[DEFINITION], mutations, view, key);
   }
-  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);
+  return actions;
 }
-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({
-        headers: sharedConfig.api?.headers,
-        query: sharedConfig.api?.query,
-        adapter: options?.adapter ?? defineApiAdapter(sharedConfig.api?.adapter)
-      });
-    }
-    return apiClient;
-  }
-  const state = {
-    memory: {
-      unit: null,
-      units: []
-    },
-    status: {}
-  };
-  for (const actionName in actions) {
-    state.status[actionName] = EndpointStatus.IDLE;
-  }
-  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 setMemorizedUnit = store.mutation("setMemorizedUnit", (state2, unit = null) => {
-    state2.memory.unit = unit;
-  });
-  const setMemorizedUnits = store.mutation("setMemorizedUnits", (state2, units = []) => {
-    state2.memory.units = units;
-    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 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) => {
-      const dropSet = new Set(
-        units.map((unit) => {
-          return unit[indicator];
-        })
-      );
-      for (const unit of units) {
-        indexCache.delete(unit[indicator]);
-      }
-      state2.memory.units = state2.memory.units.filter((memorizedUnit2) => {
-        return !dropSet.has(memorizedUnit2[indicator]);
-      });
-    }
-  );
-  const addMemorizedUnits = store.mutation(
-    "addMemorizedUnits",
-    (state2, payload) => {
-      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];
-    }
-  );
-  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);
-    }
-  );
-  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(actionName, operation) {
-    await options?.hooks?.before?.();
-    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();
-      patchStatus({
-        action: actionName,
-        status: EndpointStatus.SUCCESS
-      });
-      await options?.hooks?.after?.();
-      return result;
-    } catch (error) {
-      patchStatus({
-        action: actionName,
-        status: EndpointStatus.FAILED
-      });
-      await options?.hooks?.after?.(error);
-      throw error;
-    }
-  }
-  function applyMemoryOperation(memoryDefinition, method, response, params) {
-    if (!memoryDefinition) {
-      return;
-    }
-    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;
-          }
-        }
-        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;
-        }
-      }
-      return;
-    }
-    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;
-        }
-        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
-        });
-        break;
-      }
-      case "drop": {
-        if (params) {
-          dropMemorizedUnits([params]);
-          break;
-        }
-        dropMemorizedUnits([response]);
-        break;
-      }
-      case "add": {
-        addMemorizedUnits({
-          units: [response],
-          prepend: memoryDefinition.prepend
-        });
-        break;
-      }
-    }
-  }
-  function resolveRequestBody(actionName, params, actionOptions) {
-    if (actionOptions?.body) {
-      return actionOptions.body;
-    }
-    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;
-  }
-  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;
-          }
-        }
-        applyMemoryOperation(actionDefinition.memory, actionDefinition.endpoint.method, response, params);
-        return response;
-      });
-    };
-  }
-  const storeActions = {};
-  for (const actionName in actions) {
-    storeActions[actionName] = createActionFunction(actionName, actions[actionName]);
-  }
-  const memory = {
-    set(data) {
-      if (Array.isArray(data)) {
-        setMemorizedUnits(data);
-        return;
-      }
-      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]);
-    }
-  };
+export function createStore(config) {
+  const logger = createConsola({
+    level: runtimeConfig.logger,
+    defaults: {
+      tag: `harlemify:${config.name}`
+    }
+  });
+  const modelFactory = createModelFactory(runtimeConfig.model, logger);
+  const viewFactory = createViewFactory(runtimeConfig.view, logger);
+  const actionFactory = createActionFactory(runtimeConfig.action, logger);
+  logger.info("Creating store");
+  const modelDefinitions = config.model(modelFactory);
+  const viewDefinitions = config.view(viewFactory);
+  const actionDefinitions = config.action(actionFactory);
+  logger.debug("Initializing store");
+  const state = initializeState(modelDefinitions);
+  const source = createSourceStore(config.name, state);
+  const mutations = createMutations(source, modelDefinitions);
+  const model = createStoreModel(mutations);
+  const view = createStoreView(source, viewDefinitions);
+  const action = createStoreAction(actionDefinitions, view, mutations);
+  logger.info("Store created");
   return {
-    store,
-    alias,
-    indicator,
-    unit: memorizedUnit,
-    units: memorizedUnits,
-    action: storeActions,
-    memory,
-    monitor
+    model,
+    view,
+    action
   };
 }