tersejson 0.1.0 → 0.2.0

package/dist/index.js

@@ -10,6 +10,9 @@ var __export = (target, all) => {
 function isTersePayload(value) {
   return typeof value === "object" && value !== null && "__terse__" in value && value.__terse__ === true && "v" in value && "k" in value && "d" in value;
 }
+function isGraphQLTersePayload(value) {
+  return typeof value === "object" && value !== null && "data" in value && "__terse__" in value && typeof value.__terse__ === "object" && value.__terse__ !== null && "v" in value.__terse__ && "k" in value.__terse__ && "paths" in value.__terse__;
+}
 
 // src/core.ts
 function alphaGenerator(index) {
@@ -650,7 +653,7 @@ __export(client_exports, {
   createFetch: () => createFetch,
   default: () => client_default,
   expand: () => expand,
-  fetch: () => fetch,
+  fetch: () => fetch2,
   isTersePayload: () => isTersePayload,
   process: () => process2,
   proxy: () => wrapWithProxy,
@@ -702,7 +705,7 @@ function createFetch(options = {}) {
     });
   };
 }
-var fetch = createFetch();
+var fetch2 = createFetch();
 function useTerseFetch(options = {}) {
   return createFetch(options);
 }
@@ -720,7 +723,7 @@ var axiosInterceptor = {
     return response;
   }
 };
-var client_default = { fetch, createFetch, expand, proxy: wrapWithProxy, process: process2 };
+var client_default = { fetch: fetch2, createFetch, expand, proxy: wrapWithProxy, process: process2 };
 
 // src/integrations.ts
 var integrations_exports = {};
@@ -982,6 +985,397 @@ var integrations_default = {
   createQueryFn
 };
 
