@diphyx/harlemify 4.0.1 → 5.1.0

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

@@ -0,0 +1,36 @@
+export class ActionApiError extends Error {
+  name = "ActionApiError";
+  constructor(source) {
+    super(source.message || "API request failed");
+    this.status = source?.status ?? source?.response?.status ?? 500;
+    this.statusText = source?.statusText ?? source?.response?.statusText ?? "Internal Server Error";
+    this.data = source?.data ?? source?.response?._data ?? null;
+  }
+}
+export class ActionHandlerError extends Error {
+  name = "ActionHandlerError";
+  constructor(source) {
+    super(source.message || "Action handler failed");
+  }
+}
+export class ActionCommitError extends Error {
+  name = "ActionCommitError";
+  constructor(source) {
+    super(source.message || "Action commit failed");
+  }
+}
+export class ActionConcurrentError extends Error {
+  name = "ActionConcurrentError";
+  constructor() {
+    super("Action is already pending");
+  }
+}
+export function isError(error, ...types) {
+  return types.some((ErrorType) => error instanceof ErrorType);
+}
+export function toError(error, ErrorType) {
+  if (ErrorType) {
+    return new ErrorType(error);
+  }
+  return error instanceof Error ? error : new Error(String(error));
+}

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

@@ -1,12 +1,4 @@
 import type { Store as SourceStore, BaseState } from "@harlem/core";
-import { type Model, type ModelStateOf, type MutationsOneOptions, type MutationsManyOptions, type Mutations } from "../types/model.js";
-import { type ActionCommitter, ActionOneMode, ActionManyMode } from "../types/action.js";
-export declare function initializeState<M extends Model>(model: M): ModelStateOf<M>;
-export declare function createMutations<M extends Model>(source: SourceStore<BaseState>, model: M): Mutations<M>;
-export declare function executeCommit<M extends Model>(definition: {
-    model: keyof M;
-    mode: ActionOneMode | ActionManyMode;
-    value?: unknown;
-    options?: MutationsOneOptions | MutationsManyOptions;
-}, mutations: Mutations<M>, result?: unknown): void;
-export declare function createCommitter<M extends Model>(mutations: Mutations<M>): ActionCommitter<M>;
+import type { Shape } from "../types/shape.js";
+import { type ModelDefinition, type ModelCall } from "../types/model.js";
+export declare function createModel<S extends Shape>(definition: ModelDefinition<S>, source: SourceStore<BaseState>): ModelCall<S>;

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

@@ -1,67 +1,56 @@
 import { defu } from "defu";
 import { resolveShape } from "./shape.js";
 import {
-  ModelKind
+  ModelKind,
+  ModelOneMode,
+  ModelManyMode
 } from "../types/model.js";
