@bg-dev/nuxt-zenstack 0.0.2 → 0.0.3

package/dist/module.d.mts

@@ -1,7 +1,9 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { FetchPolicy } from '../dist/runtime/composables/common.js';
 
 interface ModuleOptions {
     apiPath: string;
+    fetchPolicy: FetchPolicy;
 }
 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.2",
+  "version": "0.0.3",
   "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.2";
+const version = "0.0.3";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -13,12 +13,14 @@ const module$1 = defineNuxtModule({
   },
   // Default configuration options of the Nuxt module
   defaults: {
-    apiPath: "/api/_zenstack"
+    apiPath: "/api/_zenstack",
+    fetchPolicy: "cache-first"
   },
   setup(_options, _nuxt) {
     _nuxt.options.runtimeConfig.public = defu(_nuxt.options.runtimeConfig.public, {
       zenstack: {
-        apiPath: _options.apiPath
+        apiPath: _options.apiPath,
+        fetchPolicy: _options.fetchPolicy
       }
     });
     const resolver = createResolver(import.meta.url);
@@ -54,10 +56,10 @@ 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>
-export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel> = never> = ItemGetPayload<Zmodel, { include: Zinclude }>
-export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel>
-export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy']
+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']
 `

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

@@ -10,4 +10,10 @@ export type Error = {
 };
 export declare function getConfig(): {
     apiPath: string;
+    fetchPolicy: FetchPolicy;
 };
+/**
+ * @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>;

package/dist/runtime/composables/common.js

@@ -3,3 +3,10 @@ export function getConfig() {
   const config = useRuntimeConfig();
   return config.public.zenstack;
 }
+let _fetch = $fetch;
+export function provideFetch(instance) {
+  _fetch = instance;
+}
+export function getFetch() {
+  return _fetch;
+}

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

@@ -3,3 +3,4 @@ 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 { provideFetch as provideZenstackFetch } from './common.js';

package/dist/runtime/composables/index.js

@@ -3,3 +3,4 @@ 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 { provideFetch as provideZenstackFetch } from "./common.js";

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

@@ -1,4 +1,4 @@
-import { getConfig } from "../common.js";
+import { getConfig, getFetch } from "../common.js";
 import { ref } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
@@ -14,17 +14,19 @@ export function useZenstackCreate(model) {
     status.value = "idle";
   }
   async function mutate(input) {
+    const _fetch = getFetch();
     const url = joinURL(config.apiPath, `/models/${model.toString()}`);
+    const method = "POST";
+    const body = { data: input };
+    store.addToFetchHistory({
+      model: model.toString(),
+      method,
+      body: JSON.stringify(body)
+    });
     reset();
     status.value = "pending";
     try {
-      const res = await $fetch(url, {
-        method: "POST",
-        body: {
-          data: input
-          // TODO: maybe include relations
-        }
-      });
+      const res = await _fetch(url, { method, body });
       if (res.data)
         store.setOne(model, res.data);
       data.value = res.data;

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

@@ -1,7 +1,7 @@
 import { ref } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
-import { getConfig } from "../common.js";
+import { getConfig, getFetch } from "../common.js";
 export function useZenstackDelete(model) {
   const data = ref(null);
   const error = ref(null);
@@ -14,13 +14,18 @@ export function useZenstackDelete(model) {
     status.value = "idle";
   }
   async function mutate(id) {
+    const _fetch = getFetch();
     const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    const method = "DELETE";
+    store.addToFetchHistory({
+      model: model.toString(),
+      id,
+      method
+    });
     reset();
     status.value = "pending";
     try {
-      const res = await $fetch(url, {
-        method: "DELETE"
-      });
+      const res = await _fetch(url, { method });
       store.deleteOne(model, id);
       data.value = res.data;
       status.value = "success";

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

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

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

@@ -1,57 +1,65 @@
-import { ref, toValue, watch, isRef } from "#imports";
+import { ref, toValue, watch, isRef, useNuxtApp } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
 import { stringify } from "superjson";
-import { getConfig } from "../common.js";
-export function useZenstackRead(model, id, opts = {}) {
+import { getConfig, getFetch } from "../common.js";
+export async function useZenstackRead(model, id, opts = {}) {
   const data = ref(null);
   const error = ref(null);
   const status = ref("idle");
   const store = useZenstackStore();
   const config = getConfig();
-  opts.fetchPolicy ??= "cache-first";
-  opts.immediate ??= true;
-  switch (opts.fetchPolicy) {
-    case "cache-first":
-      updateData();
-      if (data.value) opts.immediate = false;
-      break;
-    case "cache-and-fetch":
-      updateData();
-      break;
-    case "cache-only":
-      updateData();
-      opts.immediate = false;
-      break;
-  }
+  const nuxtApp = useNuxtApp();
   const watchedOptions = [opts.include].filter((option) => isRef(option) || typeof option === "function");
+  const method = "GET";
+  opts.fetchPolicy ??= config.fetchPolicy;
+  opts.immediate ??= true;
+  if (opts.fetchPolicy !== "fetch-only")
+    updateData();
   watch(store.state, () => updateData());
   watch(watchedOptions, () => refetch());
-  if (opts.immediate)
-    refetch();
+  if (shouldFetchInitially())
+    await refetch();
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    const entry = store.fetchHistory.value.find((entry2) => entry2.model === model && entry2.id === id && entry2.method === method && entry2.query === JSON.stringify(getQuery()));
+    if (entry?.ssr && nuxtApp.isHydrating)
+      return false;
+    if (opts.fetchPolicy === "cache-first" && entry)
+      return false;
+    return true;
+  }
   function updateData() {
     data.value = store.getOne(model, id);
   }
+  function getQuery() {
+    const json = stringify({
+      include: toValue(opts.include)
+    });
+    return { q: json };
+  }
   async function refetch() {
     if (opts.fetchPolicy === "cache-only")
       return;
+    const _fetch = getFetch();
     const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
-    const json = stringify({
-      include: toValue(opts.include)
+    const query = getQuery();
+    store.addToFetchHistory({
+      model: model.toString(),
+      id,
+      method,
+      query: JSON.stringify(query)
     });
     error.value = null;
     status.value = "pending";
     try {
-      const res = await $fetch(url, {
-        method: "GET",
-        query: {
-          q: json
-        }
-      });
+      const res = await _fetch(url, { method, query });
       if (res.data)
         store.setOne(model, res.data);
       else
         store.deleteOne(model, id);
+      updateData();
       status.value = "success";
     } catch (err) {
       error.value = err.data;

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

@@ -1,7 +1,7 @@
 import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy } from '#build/types/nuxt-zenstack';
 import type { Status, FetchPolicy } from '../common.js';
 import type { MaybeRefOrGetter, Ref } from '#imports';
-type Options<Zmodel extends $Zmodel> = {
+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.
@@ -19,17 +19,17 @@ type Options<Zmodel extends $Zmodel> = {
      * The relations to include in the query.
      * @default undefined
      */
-    include?: MaybeRefOrGetter<$Zinclude<Zmodel>>;
+    include?: MaybeRefOrGetter<Zinclude>;
     /**
      * The filter to apply to the query.
      * @default undefined
      */
-    where?: MaybeRefOrGetter<$Zwhere<Zmodel>>;
+    where?: MaybeRefOrGetter<Zwhere>;
     /**
      * The order to apply to the query.
      * @default undefined
      */
-    orderBy?: MaybeRefOrGetter<$ZorderBy<Zmodel>>;
+    orderBy?: MaybeRefOrGetter<ZorderBy>;
     /**
      * The number of items to skip.
      * @default 0
@@ -41,10 +41,10 @@ type Options<Zmodel extends $Zmodel> = {
      */
     take?: MaybeRefOrGetter<number>;
 };
-export declare function useZenstackReadMany<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel, opts?: Options<Zmodel>): {
+export declare function useZenstackReadMany<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>, Zitem extends $Zitem<Zmodel, Zinclude>, Zwhere extends $Zwhere<Zmodel>, ZorderBy extends $ZorderBy<Zmodel>>(model: Zmodel, opts?: Options<Zinclude, Zwhere, ZorderBy>): Promise<{
     data: Ref<Zitem[] | null>;
     error: Ref<Error | null>;
     status: Ref<Status>;
     refetch: () => Promise<void>;
-};
+}>;
 export {};

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

@@ -1,46 +1,44 @@
-import { ref, toValue, watch, isRef } from "#imports";
+import { ref, toValue, watch, isRef, useNuxtApp } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
 import { stringify } from "superjson";
-import { getConfig } from "../common.js";
-export function useZenstackReadMany(model, opts = {}) {
+import { getConfig, getFetch } from "../common.js";
+export async function useZenstackReadMany(model, opts = {}) {
   const data = ref(null);
   const error = ref(null);
   const status = ref("idle");
   const store = useZenstackStore();
   const config = getConfig();
-  opts.fetchPolicy ??= "cache-first";
+  const nuxtApp = useNuxtApp();
+  const watchedOptions = [opts.include, opts.where, opts.orderBy, opts.skip, opts.take].filter((option) => isRef(option) || typeof option === "function");
+  const method = "GET";
+  opts.fetchPolicy ??= config.fetchPolicy;
   opts.immediate ??= true;
   opts.skip ??= 0;
   opts.take ??= 1e3;
-  switch (opts.fetchPolicy) {
-    case "cache-first":
-      updateData();
-      if (data.value?.length) opts.immediate = false;
-      break;
-    case "cache-and-fetch":
-      updateData();
-      break;
-    case "cache-only":
-      updateData();
-      opts.immediate = false;
-      break;
-  }
-  const watchedOptions = [opts.include, opts.where, opts.orderBy, opts.skip, opts.take].filter((option) => isRef(option) || typeof option === "function");
+  if (opts.fetchPolicy !== "fetch-only")
+    updateData();
   watch(store.state, () => updateData());
   watch(watchedOptions, () => {
     updateData();
     refetch();
   });
-  if (opts.immediate)
-    refetch();
+  if (shouldFetchInitially())
+    await refetch();
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    const entry = store.fetchHistory.value.find((entry2) => entry2.model === model && entry2.method === method && entry2.query === JSON.stringify(getQuery()));
+    if (entry?.ssr && nuxtApp.isHydrating)
+      return false;
+    if (opts.fetchPolicy === "cache-first" && entry)
+      return false;
+    return true;
+  }
   function updateData() {
     data.value = store.getMany(model);
   }
-  async function refetch() {
-    if (opts.fetchPolicy === "cache-only")
-      return;
-    const url = joinURL(config.apiPath, `/models/${model.toString()}`);
+  function getQuery() {
     const json = stringify({
       include: toValue(opts.include),
       where: toValue(opts.where),
@@ -48,16 +46,25 @@ export function useZenstackReadMany(model, opts = {}) {
       skip: toValue(opts.skip),
       take: toValue(opts.take)
     });
+    return { q: json };
+  }
+  async function refetch() {
+    if (opts.fetchPolicy === "cache-only")
+      return;
+    const _fetch = getFetch();
+    const url = joinURL(config.apiPath, `/models/${model.toString()}`);
+    const query = getQuery();
+    store.addToFetchHistory({
+      model: model.toString(),
+      method,
+      query: JSON.stringify(query)
+    });
     error.value = null;
     status.value = "pending";
     try {
-      const res = await $fetch(url, {
-        method: "GET",
-        query: {
-          q: json
-        }
-      });
+      const res = await _fetch(url, { method, query });
       store.setMany(model, res.data);
+      updateData();
       status.value = "success";
     } catch (err) {
       error.value = err.data;

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

@@ -3,10 +3,10 @@ export function getModelDef(model) {
   return zenstackSchema.models[model];
 }
 export function isIdString(model) {
-  const def = getModelDef(model);
-  if (!def.uniqueFields.id)
-    throw new Error(`No id field for model ${model.toString()}`);
-  return def.uniqueFields.id.type === "String";
+  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);

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

@@ -1,4 +1,13 @@
 import type { $Zmodel, $Zid } from '#build/types/nuxt-zenstack';
+type FetchEntry = {
+    model: string;
+    method: 'GET' | 'PATCH' | 'POST' | 'DELETE';
+    ssr: boolean;
+    timestamp: number;
+    id?: string | number;
+    query?: string;
+    body?: string;
+};
 export declare function useZenstackStore(): {
     state: Readonly<import("vue").Ref<{
         readonly [x: string]: {
@@ -9,10 +18,29 @@ export declare function useZenstackStore(): {
             readonly [x: string]: object;
         };
     }>>;
+    fetchHistory: Readonly<import("vue").Ref<readonly {
+        readonly model: string;
+        readonly method: "GET" | "PATCH" | "POST" | "DELETE";
+        readonly ssr: boolean;
+        readonly timestamp: number;
+        readonly id?: string | number | undefined;
+        readonly query?: string | undefined;
+        readonly body?: string | undefined;
+    }[], readonly {
+        readonly model: string;
+        readonly method: "GET" | "PATCH" | "POST" | "DELETE";
+        readonly ssr: boolean;
+        readonly timestamp: number;
+        readonly id?: string | number | undefined;
+        readonly query?: string | undefined;
+        readonly body?: string | undefined;
+    }[]>>;
     setOne: (model: $Zmodel, input: object) => void;
     setMany: (model: $Zmodel, input: object[]) => void;
     getOne: <Zmodel extends $Zmodel>(model: Zmodel, input: $Zid<Zmodel>) => any;
     getMany: (model: $Zmodel) => any;
     deleteOne: <Model extends $Zmodel>(model: Model, id: $Zid<Model>) => void;
     deleteMany: (model: $Zmodel) => void;
+    addToFetchHistory: (entry: Omit<FetchEntry, "ssr" | "timestamp">) => void;
 };
+export {};

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

@@ -4,7 +4,8 @@ import { defu } from "defu";
 import { readonly, useState } from "#imports";
 generateNormalizrSchema();
 export function useZenstackStore() {
-  const state = useState("zenstack-store", () => ({}));
+  const state = useState("zenstack-state", () => ({}));
+  const fetchHistory = useState("zenstack-fetch-history", () => []);
   function setOne(model, input) {
     const schema = getNormalizrSchema(model);
     const res = normalize(input, schema);
@@ -45,5 +46,26 @@ export function useZenstackStore() {
     }
     state.value = newState;
   }
-  return { state: readonly(state), setOne, setMany, getOne, getMany, deleteOne, deleteMany };
+  function addToFetchHistory(entry) {
+    fetchHistory.value.push({
+      method: entry.method,
+      model: entry.model,
+      body: entry.body,
+      id: entry.id,
+      query: entry.query,
+      ssr: typeof window === "undefined",
+      timestamp: (/* @__PURE__ */ new Date()).getTime()
+    });
+  }
+  return {
+    state: readonly(state),
+    fetchHistory: readonly(fetchHistory),
+    setOne,
+    setMany,
+    getOne,
+    getMany,
+    deleteOne,
+    deleteMany,
+    addToFetchHistory
+  };
 }

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

@@ -1,7 +1,7 @@
 import { ref } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
-import { getConfig } from "../common.js";
+import { getConfig, getFetch } from "../common.js";
 export function useZenstackUpdate(model) {
   const data = ref(null);
   const error = ref(null);
@@ -14,17 +14,19 @@ export function useZenstackUpdate(model) {
     status.value = "idle";
   }
   async function mutate(id, input) {
+    const _fetch = getFetch();
     const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    const body = { data: input };
+    const method = "PATCH";
+    store.addToFetchHistory({
+      model: model.toString(),
+      method,
+      body: JSON.stringify(body)
+    });
     reset();
     status.value = "pending";
     try {
-      const res = await $fetch(url, {
-        method: "PATCH",
-        body: {
-          data: input
-          // TODO: maybe include relations
-        }
-      });
+      const res = await _fetch(url, { method, body });
       if (res.data)
         store.setOne(model, res.data);
       data.value = res.data;

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

@@ -1,13 +1,15 @@
 import { parseModel, parseId, parseUpdateData } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../../utils/index.js";
+import { getModelOperations, includeAll } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const id = parseId(event, model);
   const updateData = await parseUpdateData(event, model);
   const operations = getModelOperations(model);
+  const include = includeAll(model);
   const data = await operations.update({
     data: updateData.data,
+    include,
     where: {
       id
     }

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

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

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

@@ -1,11 +1,12 @@
 import type { ClientContract } from '@zenstackhq/orm';
-import type { $Zschema, $Zmodel, $Zoperations } from '#build/types/nuxt-zenstack';
+import type { $Zschema, $Zmodel, $Zoperations, $Zdef } from '#build/types/nuxt-zenstack';
 declare let _client: ClientContract<$Zschema> | null;
 export declare function provideClient(client: typeof _client): void;
 export declare function getClient(): ClientContract<SchemaType>;
 export declare function getModelOperations<Zmodel extends $Zmodel>(model: Zmodel): $Zoperations<Zmodel>;
-export declare function getModelDef(model: $Zmodel): any;
+export declare function getModelDef(model: $Zmodel): $Zdef;
 export declare function isIdString(model: $Zmodel): boolean;
 export declare function getModels(): $Zmodel[];
 export declare function isValidModel(model: $Zmodel): boolean;
+export declare function includeAll<Zmodel extends $Zmodel>(model: Zmodel): boolean | import("@zenstackhq/orm").SelectIncludeOmit<SchemaType, any, boolean, true>;
 export {};

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

@@ -17,7 +17,10 @@ export function getModelDef(model) {
   return zenstackSchema.models[model];
 }
 export function isIdString(model) {
-  return getModelDef(model).uniqueFields.id.type === "String";
+  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);
@@ -25,3 +28,21 @@ export function getModels() {
 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"] ?? {};
+}

package/package.json

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