@bg-dev/nuxt-zenstack 0.0.1 → 0.0.3

package/dist/module.d.mts

@@ -1,7 +1,9 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { FetchPolicy } from '../dist/runtime/composables/common.js';
 
 interface ModuleOptions {
     apiPath: string;
+    fetchPolicy: FetchPolicy;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "configKey": "zenstack",
   "builder": {
     "@nuxt/module-builder": "1.0.2",

package/dist/module.mjs

@@ -1,9 +1,9 @@
-import { defineNuxtModule, createResolver, addServerImports, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addServerImports, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler, addImportsDir } from '@nuxt/kit';
 import { joinURL } from 'ufo';
 import { defu } from 'defu';
 
 const name = "@bg-dev/nuxt-zenstack";
-const version = "0.0.1";
+const version = "0.0.3";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -13,19 +13,21 @@ const module$1 = defineNuxtModule({
   },
   // Default configuration options of the Nuxt module
   defaults: {
-    apiPath: "/api/models"
+    apiPath: "/api/_zenstack",
+    fetchPolicy: "cache-first"
   },
   setup(_options, _nuxt) {
     _nuxt.options.runtimeConfig.public = defu(_nuxt.options.runtimeConfig.public, {
       zenstack: {
-        apiPath: _options.apiPath
+        apiPath: _options.apiPath,
+        fetchPolicy: _options.fetchPolicy
       }
     });
     const resolver = createResolver(import.meta.url);
     addServerImports({
       from: resolver.resolve("./runtime/server/utils"),
       name: "provideClient",
-      as: "provideZenStackClient"
+      as: "provideZenstackClient"
     });
     addTemplate({
       write: true,
@@ -45,40 +47,44 @@ export { schema as zenstackSchema } from '~~/zenstack/schema'
       getContents: () => `
 import type { ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs } from '@zenstackhq/orm'
 import type { SchemaType } from '~~/zenstack/schema'
+import type { ModelDef } from '@zenstackhq/orm/schema'
+
 type ItemGetPayload<Zmodel extends $Zmodel, Args extends SelectIncludeOmit<SchemaType, Zmodel, true>, Options extends QueryOptions<SchemaType> = QueryOptions<SchemaType>> = SimplifiedPlainResult<SchemaType, Zmodel, Args, Options>
+
 export type $Zschema = SchemaType
 export type $Zmodel = keyof SchemaType['models']
+export type $Zdef = ModelDef
 export type $Zoperations<Zmodel extends $Zmodel> = ModelOperations<SchemaType, Zmodel>
 export type $Zid<Zmodel extends $Zmodel> = ModelResult<SchemaType, Zmodel> extends { id: infer Id } ? Id : never
-export type $Zinclude<Zmodel extends $Zmodel> = IncludeInput<SchemaType, Zmodel>
-export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel> = never> = ItemGetPayload<Zmodel, { include: Zinclude }>
-export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel>
-export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy']
+export type $Zinclude<Zmodel extends $Zmodel> = IncludeInput<SchemaType, Zmodel> | undefined
+export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude = undefined> = ItemGetPayload<Zmodel, { include: Zinclude }>
+export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel> | undefined
+export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy'] | undefined
 export type $ZcreateData<Zmodel extends $Zmodel> = CreateArgs<SchemaType, Zmodel>['data']
 export type $ZupdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel>['data']
-export type $Zerror = {message: string, reason: string, rejectedByValidation: boolean, model: string}
 `
     });
     addServerHandler({
-      route: joinURL(_options.apiPath, "/:model"),
-      handler: resolver.resolve("./runtime/server/api/[model]/index.get")
+      route: joinURL(_options.apiPath, "models/:model"),
+      handler: resolver.resolve("./runtime/server/api/models/[model]/index.get")
     });
     addServerHandler({
-      route: joinURL(_options.apiPath, "/:model"),
-      handler: resolver.resolve("./runtime/server/api/[model]/index.post")
+      route: joinURL(_options.apiPath, "models/:model"),
+      handler: resolver.resolve("./runtime/server/api/models/[model]/index.post")
     });
     addServerHandler({
-      route: joinURL(_options.apiPath, "/:model/:id"),
-      handler: resolver.resolve("./runtime/server/api/[model]/[id].patch")
+      route: joinURL(_options.apiPath, "models/:model/:id"),
+      handler: resolver.resolve("./runtime/server/api/models/[model]/[id].patch")
     });
     addServerHandler({
-      route: joinURL(_options.apiPath, "/:model/:id"),
-      handler: resolver.resolve("./runtime/server/api/[model]/[id].delete")
+      route: joinURL(_options.apiPath, "models/:model/:id"),
+      handler: resolver.resolve("./runtime/server/api/models/[model]/[id].delete")
     });
     addServerHandler({
-      route: joinURL(_options.apiPath, "/:model/:id"),
-      handler: resolver.resolve("./runtime/server/api/[model]/[id].get")
+      route: joinURL(_options.apiPath, "models/:model/:id"),
+      handler: resolver.resolve("./runtime/server/api/models/[model]/[id].get")
     });
+    addImportsDir(resolver.resolve("./runtime/composables"));
   }
 });
 

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

@@ -0,0 +1,19 @@
+export type Status = 'idle' | 'pending' | 'success' | 'error';
+export type FetchPolicy = 'cache-first' | 'fetch-only' | 'cache-only' | 'cache-and-fetch';
+export type Error = {
+    error: boolean;
+    url: string;
+    statusCode: number;
+    statusMessage: string;
+    message: string;
+    stack?: string[];
+};
+export declare function getConfig(): {
+    apiPath: string;
+    fetchPolicy: FetchPolicy;
+};
+/**
+ * @param instance a custom fetch method created by `$fetch.create`
+ */
+export declare function provideFetch(instance: typeof $fetch): void;
+export declare function getFetch(): import("nitropack/types").$Fetch<unknown, import("nitropack/types").NitroFetchRequest>;

package/dist/runtime/composables/common.js

@@ -0,0 +1,12 @@
+import { useRuntimeConfig } from "#imports";
+export function getConfig() {
+  const config = useRuntimeConfig();
+  return config.public.zenstack;
+}
+let _fetch = $fetch;
+export function provideFetch(instance) {
+  _fetch = instance;
+}
+export function getFetch() {
+  return _fetch;
+}

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

@@ -0,0 +1,6 @@
+export { useZenstackCreate } from './useZenstackCreate/index.js';
+export { useZenstackReadMany } from './useZenstackReadMany/index.js';
+export { useZenstackRead } from './useZenstackRead/index.js';
+export { useZenstackDelete } from './useZenstackDelete/index.js';
+export { useZenstackUpdate } from './useZenstackUpdate/index.js';
+export { provideFetch as provideZenstackFetch } from './common.js';

package/dist/runtime/composables/index.js

@@ -0,0 +1,6 @@
+export { useZenstackCreate } from "./useZenstackCreate/index.js";
+export { useZenstackReadMany } from "./useZenstackReadMany/index.js";
+export { useZenstackRead } from "./useZenstackRead/index.js";
+export { useZenstackDelete } from "./useZenstackDelete/index.js";
+export { useZenstackUpdate } from "./useZenstackUpdate/index.js";
+export { provideFetch as provideZenstackFetch } from "./common.js";

package/dist/runtime/composables/useZenstackCreate/index.d.ts

@@ -0,0 +1,10 @@
+import type { $Zmodel, $Zitem, $ZcreateData } from '#build/types/nuxt-zenstack';
+import type { Status, Error } from '../common.js';
+import { type Ref } from '#imports';
+export declare function useZenstackCreate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
+    data: Ref<Zitem | null>;
+    error: Ref<Error | null>;
+    status: Ref<Status>;
+    mutate: (input: $ZcreateData<Zmodel>) => Promise<void>;
+    reset: () => void;
+};

