@bg-dev/nuxt-zenstack 0.0.7 → 0.0.8

package/dist/module.json

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

package/dist/module.mjs

@@ -3,7 +3,7 @@ import { joinURL } from 'ufo';
 import { defu } from 'defu';
 
 const name = "@bg-dev/nuxt-zenstack";
-const version = "0.0.7";
+const version = "0.0.8";
 
 const module$1 = defineNuxtModule({
   meta: {

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

@@ -3,4 +3,5 @@ export { useZenstackReadMany } from './useZenstackReadMany/index.js';
 export { useZenstackRead } from './useZenstackRead/index.js';
 export { useZenstackDelete } from './useZenstackDelete/index.js';
 export { useZenstackUpdate } from './useZenstackUpdate/index.js';
+export { useZenstackStore } from './useZenstackStore/index.js';
 export { provideFetch as provideZenstackFetch } from './common.js';

package/dist/runtime/composables/index.js

@@ -3,4 +3,5 @@ export { useZenstackReadMany } from "./useZenstackReadMany/index.js";
 export { useZenstackRead } from "./useZenstackRead/index.js";
 export { useZenstackDelete } from "./useZenstackDelete/index.js";
 export { useZenstackUpdate } from "./useZenstackUpdate/index.js";
+export { useZenstackStore } from "./useZenstackStore/index.js";
 export { provideFetch as provideZenstackFetch } from "./common.js";

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

@@ -5,7 +5,7 @@ type Options<Zinclude> = {
     /**
      * - `cache-first` means that the query will first try to fetch the data from the store. If the data is not found in the store, it will fetch the data from the server and update the store.
      * - `cache-and-fetch` means that the query will first try to fetch the data from the cache. It will then fetch the data from the server and update the cache.
-     * - `fetch-only` means that the query will only fetch the data from the server. The data will be stored in the srore when the query is resolved.
+     * - `fetch-only` means that the query will only fetch the data from the server. The data will be stored in the store when the query is resolved.
      * - `cache-only` means that the query will only fetch the data from the store.
      * @default 'cache-first'
      */

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

@@ -5,7 +5,7 @@ type Options<Zinclude, Zwhere, ZorderBy> = {
     /**
      * - `cache-first` means that the query will first try to fetch the data from the store. If the data is not found in the store, it will fetch the data from the server and update the store.
      * - `cache-and-fetch` means that the query will first try to fetch the data from the cache. It will then fetch the data from the server and update the cache.
-     * - `fetch-only` means that the query will only fetch the data from the server. The data will be stored in the srore when the query is resolved.
+     * - `fetch-only` means that the query will only fetch the data from the server. The data will be stored in the store when the query is resolved.
      * - `cache-only` means that the query will only fetch the data from the store.
      * @default 'cache-first'
      */
@@ -30,16 +30,11 @@ type Options<Zinclude, Zwhere, ZorderBy> = {
      * @default undefined
      */
     orderBy?: MaybeRefOrGetter<ZorderBy>;
-    /**
-     * The number of items to skip.
-     * @default 0
-     */
-    skip?: MaybeRefOrGetter<number>;
     /**
      * The number of items to take.
      * @default 1000
      */
-    take?: MaybeRefOrGetter<number>;
+    take?: number;
 };
 export declare function useZenstackReadMany<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>, Zitem extends $Zitem<Zmodel, Zinclude>, Zwhere extends $Zwhere<Zmodel>, ZorderBy extends $ZorderBy<Zmodel>>(model: Zmodel, opts?: Options<Zinclude, Zwhere, ZorderBy>): Promise<{
     data: Ref<Zitem[] | null>;
@@ -47,5 +42,6 @@ export declare function useZenstackReadMany<Zmodel extends $Zmodel, Zinclude ext
     status: Ref<Status>;
     canFetchMore: Ref<boolean>;
     refetch: () => Promise<void>;
+    fetchMore: () => Promise<void>;
 }>;
 export {};

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

@@ -10,19 +10,20 @@ export async function useZenstackReadMany(model, opts = {}) {
   const error = ref(null);
   const status = ref("idle");
   const canFetchMore = ref(true);
+  const skip = ref(0);
   const store = useZenstackStore();
   const config = getConfig();
   const nuxtApp = useNuxtApp();
-  const watchedOptions = [opts.where, opts.orderBy, opts.skip, opts.take].filter((option) => isRef(option) || typeof option === "function");
+  const watchedOptions = [opts.where, opts.orderBy].filter((option) => isRef(option) || typeof option === "function");
   const method = "GET";
   opts.fetchPolicy ??= config.fetchPolicy;
   opts.immediate ??= true;
-  opts.skip ??= 0;
   opts.take ??= 1e3;
   if (opts.fetchPolicy !== "fetch-only")
     updateData();
   watch(store.state, () => updateData());
   watch(watchedOptions, () => {
+    skip.value = 0;
     updateData();
     if (canFetchAutomatically())
       refetch();
@@ -53,11 +54,17 @@ export async function useZenstackReadMany(model, opts = {}) {
       include: opts.include,
       where: toValue(opts.where),
       orderBy: toValue(opts.orderBy),
-      skip: toValue(opts.skip),
-      take: toValue(opts.take)
+      skip: skip.value,
+      take: opts.take
     });
     return { q: json };
   }
+  async function fetchMore() {
+    if (canFetchMore.value) {
+      skip.value += opts.take;
+      await refetch();
+    }
+  }
   async function refetch() {
     if (opts.fetchPolicy === "cache-only")
       return;
@@ -84,5 +91,5 @@ export async function useZenstackReadMany(model, opts = {}) {
       canFetchMore.value = false;
     }
   }
-  return { data, error, status, canFetchMore, refetch };
+  return { data, error, status, canFetchMore, refetch, fetchMore };
 }

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

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

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

@@ -1,46 +1,55 @@
 import { useZenstackStore } from "../useZenstackStore/index.js";
-import { useZenstackRead } from "../useZenstackRead/index.js";
 import destr from "destr";
-import { joinURL } from "ufo";
+import { joinURL, withQuery } from "ufo";
 import { getConfig } from "../common.js";
 export function useZenstackRealtime() {
   const config = getConfig();
+  const store = useZenstackStore();
   const url = joinURL(config.baseUrl, config.apiPath, "realtime");
   const subscriptions = /* @__PURE__ */ new Set();
   let eventSource = null;
   function connect() {
+    if (!import.meta.client)
+      return;
     if (eventSource)
       return;
-    eventSource = new EventSource(url);
+    const urlWithQuery = withQuery(url, { subscriptions: Array.from(subscriptions).join(",") });
+    eventSource = new EventSource(urlWithQuery);
     eventSource.onmessage = (event) => {
-      const data = destr(event.data);
-      if (data)
-        onMessage(data);
+      const message = destr(event.data);
+      if (message)
+        onMessage(message);
     };
   }
-  async function onMessage(data) {
-    if (!subscriptions.has(data.model))
+  async function onMessage(message) {
+    if (!subscriptions.has(message.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" });
-      }
+    for (const item of message.items) {
+      if (message.action === "delete")
+        store.deleteOne(message.model, item.id);
+      else
+        store.setOne(message.model, item);
     }
   }
   function disconnect() {
+    if (!import.meta.client)
+      return;
     if (eventSource)
       eventSource.close();
     eventSource = null;
   }
   function subscribe(models) {
+    if (!import.meta.client)
+      return;
     for (const model of models)
       subscriptions.add(model);
+    disconnect();
     if (subscriptions.size > 0)
       connect();
   }
   function unsubscribe(models) {
+    if (!import.meta.client)
+      return;
     for (const model of models)
       subscriptions.delete(model);
     if (subscriptions.size === 0)

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

@@ -1,4 +1,5 @@
 import type { $Zmodel, $Zid } from '#build/types/nuxt-zenstack';
+import { denormalize } from 'normalizr';
 type FetchEntry = {
     model: string;
     method: 'GET' | 'PATCH' | 'POST' | 'DELETE';
@@ -12,13 +13,13 @@ export declare function useZenstackStore(): {
     state: Readonly<import("vue").Ref<{
         readonly [x: string]: {
             readonly [x: string]: {
-                readonly [x: string]: string | number | boolean | readonly string[] | null;
+                readonly [x: string]: string | number | boolean | object | readonly (string | number)[] | null;
             };
         };
     }, {
         readonly [x: string]: {
             readonly [x: string]: {
-                readonly [x: string]: string | number | boolean | readonly string[] | null;
+                readonly [x: string]: string | number | boolean | object | readonly (string | number)[] | null;
             };
         };
     }>>;
@@ -42,7 +43,7 @@ export declare function useZenstackStore(): {
     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;
+    getMany: (model: $Zmodel) => ReturnType<typeof denormalize>;
     deleteOne: <Model extends $Zmodel>(model: Model, id: $Zid<Model>) => void;
     deleteMany: (model: $Zmodel) => void;
     addToFetchHistory: (entry: Omit<FetchEntry, "ssr" | "timestamp">) => void;

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

@@ -1,4 +1,4 @@
-import { generateNormalizrSchema, getNormalizrSchema, mergeNormalizedData } from "./normalization.js";
+import { generateNormalizrSchema, getNormalizrSchema, linkNormalizedRelations, mergeNormalizedData, breakCircularReferences } from "./normalization.js";
 import { normalize, denormalize } from "normalizr";
 import { readonly, useState } from "#imports";
 generateNormalizrSchema();
@@ -8,21 +8,25 @@ export function useZenstackStore() {
   function setOne(model, input) {
     const schema = getNormalizrSchema(model);
     const res = normalize(input, schema);
-    state.value = mergeNormalizedData(res.entities, state.value);
+    state.value = linkNormalizedRelations(mergeNormalizedData(res.entities, state.value));
   }
   function setMany(model, input) {
     const schema = [getNormalizrSchema(model)];
     const res = normalize(input, schema);
-    state.value = mergeNormalizedData(res.entities, state.value);
+    state.value = linkNormalizedRelations(mergeNormalizedData(res.entities, state.value));
   }
   function getOne(model, input) {
     const schema = getNormalizrSchema(model);
-    return denormalize(input, schema, state.value) ?? null;
+    const denormalized = denormalize(input, schema, state.value);
+    if (!denormalized)
+      return null;
+    return breakCircularReferences(denormalized);
   }
   function getMany(model) {
     const input = Object.keys(state.value[model.toString()] ?? {});
     const schema = [getNormalizrSchema(model)];
-    return denormalize(input, schema, state.value) ?? [];
+    const denormalized = denormalize(input, schema, state.value) ?? [];
+    return breakCircularReferences(denormalized);
   }
   function deleteOne(model, id) {
     const newState = {};
@@ -52,8 +56,8 @@ export function useZenstackStore() {
       body: entry.body,
       id: entry.id,
       query: entry.query,
-      ssr: typeof window === "undefined",
-      timestamp: (/* @__PURE__ */ new Date()).getTime()
+      ssr: typeof globalThis.window === "undefined",
+      timestamp: Date.now()
     });
   }
   return {

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

@@ -1,6 +1,7 @@
 import { schema as normalizrSchema } from 'normalizr';
 import type { $Zmodel } from '#build/types/nuxt-zenstack';
-type NormalizedDataField = number | string | boolean | null | string[];
+type NormalizedId = string | number;
+type NormalizedDataField = number | string | boolean | null | object | NormalizedId[];
 /**
  * Normalized data structure
  * {
@@ -13,6 +14,34 @@ type NormalizedDataField = number | string | boolean | null | string[];
  */
 export type NormalizedData = Record<string, Record<string, Record<string, NormalizedDataField>>>;
 export declare function getNormalizrSchema(model: $Zmodel): normalizrSchema.Entity<any>;
-export declare function generateNormalizrSchema(): void;
+/**
+ * Breaks circular references in a denormalized object by replacing circular references with IDs.
+ * This prevents "Converting circular structure to JSON" errors.
+ *
+ * @param obj - The denormalized object that may contain circular references
+ * @param visited - Set of visited object references (used internally for recursion)
+ * @returns A new object with circular references replaced by IDs
+ */
+export declare function breakCircularReferences(obj: unknown, visited?: WeakSet<object>): unknown;
+export declare function generateNormalizrSchema(): Map<string, normalizrSchema.Entity<any>>;
 export declare function mergeNormalizedData(newData: NormalizedData, currentData: NormalizedData): NormalizedData;
+/**
+ * Ensures relations are linked bidirectionally in normalized state.
+ *
+ * Problem: Normalizr only updates relations that are present in the payload.
+ * When a payload contains only foreign keys (e.g., `authorId`) but not the
+ * relational field (e.g., `author`) or the opposite side (e.g., `User.posts`),
+ * relations remain unlinked.
+ *
+ * Solution: This function uses ZenStack schema metadata to automatically link
+ * both sides of relations based on foreign keys.
+ *
+ * Example:
+ * - User created without posts
+ * - Post created with only authorId="user123"
+ * - This function will:
+ *   1. Set Post.author = "user123" (from authorId)
+ *   2. Add "post456" to User.posts array
+ */
+export declare function linkNormalizedRelations(input: NormalizedData): NormalizedData;
 export {};

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

@@ -8,6 +8,29 @@ export function getNormalizrSchema(model) {
     throw new Error(`Model ${model.toString()} not defined`);
   return schema;
 }
+export function breakCircularReferences(obj, visited = /* @__PURE__ */ new WeakSet()) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => breakCircularReferences(item, visited));
+  }
+  if (visited.has(obj)) {
+    if (obj && typeof obj === "object" && "id" in obj) {
+      return { id: obj.id };
+    }
+    return null;
+  }
+  visited.add(obj);
+  try {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = breakCircularReferences(value, visited);
+    }
+    return result;
+  } finally {
+  }
+}
 export function generateNormalizrSchema() {
   const models = getModels();
   for (const model of models) {
@@ -28,17 +51,141 @@ export function generateNormalizrSchema() {
       entity.define(definition);
     }
   }
+  return NORMALIZR_SCHEMA;
 }
 export function mergeNormalizedData(newData, currentData) {
   const merged = defu(newData, currentData);
   for (const model in merged) {
-    for (const id in merged[model]) {
-      for (const field in merged[model][id]) {
-        if (Array.isArray(merged[model][id][field])) {
-          merged[model][id][field] = Array.from(new Set(merged[model][id][field]));
+    const modelEntities = merged[model];
+    if (!modelEntities)
+      continue;
+    for (const id in modelEntities) {
+      const entity = modelEntities[id];
+      if (!entity)
+        continue;
+      for (const field in entity) {
+        const value = entity[field];
+        if (Array.isArray(value)) {
+          entity[field] = Array.from(new Set(value));
+        } else if (typeof value === "object" && typeof newData[model]?.[id]?.[field] !== "undefined") {
+          entity[field] = newData[model]?.[id]?.[field];
         }
       }
     }
   }
   return merged;
 }
+function isIdValue(val) {
+  return typeof val === "string" || typeof val === "number";
+}
+function cloneNormalizedData(input) {
+  const cloned = {};
+  for (const modelName in input) {
+    const sourceModel = input[modelName];
+    if (!sourceModel)
+      continue;
+    cloned[modelName] = {};
+    const destModel = cloned[modelName];
+    if (!destModel)
+      continue;
+    for (const id in sourceModel) {
+      const entity = sourceModel[id];
+      if (entity)
+        destModel[id] = { ...entity };
+    }
+  }
+  return cloned;
+}
+function extractRelatedIds(entity, relationFieldName, isArrayRelation, foreignKeyFieldName) {
+  const relationValue = entity[relationFieldName];
+  if (isArrayRelation) {
+    if (Array.isArray(relationValue)) {
+      return relationValue.filter(isIdValue);
+    }
+    return [];
+  } else {
+    if (isIdValue(relationValue)) {
+      return [relationValue];
+    }
+    if (foreignKeyFieldName) {
+      const fkValue = entity[foreignKeyFieldName];
+      if (isIdValue(fkValue)) {
+        ;
+        entity[relationFieldName] = fkValue;
+        return [fkValue];
+      }
+    }
+    return [];
+  }
+}
+function updateOppositeRelation(relatedEntity, oppositeFieldName, isArrayRelation, sourceEntityId) {
+  const entity = relatedEntity;
+  if (isArrayRelation) {
+    const currentValue = relatedEntity[oppositeFieldName];
+    const existingIds = Array.isArray(currentValue) ? currentValue.filter(isIdValue) : [];
+    if (!existingIds.includes(sourceEntityId)) {
+      entity[oppositeFieldName] = [...existingIds, sourceEntityId];
+    }
+  } else {
+    const currentValue = relatedEntity[oppositeFieldName];
+    if (!isIdValue(currentValue)) {
+      entity[oppositeFieldName] = sourceEntityId;
+    }
+  }
+}
+export function linkNormalizedRelations(input) {
+  const linked = cloneNormalizedData(input);
+  const allModels = getModels();
+  for (const model of allModels) {
+    const modelName = model.toString();
+    const modelEntities = linked[modelName];
+    if (!modelEntities)
+      continue;
+    const modelDefinition = getModelDef(model);
+    for (const field of Object.values(modelDefinition.fields)) {
+      if (!isValidModel(field.type))
+        continue;
+      if (!field.relation?.opposite)
+        continue;
+      const relatedModel = field.type;
+      const relatedModelName = relatedModel.toString();
+      const relationFieldName = field.name;
+      const oppositeFieldName = field.relation.opposite;
+      const isArrayRelation = field.array ?? false;
+      const foreignKeyFields = field.relation.fields ?? [];
+      const foreignKeyFieldName = foreignKeyFields.length === 1 ? foreignKeyFields[0] : void 0;
+      const relatedModelDefinition = getModelDef(relatedModel);
+      const oppositeFieldDefinition = relatedModelDefinition.fields[oppositeFieldName];
+      if (!oppositeFieldDefinition)
+        continue;
+      const isOppositeArray = oppositeFieldDefinition.array ?? false;
+      for (const [entityId, entity] of Object.entries(modelEntities)) {
+        if (!entity)
+          continue;
+        const relatedIds = extractRelatedIds(
+          entity,
+          relationFieldName,
+          isArrayRelation,
+          foreignKeyFieldName
+        );
+        if (relatedIds.length === 0)
+          continue;
+        const relatedModelEntities = linked[relatedModelName];
+        if (!relatedModelEntities)
+          continue;
+        for (const relatedId of relatedIds) {
+          const relatedEntity = relatedModelEntities[String(relatedId)];
+          if (!relatedEntity)
+            continue;
+          updateOppositeRelation(
+            relatedEntity,
+            oppositeFieldName,
+            isOppositeArray,
+            entityId
+          );
+        }
+      }
+    }
+  }
+  return linked;
+}

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

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

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

@@ -1,6 +1,4 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    data: {
-        [x: string]: any;
-    } & {};
+    data: import("../../../../../../.nuxt/types/nuxt-zenstack.js").$Zitem<string, import("../../../../../../.nuxt/types/nuxt-zenstack.js").$Zinclude<string>>;
 }>>;
 export default _default;

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

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

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

@@ -1,6 +1,4 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    data: ({
-        [x: string]: any;
-    } & {})[];
+    data: import("../../../../../../.nuxt/types/nuxt-zenstack.js").$Zitem<string, import("../../../../../../.nuxt/types/nuxt-zenstack.js").$Zinclude<string>>[];
 }>>;
 export default _default;

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

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

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

@@ -1,19 +1,38 @@
-import { defineEventHandler, createEventStream } from "h3";
+import { defineEventHandler, createEventStream, getQuery } from "h3";
 import { useNitroApp } from "nitropack/runtime";
 import { getConfig } from "../utils/helpers.js";
+import { useZenstack } from "../utils/index.js";
 export default defineEventHandler(async (event) => {
   const eventStream = createEventStream(event);
   const nitroApp = useNitroApp();
   const config = getConfig();
-  nitroApp.hooks.hook("zenstack:publish", (action, model, items) => {
+  const zenstack = useZenstack();
+  const query = getQuery(event);
+  const subscriptions = query.subscriptions?.split(",") ?? [];
+  nitroApp.hooks.hook("zenstack:publish", async ({ action, model, items }) => {
+    if (!subscriptions.includes(model)) {
+      return;
+    }
     if (!config.expose[model]?.find((permission) => permission === "read")) {
       return;
     }
     const message = {
       model,
       action,
-      ids: items.map((item) => item.id)
+      items: []
     };
+    if (action === "delete") {
+      message.items = items.map((item) => ({ id: item.id }));
+    } else {
+      const allowedItemsPromises = items.map((item) => zenstack.findUnique({
+        client: event.context.zenstack.client,
+        model,
+        // @ts-expect-error id not known here
+        id: item.id
+      }));
+      const allowedItems = await Promise.all(allowedItemsPromises);
+      message.items = allowedItems.map((item) => item.data);
+    }
     eventStream.push(JSON.stringify(message));
   });
   eventStream.onClosed(async () => {

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

@@ -1,9 +1,14 @@
 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;
+export declare function getConfig(): {
+    expose: Partial<Record<$Zmodel, Array<"create" | "read" | "update" | "delete">>>;
+    apiPath: string;
+    fetchPolicy: import("../../types/index.js").FetchPolicy;
+    realtime: boolean;
+    baseUrl: string;
+};

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

@@ -35,5 +35,5 @@ export function sanitizeUpdateData(model, data) {
 }
 export function getConfig() {
   const config = useRuntimeConfig();
-  return config.zenstack;
+  return { ...config.public.zenstack, ...config.zenstack };
 }

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

@@ -3,7 +3,7 @@ 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, $Zmodel } from '#build/types/nuxt-zenstack';
+import type { $Zclient, RealtimeData } from '#build/types/nuxt-zenstack';
 import type { H3Event } from 'h3';
 export declare function useZenstack(): {
     delete: typeof _delete;
@@ -12,5 +12,5 @@ export declare function useZenstack(): {
     findMany: typeof findMany;
     create: typeof create;
     setSessionClient: (event: H3Event, client: $Zclient) => void;
-    publish: (action: "create" | "update" | "delete", model: $Zmodel, items: Record<string, unknown>[]) => Promise<any>;
+    publish: (args: RealtimeData) => Promise<any>;
 };

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

@@ -11,9 +11,9 @@ export function useZenstack() {
     else
       event.context.zenstack = { client };
   }
-  function publish(action, model, items) {
+  function publish(args) {
     const nitroApp = useNitroApp();
-    return nitroApp.hooks.callHook("zenstack:publish", action, model, items);
+    return nitroApp.hooks.callHook("zenstack:publish", args);
   }
   return { delete: _delete, update, findUnique, findMany, create, setSessionClient, publish };
 }

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

@@ -1,5 +1,5 @@
 import { getModelOperations, createError } from "./common.js";
-import { sanitizeCreateData } from "../helpers.js";
+import { sanitizeCreateData, getConfig } from "../helpers.js";
 import { useZenstack } from "../index.js";
 export async function create(args) {
   const operations = getModelOperations(args.client, args.model);
@@ -9,10 +9,11 @@ export async function create(args) {
   }).catch((err) => {
     throw createError(err);
   });
-  args.publish ??= true;
+  const config = getConfig();
+  args.publish ??= config.realtime;
   if (args.publish) {
     const zenstack = useZenstack();
-    await zenstack.publish("create", args.model, [data]);
+    await zenstack.publish({ action: "create", model: args.model, items: [data] });
   }
   return { data };
 }

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

@@ -1,5 +1,6 @@
 import { useZenstack } from "../index.js";
 import { getModelOperations, createError } from "./common.js";
+import { getConfig } from "../helpers.js";
 export async function _delete(args) {
   const operations = getModelOperations(args.client, args.model);
   const data = await operations.delete({
@@ -10,10 +11,11 @@ export async function _delete(args) {
   }).catch((err) => {
     throw createError(err);
   });
-  args.publish ??= true;
+  const config = getConfig();
+  args.publish ??= config.realtime;
   if (args.publish) {
     const zenstack = useZenstack();
-    await zenstack.publish("delete", args.model, [data]);
+    await zenstack.publish({ action: "delete", model: args.model, items: [data] });
   }
   return { data };
 }

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

@@ -1,5 +1,5 @@
 import { getModelOperations, createError } from "./common.js";
-import { sanitizeUpdateData } from "../helpers.js";
+import { sanitizeUpdateData, getConfig } from "../helpers.js";
 import { useZenstack } from "../index.js";
 export async function update(args) {
   const operations = getModelOperations(args.client, args.model);
@@ -13,10 +13,11 @@ export async function update(args) {
   }).catch((err) => {
     throw createError(err);
   });
-  args.publish ??= true;
+  const config = getConfig();
+  args.publish ??= config.realtime;
   if (args.publish) {
     const zenstack = useZenstack();
-    await zenstack.publish("update", args.model, [data]);
+    await zenstack.publish({ action: "update", model: args.model, items: [data] });
   }
   return { data };
 }

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

@@ -8,7 +8,7 @@ type ReadArgs<Zmodel extends $Zmodel> = {
     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 parseModel(event: H3Event): string;
 export declare function parseId(event: H3Event, model: $Zmodel): string | number;
 export declare function parseReadArgs<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): ReadArgs<Zmodel>;
 export declare function parseCreateArgs<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): Promise<{

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

@@ -1,18 +1,16 @@
-import type { ClientContract, ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs, ORMError, RejectedByPolicyReason, ORMErrorReason } from '@zenstackhq/orm'
+import type { ModelResult, ClientContract, ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, CreateArgs, UpdateArgs, ORMError, RejectedByPolicyReason, ORMErrorReason } from '@zenstackhq/orm'
 import type { SchemaType } from '~~/zenstack/schema'
-import type { ModelDef } from '@zenstackhq/orm/schema'
+import type { ModelDef, GetModels } 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 $Zmodel = GetModels<SchemaType>
 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 $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude = undefined> = ModelResult<SchemaType, Zmodel, { include: Zinclude }>
 export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel> | undefined
 export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy'] | undefined
 
@@ -39,14 +37,14 @@ declare module 'h3' {
   }
 }
 
-type RealtimeData = {
+interface RealtimeData<Zmodel extends $Zmodel = $Zmodel> {
   action: 'create' | 'update' | 'delete'
-  model: $Zmodel
-  ids: Array<number | string>
+  model: Zmodel
+  items: $Zitem<Zmodel>[]
 }
 
 declare module 'nitropack' {
   interface NitroRuntimeHooks {
-    'zenstack:publish': (action: 'create' | 'update' | 'delete', model: $Zmodel, items: Record<string, unknown>[]) => Promise<void> | void
+    'zenstack:publish': (args: RealtimeData) => Promise<void> | void
   }
 }

package/package.json

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