@plasmicapp/data-sources 0.1.171 → 0.1.173

package/dist/index.js

@@ -73,30 +73,199 @@ __export(src_exports, {
   executePlasmicDataOp: () => executePlasmicDataOp,
   executeServerQuery: () => executeServerQuery,
   makeCacheKey: () => makeCacheKey,
+  makeQueryCacheKey: () => makeQueryCacheKey,
   mkPlasmicUndefinedServerProxy: () => mkPlasmicUndefinedServerProxy,
   normalizeData: () => normalizeData,
   useDependencyAwareQuery: () => useDependencyAwareQuery,
   useNormalizedData: () => useNormalizedData,
-  usePlasmicDataConfig: () => import_query3.usePlasmicDataConfig,
+  usePlasmicDataConfig: () => import_query5.usePlasmicDataConfig,
   usePlasmicDataMutationOp: () => usePlasmicDataMutationOp,
   usePlasmicDataOp: () => usePlasmicDataOp,
-  usePlasmicInvalidate: () => usePlasmicInvalidate
+  usePlasmicInvalidate: () => usePlasmicInvalidate,
+  usePlasmicServerQuery: () => usePlasmicServerQuery
 });
 module.exports = __toCommonJS(src_exports);
-var import_query3 = require("@plasmicapp/query");
+var import_query5 = require("@plasmicapp/query");
 
 // src/components/Fetcher.tsx
-var import_react = __toESM(require("react"));
+var import_react2 = __toESM(require("react"));
 
 // src/hooks/usePlasmicDataOp.tsx
 var import_data_sources_context = require("@plasmicapp/data-sources-context");
+var import_query3 = require("@plasmicapp/query");
+var React2 = __toESM(require("react"));
+
+// src/common.ts
+var import_query = require("@plasmicapp/query");
 var ph = __toESM(require("@plasmicapp/host"));
