@signalium/query 1.0.18 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @signalium/query
 
+## 1.1.1
+
+### Patch Changes
+
+- bb0a5a9: Fix entity proxies not being created for preloaded entities from cache, and `__entityRef` not being resolved in proxy get handler. This fixes validation errors when accessing nested entities loaded from persistent cache.
+
+## 1.1.0
+
+### Minor Changes
+
+- af443c5: Add request body support to query() function
+
+  Queries can now send JSON request bodies for POST requests, enabling read-like operations that require complex data structures (e.g., fetching prices for an array of tokens).
+
+  **New features:**
+
+  - Added `body` field to query definitions for specifying request body schema
+  - Body parameters are automatically serialized as JSON with `Content-Type: application/json` header
+  - Body params work alongside path params and search params
+  - All query features (caching, staleTime, deduplication) work with body queries
+
+  **API changes:**
+
+  - Query methods are now restricted to `GET` and `POST` only (PUT, PATCH, DELETE should use `mutation()`)
+
+  **Example:**
+
+  ```typescript
+  const getPrices = query(() => ({
+    path: '/prices',
+    method: 'POST',
+    body: {
+      tokens: t.array(t.string),
+    },
+    searchParams: {
+      currency: t.string,
+    },
+    response: {
+      prices: t.array(t.object({ token: t.string, price: t.number })),
+    },
+    cache: { staleTime: 30_000 },
+  }));
+
+  // Usage: POST /prices?currency=USD with body: {"tokens":["ETH","BTC"]}
+  const result = getPrices({ tokens: ['ETH', 'BTC'], currency: 'USD' });
+  ```
+
 ## 1.0.18
 
 ### Patch Changes

package/dist/cjs/development/index.js