package/dist/runtime/composables/useZenstackCreate/index.js

@@ -0,0 +1,40 @@
+import { getConfig, getFetch } from "../common.js";
+import { ref } from "#imports";
+import { joinURL } from "ufo";
+import { useZenstackStore } from "../useZenstackStore/index.js";
+export function useZenstackCreate(model) {
+  const data = ref(null);
+  const error = ref(null);
+  const status = ref("idle");
+  const store = useZenstackStore();
+  const config = getConfig();
+  function reset() {
+    data.value = null;
+    error.value = null;
+    status.value = "idle";
+  }
+  async function mutate(input) {
+    const _fetch = getFetch();
+    const url = joinURL(config.apiPath, `/models/${model.toString()}`);
+    const method = "POST";
+    const body = { data: input };
+    store.addToFetchHistory({
+      model: model.toString(),
+      method,
+      body: JSON.stringify(body)
+    });
+    reset();
+    status.value = "pending";
+    try {
+      const res = await _fetch(url, { method, body });
+      if (res.data)
+        store.setOne(model, res.data);
+      data.value = res.data;
+      status.value = "success";
+    } catch (err) {
+      error.value = err.data;
+      status.value = "error";
+    }
+  }
+  return { data, error, status, mutate, reset };
+}

package/dist/runtime/composables/useZenstackDelete/index.d.ts

