cabloy 5.1.56 → 5.1.58

package/.gitignore

@@ -62,6 +62,7 @@ zova/.quasar
 **/.vitepress/cache
 **/.rollup.cache
 **/.temp-dynamic-*
+/.cabloy-version
 vona/package.json
 zova/package.json
 vona/docker-compose.yml

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 5.1.58
+
+### Features
+
+- Support nullable query filters.
+- Deliver several feature updates across the library.
+
+### Improvements
+
+- Add a Docker Compose quickstart flow to the documentation.
+- Refresh the framework performance documentation.
+
+## 5.1.57
+
+### Features
+
+- Track the Cabloy version during initialization and upgrade.
+
 ## 5.1.56
 
 ### Features

package/cabloy-docs/.vitepress/config.mjs

@@ -53,6 +53,7 @@ const fullstackGroups = [
         text: 'Comparison with Other Frameworks',
         link: '/fullstack/comparison-with-other-frameworks',
       },
+      { text: 'Framework Performance', link: '/fullstack/framework-performance' },
       { text: 'Vona + Zova Integration', link: '/fullstack/vona-zova-integration' },
       { text: 'Backend OpenAPI to Frontend SDK', link: '/fullstack/openapi-to-sdk' },
       {

package/cabloy-docs/backend/dto-guide.md

@@ -73,6 +73,13 @@ class DtoStudentCreate {
 }
 ```
 
+For query-oriented DTOs, another important distinction is optional vs nullable:
+
+- `v.optional()` means the field may be omitted
+- `v.nullable()` means the field may carry a real `null`
+
+That becomes especially important for DTO query filters. A field declared with `v.optional(), v.nullable()` can preserve real `null` through query parsing so the downstream ORM filter can express SQL `IS NULL` instead of silently treating the value as omitted.
+
 ## DTO options
 
 Three especially important DTO option areas are:

package/cabloy-docs/backend/orm-select-guide.md

@@ -146,6 +146,8 @@ await this.scope.model.post.select({
 
 This lets a query builder remove one condition cleanly without rebuilding the whole `where` object by hand, while `null` remains available for SQL `IS NULL` semantics.
 
+That distinction also matters at the request-contract layer: omitting a nullable filter and passing a real `null` are different operations. When a query DTO needs `IS NULL` behavior from frontend query params, the parsing contract must explicitly preserve `null` instead of collapsing it to omission.
+
 ## Joint operators and subqueries
 
 The query language also supports joint operators such as:

package/cabloy-docs/backend/validation-guide.md

@@ -37,12 +37,20 @@ findOne(@Arg.query('id', z.number().min(6)) id: number) {}
 Inferred schemas can also be extended through helper tools like:
 
 - `v.optional`
+- `v.nullable`
 - `v.default`
 - `v.array`
 - `v.lazy`
 
 That is important because many real validation cases need augmentation rather than total replacement.
 
+A useful distinction is:
+
+- `v.optional` means the field may be omitted
+- `v.nullable` means the field may carry a real `null`
+
+For query parameters, that distinction matters because plain optional values still collapse `null` to omission, while `v.optional(), v.nullable()` allows a real `null` to survive parsing when the contract needs SQL `IS NULL` semantics downstream.
+
 ## `@Arg.filter`
 
 The validation layer also supports more advanced query-style inputs through `@Arg.filter`, which ties into DTO/query helper structures.

package/cabloy-docs/fullstack/comparison-with-other-frameworks.md

@@ -11,6 +11,7 @@ That means the comparison is not only about a backend runtime or only about a fr
 For the broader Cabloy model, start with these pages:
 
 - [Fullstack Introduction](/fullstack/introduction)
+- [Framework Performance](/fullstack/framework-performance)
 - [Vona + Zova Integration](/fullstack/vona-zova-integration)
 - [Backend OpenAPI to Frontend SDK](/fullstack/openapi-to-sdk)
 - [Frontend Metadata Back to Backend](/fullstack/frontend-metadata-to-backend)

package/cabloy-docs/fullstack/framework-performance.md

@@ -0,0 +1,89 @@
+# Framework Performance
+
+Cabloy is designed to stay fast where real systems usually become fragile: under growing business complexity.
+
+Its performance story is not only about looking fast in simplified demos. It is about keeping real business systems maintainable, expressive, and performant as they grow in size and complexity.
+
+This page explains that philosophy first, then shows a concrete runtime example from an internally generated project.
+
+## Philosophy
+
+Many frameworks highlight performance with simplified cases, but real systems face a different challenge: as business complexity grows, performance work can easily turn into a growing pile of special-case optimization code.
+
+Cabloy takes a different direction.
+
+At the framework level, the goal is not only to make one isolated path faster. The goal is to let teams build large-scale systems in a way that stays elegant, maintainable, and performance-aware over time.
+
+That philosophy comes from the earlier Vona design direction:
+
+- performance should be considered under real business complexity
+- framework support should reduce the amount of ad hoc optimization code that teams need to write themselves
+- maintainability and performance should improve together instead of fighting each other
+
+In other words, Cabloy does not treat performance as a last-minute patch. It treats performance-related capability as part of the framework design.
+
+## What supports this philosophy
+
+A practical example is **Vona** on the backend side.
+
+Vona moves caching into the framework core instead of treating caching as something every project must rebuild from scratch. That includes framework-managed cache behavior such as:
+
+- entity cache
+- query cache
+- broader cache-centered workflow support for complex data access paths
+
+This matters because large systems usually do not become slow only because one query is inefficient. They become slow because optimization logic gets scattered across the codebase and becomes difficult to keep correct.
+
+By making caching first-class, Cabloy helps teams keep performance work closer to the framework model and farther away from repetitive custom optimization code.
+
+For the current public explanation of this backend capability, see [Cache Guide](/backend/cache-guide).
+
+## Runtime example
+
+This is the kind of result Cabloy is designed to support: a framework that stays operationally calm even when the system keeps running for long periods.
+
+One internally generated project was kept running continuously for **33 hours**. At one representative PM2 snapshot, the process looked like this:
+
+```text
+┌────┬─────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
+│ id │ name            │ namespace   │ version │ mode    │ pid      │ uptime │ ↺    │ status    │ cpu      │ mem      │ user     │ watching │
+├────┼─────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
+│ 0  │ cabloy_store    │ default     │ N/A     │ cluster │ 226947   │ 33h    │ 17   │ online    │ 0%       │ 401.9mb  │ ubuntu   │ disabled │
+└────┴─────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
+```
+
+For this 33-hour continuous run, the observed result was **0 memory leak**.
+
+The value of this example is not that it is a synthetic micro-benchmark. The value is that it reflects a real long-running project process with a clear, inspectable runtime footprint.
+
+## How to read this example
+
+This example is meant to show a real runtime stability observation from an internal project.
+
+It should not be read as:
+
+- a formal benchmark against other frameworks
+- a universal guarantee for every Cabloy workload
+- proof that every deployment will show the same memory profile
+
+Actual memory usage still depends on factors such as:
+
+- enabled modules and features
+- request traffic patterns
+- data volume
+- deployment topology
+- operational configuration
+
+If you want to check your own SSR workload, you can use the `detect-ssr-leak` Claude skill in the Vona workspace to investigate long-running memory behavior and verify whether the system shows leak signals.
+
+This is a diagnostic workflow, not a universal guarantee that every deployment is leak-free.
+
+So the point of the example is not that one PM2 snapshot explains everything. The point is that Cabloy’s framework design is intended to support long-running, real business systems without forcing teams into constant performance firefighting.
+
+## Where to go next
+
+If you want to continue from the performance philosophy into the concrete framework mechanisms behind it, these pages are the best next stops:
+
+- [Cache Guide](/backend/cache-guide) — how Vona makes caching first-class in the backend model
+- [Vona + Zova Integration](/fullstack/vona-zova-integration) — how the backend and frontend stay aligned as one framework system
+- [Backend OpenAPI to Frontend SDK](/fullstack/openapi-to-sdk) — one example of how Cabloy reduces repetitive cross-stack work at scale

package/cabloy-docs/fullstack/introduction.md

@@ -41,6 +41,7 @@ Start here when you want the shortest route to a working monorepo mental model:
 Use this path when the task is about how backend and frontend stay aligned inside one framework system:
 
 - [Comparison with Other Frameworks](/fullstack/comparison-with-other-frameworks)
+- [Framework Performance](/fullstack/framework-performance)
 - [Vona + Zova Integration](/fullstack/vona-zova-integration)
 - [Backend OpenAPI to Frontend SDK](/fullstack/openapi-to-sdk)
 - [Frontend Metadata Back to Backend](/fullstack/frontend-metadata-to-backend)

package/cabloy-docs/fullstack/quickstart.md

@@ -57,13 +57,29 @@ If you are not sure which edition you are using or which one to choose, read:
 - [Cabloy Basic](/editions/cabloy-basic)
 - [Cabloy Start](/editions/cabloy-start)
 
-## 5. Upgrade an existing project
+## 5. Run with Docker Compose
+
+Both Cabloy Basic and Cabloy Start support the same Docker Compose command flow. Run these commands from the repository for the edition you are using:
+
+```bash
+npm run build:docker
+cd docker-compose
+sudo COMPOSE_BAKE=true docker-compose build
+sudo docker-compose up
+```
+
+- Web: http://localhost/
+- Admin: http://localhost/admin/
+
+These commands build the edition-specific frontend flavors from the repository you are using.
+
+## 6. Upgrade an existing project
 
 ```bash
 npm run upgrade
 ```
 
-## 6. Next steps for framework-aware development
+## 7. Next steps for framework-aware development
 
 If you are contributing to framework-aware workflows or using Cabloy CLI generation directly, prefer CLI-backed generation over manual scaffolding.
 
@@ -76,7 +92,7 @@ npm run zova :create
 
 Then narrow into the specific command family you need.
 
-## 7. Shared verification commands for deeper workflow checks
+## 8. Shared verification commands for deeper workflow checks
 
 If you are validating framework-aware changes or a broader workflow, use the shared project scripts before declaring a workflow correct:
 

package/cabloy-docs/fullstack/vona-zova-integration.md

@@ -23,6 +23,8 @@ Cabloy uses a frontend-backend separation architecture:
 - generated or built frontend output is consumed by the backend-side fullstack flow
 - type sharing is coordinated through OpenAPI, generated SDKs, and frontend-generated route/component typing
 
+For the framework-level performance philosophy behind this fullstack model, see [Framework Performance](/fullstack/framework-performance).
+
 ## Cabloy Basic
 
 In Cabloy Basic, the root repository already exposes these shared entrypoints:

package/cabloy-docs/index.md

@@ -42,6 +42,7 @@ Start here to learn the shared Cabloy architecture, see how Vona and Zova fit to
 - **Get started quickly** with the fullstack quickstart and core Cabloy concepts
 - **Learn the shared fullstack architecture** across Cabloy, Vona, and Zova
 - **Explore backend and frontend workflows** without losing the cross-stack picture
+- **Understand Cabloy’s performance philosophy and runtime stability story** with [Framework Performance](/fullstack/framework-performance)
 - **See how Cabloy Basic and Cabloy Start differ by edition** when UI assumptions, flavors, modules, SSR sites, or AI workflow guidance matter
 - **Follow source-grounded AI vibe coding guidance** for prompting, workflow selection, and verification
 
@@ -63,6 +64,13 @@ Start here to learn the shared Cabloy architecture, see how Vona and Zova fit to
 5. [Reference Introduction](/reference/introduction)
 6. [Editions Overview](/editions/overview)
 
+### For performance-oriented reading
+
+1. [Fullstack Introduction](/fullstack/introduction)
+2. [Framework Performance](/fullstack/framework-performance)
+3. [Cache Guide](/backend/cache-guide)
+4. [Vona + Zova Integration](/fullstack/vona-zova-integration)
+
 ## Documentation scope labels
 
 Use these labels throughout the site:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cabloy",
-  "version": "5.1.56",
+  "version": "5.1.58",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A Node.js fullstack framework",
   "keywords": [

package/scripts/init.ts

@@ -19,6 +19,7 @@ const VONA_DIR = resolve(ROOT_DIR, 'vona');
 const ZOVA_DIR = resolve(ROOT_DIR, 'zova');
 const CABLOY_DOCS_DIR = resolve(ROOT_DIR, 'cabloy-docs');
 const PNPM_VERSION = '11.5.2';
+const VERSION_MARKER_FILE = '.cabloy-version';
 
 // --- Helpers ---
 
@@ -70,6 +71,50 @@ function deleteGitkeepFiles(dir: string): void {
   }
 }
 
+function isValidVersion(version: string): boolean {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+function readPackageVersion(): string {
+  const filePath = resolve(ROOT_DIR, 'package.json');
+  const packageContent = JSON.parse(readFileSync(filePath, 'utf-8')) as { version?: string };
+  const version = packageContent.version?.trim();
+  if (!version || !isValidVersion(version)) {
+    throw new Error(`Invalid Cabloy version in package.json: ${version ?? '<missing>'}`);
+  }
+  return version;
+}
+
+function readVersionMarker(): string | undefined {
+  const filePath = resolve(ROOT_DIR, VERSION_MARKER_FILE);
+  if (!existsSync(filePath)) return undefined;
+  const version = readFileSync(filePath, 'utf-8').trim();
+  if (!version) return undefined;
+  if (!isValidVersion(version)) {
+    throw new Error(`Invalid Cabloy version marker: ${version}`);
+  }
+  return version;
+}
+
+function resolveVersionMarker(): string {
+  const versionFromEnv = process.env.CABLOY_VERSION?.trim();
+  if (versionFromEnv) {
+    if (!isValidVersion(versionFromEnv)) {
+      throw new Error(`Invalid CABLOY_VERSION: ${versionFromEnv}`);
+    }
+    return versionFromEnv;
+  }
+  return readVersionMarker() ?? readPackageVersion();
+}
+
+function writeVersionMarker(): void {
+  const version = resolveVersionMarker();
+  const filePath = resolve(ROOT_DIR, VERSION_MARKER_FILE);
+  writeFileSync(filePath, `${version}\n`);
+  // eslint-disable-next-line
+  console.log(`[init] Marked Cabloy version: ${version}`);
+}
+
 // --- Step 0: Set APP_NAME in .env files ---
 
 function setAppName(): void {
@@ -245,5 +290,6 @@ initVona();
 initZova();
 initCabloyDocs();
 buildSsrCabloyBasicStartBatch();
+writeVersionMarker();
 // eslint-disable-next-line
 console.log('[init] Done!');

package/scripts/upgrade.ts

@@ -1,5 +1,13 @@
 import { execSync } from 'node:child_process';
-import { cpSync, createWriteStream, existsSync, mkdirSync, rmSync, unlinkSync } from 'node:fs';
+import {
+  cpSync,
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  unlinkSync,
+} from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { pipeline } from 'node:stream/promises';
@@ -11,6 +19,7 @@ const ROOT_DIR = resolve(__dirname, '..');
 const NPM_REGISTRY = 'https://registry.npmjs.org';
 const PACKAGE_NAME = 'cabloy';
 const TEMP_DIR = resolve(ROOT_DIR, 'node_modules/.cabloy-upgrade');
+const VERSION_MARKER_FILE = '.cabloy-version';
 
 // --- Whitelist ---
 
@@ -78,13 +87,22 @@ const WHITELIST_FILES: string[] = [
   'zova/openapi.config.ts',
 ];
 
+type LatestPackageInfo = {
+  version: string;
+  tarballUrl: string;
+};
+
 // --- Helpers ---
 
 // oxlint-disable no-console
 const log = console.log; // eslint-disable-line no-console
 
-function exec(cmd: string): void {
-  execSync(cmd, { stdio: 'inherit', cwd: ROOT_DIR });
+function exec(cmd: string, env?: NodeJS.ProcessEnv): void {
+  execSync(cmd, {
+    stdio: 'inherit',
+    cwd: ROOT_DIR,
+    env: env ? { ...process.env, ...env } : process.env,
+  });
 }
 
 function shouldCopyPath(path: string): boolean {
@@ -95,6 +113,54 @@ function copyDirectory(src: string, dest: string): void {
   cpSync(src, dest, { recursive: true, filter: shouldCopyPath });
 }
 
+function isValidVersion(version: string): boolean {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+function parseVersion(version: string): [number, number, number] {
+  if (!isValidVersion(version)) {
+    throw new Error(`Invalid Cabloy version: ${version}`);
+  }
+  const [major, minor, patch] = version.split('.').map(item => Number.parseInt(item, 10));
+  return [major, minor, patch];
+}
+
+function compareVersions(left: string, right: string): number {
+  const leftParts = parseVersion(left);
+  const rightParts = parseVersion(right);
+  for (let i = 0; i < leftParts.length; i++) {
+    if (leftParts[i] > rightParts[i]) return 1;
+    if (leftParts[i] < rightParts[i]) return -1;
+  }
+  return 0;
+}
+
+function readVersionMarker(): string | undefined {
+  const filePath = resolve(ROOT_DIR, VERSION_MARKER_FILE);
+  if (!existsSync(filePath)) return undefined;
+  const version = readFileSync(filePath, 'utf-8').trim();
+  if (!version) {
+    throw new Error(`Invalid Cabloy version marker in ${VERSION_MARKER_FILE}: <empty>`);
+  }
+  if (!isValidVersion(version)) {
+    throw new Error(`Invalid Cabloy version marker in ${VERSION_MARKER_FILE}: ${version}`);
+  }
+  return version;
+}
+
+function readRequiredVersionMarker(expectedVersion: string): string {
+  const version = readVersionMarker();
+  if (!version) {
+    throw new Error(`Expected ${VERSION_MARKER_FILE} to be created after upgrade`);
+  }
+  if (version !== expectedVersion) {
+    throw new Error(
+      `Expected ${VERSION_MARKER_FILE} to be ${expectedVersion} after upgrade, received ${version}`,
+    );
+  }
+  return version;
+}
+
 async function extractTarball(tarballPath: string, targetDir: string): Promise<void> {
   rmSync(targetDir, { recursive: true, force: true });
   mkdirSync(targetDir, { recursive: true });
@@ -120,14 +186,22 @@ function preflight(): void {
 
 // --- Step 2: Download & extract ---
 
-async function fetchLatestTarballUrl(): Promise<string> {
+async function fetchLatestPackageInfo(): Promise<LatestPackageInfo> {
   const url = `${NPM_REGISTRY}/${PACKAGE_NAME}/latest`;
   const res = await fetch(url);
   if (!res.ok) {
     throw new Error(`Failed to fetch package info: ${res.status} ${res.statusText}`);
   }
-  const data = (await res.json()) as { dist: { tarball: string } };
-  return data.dist.tarball;
+  const data = (await res.json()) as { version?: string; dist?: { tarball?: string } };
+  const version = data.version?.trim();
+  const tarballUrl = data.dist?.tarball?.trim();
+  if (!version || !isValidVersion(version)) {
+    throw new Error(`Invalid latest Cabloy version from npm: ${version ?? '<missing>'}`);
+  }
+  if (!tarballUrl) {
+    throw new Error('Missing tarball URL in npm latest metadata');
+  }
+  return { version, tarballUrl };
 }
 
 async function downloadTarball(tarballUrl: string): Promise<string> {
@@ -145,8 +219,7 @@ async function downloadTarball(tarballUrl: string): Promise<string> {
   return tmpFile;
 }
 
-async function downloadAndExtract(): Promise<void> {
-  const tarballUrl = await fetchLatestTarballUrl();
+async function downloadAndExtract(tarballUrl: string): Promise<void> {
   const tarballPath = await downloadTarball(tarballUrl);
   try {
     await extractTarball(tarballPath, TEMP_DIR);
@@ -190,9 +263,12 @@ function selectiveOverwrite(dryRun?: boolean): void {
   // Delete directories
   for (const dir of BLACKLIST_DIRS) {
     const dest = resolve(ROOT_DIR, dir);
-    if (existsSync(dest)) {
-      rmSync(dest, { recursive: true, force: true });
+    if (!existsSync(dest)) continue;
+    if (dryRun) {
+      log(`  [dry-run] Delete directory: ${dir}`);
+      continue;
     }
+    rmSync(dest, { recursive: true, force: true });
   }
 
   // Overwrite files
@@ -210,12 +286,12 @@ function selectiveOverwrite(dryRun?: boolean): void {
 
 // --- Step 4: Run init ---
 
-function runInit(dryRun?: boolean): void {
+function runInit(dryRun: boolean, version: string): void {
   if (dryRun) {
     log('  [dry-run] Run: npm run init');
     return;
   }
-  exec('npm run init');
+  exec('npm run init', { CABLOY_VERSION: version } as any);
 }
 
 // --- Step 5: Cleanup ---
@@ -240,25 +316,61 @@ async function main(): Promise<void> {
   // 1. Pre-flight
   preflight();
 
-  // 2. Download & extract
-  log('Downloading latest cabloy from npm registry...');
-  await downloadAndExtract();
-  log('Downloaded and extracted successfully!\n');
+  const latestPackageInfo = await fetchLatestPackageInfo();
+  const currentVersion = readVersionMarker();
+
+  if (currentVersion) {
+    log(`Current project Cabloy version: ${currentVersion}`);
+  } else {
+    log(
+      `Warning: Missing ${VERSION_MARKER_FILE}, continuing with upgrade for backward compatibility.`,
+    );
+  }
+  log(`Latest Cabloy version: ${latestPackageInfo.version}`);
+
+  if (currentVersion) {
+    const comparison = compareVersions(currentVersion, latestPackageInfo.version);
+    if (comparison === 0) {
+      log(`Cabloy is already up to date (current: ${currentVersion}). Skipping upgrade.`);
+      return;
+    }
+    if (comparison > 0) {
+      throw new Error(
+        `Project Cabloy version ${currentVersion} is newer than npm latest ${latestPackageInfo.version}. Aborting upgrade.`,
+      );
+    }
+    log(`Upgrading Cabloy from ${currentVersion} to ${latestPackageInfo.version}...\n`);
+  } else {
+    log(`Upgrading Cabloy to ${latestPackageInfo.version}...\n`);
+  }
 
-  // 3. Selective overwrite
-  log('Overwriting framework-owned files...');
-  selectiveOverwrite(dryRun);
-  log('');
+  try {
+    // 2. Download & extract
+    log('Downloading latest cabloy from npm registry...');
+    await downloadAndExtract(latestPackageInfo.tarballUrl);
+    log('Downloaded and extracted successfully!\n');
 
-  // 4. Run init
-  log('Running npm run init...');
-  runInit(dryRun);
-  log('');
+    // 3. Selective overwrite
+    log('Overwriting framework-owned files...');
+    selectiveOverwrite(dryRun);
+    log('');
 
-  // 5. Cleanup
-  cleanup(dryRun);
+    // 4. Run init
+    log('Running npm run init...');
+    runInit(dryRun, latestPackageInfo.version);
+    log('');
 
-  log('Upgrade complete!');
+    if (dryRun) {
+      log(`[dry-run] Current Cabloy version would become: ${latestPackageInfo.version}`);
+    } else {
+      log(`Current Cabloy version: ${readRequiredVersionMarker(latestPackageInfo.version)}`);
+    }
+
+    log('Upgrade complete!');
+  } finally {
+    // 5. Cleanup
+    cleanup(dryRun);
+  }
 }
 
 main().catch(err => {

package/vona/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.108",
+  "version": "1.1.109",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli",
   "keywords": [

package/vona/packages-cli/cli-set-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli-set-api",
-  "version": "1.1.106",
+  "version": "1.1.107",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [

package/vona/packages-utils/zod-query/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabloy/zod-query",
-  "version": "2.1.8",
+  "version": "2.1.9",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "zod-query",
   "keywords": [

package/vona/packages-utils/zod-query/src/index.ts

@@ -1 +1,2 @@
 export * from './lib/query.ts';
+export * from './lib/zod-is-type.ts';