-import { ActionOneMode, ActionManyMode, AUTO } from "../types/action.js";
-export function initializeState(model) {
-  const state = {};
-  for (const [key, definition] of Object.entries(model)) {
-    if (definition.kind === ModelKind.OBJECT) {
-      state[key] = definition.options?.default ?? null;
-    } else {
-      state[key] = definition.options?.default ?? [];
-    }
-  }
-  return state;
-}
-function getIdentifier(definition) {
+function resolveIdentifier(definition, shape) {
   if (definition.options?.identifier) {
     return definition.options.identifier;
   }
-  const { identifier } = resolveShape(definition.shape);
-  if (identifier) {
-    return identifier;
-  }
-  return "id";
+  return shape.identifier ?? "id";
 }
-function createOneMutations(source, definition, key) {
-  const setOperation = source.mutation(`${key}:set`, (state, value) => {
-    state[key] = value;
+function createOneCommit(definition, source) {
+  const setOperation = source.mutation(`${definition.key}:set`, (state, value) => {
+    state[definition.key] = value;
   });
-  const resetOperation = source.mutation(`${key}:reset`, (state) => {
-    state[key] = definition.options?.default ?? null;
+  const resetOperation = source.mutation(`${definition.key}:reset`, (state) => {
+    state[definition.key] = definition.options?.default ?? null;
   });
-  const patchOperation = source.mutation(`${key}:patch`, (state, payload) => {
-    if (state[key] === null) {
-      return;
-    }
-    if (payload.options?.deep) {
-      state[key] = defu(payload.value, state[key]);
-      return;
+  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
+      };
     }
-    state[key] = {
-      ...state[key],
-      ...payload.value
-    };
-  });
+  );
   function set(value) {
     definition.logger?.debug("Model mutation", {
-      model: key,
+      model: definition.key,
       mutation: "set"
     });
     setOperation(value);
   }
   function reset() {
     definition.logger?.debug("Model mutation", {
-      model: key,
+      model: definition.key,
       mutation: "reset"
     });
     resetOperation();
   }
   function patch(value, options) {
     definition.logger?.debug("Model mutation", {
-      model: key,
+      model: definition.key,
       mutation: "patch"
     });
     patchOperation({
@@ -75,20 +64,20 @@ function createOneMutations(source, definition, key) {
     patch
   };
 }
-function createManyMutations(source, definition, key) {
-  const identifier = getIdentifier(definition);
-  const setOperation = source.mutation(`${key}:set`, (state, value) => {
-    state[key] = value;
+function createManyCommit(definition, shape, source) {
+  const identifier = resolveIdentifier(definition, shape);
+  const setOperation = source.mutation(`${definition.key}:set`, (state, value) => {
+    state[definition.key] = value;
   });
-  const resetOperation = source.mutation(`${key}:reset`, (state) => {
-    state[key] = definition.options?.default ?? [];
+  const resetOperation = source.mutation(`${definition.key}:reset`, (state) => {
+    state[definition.key] = definition.options?.default ?? [];
   });
   const patchOperation = source.mutation(
-    `${key}:patch`,
+    `${definition.key}:patch`,
     (state, payload) => {
       const items = Array.isArray(payload.value) ? payload.value : [payload.value];
       const by = payload.options?.by ?? identifier;
-      state[key] = state[key].map((item) => {
+      state[definition.key] = state[definition.key].map((item) => {
         const found = items.find((p) => {
           return p[by] === item[by];
         });
@@ -105,54 +94,60 @@ function createManyMutations(source, definition, key) {
       });
     }
   );
-  const removeOperation = source.mutation(`${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) => {
-        return item[by];
-      })
-    );
-    state[key] = state[key].filter((item) => {
-      return !ids.has(item[by]);
-    });
-  });
-  const addOperation = source.mutation(`${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[key].map((item) => {
+  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) => {
           return item[by];
         })
       );
-      items = items.filter((item) => {
-        return !existingIds.has(item[by]);
+      state[definition.key] = state[definition.key].filter((item) => {
+        return !ids.has(item[by]);
       });
     }
-    if (payload.options?.prepend) {
-      state[key] = [...items, ...state[key]];
-      return;
+  );
+  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;
+      }
+      state[definition.key] = [...state[definition.key], ...items];
     }
-    state[key] = [...state[key], ...items];
-  });
+  );
   function set(value) {
     definition.logger?.debug("Model mutation", {
-      model: key,
+      model: definition.key,
       mutation: "set"
     });
     setOperation(value);
   }
   function reset() {
     definition.logger?.debug("Model mutation", {
-      model: key,
+      model: definition.key,
       mutation: "reset"
     });
     resetOperation();
   }
   function patch(value, options) {
     definition.logger?.debug("Model mutation", {
-      model: key,
+      model: definition.key,
       mutation: "patch"
     });
     patchOperation({
@@ -162,7 +157,7 @@ function createManyMutations(source, definition, key) {
   }
   function remove(value, options) {
     definition.logger?.debug("Model mutation", {
-      model: key,
+      model: definition.key,
       mutation: "remove"
     });
     removeOperation({
@@ -172,7 +167,7 @@ function createManyMutations(source, definition, key) {
   }
   function add(value, options) {
     definition.logger?.debug("Model mutation", {
-      model: key,
+      model: definition.key,
       mutation: "add"
     });
     addOperation({
@@ -188,40 +183,39 @@ function createManyMutations(source, definition, key) {
     add
   };
 }
-export function createMutations(source, model) {
-  const mutations = {};
-  for (const [key, definition] of Object.entries(model)) {
-    definition.logger?.debug("Model registered", {
-      model: key,
-      kind: definition.kind
-    });
-    if (definition.kind === ModelKind.OBJECT) {
-      mutations[key] = createOneMutations(source, definition, key);
-    } else {
-      mutations[key] = createManyMutations(source, definition, key);
-    }
-  }
-  return mutations;
+function isOneDefinition(definition) {
+  return definition.kind === ModelKind.OBJECT;
 }
-export function executeCommit(definition, mutations, result) {
-  const handler = mutations[definition.model][definition.mode];
-  switch (definition.mode) {
-    case ActionOneMode.RESET:
-    case ActionManyMode.RESET: {
-      handler();
-      break;
-    }
-    default: {
-      handler(
-        definition.value === AUTO || definition.value === void 0 ? result : definition.value,
-        definition.options
-      );
-    }
+function resolveCommit(definition, shape, source) {
+  if (isOneDefinition(definition)) {
+    return createOneCommit(definition, source);
   }
+  return createManyCommit(definition, shape, source);
 }
-export function createCommitter(mutations) {
-  function committer(model, mode, value, options) {
-    executeCommit({ model, mode, value, options }, mutations);
-  }
-  return committer;
+export function createModel(definition, source) {
+  definition.logger?.debug("Registering model", {
+    model: definition.key,
+    kind: definition.kind
+  });
+  const shape = resolveShape(definition.shape);
+  const commit = resolveCommit(definition, shape, source);
+  const model = Object.assign(commit, {
+    commit(mode, value, options) {
+      const handler = commit[mode];
+      switch (mode) {
+        case ModelOneMode.RESET:
+        case ModelManyMode.RESET: {
+          handler();
+          break;
+        }
+        default: {
+          handler(value, options);
+        }
+      }
+    },
+    aliases() {
+      return shape.aliases;
+    }
+  });
+  return model;
 }

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

@@ -1,3 +1,6 @@
-import type { z } from "zod";
-import type { ShapeMeta } from "../types/shape.js";
-export declare function resolveShape(shape: z.ZodObject<z.ZodRawShape>): ShapeMeta;
+import type { ShapeCall, ShapeDefinition, ShapeInfer, ShapeResolved, ShapeRawDefinition } from "../types/shape.js";
+export declare function resolveShape(shape: ShapeDefinition): ShapeResolved;
+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 createShape<T extends ShapeRawDefinition>(definition: T): ShapeCall<T>;

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

@@ -1,29 +1,233 @@
+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();
+  }
+  return definition.defaultValue;
+}
+function resolveInnerZeroValue(definition) {
+  if (definition.innerType) {
+    return resolveZeroValue(definition.innerType);
+  }
+  return void 0;
+}
+function resolveZeroValue(field) {
+  const definition = field.def;
+  if (!definition?.type) {
+    return void 0;
+  }
+  switch (definition.type) {
+    case "string": {
+      return resolveStringZeroValue();
+    }
+    case "number": {
+      return resolveNumberZeroValue();
+    }
+    case "boolean": {
+      return resolveBooleanZeroValue();
+    }
+    case "bigint": {
+      return resolveBigintZeroValue();
+    }
+    case "date": {
+      return resolveDateZeroValue();
+    }
+    case "array": {
+      return resolveArrayZeroValue();
+    }
+    case "record": {
+      return resolveRecordZeroValue();
+    }
+    case "map": {
+      return resolveMapZeroValue();
+    }
+    case "set": {
+      return resolveSetZeroValue();
+    }
+    case "object": {
+      return resolveObjectZeroValue(definition);
+    }
+    case "enum": {
+      return resolveEnumZeroValue(definition);
+    }
+    case "literal": {
+      return resolveLiteralZeroValue(definition);
+    }
+    case "tuple": {
+      return resolveTupleZeroValue(definition);
+    }
+    case "union": {
+      return resolveUnionZeroValue(definition);
+    }
+    case "default": {
+      return resolveDefaultZeroValue(definition);
+    }
+    case "optional":
+    case "nullable": {
+      return resolveInnerZeroValue(definition);
+    }
+    default: {
+      return void 0;
+    }
+  }
+}
 export function resolveShape(shape) {
-  const meta = {
+  const resolved = {
     identifier: void 0,
     defaults: {},
-    fields: []
+    fields: [],
+    aliases: {}
   };
   for (const [key, field] of Object.entries(shape.shape)) {
-    meta.fields.push(key);
-    const fieldDefinition = field.def;
-    if (fieldDefinition?.meta?.identifier) {
-      meta.identifier = key;
+    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") {
-        meta.defaults[key] = fieldDefinition.defaultValue();
+        resolved.defaults[key] = fieldDefinition.defaultValue();
         continue;
       }
-      meta.defaults[key] = fieldDefinition.defaultValue;
+      resolved.defaults[key] = fieldDefinition.defaultValue;
     }
   }
-  if (!meta.identifier) {
-    if (meta.fields.includes("id")) {
-      meta.identifier = "id";
-    } else if (meta.fields.includes("_id")) {
-      meta.identifier = "_id";
+  if (!resolved.identifier) {
+    if (resolved.fields.includes("id")) {
+      resolved.identifier = "id";
+    } else if (resolved.fields.includes("_id")) {
+      resolved.identifier = "_id";
     }
   }
-  return meta;
+  return resolved;
+}
+function resolveAliasObject(data, mapping) {
+  const output = {};
+  for (const [key, value] of Object.entries(data)) {
+    output[mapping[key] ?? key] = value;
+  }
+  return output;
+}
+export function resolveAliasInbound(data, aliases) {
+  if (isEmptyRecord(aliases)) {
+    return data;
+  }
+  const reverse = {};
+  for (const [shapeKey, aliasKey] of Object.entries(aliases)) {
+    reverse[aliasKey] = shapeKey;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => {
+      if (isPlainObject(item)) {
+        return resolveAliasObject(item, reverse);
+      }
+      return item;
+    });
+  }
+  if (isPlainObject(data)) {
+    return resolveAliasObject(data, reverse);
+  }
+  return data;
+}
+export function resolveAliasOutbound(data, aliases) {
+  if (isEmptyRecord(aliases)) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => {
+      if (isPlainObject(item)) {
+        return resolveAliasObject(item, aliases);
+      }
+      return item;
+    });
+  }
+  if (isPlainObject(data)) {
+    return resolveAliasObject(data, aliases);
+  }
+  return data;
+}
+export function resolveDefaults(shape, overrides) {
+  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);
+    }
+  });
+  return shape;
 }

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

@@ -0,0 +1,8 @@
+import type { createStore as createSourceStore } from "@harlem/core";
+import { type ModelDefinitions, type ModelDefinitionsInfer, type 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>;
+export declare function createStoreModel<MD extends ModelDefinitions>(modelDefinitions: MD, source: ReturnType<typeof createSourceStore>): StoreModel<MD>;
+export declare function createStoreView<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>>(viewDefinitions: VD, source: ReturnType<typeof createSourceStore>): StoreView<MD, VD>;
+export declare function createStoreAction<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>>(actionDefinitions: Record<string, ActionDefinition<MD, VD>>, model: StoreModel<MD>, view: StoreView<MD, VD>): StoreAction<MD, VD, AD>;

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

@@ -0,0 +1,35 @@
+import { createModel } from "./model.js";
+import { createView } from "./view.js";
+import { createAction } from "./action.js";
+import { ModelKind } from "../types/model.js";
+export function createStoreState(modelDefinitions) {
+  const output = {};
+  for (const [key, { options, kind }] of Object.entries(modelDefinitions)) {
+    output[key] = options?.default ?? (kind === ModelKind.OBJECT ? null : []);
+  }
+  return output;
+}
+export function createStoreModel(modelDefinitions, source) {
+  const output = {};
+  for (const [key, definition] of Object.entries(modelDefinitions)) {
+    definition.setKey(key);
+    output[key] = createModel(definition, source);
+  }
+  return output;
+}
+export function createStoreView(viewDefinitions, source) {
+  const output = {};
+  for (const [key, definition] of Object.entries(viewDefinitions)) {
+    definition.setKey(key);
+    output[key] = createView(definition, source);
+  }
+  return output;
+}
+export function createStoreAction(actionDefinitions, model, view) {
+  const output = {};
+  for (const [key, definition] of Object.entries(actionDefinitions)) {
+    definition.setKey(key);
+    output[key] = createAction(definition, model, view);
+  }
+  return output;
+}

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

@@ -1,5 +1,4 @@
 import type { Store as SourceStore, BaseState } from "@harlem/core";
-import type { StoreView } from "../store.js";
-import type { Model } from "../types/model.js";
-import type { ViewDefinitions } from "../types/view.js";
-export declare function createView<M extends Model, VD extends ViewDefinitions<M>>(source: SourceStore<BaseState>, definitions: VD): StoreView<M, VD>;
+import type { ModelDefinitions } from "../types/model.js";
+import { type ViewDefinition, type ViewCall } from "../types/view.js";
+export declare function createView<MD extends ModelDefinitions, R = unknown>(definition: ViewDefinition<MD>, source: SourceStore<BaseState>): ViewCall<R>;