+// src/graphql.ts
+var graphql_exports = {};
+__export(graphql_exports, {
+  compressGraphQLResponse: () => compressGraphQLResponse,
+  createTerseFormatFn: () => createTerseFormatFn,
+  default: () => graphql_default,
+  findCompressibleArrays: () => findCompressibleArrays,
+  terseGraphQL: () => terseGraphQL
+});
+var DEFAULT_OPTIONS3 = {
+  minArrayLength: 2,
+  debug: false,
+  minKeyLength: 3,
+  maxDepth: 10,
+  keyPattern: "alpha",
+  nestedHandling: "deep",
+  homogeneousOnly: false,
+  excludeKeys: [],
+  includeKeys: [],
+  excludePaths: []
+};
+function findCompressibleArrays(data, basePath = "data", options, currentDepth = 0) {
+  const results = [];
+  if (currentDepth >= options.maxDepth) return results;
+  if (Array.isArray(data)) {
+    if (isCompressibleArray(data) && data.length >= options.minArrayLength && !options.excludePaths.includes(basePath)) {
+      results.push({ path: basePath, data });
+    }
+    data.forEach((item, index) => {
+      if (typeof item === "object" && item !== null) {
+        const nestedResults = findCompressibleArrays(
+          item,
+          `${basePath}[${index}]`,
+          options,
+          currentDepth + 1
+        );
+        results.push(...nestedResults);
+      }
+    });
+  } else if (typeof data === "object" && data !== null) {
+    for (const [key, value] of Object.entries(data)) {
+      const path = `${basePath}.${key}`;
+      const nestedResults = findCompressibleArrays(value, path, options, currentDepth + 1);
+      results.push(...nestedResults);
+    }
+  }
+  return results;
+}
+function collectKeysFromArrays(arrays, options) {
+  const allKeys = /* @__PURE__ */ new Set();
+  const { minKeyLength = 3, excludeKeys = [], includeKeys = [] } = options;
+  function collectFromObject(obj, depth = 0) {
+    if (depth >= (options.maxDepth ?? 10)) return;
+    for (const key of Object.keys(obj)) {
+      if (excludeKeys.includes(key)) continue;
+      const shouldInclude = includeKeys.includes(key) || key.length >= minKeyLength;
+      if (shouldInclude) {
+        allKeys.add(key);
+      }
+      const value = obj[key];
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+            collectFromObject(item, depth + 1);
+          }
+        }
+      } else if (typeof value === "object" && value !== null) {
+        collectFromObject(value, depth + 1);
+      }
+    }
+  }
+  for (const { data } of arrays) {
+    for (const item of data) {
+      collectFromObject(item);
+    }
+  }
+  return allKeys;
+}
+function compressObjectWithMap(obj, keyToShort, maxDepth, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return obj;
+  const compressed = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const shortKey = keyToShort.get(key) ?? key;
+    if (Array.isArray(value)) {
+      compressed[shortKey] = value.map((item) => {
+        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+          return compressObjectWithMap(
+            item,
+            keyToShort,
+            maxDepth,
+            currentDepth + 1
+          );
+        }
+        return item;
+      });
+    } else if (typeof value === "object" && value !== null) {
+      compressed[shortKey] = compressObjectWithMap(
+        value,
+        keyToShort,
+        maxDepth,
+        currentDepth + 1
+      );
+    } else {
+      compressed[shortKey] = value;
+    }
+  }
+  return compressed;
+}
+function setAtPath(obj, path, value) {
+  const parts = path.split(/\.|\[(\d+)\]/).filter(Boolean);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const isIndex = /^\d+$/.test(part);
+    if (isIndex) {
+      current = current[parseInt(part, 10)];
+    } else {
+      current = current[part];
+    }
+  }
+  const lastPart = parts[parts.length - 1];
+  const isLastIndex = /^\d+$/.test(lastPart);
+  if (isLastIndex) {
+    current[parseInt(lastPart, 10)] = value;
+  } else {
+    current[lastPart] = value;
+  }
+}
+function compressGraphQLResponse(response, options = {}) {
+  const config = { ...DEFAULT_OPTIONS3, ...options };
+  if (!response.data) {
+    return response;
+  }
+  const arrays = findCompressibleArrays(response.data, "data", {
+    minArrayLength: config.minArrayLength,
+    excludePaths: config.excludePaths,
+    maxDepth: config.maxDepth
+  });
+  const filteredArrays = config.shouldCompress ? arrays.filter(({ path, data }) => config.shouldCompress(data, path)) : arrays;
+  if (filteredArrays.length === 0) {
+    return response;
+  }
+  const allKeys = collectKeysFromArrays(filteredArrays, config);
+  const sortedKeys = Array.from(allKeys).sort();
+  const { generator } = createKeyGenerator(config.keyPattern);
+  const keyToShort = /* @__PURE__ */ new Map();
+  const keyMap = {};
+  sortedKeys.forEach((key, index) => {
+    const shortKey = generator(index);
+    if (shortKey.length < key.length) {
+      keyToShort.set(key, shortKey);
+      keyMap[shortKey] = key;
+    }
+  });
+  if (Object.keys(keyMap).length === 0) {
+    return response;
+  }
+  const clonedData = JSON.parse(JSON.stringify(response.data));
+  const sortedArrays = [...filteredArrays].sort((a, b) => {
+    const depthA = (a.path.match(/\./g) || []).length + (a.path.match(/\[/g) || []).length;
+    const depthB = (b.path.match(/\./g) || []).length + (b.path.match(/\[/g) || []).length;
+    return depthB - depthA;
+  });
+  const paths = [];
+  for (const { path, data } of sortedArrays) {
+    const compressedArray = data.map(
+      (item) => compressObjectWithMap(item, keyToShort, config.maxDepth)
+    );
+    setAtPath({ data: clonedData }, path, compressedArray);
+    paths.push(path);
+  }
+  const terseMeta = {
+    v: 1,
+    k: keyMap,
+    paths
+  };
+  const terseResponse = {
+    data: clonedData,
+    __terse__: terseMeta
+  };
+  if ("errors" in response && response.errors) {
+    terseResponse.errors = response.errors;
+  }
+  if ("extensions" in response && response.extensions) {
+    terseResponse.extensions = response.extensions;
+  }
+  if (config.debug) {
+    const originalSize = JSON.stringify(response).length;
+    const compressedSize = JSON.stringify(terseResponse).length;
+    const savings = ((1 - compressedSize / originalSize) * 100).toFixed(1);
+    console.log(
+      `[tersejson/graphql] Compressed ${originalSize} -> ${compressedSize} bytes (${savings}% savings)`
+    );
+    console.log(`[tersejson/graphql] Compressed paths: ${paths.join(", ")}`);
+  }
+  return terseResponse;
+}
+function createTerseFormatFn(options = {}) {
+  return function formatResult(result, _context, _info) {
+    return compressGraphQLResponse(result, options);
+  };
+}
+function terseGraphQL(graphqlMiddleware, options = {}) {
+  const config = { ...DEFAULT_OPTIONS3, ...options };
+  return function terseGraphQLMiddleware(req, res, next) {
+    const acceptsTerse = req.headers["accept-terse"] === "true" || req.headers["x-accept-terse"] === "true";
+    if (!acceptsTerse) {
+      graphqlMiddleware(req, res, next);
+      return;
+    }
+    const originalJson = res.json.bind(res);
+    res.json = function terseGraphQLJson(data) {
+      if (typeof data === "object" && data !== null && "data" in data) {
+        try {
+          const compressed = compressGraphQLResponse(
+            data,
+            config
+          );
+          if ("__terse__" in compressed) {
+            res.setHeader("x-terse-json", "graphql");
+          }
+          return originalJson(compressed);
+        } catch (error) {
+          if (config.debug) {
+            console.error("[tersejson/graphql] Compression failed:", error);
+          }
+          return originalJson(data);
+        }
+      }
+      return originalJson(data);
+    };
+    graphqlMiddleware(req, res, next);
+  };
+}
+var graphql_default = terseGraphQL;
+
+// src/graphql-client.ts
+var graphql_client_exports = {};
+__export(graphql_client_exports, {
+  createGraphQLFetch: () => createGraphQLFetch,
+  createTerseLink: () => createTerseLink,
+  default: () => graphql_client_default,
+  isGraphQLTersePayload: () => isGraphQLTersePayload,
+  processGraphQLResponse: () => processGraphQLResponse
+});
+var DEFAULT_OPTIONS4 = {
+  useProxy: true,
+  debug: false
+};
+function getAtPath(obj, path) {
+  const parts = path.split(/\.|\[(\d+)\]/).filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    const isIndex = /^\d+$/.test(part);
+    if (isIndex) {
+      current = current[parseInt(part, 10)];
+    } else {
+      current = current[part];
+    }
+  }
+  return current;
+}
+function setAtPath2(obj, path, value) {
+  const parts = path.split(/\.|\[(\d+)\]/).filter(Boolean);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const isIndex = /^\d+$/.test(part);
+    if (isIndex) {
+      current = current[parseInt(part, 10)];
+    } else {
+      current = current[part];
+    }
+  }
+  const lastPart = parts[parts.length - 1];
+  const isLastIndex = /^\d+$/.test(lastPart);
+  if (isLastIndex) {
+    current[parseInt(lastPart, 10)] = value;
+  } else {
+    current[lastPart] = value;
+  }
+}
+function expandObject2(obj, keyMap, maxDepth = 10, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return obj;
+  const shortToKey = new Map(
+    Object.entries(keyMap).map(([short, original]) => [short, original])
+  );
+  const expanded = {};
+  for (const [shortKey, value] of Object.entries(obj)) {
+    const originalKey = shortToKey.get(shortKey) ?? shortKey;
+    if (Array.isArray(value)) {
+      expanded[originalKey] = value.map((item) => {
+        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+          return expandObject2(item, keyMap, maxDepth, currentDepth + 1);
+        }
+        return item;
+      });
+    } else if (typeof value === "object" && value !== null) {
+      expanded[originalKey] = expandObject2(
+        value,
+        keyMap,
+        maxDepth,
+        currentDepth + 1
+      );
+    } else {
+      expanded[originalKey] = value;
+    }
+  }
+  return expanded;
+}
+function wrapArrayWithProxies(array, keyMap) {
+  return array.map((item) => createTerseProxy(item, keyMap));
+}
+function expandArray(array, keyMap) {
+  return array.map((item) => expandObject2(item, keyMap));
+}
+function processGraphQLResponse(response, options = {}) {
+  const config = { ...DEFAULT_OPTIONS4, ...options };
+  if (!isGraphQLTersePayload(response)) {
+    return response;
+  }
+  const terseResponse = response;
+  const { data, __terse__, ...rest } = terseResponse;
+  const { k: keyMap, paths } = __terse__;
+  if (config.debug) {
+    console.log("[tersejson/graphql-client] Processing terse response");
+    console.log("[tersejson/graphql-client] Paths:", paths);
+    console.log("[tersejson/graphql-client] Key map:", keyMap);
+  }
+  const clonedData = JSON.parse(JSON.stringify(data));
+  const result = { data: clonedData, ...rest };
+  for (const path of paths) {
+    const array = getAtPath(result, path);
+    if (!array || !Array.isArray(array)) {
+      if (config.debug) {
+        console.warn(`[tersejson/graphql-client] Path not found or not array: ${path}`);
+      }
+      continue;
+    }
+    if (config.useProxy) {
+      const proxied = wrapArrayWithProxies(array, keyMap);
+      setAtPath2(result, path, proxied);
+    } else {
+      const expanded = expandArray(array, keyMap);
+      setAtPath2(result, path, expanded);
+    }
+  }
+  return result;
+}
+function createTerseLink(options = {}) {
+  const config = { ...DEFAULT_OPTIONS4, ...options };
+  return {
+    request(operation, forward) {
+      operation.setContext({
+        ...operation.getContext(),
+        headers: {
+          ...operation.getContext().headers || {},
+          "accept-terse": "true"
+        }
+      });
+      return forward(operation).map((result) => {
+        if (isGraphQLTersePayload(result)) {
+          if (config.debug) {
+            console.log("[tersejson/apollo] Processing terse response");
+          }
+          return processGraphQLResponse(result, config);
+        }
+        return result;
+      });
+    }
+  };
+}
+function createGraphQLFetch(options = {}) {
+  const config = { ...DEFAULT_OPTIONS4, ...options };
+  return async function graphqlFetch(url, body, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("Content-Type", "application/json");
+    headers.set("accept-terse", "true");
+    const response = await fetch(url, {
+      ...init,
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    const data = await response.json();
+    return processGraphQLResponse(data, config);
+  };
+}
+var graphql_client_default = processGraphQLResponse;
+
 exports.TerseAnalytics = TerseAnalytics;
 exports.analytics = analytics;
 exports.client = client_exports;
@@ -991,9 +1385,12 @@ exports.createTerseProxy = createTerseProxy;
 exports.expand = expand;
 exports.express = express_exports;
 exports.getAnalytics = getAnalytics;
+exports.graphql = graphql_exports;
+exports.graphqlClient = graphql_client_exports;
 exports.initAnalytics = initAnalytics;
 exports.integrations = integrations_exports;
 exports.isCompressibleArray = isCompressibleArray;
+exports.isGraphQLTersePayload = isGraphQLTersePayload;
 exports.isTersePayload = isTersePayload;
 exports.recordEvent = recordEvent;
 exports.wrapWithProxy = wrapWithProxy;