-var import_query2 = require("@plasmicapp/query");
-var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+function isPlasmicUndefinedDataErrorPromise(x) {
+  return !!x && typeof x === "object" && (x == null ? void 0 : x.plasmicType) === "PlasmicUndefinedDataError";
+}
+function mkUndefinedDataProxy(promiseRef, fetchAndUpdateCache) {
+  let fetchAndUpdatePromise = void 0;
+  return new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (prop === "isPlasmicUndefinedDataProxy") {
+          return true;
+        }
+        if (!fetchAndUpdateCache) {
+          return void 0;
+        }
+        const doFetchAndUpdate = () => {
+          if (!fetchAndUpdatePromise) {
+            fetchAndUpdatePromise = fetchAndUpdateCache().finally(() => {
+              fetchAndUpdatePromise = void 0;
+            });
+          }
+          return fetchAndUpdatePromise;
+        };
+        const promise = (
+          // existing fetch
+          promiseRef.fetchingPromise || // No existing fetch, so kick off a fetch
+          doFetchAndUpdate()
+        );
+        promise.plasmicType = "PlasmicUndefinedDataError";
+        promise.message = `Cannot read property ${String(
+          prop
+        )} - data is still loading`;
+        throw promise;
+      }
+    }
+  );
+}
+var isRSC = import_react.default.isRSC;
+var reactMajorVersion = +import_react.default.version.split(".")[0];
+var enableLoadingBoundaryKey = "plasmicInternalEnableLoadingBoundary";
+var PRE_FETCHES = /* @__PURE__ */ new Map();
+function usePlasmicFetch(key, resolvedParams, fetcherFn, resultMapper, undefinedDataProxyFields, opts) {
+  var _a, _b;
+  const enableLoadingBoundary = !!((_b = (_a = ph.useDataEnv) == null ? void 0 : _a()) == null ? void 0 : _b[enableLoadingBoundaryKey]);
+  const { mutate, cache } = isRSC ? {} : (0, import_query.usePlasmicDataConfig)();
+  const isNullParams = !resolvedParams;
+  const isWaitingOnDependentQuery = isPlasmicUndefinedDataErrorPromise(resolvedParams);
+  const fetchingData = import_react.default.useMemo(
+    () => ({
+      fetchingPromise: void 0
+    }),
+    [key]
+  );
+  const fetcher = import_react.default.useMemo(
+    () => () => {
+      if (!key) {
+        throw new Error(`Fetcher should never be called without a proper key`);
+      }
+      if (fetchingData.fetchingPromise) {
+        return fetchingData.fetchingPromise;
+      }
+      if (key && PRE_FETCHES.has(key)) {
+        const existing = PRE_FETCHES.get(key);
+        fetchingData.fetchingPromise = existing;
+        return existing;
+      }
+      const fetcherPromise = fetcherFn(resolvedParams);
+      fetchingData.fetchingPromise = fetcherPromise;
+      if (key) {
+        PRE_FETCHES.set(key, fetcherPromise);
+        fetcherPromise.then(
+          () => {
+            PRE_FETCHES.delete(key);
+          },
+          () => {
+            PRE_FETCHES.delete(key);
+          }
+        );
+      }
+      return fetcherPromise;
+    },
+    [key, fetchingData]
+  );
+  const dependentKeyDataErrorPromise = isPlasmicUndefinedDataErrorPromise(
+    resolvedParams
+  ) ? resolvedParams : void 0;
+  const fetchAndUpdateCache = import_react.default.useMemo(() => {
+    if (!key && !dependentKeyDataErrorPromise) {
+      return void 0;
+    }
+    return () => {
+      if (fetchingData.fetchingPromise) {
+        return fetchingData.fetchingPromise;
+      }
+      if (dependentKeyDataErrorPromise) {
+        return dependentKeyDataErrorPromise;
+      }
+      if (!key) {
+        throw new Error(`Expected key to be non-null`);
+      }
+      const cached = cache == null ? void 0 : cache.get(key);
+      if (cached) {
+        return Promise.resolve(cached);
+      }
+      const cachedError = cache == null ? void 0 : cache.get(`$swr$${key}`);
+      if (cachedError) {
+        return Promise.reject(cachedError.error);
+      }
+      const fetcherPromise = new Promise((resolve, reject) => {
+        setTimeout(() => {
+          fetcher().then(resolve, reject);
+        }, 1);
+      });
+      if (!isRSC) {
+        fetcherPromise.then((data2) => {
+          mutate == null ? void 0 : mutate(key, data2);
+        }).catch((err) => {
+          var _a2;
+          const keyInfo = key ? "$swr$" + key : "";
+          cache == null ? void 0 : cache.set(keyInfo, __spreadProps(__spreadValues({}, (_a2 = cache == null ? void 0 : cache.get(keyInfo)) != null ? _a2 : {}), { error: err }));
+        });
+      }
+      return fetcherPromise;
+    };
+  }, [fetcher, fetchingData, cache, key, dependentKeyDataErrorPromise]);
+  const res = (0, import_query.useMutablePlasmicQueryData)(key, fetcher, {
+    fallbackData: opts == null ? void 0 : opts.fallbackData,
+    shouldRetryOnError: false,
+    // If revalidateIfStale is true, then if there's a cache entry with a key,
+    // but no mounted hook with that key yet, and when the hook mounts with the key,
+    // swr will revalidate. This may be reasonable behavior, but for us, this
+    // happens all the time -- we prepopulate the cache with proxy-invoked fetch,
+    // sometimes before swr had a chance to run the effect.  So we turn off
+    // revalidateIfStale here, and just let the user manage invalidation.
+    revalidateIfStale: false
+  });
+  const { data, error, isLoading } = res;
+  if (fetchingData.fetchingPromise != null && data !== void 0) {
+    fetchingData.fetchingPromise = void 0;
+  }
+  return import_react.default.useMemo(() => {
+    const result = resultMapper(res);
+    if (!(opts == null ? void 0 : opts.noUndefinedDataProxy) && reactMajorVersion >= 18 && enableLoadingBoundary && (isLoading || isNullParams || isWaitingOnDependentQuery) && undefinedDataProxyFields.every((field) => result[field] === void 0)) {
+      undefinedDataProxyFields.forEach((field) => {
+        if (field === "error") {
+          return;
+        }
+        result[field] = mkUndefinedDataProxy(fetchingData, fetchAndUpdateCache);
+      });
+    }
+    return result;
+  }, [
+    isNullParams,
+    isWaitingOnDependentQuery,
+    data,
+    error,
+    isLoading,
+    opts == null ? void 0 : opts.noUndefinedDataProxy,
+    enableLoadingBoundary,
+    fetchingData,
+    fetchAndUpdateCache
+  ]);
+}
 
 // src/executor.tsx
 var import_isomorphic_unfetch = __toESM(require("@plasmicapp/isomorphic-unfetch"));