@@ -0,0 +1,10 @@
+import type { $Zmodel, $Zitem, $Zid } from '#build/types/nuxt-zenstack';
+import type { Status, Error } from '../common.js';
+import { type Ref } from '#imports';
+export declare function useZenstackDelete<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
+    data: Ref<Zitem | null>;
+    error: Ref<Error | null>;
+    status: Ref<Status>;
+    mutate: (id: $Zid<Zmodel>) => Promise<void>;
+    reset: () => void;
+};

package/dist/runtime/composables/useZenstackDelete/index.js

@@ -0,0 +1,38 @@
+import { ref } from "#imports";
+import { joinURL } from "ufo";
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { getConfig, getFetch } from "../common.js";
+export function useZenstackDelete(model) {
+  const data = ref(null);
+  const error = ref(null);
+  const status = ref("idle");
+  const store = useZenstackStore();
+  const config = getConfig();
+  function reset() {
+    data.value = null;
+    error.value = null;
+    status.value = "idle";
+  }
+  async function mutate(id) {
+    const _fetch = getFetch();
+    const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    const method = "DELETE";
+    store.addToFetchHistory({
+      model: model.toString(),
+      id,
+      method
+    });
+    reset();
+    status.value = "pending";
+    try {
+      const res = await _fetch(url, { method });
+      store.deleteOne(model, id);
+      data.value = res.data;
+      status.value = "success";
+    } catch (err) {
+      error.value = err.data;
+      status.value = "error";
+    }
+  }
+  return { data, error, status, mutate, reset };
+}

package/dist/runtime/composables/useZenstackRead/index.d.ts

@@ -0,0 +1,30 @@
+import type { $Zmodel, $Zitem, $Zid, $Zinclude } from '#build/types/nuxt-zenstack';
+import type { Status, FetchPolicy } from '../common.js';
+import type { Ref, MaybeRefOrGetter } from '#imports';
+type Options<Zinclude> = {
+    /**
+     * - `cache-first` means that the query will first try to fetch the data from the store. If the data is not found in the store, it will fetch the data from the server and update the store.
+     * - `cache-and-fetch` means that the query will first try to fetch the data from the cache. It will then fetch the data from the server and update the cache.
+     * - `fetch-only` means that the query will only fetch the data from the server. The data will be stored in the srore when the query is resolved.
+     * - `cache-only` means that the query will only fetch the data from the store.
+     * @default 'cache-first'
+     */
+    fetchPolicy?: FetchPolicy;
+    /**
+     * Whether to fetch the data immediately (when the composable is called).
+     * @default true
+     */
+    immediate?: boolean;
+    /**
+     * The relations to include in the query.
+     * @default undefined
+     */
+    include?: MaybeRefOrGetter<Zinclude>;
+};
+export declare function useZenstackRead<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>, Zitem extends $Zitem<Zmodel, Zinclude>>(model: Zmodel, id: $Zid<Zmodel>, opts?: Options<Zinclude>): Promise<{
+    data: Ref<Zitem | null>;
+    error: Ref<Error | null>;
+    status: Ref<Status>;
+    refetch: () => Promise<void>;
+}>;
+export {};

package/dist/runtime/composables/useZenstackRead/index.js

