@vertz/fetch 0.2.22 → 0.2.24

package/dist/index.d.ts

@@ -71,6 +71,8 @@ interface EntityQueryMeta {
 	readonly entityType: string;
 	readonly kind: "get" | "list";
 	readonly id?: string;
+	/** Whether this entity is tenant-scoped. Set by codegen from entity manifest. */
+	readonly tenantScoped?: boolean;
 }
 /** Metadata for mutation descriptors. */
 interface MutationMeta {
@@ -205,20 +207,29 @@ interface VertzQLIncludeEntry {
 interface VertzQLParams {
 	select?: Record<string, true>;
 	include?: Record<string, true | VertzQLIncludeEntry>;
+	where?: Record<string, unknown>;
+	orderBy?: Record<string, "asc" | "desc">;
+	limit?: number;
 }
 /**
-* Encodes VertzQL parameters (select, include) into a base64url string
+* Encodes VertzQL parameters into a base64url string
 * suitable for the `q=` query parameter.
 *
 * This is the client-side counterpart to `parseVertzQL` on the server.
 */
 declare function encodeVertzQL(params: VertzQLParams): string;
 /**
-* Extracts `select` and `include` from a query object, encodes them as a
-* base64url `q` parameter, and returns the cleaned query.
+* Extracts structural VertzQL keys (`select`, `include`) from a query object,
+* encodes them as a base64url `q` parameter, and flattens `where`, `orderBy`,
+* and `limit` into URL-native query parameter format.
+*
+* - `select` / `include` → encoded in `q` (complex nested structures)
+* - `where`              → bracket notation: `where[field]=value`
+* - `orderBy`            → colon format: `orderBy=field:dir`
+* - `limit`              → flat number: `limit=N`
 *
 * Returns `undefined` if the input is `undefined`.
-* Returns the query unchanged if no `select` or `include` is present.
+* Returns the query unchanged if no VertzQL keys are present.
 */
 declare function resolveVertzQL(query?: Record<string, unknown>): Record<string, unknown> | undefined;
 export { unwrapOr, unwrap, resolveVertzQL, ok, matchError, isQueryDescriptor, isOk, isMutationDescriptor, isErr, err, encodeVertzQL, createMutationDescriptor, createErrorFromStatus, createDescriptor, VertzQLParams, UnprocessableEntityError, UnauthorizedError, StreamingRequestOptions, StreamingFormat, ServiceUnavailableError, RetryConfig, Result3 as Result, RequestOptions, RateLimitError, QueryDescriptor, OptimisticHandler, NotFoundError, MutationMeta, MutationDescriptor, ListResponse, InternalServerError, HooksConfig, GoneError, ForbiddenError, FetchResponse, FetchErrorType, FetchError2 as FetchError, FetchClientConfig, FetchClient, EntityQueryMeta, EntityErrorType, ConflictError, BadRequestError, AuthStrategy };

package/dist/index.js

@@ -526,17 +526,59 @@ function encodeVertzQL(params) {
   const b64 = btoa(json);
   return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
+var ENCODED_KEYS = new Set(["select", "include"]);
+function flattenWhere(where, target) {
+  for (const [field, value] of Object.entries(where)) {
+    if (value === undefined || value === null)
+      continue;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      for (const [op, opValue] of Object.entries(value)) {
+        if (opValue !== undefined && opValue !== null) {
+          target[`where[${field}][${op}]`] = String(opValue);
+        }
+      }
+    } else {
+      target[`where[${field}]`] = String(value);
+    }
+  }
+}
+function flattenOrderBy(orderBy) {
+  return Object.entries(orderBy).map(([field, dir]) => `${field}:${dir}`).join(",");
+}
 function resolveVertzQL(query) {
   if (!query)
     return;
-  const { select, include, ...rest } = query;
-  if (!select && !include)
+  const encodedFields = {};
+  const rest = {};
+  let hasVertzQL = false;
+  for (const key of Object.keys(query)) {
+    if (query[key] === undefined) {
+      rest[key] = query[key];
+      continue;
+    }
+    if (ENCODED_KEYS.has(key)) {
+      encodedFields[key] = query[key];
+      hasVertzQL = true;
+    } else if (key === "where") {
+      flattenWhere(query[key], rest);
+      hasVertzQL = true;
+    } else if (key === "orderBy") {
+      rest.orderBy = flattenOrderBy(query[key]);
+      hasVertzQL = true;
+    } else if (key === "limit") {
+      rest.limit = query[key];
+      hasVertzQL = true;
+    } else {
+      rest[key] = query[key];
+    }
+  }
+  if (!hasVertzQL)
     return query;
-  const q = encodeVertzQL({
-    ...select ? { select } : {},
-    ...include ? { include } : {}
-  });
-  return { ...rest, q };
+  if (Object.keys(encodedFields).length > 0) {
+    const q = encodeVertzQL(encodedFields);
+    return { ...rest, q };
+  }
+  return rest;
 }
 export {
   unwrapOr,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/fetch",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "type": "module",
   "license": "MIT",
   "description": "Type-safe HTTP client for Vertz",
@@ -25,7 +25,7 @@
     "dist"
   ],
   "dependencies": {
-    "@vertz/errors": "^0.2.21"
+    "@vertz/errors": "^0.2.23"
   },
   "scripts": {
     "build": "bunup",