@@ -912,6 +912,43 @@ function createEntityProxy(id, entityRecord, def, entityRelay, scopeOwner, warn
       if (!Object.hasOwnProperty.call(shape, prop)) {
         return value;
       }
+      if (value && typeof value === "object") {
+        const ownerWithHydrate = scopeOwner;
+        if (typeof value.__entityRef === "number") {
+          const nestedRecord = ownerWithHydrate.hydrateEntity?.(
+            value.__entityRef,
+            propDef
+          );
+          if (nestedRecord && nestedRecord.proxy) {
+            cache.set(prop, nestedRecord.proxy);
+            return nestedRecord.proxy;
+          }
+        }
+        if (Array.isArray(value) && value.length > 0) {
+          const firstItem = value[0];
+          if (firstItem && typeof firstItem === "object" && typeof firstItem.__entityRef === "number") {
+            const arrayTypeDef = propDef;
+            const isArrayType = typeof arrayTypeDef.mask === "number" && (arrayTypeDef.mask & Mask.ARRAY) !== 0;
+            const itemDef = isArrayType ? arrayTypeDef.shape : void 0;
+            if (itemDef) {
+              const hydratedArray = value.map((item) => {
+                if (item && typeof item === "object" && typeof item.__entityRef === "number") {
+                  const nestedRecord = ownerWithHydrate.hydrateEntity?.(
+                    item.__entityRef,
+                    itemDef
+                  );
+                  if (nestedRecord && nestedRecord.proxy) {
+                    return nestedRecord.proxy;
+                  }
+                }
+                return item;
+              });
+              cache.set(prop, hydratedArray);
+              return hydratedArray;
+            }
+          }
+        }
+      }
       const parsed = parseValue(value, propDef, `[[${desc}]].${prop}`, false, warn);
       cache.set(prop, parsed);
       return parsed;
@@ -1052,6 +1089,9 @@ class EntityStore {
       record.data = mergeValues(record.data, obj);
       record.notifier.notify();
       record.cache.clear();
+      if (record.proxy === void 0) {
+        record.proxy = this.createEntityProxy(record, shape);
+      }
     }
     record.entityRefs = entityRefs;
     return record;
@@ -2562,7 +2602,7 @@ var QueryType = /* @__PURE__ */ ((QueryType2) => {
   return QueryType2;
 })(QueryType || {});
 function isSignal(value) {
-  return typeof value === "object" && value !== null;
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "value" in value && "_id" in value;
 }
 function extractParamsForKey(params) {
   if (params === void 0) {
@@ -2706,7 +2746,7 @@ function createPathInterpolator(pathTemplate) {
     lastIndex = paramRegex.lastIndex;
   }
   segments.push(pathTemplate.slice(lastIndex));
-  return (params) => {
+  const interpolate = (params) => {
     let result = segments[0];
     for (let i = 0; i < paramKeys.length; i++) {
       result += encodeURIComponent(String(params[paramKeys[i]])) + segments[i + 1];
@@ -2725,6 +2765,7 @@ function createPathInterpolator(pathTemplate) {
     }
     return result;
   };
+  return { interpolate, pathParamNames: paramKeysSet };
 }
 const QUERY_DEFINITION_MAP = /* @__PURE__ */ new Map();
 function buildQueryFn(queryDefinitionBuilder) {
@@ -2734,6 +2775,8 @@ function buildQueryFn(queryDefinitionBuilder) {
       const {
         path,
         method = "GET",
+        searchParams,
+        body,
         response,
         requestOptions,
         cache,
@@ -2760,14 +2803,53 @@ function buildQueryFn(queryDefinitionBuilder) {
         shape = response;
         shapeKey = utils.hashValue(shape);
       }
-      const interpolatePath = createPathInterpolator(path);
+      const { interpolate: interpolatePath, pathParamNames } = createPathInterpolator(path);
+      const bodyParamNames = /* @__PURE__ */ new Set();
+      const hasBody = body !== void 0 && typeof body === "object" && !(body instanceof ValidatorDef) && !(body instanceof Set);
+      if (hasBody) {
+        for (const key of Object.keys(body)) {
+          bodyParamNames.add(key);
+        }
+      }
+      const searchParamNames = new Set(
+        searchParams && typeof searchParams === "object" && !(searchParams instanceof ValidatorDef) && !(searchParams instanceof Set) ? Object.keys(searchParams) : []
+      );
+      const checkConflicts = (sourceNames, targetNames, sourceLabel, targetLabel) => {
+        const conflicts = [...sourceNames].filter((name) => targetNames.has(name));
+        if (conflicts.length > 0) {
+          throw new Error(
+            `Query definition error: ${sourceLabel} [${conflicts.join(", ")}] conflict with ${targetLabel}. Please rename to avoid this conflict.`
+          );
+        }
+      };
+      checkConflicts(searchParamNames, pathParamNames, "Search param(s)", `path parameter(s) in "${path}"`);
+      checkConflicts(bodyParamNames, pathParamNames, "Body field(s)", `path parameter(s) in "${path}"`);
+      checkConflicts(bodyParamNames, searchParamNames, "Body field(s)", "search param(s)");
       const fetchFn = async (context, params) => {
-        const interpolatedPath = interpolatePath(params);
+        let bodyData;
+        let urlParams = params;
+        if (hasBody) {
+          bodyData = {};
+          urlParams = params !== void 0 ? {} : void 0;
+          if (params !== void 0) {
+            for (const key in params) {
+              if (bodyParamNames.has(key)) {
+                bodyData[key] = params[key];
+              } else {
+                urlParams[key] = params[key];
+              }
+            }
+          }
+        }
+        const interpolatedPath = interpolatePath(urlParams ?? {});
         const baseUrl = resolveBaseUrl(requestOptions?.baseUrl) ?? resolveBaseUrl(context.baseUrl);
         const fullUrl = baseUrl ? `${baseUrl}${interpolatedPath}` : interpolatedPath;
-        const { baseUrl: _baseUrl, ...fetchOptions } = requestOptions ?? {};
+        const { baseUrl: _baseUrl, headers: userHeaders, ...fetchOptions } = requestOptions ?? {};
+        const headers = bodyData ? { "Content-Type": "application/json", ...userHeaders } : userHeaders;
         const response2 = await context.fetch(fullUrl, {
           method,
+          headers,
+          body: bodyData ? JSON.stringify(bodyData) : void 0,
           ...fetchOptions
         });
         return response2.json();
@@ -2928,13 +3010,7 @@ function buildMutationFn(mutationDefinitionBuilder) {
       const id = `mutation:${method}:${path}`;
       const { shape: requestShape, shapeKey: requestShapeKey } = processTypeDef(request);
       const { shape: responseShape, shapeKey: responseShapeKey } = processTypeDef(response);
-      const interpolatePath = createPathInterpolator(path);
-      const pathParamNames = /* @__PURE__ */ new Set();
-      const paramRegex = /\[([^\]]+)\]/g;
-      let match;
-      while ((match = paramRegex.exec(path)) !== null) {
-        pathParamNames.add(match[1]);
-      }
+      const { interpolate: interpolatePath, pathParamNames } = createPathInterpolator(path);
       const mutateFn = async (context, requestData) => {
         const pathParams = {};
         for (const paramName of pathParamNames) {