@@ -0,0 +1,70 @@
+import { ref, toValue, watch, isRef, useNuxtApp } from "#imports";
+import { joinURL } from "ufo";
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { stringify } from "superjson";
+import { getConfig, getFetch } from "../common.js";
+export async function useZenstackRead(model, id, opts = {}) {
+  const data = ref(null);
+  const error = ref(null);
+  const status = ref("idle");
+  const store = useZenstackStore();
+  const config = getConfig();
+  const nuxtApp = useNuxtApp();
+  const watchedOptions = [opts.include].filter((option) => isRef(option) || typeof option === "function");
+  const method = "GET";
+  opts.fetchPolicy ??= config.fetchPolicy;
+  opts.immediate ??= true;
+  if (opts.fetchPolicy !== "fetch-only")
+    updateData();
+  watch(store.state, () => updateData());
+  watch(watchedOptions, () => refetch());
+  if (shouldFetchInitially())
+    await refetch();
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    const entry = store.fetchHistory.value.find((entry2) => entry2.model === model && entry2.id === id && entry2.method === method && entry2.query === JSON.stringify(getQuery()));
+    if (entry?.ssr && nuxtApp.isHydrating)
+      return false;
+    if (opts.fetchPolicy === "cache-first" && entry)
+      return false;
+    return true;
+  }
+  function updateData() {
+    data.value = store.getOne(model, id);
+  }
+  function getQuery() {
+    const json = stringify({
+      include: toValue(opts.include)
+    });
+    return { q: json };
+  }
+  async function refetch() {
+    if (opts.fetchPolicy === "cache-only")
+      return;
+    const _fetch = getFetch();
+    const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    const query = getQuery();
+    store.addToFetchHistory({
+      model: model.toString(),
+      id,
+      method,
+      query: JSON.stringify(query)
+    });
+    error.value = null;
+    status.value = "pending";
+    try {
+      const res = await _fetch(url, { method, query });
+      if (res.data)
+        store.setOne(model, res.data);
+      else
+        store.deleteOne(model, id);
+      updateData();
+      status.value = "success";
+    } catch (err) {
+      error.value = err.data;
+      status.value = "error";
+    }
+  }
+  return { data, error, status, refetch };
+}

package/dist/runtime/composables/useZenstackReadMany/index.d.ts

@@ -0,0 +1,50 @@
+import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy } from '#build/types/nuxt-zenstack';
+import type { Status, FetchPolicy } from '../common.js';
+import type { MaybeRefOrGetter, Ref } from '#imports';
+type Options<Zinclude, Zwhere, ZorderBy> = {
+    /**
+     * - `cache-first` means that the query will first try to fetch the data from the store. If the data is not found in the store, it will fetch the data from the server and update the store.
+     * - `cache-and-fetch` means that the query will first try to fetch the data from the cache. It will then fetch the data from the server and update the cache.
+     * - `fetch-only` means that the query will only fetch the data from the server. The data will be stored in the srore when the query is resolved.
+     * - `cache-only` means that the query will only fetch the data from the store.
+     * @default 'cache-first'
+     */
+    fetchPolicy?: FetchPolicy;
+    /**
+     * Whether to fetch the data immediately (when the composable is called).
+     * @default true
+     */
+    immediate?: boolean;
+    /**
+     * The relations to include in the query.
+     * @default undefined
+     */
+    include?: MaybeRefOrGetter<Zinclude>;
+    /**
+     * The filter to apply to the query.
+     * @default undefined
+     */
+    where?: MaybeRefOrGetter<Zwhere>;
+    /**
+     * The order to apply to the query.
+     * @default undefined
+     */
+    orderBy?: MaybeRefOrGetter<ZorderBy>;
+    /**
+     * The number of items to skip.
+     * @default 0
+     */
+    skip?: MaybeRefOrGetter<number>;
+    /**
+     * The number of items to take.
+     * @default 1000
+     */
+    take?: MaybeRefOrGetter<number>;
+};
+export declare function useZenstackReadMany<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>, Zitem extends $Zitem<Zmodel, Zinclude>, Zwhere extends $Zwhere<Zmodel>, ZorderBy extends $ZorderBy<Zmodel>>(model: Zmodel, opts?: Options<Zinclude, Zwhere, ZorderBy>): Promise<{
+    data: Ref<Zitem[] | null>;
+    error: Ref<Error | null>;
+    status: Ref<Status>;
+    refetch: () => Promise<void>;
+}>;
+export {};

package/dist/runtime/composables/useZenstackReadMany/index.js

