@bg-dev/nuxt-zenstack 0.0.3 → 0.0.4

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "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, addImportsDir } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, 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.3";
+const version = "0.0.4";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -24,11 +24,6 @@ const module$1 = defineNuxtModule({
       }
     });
     const resolver = createResolver(import.meta.url);
-    addServerImports({
-      from: resolver.resolve("./runtime/server/utils"),
-      name: "provideClient",
-      as: "provideZenstackClient"
-    });
     addTemplate({
       write: true,
       filename: "nuxt-zenstack.mjs",
@@ -45,9 +40,11 @@ export { schema as zenstackSchema } from '~~/zenstack/schema'
     addTypeTemplate({
       filename: "types/nuxt-zenstack.d.ts",
       getContents: () => `
-import type { ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs } from '@zenstackhq/orm'
+import type { ClientContract, 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'
+import type { H3Error } from 'h3'
+import { ORMError, RejectedByPolicyReason, ORMErrorReason } from '@zenstackhq/orm'
 
 type ItemGetPayload<Zmodel extends $Zmodel, Args extends SelectIncludeOmit<SchemaType, Zmodel, true>, Options extends QueryOptions<SchemaType> = QueryOptions<SchemaType>> = SimplifiedPlainResult<SchemaType, Zmodel, Args, Options>
 
@@ -62,6 +59,22 @@ export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel> | u
 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 $ZormError = ORMError
+export type $Zerror = H3Error<{
+  ormErrorReason: ORMErrorReason
+  dbErrorCode?: unknown
+  dbErrorMessage?: string
+  model?: string
+  rejectedByPolicyReason?: RejectedByPolicyReason
+}>
+
+declare module 'h3' {
+  interface H3EventContext {
+    zenstack: {
+      client: ClientContract<SchemaType>
+    }
+  }
+}
 `
     });
     addServerHandler({

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

@@ -1,13 +1,5 @@
 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;

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

@@ -1,9 +1,9 @@
-import type { $Zmodel, $Zitem, $ZcreateData } from '#build/types/nuxt-zenstack';
-import type { Status, Error } from '../common.js';
+import type { $Zmodel, $Zitem, $ZcreateData, $Zerror } from '#build/types/nuxt-zenstack';
+import type { Status } 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>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     mutate: (input: $ZcreateData<Zmodel>) => Promise<void>;
     reset: () => void;

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

@@ -1,9 +1,9 @@
-import type { $Zmodel, $Zitem, $Zid } from '#build/types/nuxt-zenstack';
-import type { Status, Error } from '../common.js';
+import type { $Zmodel, $Zitem, $Zid, $Zerror } from '#build/types/nuxt-zenstack';
+import type { Status } 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>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     mutate: (id: $Zid<Zmodel>) => Promise<void>;
     reset: () => void;

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

@@ -1,6 +1,6 @@
-import type { $Zmodel, $Zitem, $Zid, $Zinclude } from '#build/types/nuxt-zenstack';
+import type { $Zmodel, $Zitem, $Zid, $Zinclude, $Zerror } from '#build/types/nuxt-zenstack';
 import type { Status, FetchPolicy } from '../common.js';
-import type { Ref, MaybeRefOrGetter } from '#imports';
+import type { Ref } 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.
@@ -19,11 +19,11 @@ type Options<Zinclude> = {
      * The relations to include in the query.
      * @default undefined
      */
-    include?: MaybeRefOrGetter<Zinclude>;
+    include?: 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>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     refetch: () => Promise<void>;
 }>;

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

@@ -1,4 +1,4 @@
-import { ref, toValue, watch, isRef, useNuxtApp } from "#imports";
+import { ref, watch, useNuxtApp } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
 import { stringify } from "superjson";
@@ -10,19 +10,15 @@ export async function useZenstackRead(model, id, opts = {}) {
   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;
+  function canFetchAutomatically() {
     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;
@@ -30,12 +26,17 @@ export async function useZenstackRead(model, id, opts = {}) {
       return false;
     return true;
   }
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    return canFetchAutomatically();
+  }
   function updateData() {
     data.value = store.getOne(model, id);
   }
   function getQuery() {
     const json = stringify({
-      include: toValue(opts.include)
+      include: opts.include
     });
     return { q: json };
   }

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

@@ -1,4 +1,4 @@
-import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy } from '#build/types/nuxt-zenstack';
+import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy, $Zerror } from '#build/types/nuxt-zenstack';
 import type { Status, FetchPolicy } from '../common.js';
 import type { MaybeRefOrGetter, Ref } from '#imports';
 type Options<Zinclude, Zwhere, ZorderBy> = {
@@ -19,7 +19,7 @@ type Options<Zinclude, Zwhere, ZorderBy> = {
      * The relations to include in the query.
      * @default undefined
      */
-    include?: MaybeRefOrGetter<Zinclude>;
+    include?: Zinclude;
     /**
      * The filter to apply to the query.
      * @default undefined
@@ -43,8 +43,9 @@ type Options<Zinclude, Zwhere, ZorderBy> = {
 };
 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>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
+    canFetchMore: Ref<boolean>;
     refetch: () => Promise<void>;
 }>;
 export {};

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

@@ -3,14 +3,17 @@ import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
 import { stringify } from "superjson";
 import { getConfig, getFetch } from "../common.js";
+import { sort } from "./orderBy.js";
+import { matchesWhere } from "./where.js";
 export async function useZenstackReadMany(model, opts = {}) {
   const data = ref(null);
   const error = ref(null);
   const status = ref("idle");
+  const canFetchMore = ref(true);
   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 watchedOptions = [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;
@@ -21,13 +24,12 @@ export async function useZenstackReadMany(model, opts = {}) {
   watch(store.state, () => updateData());
   watch(watchedOptions, () => {
     updateData();
-    refetch();
+    if (canFetchAutomatically())
+      refetch();
   });
   if (shouldFetchInitially())
     await refetch();
-  function shouldFetchInitially() {
-    if (opts.immediate === false)
-      return false;
+  function canFetchAutomatically() {
     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;
@@ -35,12 +37,20 @@ export async function useZenstackReadMany(model, opts = {}) {
       return false;
     return true;
   }
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    return canFetchAutomatically();
+  }
   function updateData() {
-    data.value = store.getMany(model);
+    const items = store.getMany(model);
+    const filteredItems = items.filter((el) => matchesWhere(el, toValue(opts.where)));
+    const orderedFilteredItems = sort(filteredItems, toValue(opts.orderBy));
+    data.value = orderedFilteredItems;
   }
   function getQuery() {
     const json = stringify({
-      include: toValue(opts.include),
+      include: opts.include,
       where: toValue(opts.where),
       orderBy: toValue(opts.orderBy),
       skip: toValue(opts.skip),
@@ -61,15 +71,18 @@ export async function useZenstackReadMany(model, opts = {}) {
     });
     error.value = null;
     status.value = "pending";
+    canFetchMore.value = false;
     try {
       const res = await _fetch(url, { method, query });
       store.setMany(model, res.data);
       updateData();
       status.value = "success";
+      canFetchMore.value = res.data.length === toValue(opts.take);
     } catch (err) {
       error.value = err.data;
       status.value = "error";
+      canFetchMore.value = true;
     }
   }
-  return { data, error, status, refetch };
+  return { data, error, status, canFetchMore, refetch };
 }

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

@@ -0,0 +1,5 @@
+import type { $Zitem, $ZorderBy, $Zinclude, $Zmodel } from '#build/types/nuxt-zenstack';
+/**
+ * @note Sort by relational fields not supported
+ */
+export declare function sort<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>, Zitem extends $Zitem<Zmodel, Zinclude>>(items: Zitem[], orderBy: $ZorderBy<Zmodel>): Zitem[];

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

@@ -0,0 +1,25 @@
+export function sort(items, orderBy) {
+  if (!items.length || !orderBy)
+    return items;
+  return items.sort((a, b) => {
+    const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+    for (const orderByObj of orderByArray) {
+      const orderByEntries = Object.entries(orderByObj);
+      for (const [field, direction] of orderByEntries) {
+        if (direction !== "asc" && direction !== "desc") continue;
+        const aValue = a[field];
+        const bValue = b[field];
+        if (aValue == null && bValue == null) continue;
+        if (aValue == null) return 1;
+        if (bValue == null) return -1;
+        let comparison = 0;
+        if (aValue < bValue) comparison = -1;
+        else if (aValue > bValue) comparison = 1;
+        if (comparison !== 0) {
+          return direction === "asc" ? comparison : -comparison;
+        }
+      }
+    }
+    return 0;
+  });
+}

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

@@ -0,0 +1,2 @@
+import type { $Zitem, $Zwhere, $Zinclude, $Zmodel } from '#build/types/nuxt-zenstack';
+export declare function matchesWhere<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>>(item: $Zitem<Zmodel, Zinclude>, where: $Zwhere<Zmodel>): boolean;

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

@@ -0,0 +1,235 @@
+export function matchesWhere(item, where) {
+  if (!where) return true;
+  if (!item) return false;
+  const itemRecord = item;
+  const whereRecord = where;
+  for (const key of Object.keys(whereRecord)) {
+    if (whereRecord[key] === void 0) continue;
+    const filter = whereRecord[key];
+    if (key === "AND") {
+      if (Array.isArray(filter)) {
+        if (!filter.every((cond) => matchesWhere(item, cond))) return false;
+      } else {
+        if (!matchesWhere(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "OR") {
+      if (Array.isArray(filter)) {
+        if (!filter.some((cond) => matchesWhere(item, cond))) return false;
+      } else {
+        if (!matchesWhere(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "NOT") {
+      if (Array.isArray(filter)) {
+        if (filter.some((cond) => matchesWhere(item, cond))) return false;
+      } else {
+        if (matchesWhere(item, filter)) return false;
+      }
+      continue;
+    }
+    const value = itemRecord[key];
+    if (!checkCondition(value, filter)) {
+      return false;
+    }
+  }
+  return true;
+}
+function checkCondition(value, filter) {
+  if (filter === null) {
+    return value === null;
+  }
+  if (filter === void 0) {
+    return true;
+  }
+  if (typeof filter !== "object" && typeof filter !== "function") {
+    if (value instanceof Date && typeof filter === "string") {
+      return value.toISOString() === filter;
+    }
+    return value === filter;
+  }
+  if (value instanceof Date && filter instanceof Date) {
+    return value.getTime() === filter.getTime();
+  }
+  const filterRecord = filter;
+  const keys = Object.keys(filterRecord);
+  if (keys.length === 0) return true;
+  let caseInsensitive = false;
+  if (filterRecord.mode === "insensitive") {
+    caseInsensitive = true;
+  }
+  for (const op of keys) {
+    if (op === "mode") continue;
+    let expected = filterRecord[op];
+    let actual = value;
+    if (["lt", "lte", "gt", "gte", "equals", "not"].includes(op)) {
+      if (actual instanceof Date && typeof expected === "string") {
+        const d = new Date(expected);
+        if (!Number.isNaN(d.getTime())) expected = d;
+      }
+    }
+    if (caseInsensitive && typeof actual === "string" && typeof expected === "string") {
+      if (["equals", "not", "contains", "startsWith", "endsWith"].includes(op)) {
+        actual = actual.toLowerCase();
+        expected = expected.toLowerCase();
+      }
+    }
+    switch (op) {
+      case "equals":
+        if (actual instanceof Date && expected instanceof Date) {
+          if (actual.getTime() !== expected.getTime()) return false;
+        } else if (actual !== expected) {
+          return false;
+        }
+        break;
+      case "not":
+        if (typeof expected === "object" && expected !== null && !Array.isArray(expected) && !(expected instanceof Date)) {
+          if (checkCondition(value, expected)) return false;
+        } else {
+          if (actual instanceof Date && expected instanceof Date) {
+            if (actual.getTime() === expected.getTime()) return false;
+          } else if (actual === expected) {
+            return false;
+          }
+        }
+        break;
+      case "in":
+        if (!Array.isArray(expected)) return false;
+        if (caseInsensitive && typeof actual === "string") {
+          const lowerVal = actual.toLowerCase();
+          const lowerList = expected.map((e) => typeof e === "string" ? e.toLowerCase() : e);
+          if (!lowerList.includes(lowerVal)) return false;
+        } else {
+          if (actual instanceof Date) {
+            const time = actual.getTime();
+            if (!expected.some((e) => e instanceof Date && e.getTime() === time || e === actual)) return false;
+          } else {
+            if (!expected.includes(actual)) return false;
+          }
+        }
+        break;
+      case "notIn":
+        if (!Array.isArray(expected)) return false;
+        if (caseInsensitive && typeof actual === "string") {
+          const lowerVal = actual.toLowerCase();
+          const lowerList = expected.map((e) => typeof e === "string" ? e.toLowerCase() : e);
+          if (lowerList.includes(lowerVal)) return false;
+        } else {
+          if (actual instanceof Date) {
+            const time = actual.getTime();
+            if (expected.some((e) => e instanceof Date && e.getTime() === time || e === actual)) return false;
+          } else {
+            if (expected.includes(actual)) return false;
+          }
+        }
+        break;
+      case "lt":
+        if (typeof actual === "number" && typeof expected === "number") {
+          if (!(actual < expected)) return false;
+        } else if (actual instanceof Date && expected instanceof Date) {
+          if (!(actual < expected)) return false;
+        } else if (typeof actual === "string" && typeof expected === "string") {
+          if (!(actual < expected)) return false;
+        } else {
+          if (!(actual < expected)) return false;
+        }
+        break;
+      case "lte":
+        if (!(actual <= expected)) return false;
+        break;
+      case "gt":
+        if (!(actual > expected)) return false;
+        break;
+      case "gte":
+        if (!(actual >= expected)) return false;
+        break;
+      case "contains":
+        if (typeof actual !== "string" || typeof expected !== "string" || !actual.includes(expected)) return false;
+        break;
+      case "startsWith":
+        if (typeof actual !== "string" || typeof expected !== "string" || !actual.startsWith(expected)) return false;
+        break;
+      case "endsWith":
+        if (typeof actual !== "string" || typeof expected !== "string" || !actual.endsWith(expected)) return false;
+        break;
+      // Relations
+      case "some":
+        if (!Array.isArray(value)) return false;
+        if (!value.some((v) => checkInternal(v, expected))) return false;
+        break;
+      case "every":
+        if (!Array.isArray(value)) return false;
+        if (!value.every((v) => checkInternal(v, expected))) return false;
+        break;
+      case "none":
+        if (!Array.isArray(value)) return false;
+        if (value.some((v) => checkInternal(v, expected))) return false;
+        break;
+      case "is":
+        if (expected === null) {
+          if (value != null) return false;
+        } else {
+          if (value == null) return false;
+          if (!checkInternal(value, expected)) return false;
+        }
+        break;
+      case "isNot":
+        if (expected === null) {
+          if (value == null) return false;
+        } else {
+          if (value == null) break;
+          if (checkInternal(value, expected)) return false;
+        }
+        break;
+      default:
+        if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+          if (!checkCondition(value[op], expected)) return false;
+        } else {
+          return false;
+        }
+    }
+  }
+  return true;
+}
+function checkInternal(item, where) {
+  return matchesWhereInternal(item, where);
+}
+function matchesWhereInternal(item, where) {
+  if (!where) return true;
+  if (!item) return false;
+  for (const key of Object.keys(where)) {
+    if (where[key] === void 0) continue;
+    const filter = where[key];
+    if (key === "AND") {
+      if (Array.isArray(filter)) {
+        if (!filter.every((cond) => matchesWhereInternal(item, cond))) return false;
+      } else {
+        if (!matchesWhereInternal(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "OR") {
+      if (Array.isArray(filter)) {
+        if (!filter.some((cond) => matchesWhereInternal(item, cond))) return false;
+      } else {
+        if (!matchesWhereInternal(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "NOT") {
+      if (Array.isArray(filter)) {
+        if (filter.some((cond) => matchesWhereInternal(item, cond))) return false;
+      } else {
+        if (matchesWhereInternal(item, filter)) return false;
+      }
+      continue;
+    }
+    const value = item[key];
+    if (!checkCondition(value, filter)) {
+      return false;
+    }
+  }
+  return true;
+}

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

@@ -11,11 +11,15 @@ type FetchEntry = {
 export declare function useZenstackStore(): {
     state: Readonly<import("vue").Ref<{
         readonly [x: string]: {
-            readonly [x: string]: object;
+            readonly [x: string]: {
+                readonly [x: string]: string | number | boolean | readonly string[] | null;
+            };
         };
     }, {
         readonly [x: string]: {
-            readonly [x: string]: object;
+            readonly [x: string]: {
+                readonly [x: string]: string | number | boolean | readonly string[] | null;
+            };
         };
     }>>;
     fetchHistory: Readonly<import("vue").Ref<readonly {

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

@@ -1,6 +1,5 @@
-import { generateNormalizrSchema, getNormalizrSchema } from "./normalization.js";
+import { generateNormalizrSchema, getNormalizrSchema, mergeNormalizedData } from "./normalization.js";
 import { normalize, denormalize } from "normalizr";
-import { defu } from "defu";
 import { readonly, useState } from "#imports";
 generateNormalizrSchema();
 export function useZenstackStore() {
@@ -9,12 +8,12 @@ export function useZenstackStore() {
   function setOne(model, input) {
     const schema = getNormalizrSchema(model);
     const res = normalize(input, schema);
-    state.value = defu(res.entities, state.value);
+    state.value = mergeNormalizedData(res.entities, state.value);
   }
   function setMany(model, input) {
     const schema = [getNormalizrSchema(model)];
     const res = normalize(input, schema);
-    state.value = defu(res.entities, state.value);
+    state.value = mergeNormalizedData(res.entities, state.value);
   }
   function getOne(model, input) {
     const schema = getNormalizrSchema(model);

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

@@ -1,5 +1,18 @@
 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 };
+type NormalizedDataField = number | string | boolean | null | string[];
+/**
+ * Normalized data structure
+ * {
+ *   model: {
+ *     id: {
+ *       field: NormalizedDataField
+ *     }
+ *   }
+ * }
+ */
+export type NormalizedData = Record<string, Record<string, Record<string, NormalizedDataField>>>;
+export declare function getNormalizrSchema(model: $Zmodel): normalizrSchema.Entity<any>;
+export declare function generateNormalizrSchema(): void;
+export declare function mergeNormalizedData(newData: NormalizedData, currentData: NormalizedData): NormalizedData;
+export {};

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

@@ -1,13 +1,14 @@
 import { schema as normalizrSchema } from "normalizr";
 import { getModelDef, getModels, isValidModel } from "./helpers.js";
+import { defu } from "defu";
 const NORMALIZR_SCHEMA = /* @__PURE__ */ new Map();
-function getNormalizrSchema(model) {
+export function getNormalizrSchema(model) {
   const schema = NORMALIZR_SCHEMA.get(model);
   if (!schema)
     throw new Error(`Model ${model.toString()} not defined`);
   return schema;
 }
-function generateNormalizrSchema() {
+export function generateNormalizrSchema() {
   const models = getModels();
   for (const model of models) {
     NORMALIZR_SCHEMA.set(model, new normalizrSchema.Entity(model.toString()));
@@ -28,4 +29,16 @@ function generateNormalizrSchema() {
     }
   }
 }
-export { getNormalizrSchema, generateNormalizrSchema };
+export function mergeNormalizedData(newData, currentData) {
+  const merged = defu(newData, currentData);
+  for (const model in merged) {
+    for (const id in merged[model]) {
+      for (const field in merged[model][id]) {
+        if (Array.isArray(merged[model][id][field])) {
+          merged[model][id][field] = Array.from(new Set(merged[model][id][field]));
+        }
+      }
+    }
+  }
+  return merged;
+}

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

@@ -1,9 +1,9 @@
-import type { $Zmodel, $Zitem, $ZupdateData, $Zid } from '#build/types/nuxt-zenstack';
+import type { $Zmodel, $Zitem, $ZupdateData, $Zid, $Zerror } 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>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     mutate: (id: $Zid<Zmodel>, input: $ZupdateData<Zmodel>) => Promise<void>;
     reset: () => void;

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

@@ -1,14 +1,17 @@
 import { defineEventHandler } from "h3";
 import { parseModel, parseId } from "../../../utils/parsers.js";
 import { getModelOperations } from "../../../utils/index.js";
+import { createError } from "../../../utils/error.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const id = parseId(event, model);
-  const operations = getModelOperations(model);
+  const operations = getModelOperations(event, model);
   const data = await operations.delete({
     where: {
       id
     }
+  }).catch((err) => {
+    throw createError(err);
   });
   return { data };
 });

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

@@ -1,16 +1,19 @@
 import { parseModel, parseId, parseReadArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
 import { getModelOperations } from "../../../utils/index.js";
+import { createError } from "../../../utils/error.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const id = parseId(event, model);
   const readArgs = parseReadArgs(event, model);
-  const operations = getModelOperations(model);
+  const operations = getModelOperations(event, model);
   const data = await operations.findUnique({
     include: readArgs.include,
     where: {
       id
     }
+  }).catch((err) => {
+    throw createError(err);
   });
   return { data };
 });

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

@@ -1,18 +1,21 @@
-import { parseModel, parseId, parseUpdateData } from "../../../utils/parsers.js";
+import { parseModel, parseId, parseUpdateArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
 import { getModelOperations, includeAll } from "../../../utils/index.js";
+import { createError } from "../../../utils/error.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 updateArgs = await parseUpdateArgs(event, model);
+  const operations = getModelOperations(event, model);
   const include = includeAll(model);
   const data = await operations.update({
-    data: updateData.data,
+    data: updateArgs.data,
     include,
     where: {
       id
     }
+  }).catch((err) => {
+    throw createError(err);
   });
   return { data };
 });

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

@@ -1,16 +1,19 @@
 import { parseModel, parseReadArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
 import { getModelOperations } from "../../../utils/index.js";
+import { createError } from "../../../utils/error.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const readArgs = parseReadArgs(event, model);
-  const operations = getModelOperations(model);
+  const operations = getModelOperations(event, model);
   const data = await operations.findMany({
     orderBy: readArgs.orderBy,
     include: readArgs.include,
     skip: readArgs.skip,
     take: readArgs.take,
     where: readArgs.where
+  }).catch((err) => {
+    throw createError(err);
   });
   return { data };
 });

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

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

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

@@ -0,0 +1,9 @@
+import type { $ZormError } from '#build/types/nuxt-zenstack';
+import { ORMErrorReason } from '@zenstackhq/orm';
+export declare function createError(ormError: $ZormError): import("h3").H3Error<{
+    ormErrorReason: ORMErrorReason;
+    dbErrorCode?: unknown;
+    dbErrorMessage?: string;
+    model?: string;
+    rejectedByPolicyReason?: import("@zenstackhq/orm").RejectedByPolicyReason;
+}>;

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

@@ -0,0 +1,49 @@
+import { ORMErrorReason } from "@zenstackhq/orm";
+import { createError as createH3Error } from "h3";
+export function createError(ormError) {
+  let statusCode = 500;
+  switch (ormError.reason) {
+    case ORMErrorReason.CONFIG_ERROR:
+      statusCode = 500;
+      break;
+    case ORMErrorReason.DB_QUERY_ERROR:
+      statusCode = 409;
+      break;
+    case ORMErrorReason.INTERNAL_ERROR:
+      statusCode = 500;
+      break;
+    case ORMErrorReason.NOT_FOUND:
+      statusCode = 404;
+      break;
+    case ORMErrorReason.INVALID_INPUT:
+      statusCode = 400;
+      break;
+    case ORMErrorReason.NOT_SUPPORTED:
+      statusCode = 501;
+      break;
+    case ORMErrorReason.REJECTED_BY_POLICY:
+      statusCode = 401;
+      break;
+    default:
+      statusCode = 500;
+  }
+  const error = {
+    name: "Zenstack Error",
+    cause: ormError.cause,
+    message: ormError.message,
+    statusCode,
+    statusMessage: ormError.reason,
+    stack: ormError.stack,
+    fatal: false,
+    unhandled: false,
+    toJSON: () => error,
+    data: {
+      ormErrorReason: ormError.reason,
+      dbErrorCode: ormError.dbErrorCode,
+      dbErrorMessage: ormError.dbErrorMessage,
+      model: ormError.model,
+      rejectedByPolicyReason: ormError.rejectedByPolicyReason
+    }
+  };
+  return createH3Error(error);
+}

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

@@ -1,12 +1,8 @@
-import type { ClientContract } from '@zenstackhq/orm';
-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 getModelOperations<Zmodel extends $Zmodel>(model: Zmodel): $Zoperations<Zmodel>;
+import type { $Zmodel, $Zoperations, $Zdef } from '#build/types/nuxt-zenstack';
+import type { H3Event } from 'h3';
+export declare function getModelOperations<Zmodel extends $Zmodel>(event: H3Event, 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 includeAll<Zmodel extends $Zmodel>(model: Zmodel): boolean | import("@zenstackhq/orm").SelectIncludeOmit<SchemaType, any, boolean, true>;
-export {};

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

@@ -1,16 +1,12 @@
 import { zenstackSchema } from "nuxt-zenstack-server.mjs";
-let _client = null;
-export function provideClient(client) {
-  _client = client;
-}
-export function getClient() {
-  if (_client) {
-    return _client;
+function getClient(event) {
+  if (event.context.zenstack?.client) {
+    return event.context.zenstack.client;
   }
   throw new Error("ZenStack client not provided");
 }
-export function getModelOperations(model) {
-  const db = getClient();
+export function getModelOperations(event, model) {
+  const db = getClient(event);
   return db[model.toString().toLocaleLowerCase()];
 }
 export function getModelDef(model) {

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

@@ -10,10 +10,10 @@ type ReadArgs<Zmodel extends $Zmodel> = {
 export declare function parseModel(event: H3Event): string | number | symbol;
 export declare function parseId(event: H3Event, model: $Zmodel): string | number;
 export declare function parseReadArgs<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): ReadArgs<Zmodel>;
-export declare function parseCreateData<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): Promise<{
+export declare function parseCreateArgs<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): Promise<{
     data: $ZcreateData<Zmodel>;
 }>;
-export declare function parseUpdateData<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): Promise<{
+export declare function parseUpdateArgs<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): Promise<{
     data: $ZupdateData<Zmodel>;
 }>;
 export {};

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

@@ -20,9 +20,9 @@ export function parseReadArgs(event, _model) {
   const query = getQuery(event);
   return query?.q ? parse(query.q) : {};
 }
-export async function parseCreateData(event, _model) {
+export async function parseCreateArgs(event, _model) {
   return readBody(event);
 }
-export async function parseUpdateData(event, _model) {
+export async function parseUpdateArgs(event, _model) {
   return readBody(event);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "ZenStack integration for Nuxt",
   "repository": {
     "url": "https://github.com/becem-gharbi/nuxt-zenstack"
@@ -66,7 +66,9 @@
     "@nuxt/test-utils": "^3.23.0",
     "@nuxt/ui": "^4.3.0",
     "@types/node": "latest",
+    "@vueuse/core": "^14.1.0",
     "@zenstackhq/cli": "3.2.1",
+    "@zenstackhq/plugin-policy": "^3.2.1",
     "changelogen": "^0.6.2",
     "eslint": "^9.39.2",
     "libsql": "^0.5.22",