@diphyx/harlemify 5.2.0 → 5.4.0

package/dist/runtime/core/utils/model.js

@@ -1,211 +1,220 @@
 import { defu } from "defu";
-import { resolveShape } from "./shape.js";
+import { ensureArray } from "./base.js";
+import { resolveShapeAliases } from "./shape.js";
 import {
-  ModelKind,
+  ModelType,
+  ModelManyKind,
   ModelOneMode,
-  ModelManyMode
+  ModelManyMode,
+  ModelSilent
 } from "../types/model.js";
-function resolveIdentifier(definition, shape) {
-  if (definition.options?.identifier) {
-    return definition.options.identifier;
+function callHook(definition, hook, silent) {
+  if (silent === true || silent === hook) {
+    return;
   }
-  return shape.identifier ?? "id";
+  try {
+    definition.options?.[hook]?.();
+  } catch (error) {
+    definition.logger?.error(`Model ${hook} hook error`, {
+      model: definition.key,
+      error
+    });
+  }
+}
+function wrapOperation(definition, mutation, operation, silent) {
+  definition.logger?.debug("Model mutation", {
+    model: definition.key,
+    mutation
+  });
+  callHook(definition, ModelSilent.PRE, silent);
+  operation();
+  callHook(definition, ModelSilent.POST, silent);
 }
 function createOneCommit(definition, source) {
-  const setOperation = source.mutation(`${definition.key}:set`, (state, value) => {
-    state[definition.key] = value;
+  const setOperation = source.mutation(`${definition.key}:set`, (state, { payload }) => {
+    state[definition.key] = payload;
   });
   const resetOperation = source.mutation(`${definition.key}:reset`, (state) => {
-    state[definition.key] = definition.options?.default ?? null;
+    state[definition.key] = definition.default();
   });
-  const patchOperation = source.mutation(
-    `${definition.key}:patch`,
-    (state, payload) => {
-      if (state[definition.key] === null) {
-        return;
-      }
-      if (payload.options?.deep) {
-        state[definition.key] = defu(payload.value, state[definition.key]);
-        return;
-      }
-      state[definition.key] = {
-        ...state[definition.key],
-        ...payload.value
-      };
+  const patchOperation = source.mutation(`${definition.key}:patch`, (state, { payload, options }) => {
+    if (options?.deep) {
+      state[definition.key] = defu(payload, state[definition.key]);
+      return;
     }
-  );
-  function set(value) {
-    definition.logger?.debug("Model mutation", {
-      model: definition.key,
-      mutation: "set"
-    });
-    setOperation(value);
-  }
-  function reset() {
-    definition.logger?.debug("Model mutation", {
-      model: definition.key,
-      mutation: "reset"
-    });
-    resetOperation();
-  }
-  function patch(value, options) {
-    definition.logger?.debug("Model mutation", {
-      model: definition.key,
-      mutation: "patch"
-    });
-    patchOperation({
-      value,
-      options
-    });
-  }
+    state[definition.key] = {
+      ...state[definition.key],
+      ...payload
+    };
+  });
   return {
-    set,
-    reset,
-    patch
+    set(payload, options) {
+      wrapOperation(definition, "set", () => setOperation({ payload }), options?.silent);
+    },
+    reset(options) {
+      wrapOperation(definition, "reset", () => resetOperation(), options?.silent);
+    },
+    patch(payload, options) {
+      wrapOperation(definition, "patch", () => patchOperation({ payload, options }), options?.silent);
+    }
   };
 }
-function createManyCommit(definition, shape, source) {
-  const identifier = resolveIdentifier(definition, shape);
-  const setOperation = source.mutation(`${definition.key}:set`, (state, value) => {
-    state[definition.key] = value;
+function createManyListCommit(definition, source) {
+  const setOperation = source.mutation(`${definition.key}:set`, (state, { payload }) => {
+    state[definition.key] = payload;
   });
   const resetOperation = source.mutation(`${definition.key}:reset`, (state) => {
-    state[definition.key] = definition.options?.default ?? [];
-  });
-  const patchOperation = source.mutation(
-    `${definition.key}:patch`,
-    (state, payload) => {
-      const items = Array.isArray(payload.value) ? payload.value : [payload.value];
-      const by = payload.options?.by ?? identifier;
-      state[definition.key] = state[definition.key].map((item) => {
-        const found = items.find((p) => {
-          return p[by] === item[by];
-        });
-        if (!found) {
-          return item;
-        }
-        if (payload.options?.deep) {
-          return defu(found, item);
+    state[definition.key] = definition.default();
+  });
+  const patchOperation = source.mutation(`${definition.key}:patch`, (state, { payload, options }) => {
+    const items = ensureArray(payload);
+    const by = options?.by ?? definition.identifier;
+    state[definition.key] = state[definition.key].map((item) => {
+      const found = items.find((partial) => {
+        return partial[by] === item[by];
+      });
+      if (!found) {
+        return item;
+      }
+      if (options?.deep) {
+        return defu(found, item);
+      }
+      return {
+        ...item,
+        ...found
+      };
+    });
+  });
+  const removeOperation = source.mutation(`${definition.key}:remove`, (state, { payload }) => {
+    const items = ensureArray(payload);
+    state[definition.key] = state[definition.key].filter((item) => {
+      return !items.some((match) => {
+        let keys = Object.keys(match);
+        if (definition.identifier in match) {
+          keys = [definition.identifier];
         }
-        return {
-          ...item,
-          ...found
-        };
+        return keys.every((key) => {
+          return item[key] === match[key];
+        });
       });
-    }
-  );
-  const removeOperation = source.mutation(
-    `${definition.key}:remove`,
-    (state, payload) => {
-      const items = Array.isArray(payload.value) ? payload.value : [payload.value];
-      const by = payload.options?.by ?? identifier;
-      const ids = new Set(
-        items.map((item) => {
+    });
+  });
+  const addOperation = source.mutation(`${definition.key}:add`, (state, { payload, options }) => {
+    let items = ensureArray(payload);
+    if (options?.unique) {
+      const by = options.by ?? definition.identifier;
+      const existingIds = new Set(
+        state[definition.key].map((item) => {
           return item[by];
         })
       );
-      state[definition.key] = state[definition.key].filter((item) => {
-        return !ids.has(item[by]);
+      items = items.filter((item) => {
+        return !existingIds.has(item[by]);
       });
     }
-  );
-  const addOperation = source.mutation(
-    `${definition.key}:add`,
-    (state, payload) => {
-      let items = Array.isArray(payload.value) ? payload.value : [payload.value];
-      if (payload.options?.unique) {
-        const by = payload.options.by ?? identifier;
-        const existingIds = new Set(
-          state[definition.key].map((item) => {
-            return item[by];
-          })
-        );
-        items = items.filter((item) => {
-          return !existingIds.has(item[by]);
-        });
-      }
-      if (payload.options?.prepend) {
-        state[definition.key] = [...items, ...state[definition.key]];
-        return;
+    if (options?.prepend) {
+      state[definition.key] = [...items, ...state[definition.key]];
+      return;
+    }
+    state[definition.key] = [...state[definition.key], ...items];
+  });
+  return {
+    set(payload, options) {
+      wrapOperation(definition, "set", () => setOperation({ payload }), options?.silent);
+    },
+    reset(options) {
+      wrapOperation(definition, "reset", () => resetOperation(), options?.silent);
+    },
+    patch(payload, options) {
+      wrapOperation(definition, "patch", () => patchOperation({ payload, options }), options?.silent);
+    },
+    remove(payload, options) {
+      wrapOperation(definition, "remove", () => removeOperation({ payload }), options?.silent);
+    },
+    add(payload, options) {
+      wrapOperation(definition, "add", () => addOperation({ payload, options }), options?.silent);
+    }
+  };
+}
+function createManyRecordCommit(definition, source) {
+  const setOperation = source.mutation(`${definition.key}:set`, (state, { payload }) => {
+    state[definition.key] = payload;
+  });
+  const resetOperation = source.mutation(`${definition.key}:reset`, (state) => {
+    state[definition.key] = definition.default();
+  });
+  const patchOperation = source.mutation(`${definition.key}:patch`, (state, { payload, options }) => {
+    if (options?.deep) {
+      state[definition.key] = defu(payload, state[definition.key]);
+      return;
+    }
+    state[definition.key] = {
+      ...state[definition.key],
+      ...payload
+    };
+  });
+  const removeOperation = source.mutation(`${definition.key}:remove`, (state, { payload }) => {
+    const record = {};
+    for (const entry of Object.keys(state[definition.key])) {
+      if (entry !== payload) {
+        record[entry] = state[definition.key][entry];
       }
-      state[definition.key] = [...state[definition.key], ...items];
     }
-  );
-  function set(value) {
-    definition.logger?.debug("Model mutation", {
-      model: definition.key,
-      mutation: "set"
-    });
-    setOperation(value);
-  }
-  function reset() {
-    definition.logger?.debug("Model mutation", {
-      model: definition.key,
-      mutation: "reset"
-    });
-    resetOperation();
-  }
-  function patch(value, options) {
-    definition.logger?.debug("Model mutation", {
-      model: definition.key,
-      mutation: "patch"
-    });
-    patchOperation({
-      value,
-      options
-    });
-  }
-  function remove(value, options) {
-    definition.logger?.debug("Model mutation", {
-      model: definition.key,
-      mutation: "remove"
-    });
-    removeOperation({
-      value,
-      options
-    });
-  }
-  function add(value, options) {
-    definition.logger?.debug("Model mutation", {
-      model: definition.key,
-      mutation: "add"
-    });
-    addOperation({
-      value,
-      options
-    });
-  }
+    state[definition.key] = record;
+  });
+  const addOperation = source.mutation(`${definition.key}:add`, (state, { payload }) => {
+    state[definition.key] = {
+      ...state[definition.key],
+      [payload.key]: payload.value
+    };
+  });
   return {
-    set,
-    reset,
-    patch,
-    remove,
-    add
+    set(payload, options) {
+      wrapOperation(definition, "set", () => setOperation({ payload }), options?.silent);
+    },
+    reset(options) {
+      wrapOperation(definition, "reset", () => resetOperation(), options?.silent);
+    },
+    patch(payload, options) {
+      wrapOperation(definition, "patch", () => patchOperation({ payload, options }), options?.silent);
+    },
+    remove(payload, options) {
+      wrapOperation(definition, "remove", () => removeOperation({ payload }), options?.silent);
+    },
+    add(payload, options) {
+      wrapOperation(definition, "add", () => addOperation({ payload }), options?.silent);
+    }
   };
 }
 function isOneDefinition(definition) {
-  return definition.kind === ModelKind.OBJECT;
+  return definition.type === ModelType.ONE;
 }
-function resolveCommit(definition, shape, source) {
+function isManyRecordDefinition(definition) {
+  return definition.kind === ModelManyKind.RECORD;
+}
+function resolveCommit(definition, source) {
   if (isOneDefinition(definition)) {
     return createOneCommit(definition, source);
   }
-  return createManyCommit(definition, shape, source);
+  if (isManyRecordDefinition(definition)) {
+    return createManyRecordCommit(definition, source);
+  }
+  return createManyListCommit(definition, source);
 }
 export function createModel(definition, source) {
   definition.logger?.debug("Registering model", {
     model: definition.key,
-    kind: definition.kind
+    type: definition.type
   });
-  const shape = resolveShape(definition.shape);
-  const commit = resolveCommit(definition, shape, source);
+  const commit = resolveCommit(definition, source);
+  const aliases = resolveShapeAliases(definition.shape);
   const model = Object.assign(commit, {
     commit(mode, value, options) {
       const handler = commit[mode];
       switch (mode) {
         case ModelOneMode.RESET:
         case ModelManyMode.RESET: {
-          handler();
+          handler(options);
           break;
         }
         default: {
@@ -214,7 +223,7 @@ export function createModel(definition, source) {
       }
     },
     aliases() {
-      return shape.aliases;
+      return aliases;
     }
   });
   return model;

package/dist/runtime/core/utils/shape.d.ts

@@ -1,6 +1,7 @@
-import type { ShapeCall, ShapeDefinition, ShapeInfer, ShapeResolved, ShapeRawDefinition } from "../types/shape.js";
-export declare function resolveShape(shape: ShapeDefinition): ShapeResolved;
+import type { ShapeCall, ShapeDefinition, ShapeInfer, ShapeRawDefinition, ShapeType } from "../types/shape.js";
 export declare function resolveAliasInbound<T = unknown>(data: T, aliases?: Record<string, string>): T;
 export declare function resolveAliasOutbound<T = unknown>(data: T, aliases?: Record<string, string>): T;
-export declare function resolveDefaults<T extends ShapeDefinition>(shape: T, overrides?: Partial<ShapeInfer<T>>): ShapeInfer<T>;
+export declare function resolveShapeIdentifier(shape: ShapeType<unknown>, ...overrides: (string | undefined)[]): string;
+export declare function resolveShapeAliases(shape: ShapeType<unknown>): Record<string, string>;
+export declare function resolveZeroValues<T extends ShapeDefinition>(shape: T): ShapeInfer<T>;
 export declare function createShape<T extends ShapeRawDefinition>(definition: T): ShapeCall<T>;

package/dist/runtime/core/utils/shape.js

@@ -1,77 +1,14 @@
 import { defu } from "defu";
 import { z } from "zod";
 import { isPlainObject, isEmptyRecord } from "./base.js";
-function resolveStringZeroValue() {
-  return "";
-}
-function resolveNumberZeroValue() {
-  return 0;
-}
-function resolveBooleanZeroValue() {
-  return false;
-}
-function resolveBigintZeroValue() {
-  return BigInt(0);
-}
-function resolveDateZeroValue() {
-  return /* @__PURE__ */ new Date(0);
-}
-function resolveArrayZeroValue() {
-  return [];
-}
-function resolveRecordZeroValue() {
-  return {};
-}
-function resolveMapZeroValue() {
-  return /* @__PURE__ */ new Map();
-}
-function resolveSetZeroValue() {
-  return /* @__PURE__ */ new Set();
-}
-function resolveObjectZeroValue(definition) {
-  const output = {};
-  if (definition.shape) {
-    for (const [key, value] of Object.entries(definition.shape)) {
-      output[key] = resolveZeroValue(value);
-    }
-  }
-  return output;
-}
-function resolveEnumZeroValue(definition) {
-  if (definition.entries) {
-    return Object.values(definition.entries)[0];
-  }
-  return void 0;
-}
-function resolveLiteralZeroValue(definition) {
-  if (definition.values) {
-    return definition.values[0];
-  }
-  return void 0;
-}
-function resolveTupleZeroValue(definition) {
-  if (definition.items) {
-    return definition.items.map(resolveZeroValue);
-  }
-  return [];
-}
-function resolveUnionZeroValue(definition) {
-  if (definition.options?.[0]) {
-    return resolveZeroValue(definition.options[0]);
-  }
-  return void 0;
-}
-function resolveDefaultZeroValue(definition) {
-  if (typeof definition.defaultValue === "function") {
-    return definition.defaultValue();
+function resolveShapeFields(shape) {
+  if (!("shape" in shape) || typeof shape.shape !== "object" || !shape.shape) {
+    return void 0;
   }
-  return definition.defaultValue;
+  return shape.shape;
 }
-function resolveInnerZeroValue(definition) {
-  if (definition.innerType) {
-    return resolveZeroValue(definition.innerType);
-  }
-  return void 0;
+function resolveFieldMeta(field) {
+  return field?.meta?.();
 }
 function resolveZeroValue(field) {
   const definition = field.def;
@@ -80,93 +17,83 @@ function resolveZeroValue(field) {
   }
   switch (definition.type) {
     case "string": {
-      return resolveStringZeroValue();
+      return "";
     }
     case "number": {
-      return resolveNumberZeroValue();
+      return 0;
     }
     case "boolean": {
-      return resolveBooleanZeroValue();
+      return false;
     }
     case "bigint": {
-      return resolveBigintZeroValue();
+      return BigInt(0);
     }
     case "date": {
-      return resolveDateZeroValue();
+      return /* @__PURE__ */ new Date(0);
     }
     case "array": {
-      return resolveArrayZeroValue();
+      return [];
     }
     case "record": {
-      return resolveRecordZeroValue();
+      return {};
     }
     case "map": {
-      return resolveMapZeroValue();
+      return /* @__PURE__ */ new Map();
     }
     case "set": {
-      return resolveSetZeroValue();
+      return /* @__PURE__ */ new Set();
     }
     case "object": {
-      return resolveObjectZeroValue(definition);
+      const output = {};
+      if (definition.shape) {
+        for (const [key, value] of Object.entries(definition.shape)) {
+          output[key] = resolveZeroValue(value);
+        }
+      }
+      return output;
     }
     case "enum": {
-      return resolveEnumZeroValue(definition);
+      if (definition.entries) {
+        return Object.values(definition.entries)[0];
+      }
+      return void 0;
     }
     case "literal": {
-      return resolveLiteralZeroValue(definition);
+      if (definition.values) {
+        return definition.values[0];
+      }
+      return void 0;
     }
     case "tuple": {
-      return resolveTupleZeroValue(definition);
+      if (definition.items) {
+        return definition.items.map(resolveZeroValue);
+      }
+      return [];
     }
     case "union": {
-      return resolveUnionZeroValue(definition);
+      if (definition.options?.[0]) {
+        return resolveZeroValue(definition.options[0]);
+      }
+      return void 0;
     }
     case "default": {
-      return resolveDefaultZeroValue(definition);
+      if (typeof definition.defaultValue === "function") {
+        return definition.defaultValue();
+      }
+      return definition.defaultValue;
     }
     case "optional":
     case "nullable": {
-      return resolveInnerZeroValue(definition);
+      if (definition.innerType) {
+        return resolveZeroValue(definition.innerType);
+      }
+      return void 0;
     }
     default: {
       return void 0;
     }
   }
 }
-export function resolveShape(shape) {
-  const resolved = {
-    identifier: void 0,
-    defaults: {},
-    fields: [],
-    aliases: {}
-  };
-  for (const [key, field] of Object.entries(shape.shape)) {
-    resolved.fields.push(key);
-    const fieldMeta = field.meta();
-    if (fieldMeta?.identifier) {
-      resolved.identifier = key;
-    }
-    if (fieldMeta?.alias) {
-      resolved.aliases[key] = fieldMeta.alias;
-    }
-    const fieldDefinition = field.def;
-    if (fieldDefinition?.defaultValue !== void 0) {
-      if (typeof fieldDefinition.defaultValue === "function") {
-        resolved.defaults[key] = fieldDefinition.defaultValue();
-        continue;
-      }
-      resolved.defaults[key] = fieldDefinition.defaultValue;
-    }
-  }
-  if (!resolved.identifier) {
-    if (resolved.fields.includes("id")) {
-      resolved.identifier = "id";
-    } else if (resolved.fields.includes("_id")) {
-      resolved.identifier = "_id";
-    }
-  }
-  return resolved;
-}
 function resolveAliasObject(data, mapping) {
   const output = {};
   for (const [key, value] of Object.entries(data)) {
@@ -212,21 +139,54 @@ export function resolveAliasOutbound(data, aliases) {
   }
   return data;
 }
-export function resolveDefaults(shape, overrides) {
+export function resolveShapeIdentifier(shape, ...overrides) {
+  for (const key of overrides) {
+    if (key) {
+      return key;
+    }
+  }
+  const fields = resolveShapeFields(shape);
+  if (!fields) {
+    return "id";
+  }
+  for (const [key, field] of Object.entries(fields)) {
+    const meta = resolveFieldMeta(field);
+    if (meta?.identifier) {
+      return key;
+    }
+  }
+  return "id";
+}
+export function resolveShapeAliases(shape) {
+  const output = {};
+  const fields = resolveShapeFields(shape);
+  if (!fields) {
+    return output;
+  }
+  for (const [key, field] of Object.entries(fields)) {
+    const meta = resolveFieldMeta(field);
+    if (meta?.alias) {
+      output[key] = meta.alias;
+    }
+  }
+  return output;
+}
+export function resolveZeroValues(shape) {
   const output = {};
   for (const [key, field] of Object.entries(shape.shape)) {
     output[key] = resolveZeroValue(field);
   }
-  if (overrides) {
-    return defu(overrides, output);
-  }
   return output;
 }
 export function createShape(definition) {
   const object = z.object(definition);
   const shape = Object.assign(object, {
     defaults(overrides) {
-      return resolveDefaults(object, overrides);
+      const zero = resolveZeroValues(object);
+      if (overrides) {
+        return defu(overrides, zero);
+      }
+      return zero;
     }
   });
   return shape;

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

@@ -1,5 +1,5 @@
 import type { createStore as createSourceStore } from "@harlem/core";
-import { type ModelDefinitions, type ModelDefinitionsInfer, type StoreModel } from "../types/model.js";
+import type { ModelDefinitions, ModelDefinitionsInfer, StoreModel } from "../types/model.js";
 import type { ViewDefinitions, StoreView } from "../types/view.js";
 import type { ActionDefinition, ActionDefinitions, StoreAction } from "../types/action.js";
 export declare function createStoreState<MD extends ModelDefinitions>(modelDefinitions: MD): ModelDefinitionsInfer<MD>;