@bg-dev/nuxt-zenstack 0.0.1 → 0.0.2

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "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.2";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -13,7 +13,7 @@ const module$1 = defineNuxtModule({
   },
   // Default configuration options of the Nuxt module
   defaults: {
-    apiPath: "/api/models"
+    apiPath: "/api/_zenstack"
   },
   setup(_options, _nuxt) {
     _nuxt.options.runtimeConfig.public = defu(_nuxt.options.runtimeConfig.public, {
@@ -25,7 +25,7 @@ const module$1 = defineNuxtModule({
     addServerImports({
       from: resolver.resolve("./runtime/server/utils"),
       name: "provideClient",
-      as: "provideZenStackClient"
+      as: "provideZenstackClient"
     });
     addTemplate({
       write: true,
@@ -45,9 +45,13 @@ 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>
@@ -56,29 +60,29 @@ export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel>
 export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy']
 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,13 @@
+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;
+};

package/dist/runtime/composables/common.js

@@ -0,0 +1,5 @@
+import { useRuntimeConfig } from "#imports";
+export function getConfig() {
+  const config = useRuntimeConfig();
+  return config.public.zenstack;
+}

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

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

package/dist/runtime/composables/index.js

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

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,38 @@
+import { getConfig } 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 url = joinURL(config.apiPath, `/models/${model.toString()}`);
+    reset();
+    status.value = "pending";
+    try {
+      const res = await $fetch(url, {
+        method: "POST",
+        body: {
+          data: input
+          // TODO: maybe include relations
+        }
+      });
+      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,33 @@
+import { ref } from "#imports";
+import { joinURL } from "ufo";
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { getConfig } 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 url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    reset();
+    status.value = "pending";
+    try {
+      const res = await $fetch(url, {
+        method: "DELETE"
+      });
+      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<Zmodel extends $Zmodel> = {
+    /**
+     * - `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<Zmodel>>;
+};
+export declare function useZenstackRead<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel, id: $Zid<Zmodel>, opts?: Options<Zmodel>): {
+    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,62 @@
+import { ref, toValue, watch, isRef } from "#imports";
+import { joinURL } from "ufo";
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { stringify } from "superjson";
+import { getConfig } from "../common.js";
+export function useZenstackRead(model, id, opts = {}) {
+  const data = ref(null);
+  const error = ref(null);
+  const status = ref("idle");
+  const store = useZenstackStore();
+  const config = getConfig();
+  opts.fetchPolicy ??= "cache-first";
+  opts.immediate ??= true;
+  switch (opts.fetchPolicy) {
+    case "cache-first":
+      updateData();
+      if (data.value) opts.immediate = false;
+      break;
+    case "cache-and-fetch":
+      updateData();
+      break;
+    case "cache-only":
+      updateData();
+      opts.immediate = false;
+      break;
+  }
+  const watchedOptions = [opts.include].filter((option) => isRef(option) || typeof option === "function");
+  watch(store.state, () => updateData());
+  watch(watchedOptions, () => refetch());
+  if (opts.immediate)
+    refetch();
+  function updateData() {
+    data.value = store.getOne(model, id);
+  }
+  async function refetch() {
+    if (opts.fetchPolicy === "cache-only")
+      return;
+    const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    const json = stringify({
+      include: toValue(opts.include)
+    });
+    error.value = null;
+    status.value = "pending";
+    try {
+      const res = await $fetch(url, {
+        method: "GET",
+        query: {
+          q: json
+        }
+      });
+      if (res.data)
+        store.setOne(model, res.data);
+      else
+        store.deleteOne(model, id);
+      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<Zmodel extends $Zmodel> = {
+    /**
+     * - `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<Zmodel>>;
+    /**
+     * The filter to apply to the query.
+     * @default undefined
+     */
+    where?: MaybeRefOrGetter<$Zwhere<Zmodel>>;
+    /**
+     * The order to apply to the query.
+     * @default undefined
+     */
+    orderBy?: MaybeRefOrGetter<$ZorderBy<Zmodel>>;
+    /**
+     * 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, Zitem extends $Zitem<Zmodel>>(model: Zmodel, opts?: Options<Zmodel>): {
+    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,68 @@
+import { ref, toValue, watch, isRef } from "#imports";
+import { joinURL } from "ufo";
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { stringify } from "superjson";
+import { getConfig } from "../common.js";
+export function useZenstackReadMany(model, opts = {}) {
+  const data = ref(null);
+  const error = ref(null);
+  const status = ref("idle");
+  const store = useZenstackStore();
+  const config = getConfig();
+  opts.fetchPolicy ??= "cache-first";
+  opts.immediate ??= true;
+  opts.skip ??= 0;
+  opts.take ??= 1e3;
+  switch (opts.fetchPolicy) {
+    case "cache-first":
+      updateData();
+      if (data.value?.length) opts.immediate = false;
+      break;
+    case "cache-and-fetch":
+      updateData();
+      break;
+    case "cache-only":
+      updateData();
+      opts.immediate = false;
+      break;
+  }
+  const watchedOptions = [opts.include, opts.where, opts.orderBy, opts.skip, opts.take].filter((option) => isRef(option) || typeof option === "function");
+  watch(store.state, () => updateData());
+  watch(watchedOptions, () => {
+    updateData();
+    refetch();
+  });
+  if (opts.immediate)
+    refetch();
+  function updateData() {
+    data.value = store.getMany(model);
+  }
+  async function refetch() {
+    if (opts.fetchPolicy === "cache-only")
+      return;
+    const url = joinURL(config.apiPath, `/models/${model.toString()}`);
+    const json = stringify({
+      include: toValue(opts.include),
+      where: toValue(opts.where),
+      orderBy: toValue(opts.orderBy),
+      skip: toValue(opts.skip),
+      take: toValue(opts.take)
+    });
+    error.value = null;
+    status.value = "pending";
+    try {
+      const res = await $fetch(url, {
+        method: "GET",
+        query: {
+          q: json
+        }
+      });
+      store.setMany(model, res.data);
+      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 def = getModelDef(model);
+  if (!def.uniqueFields.id)
+    throw new Error(`No id field for model ${model.toString()}`);
+  return def.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,18 @@
+import type { $Zmodel, $Zid } from '#build/types/nuxt-zenstack';
+export declare function useZenstackStore(): {
+    state: Readonly<import("vue").Ref<{
+        readonly [x: string]: {
+            readonly [x: string]: object;
+        };
+    }, {
+        readonly [x: string]: {
+            readonly [x: string]: object;
+        };
+    }>>;
+    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;
+};

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

@@ -0,0 +1,49 @@
+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-store", () => ({}));
+  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;
+  }
+  return { state: readonly(state), setOne, setMany, getOne, getMany, deleteOne, deleteMany };
+}

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,38 @@
+import { ref } from "#imports";
+import { joinURL } from "ufo";
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { getConfig } 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 url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    reset();
+    status.value = "pending";
+    try {
+      const res = await $fetch(url, {
+        method: "PATCH",
+        body: {
+          data: input
+          // TODO: maybe include relations
+        }
+      });
+      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,6 +1,6 @@
-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 } 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]}/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,6 +1,6 @@
-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 } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const createData = await parseCreateData(event, model);

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

@@ -3,9 +3,9 @@ import type { $Zschema, $Zmodel, $Zoperations } 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>;
 export declare function getModelDef(model: $Zmodel): any;
 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 {};

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

@@ -9,6 +9,10 @@ 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];
 }
@@ -21,7 +25,3 @@ export function getModels() {
 export function isValidModel(model) {
   return getModels().includes(model);
 }
-export function getModelOperations(model) {
-  const db = getClient();
-  return db[model.toString().toLocaleLowerCase()];
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "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"