-var import_query = require("@plasmicapp/query");
+var import_query2 = require("@plasmicapp/query");
 var import_fast_stringify = __toESM(require("fast-stringify"));
 
 // src/placeholders.ts
@@ -124,7 +293,7 @@ function executePlasmicDataOp(op, opts) {
       _executePlasmicDataOp
     );
     op.userArgs = addPlaceholdersToUserArgs(op.userArgs);
-    const res = yield (0, import_query.wrapLoadingFetcher)(func)(op, opts);
+    const res = yield (0, import_query2.wrapLoadingFetcher)(func)(op, opts);
     return res;
   });
 }
@@ -194,7 +363,6 @@ function withoutNils(xs) {
 }
 
 // src/hooks/usePlasmicDataOp.tsx
-var isRSC2 = React.isRSC;
 function makeCacheKey(dataOp, opts) {
   const queryDependencies = JSON.stringify({
     sourceId: dataOp.sourceId,
@@ -206,7 +374,7 @@ function makeCacheKey(dataOp, opts) {
   return dataOp.cacheKey ? `${dataOp.cacheKey}${queryDependencies}` : queryDependencies;
 }
 function usePlasmicInvalidate() {
-  const { cache, fallback, mutate } = (0, import_query2.usePlasmicDataConfig)();
+  const { cache, fallback, mutate } = (0, import_query3.usePlasmicDataConfig)();
   return (invalidatedKeys) => __async(this, null, function* () {
     const getKeysToInvalidate = () => {
       var _a, _b;
@@ -255,45 +423,6 @@ function usePlasmicInvalidate() {
     return yield Promise.all(keys.map((key) => invalidateKey(key)));
   });
 }
-var enableLoadingBoundaryKey = "plasmicInternalEnableLoadingBoundary";
-function mkUndefinedDataProxy(promiseRef, fetchAndUpdateCache) {
-  let fetchAndUpdatePromise = void 0;
-  return new Proxy(
-    {},
-    {
-      get: (_target, prop) => {
-        if (prop === "isPlasmicUndefinedDataProxy") {
-          return true;
-        }
-        if (!fetchAndUpdateCache) {
-          return void 0;
-        }
-        const doFetchAndUpdate = () => {
-          if (!fetchAndUpdatePromise) {
-            fetchAndUpdatePromise = fetchAndUpdateCache().finally(() => {
-              fetchAndUpdatePromise = void 0;
-            });
-          }
-          return fetchAndUpdatePromise;
-        };
-        const promise = (
-          // existing fetch
-          promiseRef.fetchingPromise || // No existing fetch, so kick off a fetch
-          doFetchAndUpdate()
-        );
-        promise.plasmicType = "PlasmicUndefinedDataError";
-        promise.message = `Cannot read property ${String(
-          prop
-        )} - data is still loading`;
-        throw promise;
-      }
-    }
-  );
-}
-function isPlasmicUndefinedDataErrorPromise(x) {
-  return !!x && typeof x === "object" && x.plasmicType === "PlasmicUndefinedDataError";
-}
-var reactMajorVersion = +React.version.split(".")[0];
 function resolveDataOp(dataOp) {
   if (typeof dataOp === "function") {
     try {
@@ -308,138 +437,39 @@ function resolveDataOp(dataOp) {
     return dataOp;
   }
 }
-var PRE_FETCHES = /* @__PURE__ */ new Map();
 function usePlasmicDataOp(dataOp, opts) {
-  var _a, _b;
   const resolvedDataOp = resolveDataOp(dataOp);
   const ctx = (0, import_data_sources_context.usePlasmicDataSourceContext)();
-  const enableLoadingBoundary = !!((_b = (_a = ph.useDataEnv) == null ? void 0 : _a()) == null ? void 0 : _b[enableLoadingBoundaryKey]);
-  const { mutate, cache } = isRSC2 ? {} : (0, import_query2.usePlasmicDataConfig)();
-  const isNullDataOp = !resolvedDataOp;
-  const isWaitingOnDependentQuery = isPlasmicUndefinedDataErrorPromise(resolvedDataOp);
   const key = !resolvedDataOp || isPlasmicUndefinedDataErrorPromise(resolvedDataOp) ? null : makeCacheKey(resolvedDataOp, {
     paginate: opts == null ? void 0 : opts.paginate,
     userAuthToken: ctx == null ? void 0 : ctx.userAuthToken
   });
-  const fetchingData = React.useMemo(
-    () => ({
-      fetchingPromise: void 0
-    }),
-    [key]
-  );
-  const fetcher = React.useMemo(
-    () => () => {
-      if (!key) {
-        throw new Error(`Fetcher should never be called without a proper key`);
-      }
-      if (fetchingData.fetchingPromise) {
-        return fetchingData.fetchingPromise;
-      }
-      if (key && PRE_FETCHES.has(key)) {
-        const existing = PRE_FETCHES.get(key);
-        fetchingData.fetchingPromise = existing;
-        return existing;
-      }
-      const fetcherFn = () => executePlasmicDataOp(resolvedDataOp, {
-        userAuthToken: (ctx == null ? void 0 : ctx.userAuthToken) || void 0,
-        user: ctx == null ? void 0 : ctx.user,
-        paginate: opts == null ? void 0 : opts.paginate
-      });
-      const fetcherPromise = fetcherFn();
-      fetchingData.fetchingPromise = fetcherPromise;
-      if (key) {
-        PRE_FETCHES.set(key, fetcherPromise);
-        fetcherPromise.then(
-          () => {
-            PRE_FETCHES.delete(key);
-          },
-          () => {
-            PRE_FETCHES.delete(key);
-          }
-        );
-      }
-      return fetcherPromise;
-    },
-    [key, fetchingData]
-  );
-  const dependentKeyDataErrorPromise = isPlasmicUndefinedDataErrorPromise(
-    resolvedDataOp
-  ) ? resolvedDataOp : void 0;
-  const fetchAndUpdateCache = React.useMemo(() => {
-    if (!key && !dependentKeyDataErrorPromise) {
-      return void 0;
-    }
-    return () => {
-      if (fetchingData.fetchingPromise) {
-        return fetchingData.fetchingPromise;
-      }
-      if (dependentKeyDataErrorPromise) {
-        return dependentKeyDataErrorPromise;
-      }
-      if (!key) {
-        throw new Error(`Expected key to be non-null`);
-      }
-      const cached = cache == null ? void 0 : cache.get(key);
-      if (cached) {
-        return Promise.resolve(cached);
-      }
-      const cachedError = cache == null ? void 0 : cache.get(`$swr$${key}`);
-      if (cachedError) {
-        return Promise.reject(cachedError.error);
-      }
-      const fetcherPromise = new Promise((resolve, reject) => {
-        setTimeout(() => {
-          fetcher().then(resolve, reject);
-        }, 1);
-      });
-      if (!isRSC2)
-        fetcherPromise.then((data2) => {
-          mutate == null ? void 0 : mutate(key, data2);
-        }).catch((err) => {
-          var _a2;
-          const keyInfo = key ? "$swr$" + key : "";
-          cache == null ? void 0 : cache.set(keyInfo, __spreadProps(__spreadValues({}, (_a2 = cache == null ? void 0 : cache.get(keyInfo)) != null ? _a2 : {}), { error: err }));
-        });
-      return fetcherPromise;
-    };
-  }, [fetcher, fetchingData, cache, key, dependentKeyDataErrorPromise]);
-  const res = (0, import_query2.useMutablePlasmicQueryData)(key, fetcher, {
-    shouldRetryOnError: false,
-    // If revalidateIfStale is true, then if there's a cache entry with a key,
-    // but no mounted hook with that key yet, and when the hook mounts with the key,
-    // swr will revalidate. This may be reasonable behavior, but for us, this
-    // happens all the time -- we prepopulate the cache with proxy-invoked fetch,
-    // sometimes before swr had a chance to run the effect.  So we turn off
-    // revalidateIfStale here, and just let the user manage invalidation.
-    revalidateIfStale: false
-  });
-  const { data, error, isLoading } = res;
-  if (fetchingData.fetchingPromise != null && data !== void 0) {
-    fetchingData.fetchingPromise = void 0;
-  }
-  return React.useMemo(() => {
-    const result = __spreadValues(__spreadValues({}, data != null ? data : {}), pick(res, "isLoading", "error"));
-    if (!(opts == null ? void 0 : opts.noUndefinedDataProxy) && reactMajorVersion >= 18 && enableLoadingBoundary && (isLoading || isNullDataOp || isWaitingOnDependentQuery) && result.data === void 0 && result.schema === void 0 && result.error === void 0) {
-      result.data = mkUndefinedDataProxy(fetchingData, fetchAndUpdateCache);
-      result.schema = mkUndefinedDataProxy(fetchingData, fetchAndUpdateCache);
+  const fetcher = (op) => {
+    return executePlasmicDataOp(op, {
+      userAuthToken: (ctx == null ? void 0 : ctx.userAuthToken) || void 0,
+      user: ctx == null ? void 0 : ctx.user,
+      paginate: opts == null ? void 0 : opts.paginate
+    });
+  };
+  const resultMapper = (result) => {
+    var _a;
+    return __spreadValues(__spreadValues({}, (_a = result.data) != null ? _a : {}), pick(result, "error", "isLoading"));
+  };
+  return usePlasmicFetch(
+    key,
+    resolvedDataOp,
+    fetcher,
+    resultMapper,
+    ["data", "schema", "error"],
+    {
+      noUndefinedDataProxy: opts == null ? void 0 : opts.noUndefinedDataProxy
     }
-    return result;
-  }, [
-    isNullDataOp,
-    isWaitingOnDependentQuery,
-    data,
-    error,
-    isLoading,
-    opts == null ? void 0 : opts.noUndefinedDataProxy,
-    enableLoadingBoundary,
-    fetchingData,
-    fetchAndUpdateCache
-  ]);
+  );
 }
 function usePlasmicDataMutationOp(dataOp) {
   const ctx = (0, import_data_sources_context.usePlasmicDataSourceContext)();
   const userToken = ctx == null ? void 0 : ctx.userAuthToken;
-  const getRealDataOp = React.useCallback(() => __async(this, null, function* () {
+  const getRealDataOp = React2.useCallback(() => __async(this, null, function* () {
     const tryGetRealDataOp = () => __async(this, null, function* () {
       const resolved = resolveDataOp(dataOp);
       if (!resolved) {
@@ -453,7 +483,7 @@ function usePlasmicDataMutationOp(dataOp) {
     });
     return yield tryGetRealDataOp();
   }), [dataOp]);
-  return React.useCallback(() => __async(this, null, function* () {
+  return React2.useCallback(() => __async(this, null, function* () {
     var _a;
     const { sourceId, opId, userArgs } = (_a = yield getRealDataOp()) != null ? _a : {};
     if (!sourceId || !opId) {
@@ -476,7 +506,7 @@ function Fetcher(props) {
   const data = usePlasmicDataOp(dataOp, __spreadValues({}, !!pageIndex && !!pageSize && {
     paginate: { pageIndex, pageSize }
   }));
-  const $queries = import_react.default.useMemo(
+  const $queries = import_react2.default.useMemo(
     () => __spreadProps(__spreadValues({}, props.queries), { [name != null ? name : "data"]: data }),
     [props.queries, name, data]
   );
@@ -518,7 +548,7 @@ var FetcherMeta = {
 };
 
 // src/helpers.ts
-var import_react2 = require("react");
+var import_react3 = require("react");
 function normalizeData(rawData) {
   var _a;
   if (!rawData) {
@@ -535,7 +565,7 @@ function normalizeData(rawData) {
   return { data: dataArray, schema };
 }
 function useNormalizedData(rawData) {
-  return (0, import_react2.useMemo)(() => normalizeData(rawData), [rawData]);
+  return (0, import_react3.useMemo)(() => normalizeData(rawData), [rawData]);
 }
 function tryGetDataArray(rawData) {
   if (rawData == null || typeof rawData !== "object") {
@@ -629,10 +659,10 @@ function deriveFieldConfigs(specifiedFieldsPartial, schema, makeDefaultConfig) {
 }
 
 // src/hooks/useDependencyAwareQuery.tsx
-var import_react3 = __toESM(require("react"));
+var import_react4 = __toESM(require("react"));
 function usePrevious(value) {
-  const prevValue = import_react3.default.useRef(void 0);
-  import_react3.default.useEffect(() => {
+  const prevValue = import_react4.default.useRef(void 0);
+  import_react4.default.useEffect(() => {
     prevValue.current = value;
     return () => {
       prevValue.current = void 0;
@@ -653,7 +683,7 @@ function useDependencyAwareQuery({
   }));
   const finalName = name != null ? name : "data";
   const prevName = usePrevious(finalName);
-  import_react3.default.useEffect(() => {
+  import_react4.default.useEffect(() => {
     if (!(finalName in $queries) || $queries[finalName] !== data) {
       const $queries2 = __spreadProps(__spreadValues({}, $queries), {
         [finalName]: data
@@ -666,6 +696,48 @@ function useDependencyAwareQuery({
   }, [finalName, prevName, data, $queries, setDollarQueries]);
 }
 
+// src/serverQueries/client.ts
+var import_query4 = require("@plasmicapp/query");
+
+// src/serverQueries/common.ts
+function resolveParams(params, errorFn) {
+  try {
+    return params();
+  } catch (err) {
+    return errorFn(err);
+  }
+}
+
+// src/serverQueries/client.ts
+function makeQueryCacheKey(id, params) {
+  return `${id}:${JSON.stringify(params)}`;
+}
+function usePlasmicServerQuery(serverQuery, fallbackData, opts) {
+  const resolvedParams = resolveParams(serverQuery.execParams, (err) => {
+    if (isPlasmicUndefinedDataErrorPromise(err)) {
+      return err;
+    }
+    throw err;
+  });
+  const key = !resolvedParams || isPlasmicUndefinedDataErrorPromise(resolvedParams) ? null : makeQueryCacheKey(serverQuery.id, resolvedParams);
+  const fetcher = (params) => {
+    return (0, import_query4.wrapLoadingFetcher)(serverQuery.fn)(...params);
+  };
+  const resultMapper = (result) => {
+    return __spreadValues({}, pick(result, "data", "error", "isLoading"));
+  };
+  return usePlasmicFetch(
+    key,
+    resolvedParams,
+    fetcher,
+    resultMapper,
+    ["data", "error"],
+    __spreadValues({
+      fallbackData
+    }, opts)
+  );
+}
+
 // src/serverQueries/server.ts
 var PlasmicUndefinedServerError = class extends Error {
   constructor(msg) {
@@ -694,19 +766,14 @@ function mkPlasmicUndefinedServerProxy() {
     isLoading: true
   };
 }
-function resolveParams(params) {
-  try {
-    return params();
-  } catch (err) {
-    if (isPlasmicUndefinedServerError(err)) {
-      return err;
-    }
-    throw err;
-  }
-}
 function executeServerQuery(serverQuery) {
   return __async(this, null, function* () {
-    const resolvedParams = resolveParams(serverQuery.execParams);
+    const resolvedParams = resolveParams(serverQuery.execParams, (err) => {
+      if (isPlasmicUndefinedServerError(err)) {
+        return err;
+      }
+      throw err;
+    });
     if (isPlasmicUndefinedServerError(resolvedParams)) {
       return mkPlasmicUndefinedServerProxy();
     }