@@ -0,0 +1,75 @@
+import { ref, toValue, watch, isRef, useNuxtApp } from "#imports";
+import { joinURL } from "ufo";
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { stringify } from "superjson";
+import { getConfig, getFetch } from "../common.js";
+export async function useZenstackReadMany(model, opts = {}) {
+  const data = ref(null);
+  const error = ref(null);
+  const status = ref("idle");
+  const store = useZenstackStore();
+  const config = getConfig();
+  const nuxtApp = useNuxtApp();
+  const watchedOptions = [opts.include, opts.where, opts.orderBy, opts.skip, opts.take].filter((option) => isRef(option) || typeof option === "function");
+  const method = "GET";
+  opts.fetchPolicy ??= config.fetchPolicy;
+  opts.immediate ??= true;
+  opts.skip ??= 0;
+  opts.take ??= 1e3;
+  if (opts.fetchPolicy !== "fetch-only")
+    updateData();
+  watch(store.state, () => updateData());
+  watch(watchedOptions, () => {
+    updateData();
+    refetch();
+  });
+  if (shouldFetchInitially())
+    await refetch();
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    const entry = store.fetchHistory.value.find((entry2) => entry2.model === model && entry2.method === method && entry2.query === JSON.stringify(getQuery()));
+    if (entry?.ssr && nuxtApp.isHydrating)
+      return false;
+    if (opts.fetchPolicy === "cache-first" && entry)
+      return false;
+    return true;
+  }
+  function updateData() {
+    data.value = store.getMany(model);
+  }
+  function getQuery() {
+    const json = stringify({
+      include: toValue(opts.include),
+      where: toValue(opts.where),
+      orderBy: toValue(opts.orderBy),
+      skip: toValue(opts.skip),
+      take: toValue(opts.take)
+    });
+    return { q: json };
+  }
+  async function refetch() {
+    if (opts.fetchPolicy === "cache-only")
+      return;
+    const _fetch = getFetch();
+    const url = joinURL(config.apiPath, `/models/${model.toString()}`);
+    const query = getQuery();
+    store.addToFetchHistory({
+      model: model.toString(),
+      method,
+      query: JSON.stringify(query)
+    });
+    error.value = null;
+    status.value = "pending";
+    try {
+      const res = await _fetch(url, { method, query });
+      store.setMany(model, res.data);
+      updateData();
+      status.value = "success";
+    } catch (err) {
+      error.value = err.data;
+      status.value = "error";
+    }
+  }
+  return { data, error, status, refetch };
+}

package/dist/runtime/composables/useZenstackStore/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { $Zmodel, $Zdef } from '#build/types/nuxt-zenstack';
+export declare function getModelDef(model: $Zmodel): $Zdef;
+export declare function isIdString(model: $Zmodel): boolean;
+export declare function getModels(): $Zmodel[];
+export declare function isValidModel(model: $Zmodel): boolean;

package/dist/runtime/composables/useZenstackStore/helpers.js

@@ -0,0 +1,16 @@
+import { zenstackSchema } from "#build/nuxt-zenstack.mjs";
+export function getModelDef(model) {
+  return zenstackSchema.models[model];
+}
+export function isIdString(model) {
+  const modelDef = getModelDef(model);
+  if (!modelDef.uniqueFields.id)
+    throw new Error(`Model ${model.toString()} does not have an id as a unique field`);
+  return modelDef.uniqueFields.id.type === "String";
+}
+export function getModels() {
+  return Object.keys(zenstackSchema.models);
+}
+export function isValidModel(model) {
+  return getModels().includes(model);
+}

package/dist/runtime/composables/useZenstackStore/index.d.ts

@@ -0,0 +1,46 @@
+import type { $Zmodel, $Zid } from '#build/types/nuxt-zenstack';
+type FetchEntry = {
+    model: string;
+    method: 'GET' | 'PATCH' | 'POST' | 'DELETE';
+    ssr: boolean;
+    timestamp: number;
+    id?: string | number;
+    query?: string;
+    body?: string;
+};
+export declare function useZenstackStore(): {
+    state: Readonly<import("vue").Ref<{
+        readonly [x: string]: {
+            readonly [x: string]: object;
+        };
+    }, {
+        readonly [x: string]: {
+            readonly [x: string]: object;
+        };
+    }>>;
+    fetchHistory: Readonly<import("vue").Ref<readonly {
+        readonly model: string;
+        readonly method: "GET" | "PATCH" | "POST" | "DELETE";
+        readonly ssr: boolean;
+        readonly timestamp: number;
+        readonly id?: string | number | undefined;
+        readonly query?: string | undefined;
+        readonly body?: string | undefined;
+    }[], readonly {
+        readonly model: string;
+        readonly method: "GET" | "PATCH" | "POST" | "DELETE";
+        readonly ssr: boolean;
+        readonly timestamp: number;
+        readonly id?: string | number | undefined;
+        readonly query?: string | undefined;
+        readonly body?: string | undefined;
+    }[]>>;
+    setOne: (model: $Zmodel, input: object) => void;
+    setMany: (model: $Zmodel, input: object[]) => void;
+    getOne: <Zmodel extends $Zmodel>(model: Zmodel, input: $Zid<Zmodel>) => any;
+    getMany: (model: $Zmodel) => any;
+    deleteOne: <Model extends $Zmodel>(model: Model, id: $Zid<Model>) => void;
+    deleteMany: (model: $Zmodel) => void;
+    addToFetchHistory: (entry: Omit<FetchEntry, "ssr" | "timestamp">) => void;
+};
+export {};

