@bg-dev/nuxt-zenstack 0.0.4 → 0.0.5

package/dist/module.d.mts

@@ -4,6 +4,8 @@ import { FetchPolicy } from '../dist/runtime/composables/common.js';
 interface ModuleOptions {
     apiPath: string;
     fetchPolicy: FetchPolicy;
+    realtime: boolean;
+    baseUrl: string;
 }
 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.4",
+  "version": "0.0.5",
   "configKey": "zenstack",
   "builder": {
     "@nuxt/module-builder": "1.0.2",

package/dist/module.mjs

@@ -1,9 +1,9 @@
-import { defineNuxtModule, createResolver, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler, addImportsDir } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler, addImportsDir, addServerImports, addImports } from '@nuxt/kit';
 import { joinURL } from 'ufo';
 import { defu } from 'defu';
 
 const name = "@bg-dev/nuxt-zenstack";
-const version = "0.0.4";
+const version = "0.0.5";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -14,13 +14,17 @@ const module$1 = defineNuxtModule({
   // Default configuration options of the Nuxt module
   defaults: {
     apiPath: "/api/_zenstack",
-    fetchPolicy: "cache-first"
+    fetchPolicy: "cache-first",
+    realtime: false,
+    baseUrl: "http://localhost:3000"
   },
   setup(_options, _nuxt) {
     _nuxt.options.runtimeConfig.public = defu(_nuxt.options.runtimeConfig.public, {
       zenstack: {
         apiPath: _options.apiPath,
-        fetchPolicy: _options.fetchPolicy
+        fetchPolicy: _options.fetchPolicy,
+        realtime: _options.realtime,
+        baseUrl: _options.baseUrl
       }
     });
     const resolver = createResolver(import.meta.url);
@@ -49,6 +53,7 @@ import { ORMError, RejectedByPolicyReason, ORMErrorReason } from '@zenstackhq/or
 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 $Zclient = ClientContract<SchemaType>
 export type $Zmodel = keyof SchemaType['models']
 export type $Zdef = ModelDef
 export type $Zoperations<Zmodel extends $Zmodel> = ModelOperations<SchemaType, Zmodel>
@@ -57,8 +62,13 @@ export type $Zinclude<Zmodel extends $Zmodel> = IncludeInput<SchemaType, Zmodel>
 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']
+
+type NonRelationalFields<Zmodel extends $Zmodel> = keyof $Zitem<Zmodel>
+type CreateData<Zmodel extends $Zmodel> = CreateArgs<SchemaType, Zmodel>['data']
+type UpdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel>['data']
+
+export type $ZcreateData<Zmodel extends $Zmodel> = Pick<CreateData<Zmodel>, NonRelationalFields<Zmodel>>
+export type $ZupdateData<Zmodel extends $Zmodel> = Pick<UpdateData<Zmodel>, NonRelationalFields<Zmodel>>
 export type $ZormError = ORMError
 export type $Zerror = H3Error<{
   ormErrorReason: ORMErrorReason
@@ -75,6 +85,18 @@ declare module 'h3' {
     }
   }
 }
+
+type RealtimeData = {
+  action: 'create' | 'update' | 'delete'
+  model: $Zmodel
+  ids: Array<number | string>
+}
+
+declare module 'nitropack' {
+  interface NitroRuntimeHooks {
+    'zenstack:after_mutation': (action: 'create' | 'update' | 'delete', model: $Zmodel, items: Record<string, unknown>[]) => Promise<void> | void
+  }
+}
 `
     });
     addServerHandler({
@@ -98,6 +120,20 @@ declare module 'h3' {
       handler: resolver.resolve("./runtime/server/api/models/[model]/[id].get")
     });
     addImportsDir(resolver.resolve("./runtime/composables"));
+    addServerImports({
+      from: resolver.resolve("./runtime/server/utils"),
+      name: "useZenstack"
+    });
+    if (_options.realtime) {
+      addServerHandler({
+        route: joinURL(_options.apiPath, "realtime"),
+        handler: resolver.resolve("./runtime/server/routes/realtime")
+      });
+      addImports({
+        from: resolver.resolve("./runtime/composables/useZenstackRealtime"),
+        name: "useZenstackRealtime"
+      });
+    }
   }
 });
 

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

@@ -1,11 +1,9 @@
+import type { ModuleOptions } from '../../module.js';
 export type Status = 'idle' | 'pending' | 'success' | 'error';
 export type FetchPolicy = 'cache-first' | 'fetch-only' | 'cache-only' | 'cache-and-fetch';
-export declare function getConfig(): {
-    apiPath: string;
-    fetchPolicy: FetchPolicy;
-};
+export declare function getConfig(): ModuleOptions;
 /**
  * @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>;
+export declare function getFetch(): import("nitropack").$Fetch<unknown, import("nitropack").NitroFetchRequest>;

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

@@ -0,0 +1,6 @@
+import type { $Zmodel } from '#build/types/nuxt-zenstack';
+export declare function useZenstackRealtime(): {
+    subscribe: (models: $Zmodel[]) => void;
+    unsubscribe: (models: $Zmodel[]) => void;
+    getSubscriptions: () => (string | number | symbol)[];
+};

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

@@ -0,0 +1,53 @@
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { useZenstackRead } from "../useZenstackRead/index.js";
+import destr from "destr";
+import { joinURL } from "ufo";
+import { getConfig } from "../common.js";
+export function useZenstackRealtime() {
+  const config = getConfig();
+  const url = joinURL(config.baseUrl, config.apiPath, "realtime");
+  const subscriptions = /* @__PURE__ */ new Set();
+  let eventSource = null;
+  function connect() {
+    if (eventSource)
+      return;
+    eventSource = new EventSource(url);
+    eventSource.onmessage = (event) => {
+      const data = destr(event.data);
+      if (data)
+        onMessage(data);
+    };
+  }
+  async function onMessage(data) {
+    if (!subscriptions.has(data.model))
+      return;
+    for (const id of data.ids) {
+      if (data.action === "delete") {
+        useZenstackStore().deleteOne(data.model, id);
+      } else {
+        await useZenstackRead(data.model, id, { fetchPolicy: "fetch-only" });
+      }
+    }
+  }
+  function disconnect() {
+    if (eventSource)
+      eventSource.close();
+    eventSource = null;
+  }
+  function subscribe(models) {
+    for (const model of models)
+      subscriptions.add(model);
+    if (subscriptions.size > 0)
+      connect();
+  }
+  function unsubscribe(models) {
+    for (const model of models)
+      subscriptions.delete(model);
+    if (subscriptions.size === 0)
+      disconnect();
+  }
+  function getSubscriptions() {
+    return Array.from(subscriptions);
+  }
+  return { subscribe, unsubscribe, getSubscriptions };
+}

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

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     data: {
         [x: string]: any;
-    };
+    } & {};
 }>>;
 export default _default;

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

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

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

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     data: {
         [x: string]: any;
-    } | null;
+    } & {};
 }>>;
 export default _default;

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

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

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

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     data: {
         [x: string]: any;
-    };
+    } & {};
 }>>;
 export default _default;

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

@@ -1,21 +1,11 @@
-import { parseModel, parseId, parseUpdateArgs } from "../../../utils/parsers.js";
+import { parseModel, parseId, parseUpdateArgs, parseClient } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations, includeAll } from "../../../utils/index.js";
-import { createError } from "../../../utils/error.js";
+import { useZenstack } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
+  const client = parseClient(event);
   const model = parseModel(event);
   const id = parseId(event, model);
   const updateArgs = await parseUpdateArgs(event, model);
-  const operations = getModelOperations(event, model);
-  const include = includeAll(model);
-  const data = await operations.update({
-    data: updateArgs.data,
-    include,
-    where: {
-      id
-    }
-  }).catch((err) => {
-    throw createError(err);
-  });
-  return { data };
+  const zenstack = useZenstack();
+  return zenstack.update({ client, model, id, data: updateArgs.data });
 });

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

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    data: {
+    data: ({
         [x: string]: any;
-    }[];
+    } & {})[];
 }>>;
 export default _default;

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

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

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

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     data: {
         [x: string]: any;
-    };
+    } & {};
 }>>;
 export default _default;

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

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

package/dist/runtime/server/routes/realtime.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/routes/realtime.js

@@ -0,0 +1,18 @@
+import { defineEventHandler, createEventStream } from "h3";
+import { useNitroApp } from "nitropack/runtime";
+export default defineEventHandler(async (event) => {
+  const eventStream = createEventStream(event);
+  const nitroApp = useNitroApp();
+  nitroApp.hooks.hook("zenstack:after_mutation", (action, model, items) => {
+    const message = {
+      model,
+      action,
+      ids: items.map((item) => item.id)
+    };
+    eventStream.push(JSON.stringify(message));
+  });
+  eventStream.onClosed(async () => {
+    await eventStream.close();
+  });
+  return eventStream.send();
+});

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

@@ -0,0 +1,7 @@
+import type { $Zmodel, $Zdef, $ZcreateData, $ZupdateData } 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;
+export declare function sanitizeCreateData<Zmodel extends $Zmodel>(model: Zmodel, data: $ZcreateData<Zmodel>): $ZcreateData<Zmodel>;
+export declare function sanitizeUpdateData<Zmodel extends $Zmodel>(model: Zmodel, data: $ZupdateData<Zmodel>): $ZupdateData<Zmodel>;

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

@@ -0,0 +1,34 @@
+import { zenstackSchema } from "nuxt-zenstack-server.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);
+}
+function getRelationalFields(model) {
+  const modelDef = getModelDef(model);
+  return Object.entries(modelDef.fields).filter(([_field, fieldDef]) => isValidModel(fieldDef.type)).map(([field]) => field);
+}
+export function sanitizeCreateData(model, data) {
+  const relationalFields = getRelationalFields(model);
+  relationalFields.forEach((field) => {
+    data[field] = void 0;
+  });
+  return data;
+}
+export function sanitizeUpdateData(model, data) {
+  const relationalFields = getRelationalFields(model);
+  relationalFields.forEach((field) => {
+    data[field] = void 0;
+  });
+  return data;
+}

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

@@ -1,8 +1,15 @@
-import type { $Zmodel, $Zoperations, $Zdef } from '#build/types/nuxt-zenstack';
+import { _delete } from './operations/delete.js';
+import { update } from './operations/update.js';
+import { findUnique } from './operations/findUnique.js';
+import { findMany } from './operations/findMany.js';
+import { create } from './operations/create.js';
+import type { $Zclient } 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 declare function useZenstack(): {
+    delete: typeof _delete;
+    update: typeof update;
+    findUnique: typeof findUnique;
+    findMany: typeof findMany;
+    create: typeof create;
+    setSessionClient: (event: H3Event, client: $Zclient) => void;
+};

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

@@ -1,44 +1,14 @@
-import { zenstackSchema } from "nuxt-zenstack-server.mjs";
-function getClient(event) {
-  if (event.context.zenstack?.client) {
-    return event.context.zenstack.client;
+import { _delete } from "./operations/delete.js";
+import { update } from "./operations/update.js";
+import { findUnique } from "./operations/findUnique.js";
+import { findMany } from "./operations/findMany.js";
+import { create } from "./operations/create.js";
+export function useZenstack() {
+  function setSessionClient(event, client) {
+    if (event.context.zenstack)
+      event.context.zenstack.client = client;
+    else
+      event.context.zenstack = { client };
   }
-  throw new Error("ZenStack client not provided");
-}
-export function getModelOperations(event, model) {
-  const db = getClient(event);
-  return db[model.toString().toLocaleLowerCase()];
-}
-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);
-}
-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"] ?? {};
+  return { delete: _delete, update, findUnique, findMany, create, setSessionClient };
 }

package/dist/runtime/server/utils/{error.d.ts → operations/common.d.ts}

@@ -1,4 +1,4 @@
-import type { $ZormError } from '#build/types/nuxt-zenstack';
+import type { $Zmodel, $Zoperations, $Zclient, $ZormError } from '#build/types/nuxt-zenstack';
 import { ORMErrorReason } from '@zenstackhq/orm';
 export declare function createError(ormError: $ZormError): import("h3").H3Error<{
     ormErrorReason: ORMErrorReason;
@@ -7,3 +7,4 @@ export declare function createError(ormError: $ZormError): import("h3").H3Error<
     model?: string;
     rejectedByPolicyReason?: import("@zenstackhq/orm").RejectedByPolicyReason;
 }>;
+export declare function getModelOperations<Zmodel extends $Zmodel>(client: $Zclient, model: Zmodel): $Zoperations<Zmodel>;

package/dist/runtime/server/utils/{error.js → operations/common.js}

@@ -47,3 +47,6 @@ export function createError(ormError) {
   };
   return createH3Error(error);
 }
+export function getModelOperations(client, model) {
+  return client[model.toString().toLocaleLowerCase()];
+}

package/dist/runtime/server/utils/operations/create.d.ts

@@ -0,0 +1,10 @@
+import type { $Zclient, $Zmodel, $ZcreateData, $Zitem } from '#build/types/nuxt-zenstack';
+type CreateArgs<Zmodel extends $Zmodel> = {
+    client: $Zclient;
+    model: Zmodel;
+    data: $ZcreateData<Zmodel>;
+};
+export declare function create<Zmodel extends $Zmodel>(args: CreateArgs<Zmodel>): Promise<{
+    data: $Zitem<Zmodel>;
+}>;
+export {};

package/dist/runtime/server/utils/operations/create.js

@@ -0,0 +1,15 @@
+import { getModelOperations, createError } from "./common.js";
+import { sanitizeCreateData } from "../helpers.js";
+import { useNitroApp } from "nitropack/runtime";
+export async function create(args) {
+  const operations = getModelOperations(args.client, args.model);
+  const sanitizedData = sanitizeCreateData(args.model, args.data);
+  const data = await operations.create({
+    data: sanitizedData
+  }).catch((err) => {
+    throw createError(err);
+  });
+  const nitroApp = useNitroApp();
+  await nitroApp.hooks.callHook("zenstack:after_mutation", "create", args.model, [data]);
+  return { data };
+}

package/dist/runtime/server/utils/operations/delete.d.ts

@@ -0,0 +1,10 @@
+import type { $Zclient, $Zmodel, $Zid, $Zitem } from '#build/types/nuxt-zenstack';
+type DeleteArgs<Zmodel extends $Zmodel> = {
+    client: $Zclient;
+    model: Zmodel;
+    id: $Zid<Zmodel>;
+};
+export declare function _delete<Zmodel extends $Zmodel>(args: DeleteArgs<Zmodel>): Promise<{
+    data: $Zitem<Zmodel>;
+}>;
+export {};

package/dist/runtime/server/utils/operations/delete.js

@@ -0,0 +1,16 @@
+import { getModelOperations, createError } from "./common.js";
+import { useNitroApp } from "nitropack/runtime";
+export async function _delete(args) {
+  const operations = getModelOperations(args.client, args.model);
+  const data = await operations.delete({
+    // @ts-expect-error id not known here
+    where: {
+      id: args.id
+    }
+  }).catch((err) => {
+    throw createError(err);
+  });
+  const nitroApp = useNitroApp();
+  await nitroApp.hooks.callHook("zenstack:after_mutation", "delete", args.model, [data]);
+  return { data };
+}

package/dist/runtime/server/utils/operations/findMany.d.ts

@@ -0,0 +1,14 @@
+import type { $Zclient, $Zmodel, $Zinclude, $ZorderBy, $Zwhere, $Zitem } from '#build/types/nuxt-zenstack';
+type FindManyArgs<Zmodel extends $Zmodel> = {
+    client: $Zclient;
+    model: Zmodel;
+    include?: $Zinclude<Zmodel>;
+    orderBy?: $ZorderBy<Zmodel>;
+    where?: $Zwhere<Zmodel>;
+    skip?: number;
+    take?: number;
+};
+export declare function findMany<Zmodel extends $Zmodel>(args: FindManyArgs<Zmodel>): Promise<{
+    data: $Zitem<Zmodel, $Zinclude<Zmodel>>[];
+}>;
+export {};

package/dist/runtime/server/utils/operations/findMany.js

@@ -0,0 +1,14 @@
+import { getModelOperations, createError } from "./common.js";
+export async function findMany(args) {
+  const operations = getModelOperations(args.client, args.model);
+  const data = await operations.findMany({
+    orderBy: args.orderBy,
+    include: args.include,
+    skip: args.skip,
+    take: args.take,
+    where: args.where
+  }).catch((err) => {
+    throw createError(err);
+  });
+  return { data };
+}

package/dist/runtime/server/utils/operations/findUnique.d.ts

@@ -0,0 +1,11 @@
+import type { $Zclient, $Zmodel, $Zinclude, $Zid, $Zitem } from '#build/types/nuxt-zenstack';
+type FindUniqueArgs<Zmodel extends $Zmodel> = {
+    client: $Zclient;
+    model: Zmodel;
+    id: $Zid<Zmodel>;
+    include?: $Zinclude<Zmodel>;
+};
+export declare function findUnique<Zmodel extends $Zmodel>(args: FindUniqueArgs<Zmodel>): Promise<{
+    data: $Zitem<Zmodel, $Zinclude<Zmodel>>;
+}>;
+export {};

package/dist/runtime/server/utils/operations/findUnique.js

@@ -0,0 +1,14 @@
+import { getModelOperations, createError } from "./common.js";
+export async function findUnique(args) {
+  const operations = getModelOperations(args.client, args.model);
+  const data = await operations.findUnique({
+    include: args.include,
+    // @ts-expect-error id not known here
+    where: {
+      id: args.id
+    }
+  }).catch((err) => {
+    throw createError(err);
+  });
+  return { data };
+}

package/dist/runtime/server/utils/operations/update.d.ts

@@ -0,0 +1,11 @@
+import type { $Zclient, $Zmodel, $Zid, $ZupdateData, $Zitem } from '#build/types/nuxt-zenstack';
+type UpdateArgs<Zmodel extends $Zmodel> = {
+    client: $Zclient;
+    model: Zmodel;
+    id: $Zid<Zmodel>;
+    data: $ZupdateData<Zmodel>;
+};
+export declare function update<Zmodel extends $Zmodel>(args: UpdateArgs<Zmodel>): Promise<{
+    data: $Zitem<Zmodel>;
+}>;
+export {};

package/dist/runtime/server/utils/operations/update.js

@@ -0,0 +1,19 @@
+import { getModelOperations, createError } from "./common.js";
+import { sanitizeUpdateData } from "../helpers.js";
+import { useNitroApp } from "nitropack/runtime";
+export async function update(args) {
+  const operations = getModelOperations(args.client, args.model);
+  const sanitizedData = sanitizeUpdateData(args.model, args.data);
+  const data = await operations.update({
+    data: sanitizedData,
+    // @ts-expect-error id not known here
+    where: {
+      id: args.id
+    }
+  }).catch((err) => {
+    throw createError(err);
+  });
+  const nitroApp = useNitroApp();
+  await nitroApp.hooks.callHook("zenstack:after_mutation", "update", args.model, [data]);
+  return { data };
+}

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

@@ -7,6 +7,7 @@ type ReadArgs<Zmodel extends $Zmodel> = {
     skip?: number;
     take?: number;
 };
+export declare function parseClient(event: H3Event): import("@zenstackhq/orm").ClientContract<SchemaType>;
 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>;

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

@@ -1,6 +1,12 @@
 import { getRouterParam, createError, getQuery, readBody } from "h3";
-import { isValidModel, isIdString } from "./index.js";
+import { isValidModel, isIdString } from "./helpers.js";
 import { parse } from "superjson";
+export function parseClient(event) {
+  if (event.context.zenstack?.client) {
+    return event.context.zenstack.client;
+  }
+  throw new Error("ZenStack client not provided");
+}
 export function parseModel(event) {
   const model = getRouterParam(event, "model");
   if (isValidModel(model) === false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "ZenStack integration for Nuxt",
   "repository": {
     "url": "https://github.com/becem-gharbi/nuxt-zenstack"