@diphyx/harlemify 5.3.0 → 5.4.0

package/README.md

@@ -2,40 +2,66 @@
 
 > Factory-driven state management for Nuxt powered by [Harlem](https://harlemjs.com/)
 
+![Version](https://img.shields.io/badge/version-5.3.0-42b883)
+![License](https://img.shields.io/badge/license-MIT-blue)
+
 Define your data **shape** once with Zod — get typed **models**, computed **views**, and async **actions** with a single `createStore` call.
 
-- **Schema-first** — Define your data shape once, get TypeScript types and validation automatically
-- **Reactive state** — Single items and collections with built-in mutations
-- **Computed views** — Derived read-only state that updates when models change
-- **API integration** — Declarative HTTP actions that fetch and commit data in one step
-- **Status tracking** — Every action exposes loading, error, and status reactively
-- **Concurrency control** — Block, skip, cancel, or allow parallel calls per action
-- **Vue composables** — Reactive helpers for actions, models, and views in components
-- **SSR ready** — Server-side rendering with automatic state hydration
+Built on top of [Harlem](https://harlemjs.com/), a powerful and extensible state management library for Vue 3.
 
-## Install
+---
 
-```bash
-npm install @diphyx/harlemify
-```
+## The Problem
+
+Every Nuxt app has the same boilerplate for every API resource:
 
 ```typescript
-// nuxt.config.ts
-export default defineNuxtConfig({
-    modules: ["@diphyx/harlemify"],
-});
+// Without Harlemify — this gets written for EVERY resource
+
+// 1. Define types manually
+interface User {
+    id: number;
+    name: string;
+    email: string;
+}
+
+// 2. Define state
+const users = ref<User[]>([]);
+const currentUser = ref<User | null>(null);
+const loading = ref(false);
+const error = ref<Error | null>(null);
+
+// 3. Write fetch logic
+async function fetchUsers() {
+    loading.value = true;
+    error.value = null;
+    try {
+        users.value = await $fetch("/api/users");
+    } catch (e) {
+        error.value = e as Error;
+    } finally {
+        loading.value = false;
+    }
+}
+
+// 4. Repeat for create, update, delete...
+// 5. Repeat for every resource in your app...
 ```
 
-## Usage
+## The Solution
+
+With Harlemify, define a data shape once and get everything else for free:
 
 ```typescript
-const userShape = shape((factory) => ({
-    id: factory.number().meta({
-        identifier: true,
-    }),
-    name: factory.string(),
-    email: factory.email(),
-}));
+const userShape = shape((factory) => {
+    return {
+        id: factory.number().meta({
+            identifier: true,
+        }),
+        name: factory.string(),
+        email: factory.email(),
+    };
+});
 
 export const userStore = createStore({
     name: "users",
@@ -57,35 +83,73 @@ export const userStore = createStore({
                 {
                     url: "/users",
                 },
+                { model: "list", mode: ModelManyMode.SET },
+            ),
+            get: api.get(
                 {
-                    model: "list",
-                    mode: ModelManyMode.SET,
+                    url(view) {
+                        return `/users/${view.user.value?.id}`;
+                    },
+                },
+                { model: "current", mode: ModelOneMode.SET },
+            ),
+            create: api.post(
+                {
+                    url: "/users",
                 },
+                { model: "list", mode: ModelManyMode.ADD },
+            ),
+            delete: api.delete(
+                {
+                    url(view) {
+                        return `/users/${view.user.value?.id}`;
+                    },
+                },
+                { model: "list", mode: ModelManyMode.REMOVE },
             ),
         };
     },
 });
 ```
 
+Use it in any component with built-in composables:
+
 ```vue
 <script setup>
-const { execute, loading } = useStoreAction(userStore, "list");
-const { data } = useStoreView(userStore, "users");
+const { execute, loading, error } = useStoreAction(userStore, "list");
+const { data: users } = useStoreView(userStore, "users");
 
 await execute();
 </script>
 
 <template>
-    <ul v-if="!loading">
-        <li v-for="user in data.value" :key="user.id">{{ user.name }}</li>
+    <p v-if="error">{{ error.message }}</p>
+    <ul v-else-if="!loading">
+        <li v-for="user in users" :key="user.id">{{ user.name }}</li>
     </ul>
 </template>
 ```
 
+## Compatibility
+
+| Dependency | Version               |
+| ---------- | --------------------- |
+| Nuxt       | `^3.14.0` or `^4.0.0` |
+| Vue        | `^3.5.0`              |
+| Zod        | `^4.0.0`              |
+
+> **Note:** Early Nuxt 4 versions (e.g., 4.1.x) may have issues resolving the `#build` alias for module templates. If you encounter build errors related to `#build/harlemify.config`, upgrade to the latest Nuxt 4 release.
+
 ## Documentation
 
+Full docs with guides, API reference, and examples:
+
 [https://diphyx.github.io/harlemify/](https://diphyx.github.io/harlemify/)
 
+## Contributing
+
+Contributions are welcome! Please open an issue first to discuss what you'd like to change.
+
 ## License
 
-MIT
+[MIT](LICENSE)

package/dist/module.json

@@ -2,9 +2,9 @@
   "name": "harlemify",
   "configKey": "harlemify",
   "compatibility": {
-    "nuxt": ">=3.0.0 || >=4.0.0"
+    "nuxt": "^3.14.0 || ^4.0.0"
   },
-  "version": "5.3.0",
+  "version": "5.4.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,17 +1,18 @@
-import { defineNuxtModule, createResolver, addTemplate, addPlugin, addImportsDir, addImports } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addTemplate, addPlugin, addImportsDir, addImports } from '@nuxt/kit';
 
+const logger = useLogger("harlemify");
 const module = defineNuxtModule({
   meta: {
     name: "harlemify",
     configKey: "harlemify",
     compatibility: {
-      nuxt: ">=3.0.0 || >=4.0.0"
+      nuxt: "^3.14.0 || ^4.0.0"
     }
   },
   defaults: {},
   setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    addTemplate({
+    const template = addTemplate({
       write: true,
       filename: "harlemify.config.mjs",
       getContents() {
@@ -27,6 +28,7 @@ const module = defineNuxtModule({
       }
     ]);
     nuxt.options.build.transpile.push(/@harlem\//);
+    logger.success(`Module registered, config template: ${template.dst}`);
   }
 });
 

package/dist/runtime/composables/compose.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from "vue";
+import type { ComposeCallback, ComposeDefinitions, StoreCompose } from "../core/types/compose.js";
+export type UseStoreCompose<A extends any[] = any[]> = {
+    execute: (...args: A) => Promise<void>;
+    active: Readonly<Ref<boolean>>;
+};
+export declare function useStoreCompose<CD extends ComposeDefinitions, K extends keyof StoreCompose<CD> & string, A extends any[] = CD[K] extends ComposeCallback<infer P> ? P : any[]>(store: {
+    compose: StoreCompose<CD>;
+}, key: K): UseStoreCompose<A>;

package/dist/runtime/composables/compose.js

@@ -0,0 +1,10 @@
+export function useStoreCompose(store, key) {
+  const compose = store.compose[key];
+  if (!compose) {
+    throw new Error(`Compose "${key}" not found in store`);
+  }
+  return {
+    execute: (...args) => compose(...args),
+    active: compose.active
+  };
+}

package/dist/runtime/composables/view.d.ts

@@ -6,9 +6,8 @@ export interface UseStoreViewTrackOptions {
     debounce?: number;
     throttle?: number;
 }
-export interface UseStoreViewOptions<T> {
+export interface UseStoreViewOptions {
     proxy?: boolean;
-    default?: T;
 }
 export type UseStoreViewData<T> = {
     value: T;
@@ -25,9 +24,9 @@ export type UseStoreViewComputed<T> = {
 };
 export declare function useStoreView<V extends Record<string, ViewCall>, K extends keyof V & string, T = V[K] extends ComputedRef<infer R> ? R : unknown>(store: {
     view: V;
-}, key: K, options: UseStoreViewOptions<T> & {
+}, key: K, options: UseStoreViewOptions & {
     proxy: false;
 }): UseStoreViewComputed<T>;
 export declare function useStoreView<V extends Record<string, ViewCall>, K extends keyof V & string, T = V[K] extends ComputedRef<infer R> ? R : unknown>(store: {
     view: V;
-}, key: K, options?: UseStoreViewOptions<T>): UseStoreViewProxy<T>;
+}, key: K, options?: UseStoreViewOptions): UseStoreViewProxy<T>;

package/dist/runtime/composables/view.js

@@ -1,17 +1,5 @@
-import { computed, watch } from "vue";
+import { watch } from "vue";
 import { debounce, throttle, toReactiveProxy } from "../core/utils/base.js";
-function resolveDefault(view, defaultValue) {
-  if (defaultValue === void 0) {
-    return view;
-  }
-  return computed(() => {
-    const value = view.value;
-    if (value == null) {
-      return defaultValue;
-    }
-    return value;
-  });
-}
 function resolveData(source, proxy) {
   if (proxy !== false) {
     return toReactiveProxy(source);
@@ -22,7 +10,7 @@ export function useStoreView(store, key, options) {
   if (!store.view[key]) {
     throw new Error(`View "${key}" not found in store`);
   }
-  const source = resolveDefault(store.view[key], options?.default);
+  const source = store.view[key];
   const data = resolveData(source, options?.proxy);
   function resolveCallback(callback, callbackOptions) {
     if (callbackOptions?.debounce) {

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

@@ -1,26 +1,55 @@
 import { wrapBaseDefinition } from "../utils/base.js";
+import { resolveShapeIdentifier } from "../utils/shape.js";
 import {
-  ModelType
+  ModelType,
+  ModelManyKind
 } from "../types/model.js";
 export function createModelFactory(config, logger) {
   function one(shape, options) {
+    function defaultResolver() {
+      if (options?.default) {
+        return options.default();
+      }
+      if ("defaults" in shape && typeof shape.defaults === "function") {
+        return shape.defaults();
+      }
+      return {};
+    }
     return wrapBaseDefinition({
       shape,
       type: ModelType.ONE,
+      default: defaultResolver,
       options: {
-        identifier: config?.identifier,
-        ...options
+        pre: options?.pre,
+        post: options?.post
       },
       logger
     });
   }
   function many(shape, options) {
+    const kind = options?.kind ?? ModelManyKind.LIST;
+    let identifier;
+    if (kind === ModelManyKind.LIST) {
+      identifier = resolveShapeIdentifier(shape, options?.identifier, config?.identifier);
+    }
+    function defaultResolver() {
+      if (options?.default) {
+        return options.default();
+      }
+      if (kind === ModelManyKind.LIST) {
+        return [];
+      }
+      return {};
+    }
     return wrapBaseDefinition({
       shape,
       type: ModelType.MANY,
+      kind,
+      identifier,
+      default: defaultResolver,
       options: {
-        identifier: config?.identifier,
-        ...options
+        pre: options?.pre,
+        post: options?.post
       },
       logger
     });

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

@@ -1,5 +1,6 @@
 import type { ModelDefinitions } from "./types/model.js";
 import type { ViewDefinitions } from "./types/view.js";
 import type { ActionDefinitions } from "./types/action.js";
+import type { ComposeDefinitions } from "./types/compose.js";
 import type { Store, StoreConfig } from "./types/store.js";
-export declare function createStore<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>>(config: StoreConfig<MD, VD, AD>): Store<MD, VD, AD>;
+export declare function createStore<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>, CD extends ComposeDefinitions = ComposeDefinitions>(config: StoreConfig<MD, VD, AD, CD>): Store<MD, VD, AD, CD>;

package/dist/runtime/core/store.js

@@ -5,29 +5,46 @@ import { createModelFactory } from "./layers/model.js";
 import { createViewFactory } from "./layers/view.js";
 import { createActionFactory } from "./layers/action.js";
 import { createStoreState, createStoreModel, createStoreView, createStoreAction } from "./utils/store.js";
+import { createStoreCompose } from "./utils/compose.js";
 export function createStore(config) {
-  const logger = createConsola({
-    level: runtimeConfig.logger,
-    defaults: {
-      tag: `harlemify:${config.name}`
-    }
-  });
-  logger.info("Creating store");
-  const modelFactory = createModelFactory(runtimeConfig.model, logger);
-  const viewFactory = createViewFactory(runtimeConfig.view, logger);
-  const actionFactory = createActionFactory(runtimeConfig.action, logger);
-  const modelDefinitions = config.model(modelFactory);
-  const viewDefinitions = config.view(viewFactory);
-  const actionDefinitions = config.action(actionFactory);
-  const state = createStoreState(modelDefinitions);
-  const source = createStoreSource(config.name, state);
-  const model = createStoreModel(modelDefinitions, source);
-  const view = createStoreView(viewDefinitions, source);
-  const action = createStoreAction(actionDefinitions, model, view);
-  logger.info("Store created");
-  return {
-    model,
-    view,
-    action
-  };
+  function init() {
+    const logger = createConsola({
+      level: runtimeConfig.logger,
+      defaults: {
+        tag: `harlemify:${config.name}`
+      }
+    });
+    logger.info("Creating store");
+    const modelFactory = createModelFactory(runtimeConfig.model, logger);
+    const viewFactory = createViewFactory(runtimeConfig.view, logger);
+    const actionFactory = createActionFactory(runtimeConfig.action, logger);
+    const modelDefinitions = config.model(modelFactory);
+    const viewDefinitions = config.view(viewFactory);
+    const actionDefinitions = config.action(actionFactory);
+    const state = createStoreState(modelDefinitions);
+    const source = createStoreSource(config.name, state);
+    const model = createStoreModel(modelDefinitions, source);
+    const view = createStoreView(viewDefinitions, source);
+    const action = createStoreAction(actionDefinitions, model, view);
+    const compose = createStoreCompose(config.compose, { model, view, action }, logger);
+    logger.info("Store created");
+    return {
+      model,
+      view,
+      action,
+      compose
+    };
+  }
+  if (config.lazy) {
+    let instance;
+    return new Proxy({}, {
+      get(_, prop) {
+        if (!instance) {
+          instance = init();
+        }
+        return instance[prop];
+      }
+    });
+  }
+  return init();
 }

package/dist/runtime/core/types/action.d.ts

@@ -64,7 +64,7 @@ export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDe
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
     payload: P;
-}) => Promise<R>;
+}) => Promise<R> | R;
 export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, P = unknown, R = void> extends BaseDefinition {
     callback: ActionHandlerCallback<MD, VD, P, R>;
     options?: ActionHandlerOptions<P>;

package/dist/runtime/core/types/compose.d.ts

@@ -0,0 +1,18 @@
+import type { Ref } from "vue";
+import type { ModelDefinitions, StoreModel } from "./model.js";
+import type { ViewDefinitions, StoreView } from "./view.js";
+import type { ActionDefinitions, StoreAction } from "./action.js";
+export type ComposeCallback<A extends any[] = any[]> = (...args: A) => Promise<void> | void;
+export type ComposeDefinitions = Record<string, ComposeCallback<any[]>>;
+export interface ComposeContext<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
+    model: StoreModel<MD>;
+    view: StoreView<MD, VD>;
+    action: StoreAction<MD, VD, AD>;
+}
+export type ComposeCall<A extends any[] = any[]> = {
+    (...args: A): Promise<void>;
+    active: Readonly<Ref<boolean>>;
+};
+export type StoreCompose<CD extends ComposeDefinitions> = {
+    [K in keyof CD]: CD[K] extends ComposeCallback<infer A> ? ComposeCall<A> : never;
+};

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

@@ -23,33 +23,35 @@ export declare enum ModelManyMode {
     REMOVE = "remove",
     ADD = "add"
 }
+export declare enum ModelSilent {
+    PRE = "pre",
+    POST = "post"
+}
 export type ModelDefaultIdentifier<S extends Shape> = "id" extends keyof S ? "id" : keyof S;
 export type AtLeastOne<S extends Shape> = {
     [K in keyof S]: Pick<S, K>;
 }[keyof S];
-export interface ModelOneDefinitionOptions<S extends Shape> {
-    identifier?: keyof S;
-    default?: S;
+export interface ModelDefinitionOptions {
+    pre?: () => void;
+    post?: () => void;
 }
-export type ModelManyDefinitionOptions<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> = {
-    kind?: T;
-    default?: [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>;
-} & ([T] extends [ModelManyKind.LIST] ? {
-    identifier?: I;
-} : {});
 export interface ModelOneDefinition<S extends Shape> extends BaseDefinition {
     shape: ShapeType<S>;
     type: ModelType.ONE;
-    options?: ModelOneDefinitionOptions<S>;
+    default: () => S;
+    options?: ModelDefinitionOptions;
 }
 export interface ModelManyDefinition<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> extends BaseDefinition {
     shape: ShapeType<S>;
     type: ModelType.MANY;
-    options?: ModelManyDefinitionOptions<S, I, T>;
+    kind: T;
+    identifier: [T] extends [ModelManyKind.LIST] ? I : never;
+    default: () => [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>;
+    options?: ModelDefinitionOptions;
 }
 export type ModelDefinition<S extends Shape> = ModelOneDefinition<S> | ModelManyDefinition<S, any, any>;
 export type ModelDefinitions = Record<string, ModelDefinition<any>>;
-export type ModelDefinitionInfer<MD extends ModelDefinitions, K extends keyof MD> = MD[K] extends ModelOneDefinition<infer S> ? S | null : MD[K] extends ModelManyDefinition<infer S, any, infer T> ? [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]> : never;
+export type ModelDefinitionInfer<MD extends ModelDefinitions, K extends keyof MD> = MD[K] extends ModelOneDefinition<infer S> ? S : MD[K] extends ModelManyDefinition<infer S, any, infer T> ? [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]> : never;
 export type ModelDefinitionInferTuple<MD extends ModelDefinitions, K extends readonly (keyof MD)[]> = {
     [I in keyof K]: K[I] extends keyof MD ? ModelDefinitionInfer<MD, K[I]> : never;
 };
@@ -57,36 +59,47 @@ export type ModelDefinitionsInfer<MD extends ModelDefinitions> = {
     [K in keyof MD]: ModelDefinitionInfer<MD, K>;
 };
 export interface ModelFactory {
-    one<S extends Shape>(shape: ShapeType<S>, options?: ModelOneDefinitionOptions<S>): ModelOneDefinition<S>;
-    many<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST>(shape: ShapeType<S>, options?: ModelManyDefinitionOptions<S, I, T>): ModelManyDefinition<S, I, T>;
+    one<S extends Shape>(shape: ShapeType<S>, options?: ModelDefinitionOptions & {
+        default?: () => S;
+    }): ModelOneDefinition<S>;
+    many<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST>(shape: ShapeType<S>, options?: ModelDefinitionOptions & {
+        kind?: T;
+        identifier?: [T] extends [ModelManyKind.LIST] ? I : never;
+        default?: () => [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>;
+    }): ModelManyDefinition<S, I, T>;
 }
 export interface ModelOneCommitOptions {
     deep?: boolean;
+    silent?: true | ModelSilent;
 }
 export interface ModelManyCommitOptions {
     by?: string;
     prepend?: boolean;
     unique?: boolean;
     deep?: boolean;
+    silent?: true | ModelSilent;
 }
 export interface ModelOneCommit<S extends Shape> {
-    set: (value: S) => void;
-    reset: () => void;
-    patch: (value: Partial<S>, options?: ModelOneCommitOptions) => void;
+    set: (payload: S, options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    reset: (options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    patch: (payload: Partial<S>, options?: Pick<ModelOneCommitOptions, "deep" | "silent">) => void;
 }
 export interface ModelManyListCommit<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>> {
-    set: (value: S[]) => void;
-    reset: () => void;
-    patch: (value: Partial<S> | Partial<S>[], options?: ModelManyCommitOptions) => void;
-    remove: (value: Pick<S, I> | Pick<S, I>[] | AtLeastOne<S> | AtLeastOne<S>[]) => void;
-    add: (value: S | S[], options?: ModelManyCommitOptions) => void;
+    set: (payload: S[], options?: Pick<ModelManyCommitOptions, "silent">) => void;
+    reset: (options?: Pick<ModelManyCommitOptions, "silent">) => void;
+    patch: (payload: Partial<S> | Partial<S>[], options?: Pick<ModelManyCommitOptions, "by" | "deep" | "silent">) => void;
+    remove: (payload: Pick<S, I> | Pick<S, I>[] | AtLeastOne<S> | AtLeastOne<S>[], options?: Pick<ModelManyCommitOptions, "silent">) => void;
+    add: (payload: S | S[], options?: Pick<ModelManyCommitOptions, "by" | "prepend" | "unique" | "silent">) => void;
 }
 export interface ModelManyRecordCommit<S extends Shape> {
-    set: (value: Record<string, S[]>) => void;
-    reset: () => void;
-    patch: (value: Record<string, S[]>, options?: ModelOneCommitOptions) => void;
-    remove: (key: string) => void;
-    add: (key: string, value: S[]) => void;
+    set: (payload: Record<string, S[]>, options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    reset: (options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    patch: (payload: Record<string, S[]>, options?: Pick<ModelOneCommitOptions, "deep" | "silent">) => void;
+    remove: (payload: string, options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    add: (payload: {
+        key: string;
+        value: S[];
+    }, options?: Pick<ModelOneCommitOptions, "silent">) => void;
 }
 export type ModelManyCommit<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> = [T] extends [ModelManyKind.LIST] ? ModelManyListCommit<S, I> : ModelManyRecordCommit<S>;
 export type ModelOneCall<S extends Shape> = ModelOneCommit<S> & {

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

@@ -22,3 +22,8 @@ export var ModelManyMode = /* @__PURE__ */ ((ModelManyMode2) => {
   ModelManyMode2["ADD"] = "add";
   return ModelManyMode2;
 })(ModelManyMode || {});
+export var ModelSilent = /* @__PURE__ */ ((ModelSilent2) => {
+  ModelSilent2["PRE"] = "pre";
+  ModelSilent2["POST"] = "post";
+  return ModelSilent2;
+})(ModelSilent || {});

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

@@ -7,12 +7,6 @@ export type ShapeInfer<T extends z.ZodType<any>> = z.infer<T>;
 export type ShapeCall<T extends ShapeRawDefinition> = z.ZodObject<T> & {
     defaults: (overrides?: Partial<z.infer<z.ZodObject<T>>>) => z.infer<z.ZodObject<T>>;
 };
-export interface ShapeResolved<T extends ShapeDefinition = ShapeDefinition> {
-    identifier?: keyof T["shape"] & string;
-    defaults: Record<string, unknown>;
-    fields: (keyof T["shape"] & string)[];
-    aliases: Record<string, string>;
-}
 export interface ShapeFieldDefinition {
     meta?: {
         identifier?: boolean;

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

@@ -1,14 +1,18 @@
 import type { ModelDefinitions, ModelFactory, StoreModel } from "./model.js";
 import type { ViewDefinitions, ViewFactory, StoreView } from "./view.js";
 import type { ActionDefinitions, ActionFactory, StoreAction } from "./action.js";
-export interface StoreConfig<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
+import type { ComposeDefinitions, ComposeContext, StoreCompose } from "./compose.js";
+export interface StoreConfig<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>, CD extends ComposeDefinitions = ComposeDefinitions> {
     name: string;
     model: (factory: ModelFactory) => MD;
     view: (factory: ViewFactory<MD>) => VD;
     action: (factory: ActionFactory<MD, VD>) => AD;
+    compose?: (context: ComposeContext<MD, VD, AD>) => CD;
+    lazy?: boolean;
 }
-export interface Store<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
+export interface Store<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>, CD extends ComposeDefinitions = ComposeDefinitions> {
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
     action: StoreAction<MD, VD, AD>;
+    compose: StoreCompose<CD>;
 }

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

@@ -0,0 +1,3 @@
+import type { ConsolaInstance } from "consola";
+import type { ComposeDefinitions, StoreCompose } from "../types/compose.js";
+export declare function createStoreCompose<CD extends ComposeDefinitions>(composeConfig: ((...args: any[]) => CD) | undefined, context: Record<string, unknown>, logger?: ConsolaInstance): StoreCompose<CD>;