package/dist/runtime/composables/useZenstackStore/index.js

@@ -0,0 +1,71 @@
+import { generateNormalizrSchema, getNormalizrSchema } from "./normalization.js";
+import { normalize, denormalize } from "normalizr";
+import { defu } from "defu";
+import { readonly, useState } from "#imports";
+generateNormalizrSchema();
+export function useZenstackStore() {
+  const state = useState("zenstack-state", () => ({}));
+  const fetchHistory = useState("zenstack-fetch-history", () => []);
+  function setOne(model, input) {
+    const schema = getNormalizrSchema(model);
+    const res = normalize(input, schema);
+    state.value = defu(res.entities, state.value);
+  }
+  function setMany(model, input) {
+    const schema = [getNormalizrSchema(model)];
+    const res = normalize(input, schema);
+    state.value = defu(res.entities, state.value);
+  }
+  function getOne(model, input) {
+    const schema = getNormalizrSchema(model);
+    return denormalize(input, schema, state.value) ?? null;
+  }
+  function getMany(model) {
+    const input = Object.keys(state.value[model.toString()] ?? {});
+    const schema = [getNormalizrSchema(model)];
+    return denormalize(input, schema, state.value) ?? [];
+  }
+  function deleteOne(model, id) {
+    const newState = {};
+    for (const _model in state.value) {
+      for (const _id in state.value[_model]) {
+        if (_id == id && _model === model)
+          continue;
+        newState[_model] ||= {};
+        newState[_model][_id] = { ...state.value[_model][_id] };
+      }
+    }
+    state.value = newState;
+  }
+  function deleteMany(model) {
+    const newState = {};
+    for (const _model in state.value) {
+      if (_model === model)
+        continue;
+      newState[_model] = { ...state.value[_model] };
+    }
+    state.value = newState;
+  }
+  function addToFetchHistory(entry) {
+    fetchHistory.value.push({
+      method: entry.method,
+      model: entry.model,
+      body: entry.body,
+      id: entry.id,
+      query: entry.query,
+      ssr: typeof window === "undefined",
+      timestamp: (/* @__PURE__ */ new Date()).getTime()
+    });
+  }
+  return {
+    state: readonly(state),
+    fetchHistory: readonly(fetchHistory),
+    setOne,
+    setMany,
+    getOne,
+    getMany,
+    deleteOne,
+    deleteMany,
+    addToFetchHistory
+  };
+}

package/dist/runtime/composables/useZenstackStore/normalization.d.ts

@@ -0,0 +1,5 @@
+import { schema as normalizrSchema } from 'normalizr';
+import type { $Zmodel } from '#build/types/nuxt-zenstack';
+declare function getNormalizrSchema(model: $Zmodel): normalizrSchema.Entity<any>;
+declare function generateNormalizrSchema(): void;
+export { getNormalizrSchema, generateNormalizrSchema };

package/dist/runtime/composables/useZenstackStore/normalization.js

@@ -0,0 +1,31 @@
+import { schema as normalizrSchema } from "normalizr";
+import { getModelDef, getModels, isValidModel } from "./helpers.js";
+const NORMALIZR_SCHEMA = /* @__PURE__ */ new Map();
+function getNormalizrSchema(model) {
+  const schema = NORMALIZR_SCHEMA.get(model);
+  if (!schema)
+    throw new Error(`Model ${model.toString()} not defined`);
+  return schema;
+}
+function generateNormalizrSchema() {
+  const models = getModels();
+  for (const model of models) {
+    NORMALIZR_SCHEMA.set(model, new normalizrSchema.Entity(model.toString()));
+  }
+  for (const model of models) {
+    const entity = getNormalizrSchema(model);
+    const modelDef = getModelDef(model);
+    const definition = {};
+    for (const field of Object.values(modelDef.fields)) {
+      if (isValidModel(field.type)) {
+        const relatedModel = field.type;
+        const relatedEntity = getNormalizrSchema(relatedModel);
+        definition[field.name] = field.array ? [relatedEntity] : relatedEntity;
+      }
+    }
+    if (Object.keys(definition).length > 0) {
+      entity.define(definition);
+    }
+  }
+}
+export { getNormalizrSchema, generateNormalizrSchema };

