@bg-dev/nuxt-zenstack 0.0.3 → 0.0.5

package/dist/module.d.mts

@@ -4,6 +4,8 @@ import { FetchPolicy } from '../dist/runtime/composables/common.js';
 interface ModuleOptions {
     apiPath: string;
     fetchPolicy: FetchPolicy;
+    realtime: boolean;
+    baseUrl: string;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/module.json

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

package/dist/module.mjs

@@ -1,9 +1,9 @@
-import { defineNuxtModule, createResolver, addServerImports, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler, 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.3";
+const version = "0.0.5";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -14,21 +14,20 @@ const module$1 = defineNuxtModule({
   // Default configuration options of the Nuxt module
   defaults: {
     apiPath: "/api/_zenstack",
-    fetchPolicy: "cache-first"
+    fetchPolicy: "cache-first",
+    realtime: false,
+    baseUrl: "http://localhost:3000"
   },
   setup(_options, _nuxt) {
     _nuxt.options.runtimeConfig.public = defu(_nuxt.options.runtimeConfig.public, {
       zenstack: {
         apiPath: _options.apiPath,
-        fetchPolicy: _options.fetchPolicy
+        fetchPolicy: _options.fetchPolicy,
+        realtime: _options.realtime,
+        baseUrl: _options.baseUrl
       }
     });
     const resolver = createResolver(import.meta.url);
-    addServerImports({
-      from: resolver.resolve("./runtime/server/utils"),
-      name: "provideClient",
-      as: "provideZenstackClient"
-    });
     addTemplate({
       write: true,
       filename: "nuxt-zenstack.mjs",
@@ -45,13 +44,16 @@ export { schema as zenstackSchema } from '~~/zenstack/schema'
     addTypeTemplate({
       filename: "types/nuxt-zenstack.d.ts",
       getContents: () => `
-import type { ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs } from '@zenstackhq/orm'
+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 $Zclient = ClientContract<SchemaType>
 export type $Zmodel = keyof SchemaType['models']
 export type $Zdef = ModelDef
 export type $Zoperations<Zmodel extends $Zmodel> = ModelOperations<SchemaType, Zmodel>
@@ -60,8 +62,41 @@ export type $Zinclude<Zmodel extends $Zmodel> = IncludeInput<SchemaType, Zmodel>
 export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude = undefined> = ItemGetPayload<Zmodel, { include: Zinclude }>
 export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel> | undefined
 export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy'] | undefined
-export type $ZcreateData<Zmodel extends $Zmodel> = CreateArgs<SchemaType, Zmodel>['data']
-export type $ZupdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel>['data']
+
+type NonRelationalFields<Zmodel extends $Zmodel> = keyof $Zitem<Zmodel>
+type CreateData<Zmodel extends $Zmodel> = CreateArgs<SchemaType, Zmodel>['data']
+type UpdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel>['data']
+
+export type $ZcreateData<Zmodel extends $Zmodel> = Pick<CreateData<Zmodel>, NonRelationalFields<Zmodel>>
+export type $ZupdateData<Zmodel extends $Zmodel> = Pick<UpdateData<Zmodel>, NonRelationalFields<Zmodel>>
+export type $ZormError = ORMError
+export type $Zerror = H3Error<{
+  ormErrorReason: ORMErrorReason
+  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
+  }
+}
 `
     });
     addServerHandler({
@@ -85,6 +120,20 @@ export type $ZupdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel
       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,19 +1,9 @@
+import type { ModuleOptions } from '../../module.js';
 export type Status = 'idle' | 'pending' | 'success' | 'error';
 export type FetchPolicy = 'cache-first' | 'fetch-only' | 'cache-only' | 'cache-and-fetch';
-export type Error = {
-    error: boolean;
-    url: string;
-    statusCode: number;
-    statusMessage: string;
-    message: string;
-    stack?: string[];
-};
-export declare function getConfig(): {
-    apiPath: string;
-    fetchPolicy: FetchPolicy;
-};
+export declare function getConfig(): ModuleOptions;
 /**
  * @param instance a custom fetch method created by `$fetch.create`
  */
 export declare function provideFetch(instance: typeof $fetch): void;
-export declare function getFetch(): import("nitropack/types").$Fetch<unknown, import("nitropack/types").NitroFetchRequest>;
+export declare function getFetch(): import("nitropack").$Fetch<unknown, import("nitropack").NitroFetchRequest>;

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

@@ -1,9 +1,9 @@
-import type { $Zmodel, $Zitem, $ZcreateData } from '#build/types/nuxt-zenstack';
-import type { Status, Error } from '../common.js';
+import type { $Zmodel, $Zitem, $ZcreateData, $Zerror } from '#build/types/nuxt-zenstack';
+import type { Status } from '../common.js';
 import { type Ref } from '#imports';
 export declare function useZenstackCreate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;
-    error: Ref<Error | null>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     mutate: (input: $ZcreateData<Zmodel>) => Promise<void>;
     reset: () => void;

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

@@ -1,9 +1,9 @@
-import type { $Zmodel, $Zitem, $Zid } from '#build/types/nuxt-zenstack';
-import type { Status, Error } from '../common.js';
+import type { $Zmodel, $Zitem, $Zid, $Zerror } from '#build/types/nuxt-zenstack';
+import type { Status } from '../common.js';
 import { type Ref } from '#imports';
 export declare function useZenstackDelete<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;
-    error: Ref<Error | null>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     mutate: (id: $Zid<Zmodel>) => Promise<void>;
     reset: () => void;

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

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

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

@@ -1,4 +1,4 @@
-import { ref, toValue, watch, isRef, useNuxtApp } from "#imports";
+import { ref, watch, useNuxtApp } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
 import { stringify } from "superjson";
@@ -10,19 +10,15 @@ export async function useZenstackRead(model, id, opts = {}) {
   const store = useZenstackStore();
   const config = getConfig();
   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 (shouldFetchInitially())
     await refetch();
-  function shouldFetchInitially() {
-    if (opts.immediate === false)
-      return false;
+  function canFetchAutomatically() {
     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;
@@ -30,12 +26,17 @@ export async function useZenstackRead(model, id, opts = {}) {
       return false;
     return true;
   }
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    return canFetchAutomatically();
+  }
   function updateData() {
     data.value = store.getOne(model, id);
   }
   function getQuery() {
     const json = stringify({
-      include: toValue(opts.include)
+      include: opts.include
     });
     return { q: json };
   }

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

@@ -1,4 +1,4 @@
-import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy } from '#build/types/nuxt-zenstack';
+import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy, $Zerror } from '#build/types/nuxt-zenstack';
 import type { Status, FetchPolicy } from '../common.js';
 import type { MaybeRefOrGetter, Ref } from '#imports';
 type Options<Zinclude, Zwhere, ZorderBy> = {
@@ -19,7 +19,7 @@ type Options<Zinclude, Zwhere, ZorderBy> = {
      * The relations to include in the query.
      * @default undefined
      */
-    include?: MaybeRefOrGetter<Zinclude>;
+    include?: Zinclude;
     /**
      * The filter to apply to the query.
      * @default undefined
@@ -43,8 +43,9 @@ type Options<Zinclude, Zwhere, ZorderBy> = {
 };
 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>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
+    canFetchMore: Ref<boolean>;
     refetch: () => Promise<void>;
 }>;
 export {};

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

@@ -3,14 +3,17 @@ import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
 import { stringify } from "superjson";
 import { getConfig, getFetch } from "../common.js";
+import { sort } from "./orderBy.js";
+import { matchesWhere } from "./where.js";
 export async function useZenstackReadMany(model, opts = {}) {
   const data = ref(null);
   const error = ref(null);
   const status = ref("idle");
+  const canFetchMore = ref(true);
   const store = useZenstackStore();
   const config = getConfig();
   const nuxtApp = useNuxtApp();
-  const watchedOptions = [opts.include, opts.where, opts.orderBy, opts.skip, opts.take].filter((option) => isRef(option) || typeof option === "function");
+  const watchedOptions = [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;
@@ -21,13 +24,12 @@ export async function useZenstackReadMany(model, opts = {}) {
   watch(store.state, () => updateData());
   watch(watchedOptions, () => {
     updateData();
-    refetch();
+    if (canFetchAutomatically())
+      refetch();
   });
   if (shouldFetchInitially())
     await refetch();
-  function shouldFetchInitially() {
-    if (opts.immediate === false)
-      return false;
+  function canFetchAutomatically() {
     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;
@@ -35,12 +37,20 @@ export async function useZenstackReadMany(model, opts = {}) {
       return false;
     return true;
   }
+  function shouldFetchInitially() {
+    if (opts.immediate === false)
+      return false;
+    return canFetchAutomatically();
+  }
   function updateData() {
-    data.value = store.getMany(model);
+    const items = store.getMany(model);
+    const filteredItems = items.filter((el) => matchesWhere(el, toValue(opts.where)));
+    const orderedFilteredItems = sort(filteredItems, toValue(opts.orderBy));
+    data.value = orderedFilteredItems;
   }
   function getQuery() {
     const json = stringify({
-      include: toValue(opts.include),
+      include: opts.include,
       where: toValue(opts.where),
       orderBy: toValue(opts.orderBy),
       skip: toValue(opts.skip),
@@ -61,15 +71,18 @@ export async function useZenstackReadMany(model, opts = {}) {
     });
     error.value = null;
     status.value = "pending";
+    canFetchMore.value = false;
     try {
       const res = await _fetch(url, { method, query });
       store.setMany(model, res.data);
       updateData();
       status.value = "success";
+      canFetchMore.value = res.data.length === toValue(opts.take);
     } catch (err) {
       error.value = err.data;
       status.value = "error";
+      canFetchMore.value = true;
     }
   }
-  return { data, error, status, refetch };
+  return { data, error, status, canFetchMore, refetch };
 }

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

@@ -0,0 +1,5 @@
+import type { $Zitem, $ZorderBy, $Zinclude, $Zmodel } from '#build/types/nuxt-zenstack';
+/**
+ * @note Sort by relational fields not supported
+ */
+export declare function sort<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>, Zitem extends $Zitem<Zmodel, Zinclude>>(items: Zitem[], orderBy: $ZorderBy<Zmodel>): Zitem[];

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

@@ -0,0 +1,25 @@
+export function sort(items, orderBy) {
+  if (!items.length || !orderBy)
+    return items;
+  return items.sort((a, b) => {
+    const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+    for (const orderByObj of orderByArray) {
+      const orderByEntries = Object.entries(orderByObj);
+      for (const [field, direction] of orderByEntries) {
+        if (direction !== "asc" && direction !== "desc") continue;
+        const aValue = a[field];
+        const bValue = b[field];
+        if (aValue == null && bValue == null) continue;
+        if (aValue == null) return 1;
+        if (bValue == null) return -1;
+        let comparison = 0;
+        if (aValue < bValue) comparison = -1;
+        else if (aValue > bValue) comparison = 1;
+        if (comparison !== 0) {
+          return direction === "asc" ? comparison : -comparison;
+        }
+      }
+    }
+    return 0;
+  });
+}

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

@@ -0,0 +1,2 @@
+import type { $Zitem, $Zwhere, $Zinclude, $Zmodel } from '#build/types/nuxt-zenstack';
+export declare function matchesWhere<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel>>(item: $Zitem<Zmodel, Zinclude>, where: $Zwhere<Zmodel>): boolean;

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

@@ -0,0 +1,235 @@
+export function matchesWhere(item, where) {
+  if (!where) return true;
+  if (!item) return false;
+  const itemRecord = item;
+  const whereRecord = where;
+  for (const key of Object.keys(whereRecord)) {
+    if (whereRecord[key] === void 0) continue;
+    const filter = whereRecord[key];
+    if (key === "AND") {
+      if (Array.isArray(filter)) {
+        if (!filter.every((cond) => matchesWhere(item, cond))) return false;
+      } else {
+        if (!matchesWhere(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "OR") {
+      if (Array.isArray(filter)) {
+        if (!filter.some((cond) => matchesWhere(item, cond))) return false;
+      } else {
+        if (!matchesWhere(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "NOT") {
+      if (Array.isArray(filter)) {
+        if (filter.some((cond) => matchesWhere(item, cond))) return false;
+      } else {
+        if (matchesWhere(item, filter)) return false;
+      }
+      continue;
+    }
+    const value = itemRecord[key];
+    if (!checkCondition(value, filter)) {
+      return false;
+    }
+  }
+  return true;
+}
+function checkCondition(value, filter) {
+  if (filter === null) {
+    return value === null;
+  }
+  if (filter === void 0) {
+    return true;
+  }
+  if (typeof filter !== "object" && typeof filter !== "function") {
+    if (value instanceof Date && typeof filter === "string") {
+      return value.toISOString() === filter;
+    }
+    return value === filter;
+  }
+  if (value instanceof Date && filter instanceof Date) {
+    return value.getTime() === filter.getTime();
+  }
+  const filterRecord = filter;
+  const keys = Object.keys(filterRecord);
+  if (keys.length === 0) return true;
+  let caseInsensitive = false;
+  if (filterRecord.mode === "insensitive") {
+    caseInsensitive = true;
+  }
+  for (const op of keys) {
+    if (op === "mode") continue;
+    let expected = filterRecord[op];
+    let actual = value;
+    if (["lt", "lte", "gt", "gte", "equals", "not"].includes(op)) {
+      if (actual instanceof Date && typeof expected === "string") {
+        const d = new Date(expected);
+        if (!Number.isNaN(d.getTime())) expected = d;
+      }
+    }
+    if (caseInsensitive && typeof actual === "string" && typeof expected === "string") {
+      if (["equals", "not", "contains", "startsWith", "endsWith"].includes(op)) {
+        actual = actual.toLowerCase();
+        expected = expected.toLowerCase();
+      }
+    }
+    switch (op) {
+      case "equals":
+        if (actual instanceof Date && expected instanceof Date) {
+          if (actual.getTime() !== expected.getTime()) return false;
+        } else if (actual !== expected) {
+          return false;
+        }
+        break;
+      case "not":
+        if (typeof expected === "object" && expected !== null && !Array.isArray(expected) && !(expected instanceof Date)) {
+          if (checkCondition(value, expected)) return false;
+        } else {
+          if (actual instanceof Date && expected instanceof Date) {
+            if (actual.getTime() === expected.getTime()) return false;
+          } else if (actual === expected) {
+            return false;
+          }
+        }
+        break;
+      case "in":
+        if (!Array.isArray(expected)) return false;
+        if (caseInsensitive && typeof actual === "string") {
+          const lowerVal = actual.toLowerCase();
+          const lowerList = expected.map((e) => typeof e === "string" ? e.toLowerCase() : e);
+          if (!lowerList.includes(lowerVal)) return false;
+        } else {
+          if (actual instanceof Date) {
+            const time = actual.getTime();
+            if (!expected.some((e) => e instanceof Date && e.getTime() === time || e === actual)) return false;
+          } else {
+            if (!expected.includes(actual)) return false;
+          }
+        }
+        break;
+      case "notIn":
+        if (!Array.isArray(expected)) return false;
+        if (caseInsensitive && typeof actual === "string") {
+          const lowerVal = actual.toLowerCase();
+          const lowerList = expected.map((e) => typeof e === "string" ? e.toLowerCase() : e);
+          if (lowerList.includes(lowerVal)) return false;
+        } else {
+          if (actual instanceof Date) {
+            const time = actual.getTime();
+            if (expected.some((e) => e instanceof Date && e.getTime() === time || e === actual)) return false;
+          } else {
+            if (expected.includes(actual)) return false;
+          }
+        }
+        break;
+      case "lt":
+        if (typeof actual === "number" && typeof expected === "number") {
+          if (!(actual < expected)) return false;
+        } else if (actual instanceof Date && expected instanceof Date) {
+          if (!(actual < expected)) return false;
+        } else if (typeof actual === "string" && typeof expected === "string") {
+          if (!(actual < expected)) return false;
+        } else {
+          if (!(actual < expected)) return false;
+        }
+        break;
+      case "lte":
+        if (!(actual <= expected)) return false;
+        break;
+      case "gt":
+        if (!(actual > expected)) return false;
+        break;
+      case "gte":
+        if (!(actual >= expected)) return false;
+        break;
+      case "contains":
+        if (typeof actual !== "string" || typeof expected !== "string" || !actual.includes(expected)) return false;
+        break;
+      case "startsWith":
+        if (typeof actual !== "string" || typeof expected !== "string" || !actual.startsWith(expected)) return false;
+        break;
+      case "endsWith":
+        if (typeof actual !== "string" || typeof expected !== "string" || !actual.endsWith(expected)) return false;
+        break;
+      // Relations
+      case "some":
+        if (!Array.isArray(value)) return false;
+        if (!value.some((v) => checkInternal(v, expected))) return false;
+        break;
+      case "every":
+        if (!Array.isArray(value)) return false;
+        if (!value.every((v) => checkInternal(v, expected))) return false;
+        break;
+      case "none":
+        if (!Array.isArray(value)) return false;
+        if (value.some((v) => checkInternal(v, expected))) return false;
+        break;
+      case "is":
+        if (expected === null) {
+          if (value != null) return false;
+        } else {
+          if (value == null) return false;
+          if (!checkInternal(value, expected)) return false;
+        }
+        break;
+      case "isNot":
+        if (expected === null) {
+          if (value == null) return false;
+        } else {
+          if (value == null) break;
+          if (checkInternal(value, expected)) return false;
+        }
+        break;
+      default:
+        if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+          if (!checkCondition(value[op], expected)) return false;
+        } else {
+          return false;
+        }
+    }
+  }
+  return true;
+}
+function checkInternal(item, where) {
+  return matchesWhereInternal(item, where);
+}
+function matchesWhereInternal(item, where) {
+  if (!where) return true;
+  if (!item) return false;
+  for (const key of Object.keys(where)) {
+    if (where[key] === void 0) continue;
+    const filter = where[key];
+    if (key === "AND") {
+      if (Array.isArray(filter)) {
+        if (!filter.every((cond) => matchesWhereInternal(item, cond))) return false;
+      } else {
+        if (!matchesWhereInternal(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "OR") {
+      if (Array.isArray(filter)) {
+        if (!filter.some((cond) => matchesWhereInternal(item, cond))) return false;
+      } else {
+        if (!matchesWhereInternal(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "NOT") {
+      if (Array.isArray(filter)) {
+        if (filter.some((cond) => matchesWhereInternal(item, cond))) return false;
+      } else {
+        if (matchesWhereInternal(item, filter)) return false;
+      }
+      continue;
+    }
+    const value = item[key];
+    if (!checkCondition(value, filter)) {
+      return false;
+    }
+  }
+  return true;
+}

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)[];
+};