@bg-dev/nuxt-zenstack 0.0.4 → 0.0.6

package/dist/module.d.mts

@@ -1,9 +1,7 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { FetchPolicy } from '../dist/runtime/composables/common.js';
+import { PublicModuleOptions, PrivateModuleOptions } from '../dist/runtime/types/index.js';
 
-interface ModuleOptions {
-    apiPath: string;
-    fetchPolicy: FetchPolicy;
+interface ModuleOptions extends PublicModuleOptions, PrivateModuleOptions {
 }
 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.6",
   "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.6";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -14,15 +14,24 @@ 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",
+    expose: {}
   },
   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
       }
     });
+    _nuxt.options.runtimeConfig.zenstack = {
+      expose: _options.expose,
+      ..._nuxt.options.runtimeConfig.zenstack ?? {}
+    };
     const resolver = createResolver(import.meta.url);
     addTemplate({
       write: true,
@@ -39,43 +48,7 @@ export { schema as zenstackSchema } from '~~/zenstack/schema'
     });
     addTypeTemplate({
       filename: "types/nuxt-zenstack.d.ts",
-      getContents: () => `
-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>
-
-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> | undefined
-export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude = undefined> = ItemGetPayload<Zmodel, { include: Zinclude }>
-export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel> | undefined
-export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy'] | undefined
-export type $ZcreateData<Zmodel extends $Zmodel> = CreateArgs<SchemaType, Zmodel>['data']
-export type $ZupdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel>['data']
-export type $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>
-    }
-  }
-}
-`
+      src: resolver.resolve("./runtime/types/template.d.ts")
     });
     addServerHandler({
       route: joinURL(_options.apiPath, "models/:model"),
@@ -98,6 +71,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,7 @@
-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;
-};
+import type { PublicModuleOptions } from '../types/index.js';
+export declare function getConfig(): PublicModuleOptions;
 /**
  * @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/useZenstackCreate/index.d.ts

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $ZcreateData, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status } from '../common.js';
+import type { Status } from '../../types/index.js';
 import { type Ref } from '#imports';
 export declare function useZenstackCreate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;

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

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $Zid, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status } from '../common.js';
+import type { Status } from '../../types/index.js';
 import { type Ref } from '#imports';
 export declare function useZenstackDelete<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;

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

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $Zid, $Zinclude, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status, FetchPolicy } from '../common.js';
+import type { Status, FetchPolicy } from '../../types/index.js';
 import type { Ref } from '#imports';
 type Options<Zinclude> = {
     /**

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

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status, FetchPolicy } from '../common.js';
+import type { Status, FetchPolicy } from '../../types/index.js';
 import type { MaybeRefOrGetter, Ref } from '#imports';
 type Options<Zinclude, Zwhere, ZorderBy> = {
     /**

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

@@ -81,7 +81,7 @@ export async function useZenstackReadMany(model, opts = {}) {
     } catch (err) {
       error.value = err.data;
       status.value = "error";
-      canFetchMore.value = true;
+      canFetchMore.value = false;
     }
   }
   return { data, error, status, canFetchMore, refetch };

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/composables/useZenstackUpdate/index.d.ts

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $ZupdateData, $Zid, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status } from '../common.js';
+import type { Status } from '../../types/index.js';
 import type { Ref } from '#imports';
 export declare function useZenstackUpdate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;

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,15 @@
-import { defineEventHandler } from "h3";
-import { parseModel, parseId } from "../../../utils/parsers.js";
-import { getModelOperations } from "../../../utils/index.js";
-import { createError } from "../../../utils/error.js";
+import { defineEventHandler, createError } from "h3";
+import { parseModel, parseId, parseClient } from "../../../utils/parsers.js";
+import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "delete")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(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,16 @@
-import { parseModel, parseId, parseReadArgs } from "../../../utils/parsers.js";
-import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../../utils/index.js";
-import { createError } from "../../../utils/error.js";
+import { parseModel, parseId, parseReadArgs, parseClient } from "../../../utils/parsers.js";
+import { defineEventHandler, createError } from "h3";
+import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "read")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(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,16 @@
-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";
+import { parseModel, parseId, parseUpdateArgs, parseClient } from "../../../utils/parsers.js";
+import { defineEventHandler, createError } from "h3";
+import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "update")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(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,23 @@
-import { parseModel, parseReadArgs } from "../../../utils/parsers.js";
-import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../../utils/index.js";
-import { createError } from "../../../utils/error.js";
+import { parseClient, parseModel, parseReadArgs } from "../../../utils/parsers.js";
+import { defineEventHandler, createError } from "h3";
+import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "read")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(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,15 @@
-import { parseModel, parseCreateArgs } from "../../../utils/parsers.js";
-import { defineEventHandler } from "h3";
-import { getModelOperations, includeAll } from "../../../utils/index.js";
-import { createError } from "../../../utils/error.js";
+import { parseModel, parseCreateArgs, parseClient } from "../../../utils/parsers.js";
+import { defineEventHandler, createError } from "h3";
+import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "create")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(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,23 @@
+import { defineEventHandler, createEventStream } from "h3";
+import { useNitroApp } from "nitropack/runtime";
+import { getConfig } from "../utils/helpers.js";
+export default defineEventHandler(async (event) => {
+  const eventStream = createEventStream(event);
+  const nitroApp = useNitroApp();
+  const config = getConfig();
+  nitroApp.hooks.hook("zenstack:after_mutation", (action, model, items) => {
+    if (!config.expose[model]?.find((permission) => permission === "read")) {
+      return;
+    }
+    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,9 @@
+import type { $Zmodel, $Zdef, $ZcreateData, $ZupdateData } from '#build/types/nuxt-zenstack';
+import type { PrivateModuleOptions } from '../../types/index.js';
+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>;
+export declare function getConfig(): PrivateModuleOptions;

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

@@ -0,0 +1,39 @@
+import { zenstackSchema } from "nuxt-zenstack-server.mjs";
+import { useRuntimeConfig } from "#imports";
+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;
+}
+export function getConfig() {
+  const config = useRuntimeConfig();
+  return config.zenstack;
+}

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/dist/runtime/types/index.d.ts

@@ -0,0 +1,12 @@
+import type { $Zmodel } from '#build/types/nuxt-zenstack';
+export type Status = 'idle' | 'pending' | 'success' | 'error';
+export type FetchPolicy = 'cache-first' | 'fetch-only' | 'cache-only' | 'cache-and-fetch';
+export interface PublicModuleOptions {
+    apiPath: string;
+    fetchPolicy: FetchPolicy;
+    realtime: boolean;
+    baseUrl: string;
+}
+export interface PrivateModuleOptions {
+    expose: Partial<Record<$Zmodel, Array<'create' | 'read' | 'update' | 'delete'>>>;
+}

package/dist/runtime/types/template.d.ts

@@ -0,0 +1,52 @@
+import type { ClientContract, ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs, ORMError, RejectedByPolicyReason, ORMErrorReason } from '@zenstackhq/orm'
+import type { SchemaType } from '~~/zenstack/schema'
+import type { ModelDef } from '@zenstackhq/orm/schema'
+import type { H3Error } from 'h3'
+
+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>
+export type $Zid<Zmodel extends $Zmodel> = ModelResult<SchemaType, Zmodel> extends { id: infer Id } ? Id : never
+export type $Zinclude<Zmodel extends $Zmodel> = IncludeInput<SchemaType, Zmodel> | undefined
+export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude = undefined> = ItemGetPayload<Zmodel, { include: Zinclude }>
+export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel> | undefined
+export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy'] | undefined
+
+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
+  dbErrorCode?: unknown
+  dbErrorMessage?: string
+  model?: string
+  rejectedByPolicyReason?: RejectedByPolicyReason
+}>
+
+declare module 'h3' {
+  interface H3EventContext {
+    zenstack: {
+      client: ClientContract<SchemaType>
+    }
+  }
+}
+
+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
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "ZenStack integration for Nuxt",
   "repository": {
     "url": "https://github.com/becem-gharbi/nuxt-zenstack"
@@ -42,7 +42,7 @@
     "dev:db:push": "cd playground && zen db push",
     "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
     "lint": "eslint .",
-    "test": "vitest run",
+    "test": "vitest run --no-file-parallelism",
     "test:watch": "vitest watch",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
     "test:db:push": "cd test/fixtures/basic && zen db push",
@@ -73,7 +73,7 @@
     "eslint": "^9.39.2",
     "libsql": "^0.5.22",
     "nuxt": "^4.2.2",
-    "playwright-core": "^1.57.0",
+    "playwright-core": "^1.58.0",
     "typescript": "~5.9.3",
     "vitest": "^4.0.17",
     "vue-tsc": "^3.2.2"