package/dist/runtime/composables/useZenstackUpdate/index.d.ts

@@ -0,0 +1,10 @@
+import type { $Zmodel, $Zitem, $ZupdateData, $Zid } from '#build/types/nuxt-zenstack';
+import type { Status } from '../common.js';
+import type { Ref } from '#imports';
+export declare function useZenstackUpdate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
+    data: Ref<Zitem | null>;
+    error: Ref<Error | null>;
+    status: Ref<Status>;
+    mutate: (id: $Zid<Zmodel>, input: $ZupdateData<Zmodel>) => Promise<void>;
+    reset: () => void;
+};

package/dist/runtime/composables/useZenstackUpdate/index.js

@@ -0,0 +1,40 @@
+import { ref } from "#imports";
+import { joinURL } from "ufo";
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { getConfig, getFetch } from "../common.js";
+export function useZenstackUpdate(model) {
+  const data = ref(null);
+  const error = ref(null);
+  const status = ref("idle");
+  const store = useZenstackStore();
+  const config = getConfig();
+  function reset() {
+    data.value = null;
+    error.value = null;
+    status.value = "idle";
+  }
+  async function mutate(id, input) {
+    const _fetch = getFetch();
+    const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    const body = { data: input };
+    const method = "PATCH";
+    store.addToFetchHistory({
+      model: model.toString(),
+      method,
+      body: JSON.stringify(body)
+    });
+    reset();
+    status.value = "pending";
+    try {
+      const res = await _fetch(url, { method, body });
+      if (res.data)
+        store.setOne(model, res.data);
+      data.value = res.data;
+      status.value = "success";
+    } catch (err) {
+      error.value = err.data;
+      status.value = "error";
+    }
+  }
+  return { data, error, status, mutate, reset };
+}

package/dist/runtime/server/api/{[model] → models/[model]}/[id].delete.js

@@ -1,6 +1,6 @@
 import { defineEventHandler } from "h3";
-import { parseModel, parseId } from "../../utils/parsers.js";
-import { getModelOperations } from "../../utils/index.js";
+import { parseModel, parseId } from "../../../utils/parsers.js";
+import { getModelOperations } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const id = parseId(event, model);

package/dist/runtime/server/api/{[model] → models/[model]}/[id].get.js

@@ -1,6 +1,6 @@
-import { parseModel, parseId, parseReadArgs } from "../../utils/parsers.js";
+import { parseModel, parseId, parseReadArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../utils/index.js";
+import { getModelOperations } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const id = parseId(event, model);

package/dist/runtime/server/api/{[model] → models/[model]}/[id].patch.js

@@ -1,13 +1,15 @@
-import { parseModel, parseId, parseUpdateData } from "../../utils/parsers.js";
+import { parseModel, parseId, parseUpdateData } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../utils/index.js";
+import { getModelOperations, includeAll } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const id = parseId(event, model);
   const updateData = await parseUpdateData(event, model);
   const operations = getModelOperations(model);
+  const include = includeAll(model);
   const data = await operations.update({
     data: updateData.data,
+    include,
     where: {
       id
     }

package/dist/runtime/server/api/{[model] → models/[model]}/index.get.js

@@ -1,6 +1,6 @@
-import { parseModel, parseReadArgs } from "../../utils/parsers.js";
+import { parseModel, parseReadArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../utils/index.js";
+import { getModelOperations } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const readArgs = parseReadArgs(event, model);

package/dist/runtime/server/api/{[model] → models/[model]}/index.post.js

@@ -1,12 +1,14 @@
-import { parseModel, parseCreateData } from "../../utils/parsers.js";
+import { parseModel, parseCreateData } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../utils/index.js";
+import { getModelOperations, includeAll } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const createData = await parseCreateData(event, model);
   const operations = getModelOperations(model);
+  const include = includeAll(model);
   const data = await operations.create({
-    data: createData.data
+    data: createData.data,
+    include
   });
   return { data };
 });

package/dist/runtime/server/utils/index.d.ts

@@ -1,11 +1,12 @@
 import type { ClientContract } from '@zenstackhq/orm';
-import type { $Zschema, $Zmodel, $Zoperations } from '#build/types/nuxt-zenstack';
+import type { $Zschema, $Zmodel, $Zoperations, $Zdef } from '#build/types/nuxt-zenstack';
 declare let _client: ClientContract<$Zschema> | null;
 export declare function provideClient(client: typeof _client): void;
 export declare function getClient(): ClientContract<SchemaType>;
-export declare function getModelDef(model: $Zmodel): any;
+export declare function getModelOperations<Zmodel extends $Zmodel>(model: Zmodel): $Zoperations<Zmodel>;
+export declare function getModelDef(model: $Zmodel): $Zdef;
 export declare function isIdString(model: $Zmodel): boolean;
 export declare function getModels(): $Zmodel[];
 export declare function isValidModel(model: $Zmodel): boolean;
-export declare function getModelOperations<Zmodel extends $Zmodel>(model: Zmodel): $Zoperations<Zmodel>;
+export declare function includeAll<Zmodel extends $Zmodel>(model: Zmodel): boolean | import("@zenstackhq/orm").SelectIncludeOmit<SchemaType, any, boolean, true>;
 export {};

package/dist/runtime/server/utils/index.js

@@ -9,11 +9,18 @@ export function getClient() {
   }
   throw new Error("ZenStack client not provided");
 }
+export function getModelOperations(model) {
+  const db = getClient();
+  return db[model.toString().toLocaleLowerCase()];
+}
 export function getModelDef(model) {
   return zenstackSchema.models[model];
 }
 export function isIdString(model) {
-  return getModelDef(model).uniqueFields.id.type === "String";
+  const modelDef = getModelDef(model);
+  if (!modelDef.uniqueFields.id)
+    throw new Error(`Model ${model.toString()} does not have an id as a unique field`);
+  return modelDef.uniqueFields.id.type === "String";
 }
 export function getModels() {
   return Object.keys(zenstackSchema.models);
@@ -21,7 +28,21 @@ export function getModels() {
 export function isValidModel(model) {
   return getModels().includes(model);
 }
-export function getModelOperations(model) {
-  const db = getClient();
-  return db[model.toString().toLocaleLowerCase()];
+export function includeAll(model) {
+  const include = {};
+  const modelSet = /* @__PURE__ */ new Set();
+  function iterate(_model, acc) {
+    const modelDef = getModelDef(_model);
+    for (const [field, fieldDef] of Object.entries(modelDef.fields)) {
+      if (isValidModel(fieldDef.type) && !modelSet.has(fieldDef.type)) {
+        acc["include"] ||= {};
+        acc["include"][field] = {};
+        modelSet.add(fieldDef.type);
+        iterate(fieldDef.type, acc["include"][field]);
+      }
+    }
+  }
+  modelSet.add(model);
+  iterate(model, include);
+  return include["include"] ?? {};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "ZenStack integration for Nuxt",
   "repository": {
     "url": "https://github.com/becem-gharbi/nuxt-zenstack"
@@ -36,6 +36,7 @@
     "prepack": "nuxt-module-build build",
     "dev": "npm run dev:prepare && nuxt dev playground",
     "dev:build": "nuxt build playground",
+    "dev:preview": "nuxt preview playground",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
     "dev:db:generate": "cd playground && zen generate",
     "dev:db:push": "cd playground && zen db push",
@@ -52,6 +53,7 @@
     "@nuxt/kit": "^4.2.2",
     "@zenstackhq/orm": "3.2.1",
     "defu": "^6.1.4",
+    "normalizr": "^3.6.2",
     "superjson": "^2.2.6",
     "ufo": "^1.6.3"
   },
@@ -62,12 +64,14 @@
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "^4.2.2",
     "@nuxt/test-utils": "^3.23.0",
+    "@nuxt/ui": "^4.3.0",
     "@types/node": "latest",
     "@zenstackhq/cli": "3.2.1",
     "changelogen": "^0.6.2",
     "eslint": "^9.39.2",
     "libsql": "^0.5.22",
     "nuxt": "^4.2.2",
+    "playwright-core": "^1.57.0",
     "typescript": "~5.9.3",
     "vitest": "^4.0.17",
     "vue-tsc": "^3.2.2"