@plasmicapp/data-sources 0.1.202 → 0.1.203

package/dist/index.esm.js

@@ -38,18 +38,13 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// src/index.tsx
-import { usePlasmicDataConfig as usePlasmicDataConfig3 } from "@plasmicapp/query";
-
-// src/components/Fetcher.tsx
-import React3 from "react";
-
-// src/hooks/usePlasmicDataOp.tsx
-import { usePlasmicDataSourceContext } from "@plasmicapp/data-sources-context";
+// src/serverQueries/client.ts
 import {
-  usePlasmicDataConfig as usePlasmicDataConfig2
+  useMutablePlasmicQueryData as useMutablePlasmicQueryData2,
+  usePlasmicDataConfig as usePlasmicDataConfig2,
+  wrapLoadingFetcher
 } from "@plasmicapp/query";
-import * as React2 from "react";
+import * as React3 from "react";
 
 // src/common.ts
 import {
@@ -61,6 +56,14 @@ import React from "react";
 function isPlasmicUndefinedDataErrorPromise(x) {
   return !!x && typeof x === "object" && (x == null ? void 0 : x.plasmicType) === "PlasmicUndefinedDataError";
 }
+function tagPlasmicUndefinedDataErrorPromise(promise) {
+  promise.plasmicType = "PlasmicUndefinedDataError";
+  promise.message = "Query is not done";
+}
+function untagPlasmicUndefinedDataErrorPromise(promise) {
+  delete promise.plasmicType;
+  delete promise.message;
+}
 function mkUndefinedDataProxy(promiseRef, fetchAndUpdateCache) {
   let fetchAndUpdatePromise = void 0;
   return new Proxy(
@@ -230,9 +233,694 @@ function getConfig(key, defaultValue) {
   }
 }
 
+// src/utils.ts
+function noopFn() {
+}
+function swallow(f) {
+  try {
+    return f();
+  } catch (e) {
+    return void 0;
+  }
+}
+function pick(obj, ...keys) {
+  const res = {};
+  for (const key of keys) {
+    if (key in obj) {
+      res[key] = obj[key];
+    }
+  }
+  return res;
+}
+var tuple = (...args) => args;
+function mkIdMap(xs) {
+  return new Map(xs.map((x) => tuple(x.id, x)));
+}
+function notNil(x) {
+  return x !== null && x !== void 0;
+}
+function withoutNils(xs) {
+  return xs.filter(notNil);
+}
+function mapRecordEntries(callback, record1, record2, record3) {
+  return Object.entries(record1).map(([k, v1]) => {
+    const v2 = record2 == null ? void 0 : record2[k];
+    const v3 = record3 == null ? void 0 : record3[k];
+    return callback(
+      k,
+      v1,
+      v2,
+      v3
+    );
+  });
+}
+function mapRecords(callback, record1, record2, record3) {
+  return Object.fromEntries(
+    mapRecordEntries(
+      (k, v1, v2, v3) => [k, callback(k, v1, v2, v3)],
+      record1,
+      record2,
+      record3
+    )
+  );
+}
+
+// src/serverQueries/common.ts
+import React2 from "react";
+function createDollarQueries(queryNames) {
+  return Object.fromEntries(
+    queryNames.map((queryName) => {
+      return [queryName, new StatefulQueryResult()];
+    })
+  );
+}
+var StatefulQueryResult = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.current = { state: "initial", key: null };
+    this.settable = new SettablePromise();
+    tagPlasmicUndefinedDataErrorPromise(this.settable.promise);
+  }
+  transitionState(next) {
+    const prev = this.current;
+    if (prev.state === next.state && prev.key === next.key && ("data" in prev ? prev.data : void 0) === ("data" in next ? next.data : void 0) && ("error" in prev ? prev.error : void 0) === ("error" in next ? next.error : void 0)) {
+      return;
+    }
+    if (prev.key !== null && // the promise was already bound to a key AND
+    // NOT the loading -> done transition with the same key
+    !(prev.key === next.key && prev.state === "loading" && next.state === "done")) {
+      this.settable = new SettablePromise();
+      tagPlasmicUndefinedDataErrorPromise(this.settable.promise);
+    }
+    this.current = next;
+    this.notifyListeners(prev);
+  }
+  addListener(listener) {
+    this.listeners.add(listener);
+  }
+  removeListener(listener) {
+    this.listeners.delete(listener);
+  }
+  notifyListeners(prev) {
+    for (const listener of this.listeners) {
+      listener(this.current, prev);
+    }
+  }
+  reset() {
+    this.transitionState({
+      state: "initial",
+      key: null
+    });
+  }
+  loadingPromise(key, promise) {
+    this.transitionState({
+      state: "loading",
+      key
+    });
+    promise.then(
+      (value) => this.resolvePromise(key, value),
+      (err) => this.rejectPromise(key, err)
+    );
+  }
+  /**
+   * Resolve is allowed if:
+   * 1) no key / state is initial, which means we are resolving from cache
+   * 2) key / state is loading, which means we need to check the keys match
+   */
+  resolvePromise(key, data) {
+    if (this.current.key === null || this.current.key === key) {
+      this.transitionState({
+        state: "done",
+        key,
+        data
+      });
+      this.settable.resolve(data);
+      untagPlasmicUndefinedDataErrorPromise(this.settable.promise);
+    }
+  }
+  /**
+   * Reject is allowed if:
+   * 1) no key / state is initial, which means params resolution failed
+   * 2) key / state is loading, which means we need to check the keys match
+   */
+  rejectPromise(key, error) {
+    if (this.current.key === null || this.current.key === key) {
+      this.transitionState({
+        state: "done",
+        key,
+        error
+      });
+      this.settable.promise.catch(noopFn);
+      this.settable.reject(error);
+      untagPlasmicUndefinedDataErrorPromise(this.settable.promise);
+    }
+  }
+  get key() {
+    return this.current.key;
+  }
+  get data() {
+    if (this.current.state === "done") {
+      if ("data" in this.current) {
+        return this.current.data;
+      } else {
+        throw this.current.error;
+      }
+    } else {
+      throw this.settable.promise;
+    }
+  }
+  get isLoading() {
+    return this.current.state === "initial" || this.current.state === "loading";
+  }
+  getDoneResult() {
+    return __async(this, null, function* () {
+      yield this.settable.promise;
+      return this;
+    });
+  }
+};
+function safeExec(tryData, ifUndefined, ifError) {
+  try {
+    return tryData();
+  } catch (err) {
+    if (isPlasmicUndefinedDataErrorPromise(err)) {
+      return ifUndefined(err);
+    } else {
+      return ifError(err);
+    }
+  }
+}
+function resolveParams(params) {
+  return safeExec(
+    () => ({
+      status: "ready",
+      resolvedParams: params()
+    }),
+    (promise) => ({
+      status: "blocked",
+      promise
+    }),
+    (err) => ({
+      status: "error",
+      error: new Error("Error resolving function params", { cause: err })
+    })
+  );
+}
+function wrapDollarQueriesForMetadata($queries, ifUndefined, ifError) {
+  return wrapDollarQueriesWithFallbacks(
+    $queries,
+    ifUndefined != null ? ifUndefined : () => "\u2026",
+    ifError != null ? ifError : () => "[ERROR]"
+  );
+}
+function wrapDollarQueriesWithFallbacks($queries, ifUndefined, ifError) {
+  return mapRecords(
+    (_queryName, $query) => new FallbackQueryResult($query, ifUndefined, ifError),
+    $queries
+  );
+}
+var FallbackQueryResult = class {
+  constructor($query, ifUndefined, ifError) {
+    this.$query = $query;
+    this.ifUndefined = ifUndefined;
+    this.ifError = ifError;
+  }
+  get key() {
+    return this.$query.key;
+  }
+  get data() {
+    return safeExec(
+      () => this.$query.data,
+      (promise) => createConstantProxy(this.ifUndefined(promise)),
+      (err) => createConstantProxy(this.ifError(err))
+    );
+  }
+  get isLoading() {
+    return this.$query.isLoading;
+  }
+};
+function createConstantProxy(constant) {
+  const constantProxy = new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        return prop === Symbol.toPrimitive ? () => constant : constantProxy;
+      }
+    }
+  );
+  return constantProxy;
+}
+var SyncPromise = class {
+  constructor(promise) {
+    this.promise = promise;
+    this.result = void 0;
+    promise.then(
+      (value) => {
+        this.result = {
+          state: "resolved",
+          value
+        };
+      },
+      (error) => {
+        this.result = {
+          state: "rejected",
+          error
+        };
+      }
+    );
+  }
+};
+var SettablePromise = class {
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(value) {
+    this._resolve(value);
+  }
+  reject(error) {
+    this._reject(error);
+  }
+};
+function useRenderEffect(effect, deps) {
+  const ref = React2.useRef({ deps: void 0, cleanup: void 0 });
+  const depsChanged = ref.current.deps === void 0 || deps.length !== ref.current.deps.length || deps.some((dep, i) => !Object.is(dep, ref.current.deps[i]));
+  if (depsChanged) {
+    if (ref.current.cleanup) {
+      ref.current.cleanup();
+    }
+    const prevDeps = ref.current.deps;
+    ref.current.cleanup = effect(prevDeps);
+    ref.current.deps = deps;
+  }
+  React2.useEffect(() => {
+    return () => {
+      if (ref.current.cleanup) {
+        ref.current.cleanup();
+      }
+    };
+  }, []);
+}
+
+// src/serverQueries/makeQueryCacheKey.ts
+function makeQueryCacheKey(id, params) {
+  return `${id}:${safeStableStringify(params)}`;
+}
+var shortPlasmicPrefix = "\u03C1";
+function safeStableStringify(unstableValue) {
+  const stableValue = sortObjectsDeep(unstableValue, /* @__PURE__ */ new Map());
+  const visitedPaths = /* @__PURE__ */ new Map();
+  return JSON.stringify(stableValue, function(key, value) {
+    switch (typeof value) {
+      case "undefined":
+        return `${shortPlasmicPrefix}:UNDEFINED`;
+      case "function":
+        return `${shortPlasmicPrefix}:FUNCTION:${value.name}`;
+      case "symbol":
+        return `${shortPlasmicPrefix}:SYMBOL:${value.description}`;
+      case "bigint":
+        return value.toString();
+      case "object":
+        if (value !== null) {
+          const cyclePath = visitedPaths.get(value);
+          if (cyclePath) {
+            return `${shortPlasmicPrefix}:REF:${cyclePath}`;
+          }
+          const parentPath = visitedPaths.get(this);
+          const valuePath = parentPath === void 0 ? "$" : `${parentPath}.${key}`;
+          visitedPaths.set(value, valuePath);
+        }
+        return value;
+      default:
+        return value;
+    }
+  });
+}
+function sortObjectsDeep(value, visitedObjects) {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const visitedValue = visitedObjects.get(value);
+  if (visitedValue) {
+    return visitedValue;
+  }
+  if (Array.isArray(value)) {
+    const newArr = [];
+    visitedObjects.set(value, newArr);
+    value.forEach((item, key) => {
+      newArr[key] = sortObjectsDeep(item, visitedObjects);
+    });
+    return newArr;
+  } else {
+    const newObj = {};
+    visitedObjects.set(value, newObj);
+    Object.keys(value).sort().forEach((key) => {
+      newObj[key] = sortObjectsDeep(value[key], visitedObjects);
+    });
+    return newObj;
+  }
+}
+
+// src/serverQueries/client.ts
+var GLOBAL_CACHE = /* @__PURE__ */ new Map();
+function usePlasmicQueries($queries, queries) {
+  const wrappedQueries = React3.useMemo(() => wrapQueries(queries), [queries]);
+  const $queryStates = $queries;
+  const { fallback: prefetchedCache, cache: swrCache } = usePlasmicDataConfig2();
+  const [settledCount, setSettledCount] = React3.useState(0);
+  React3.useEffect(() => {
+    let cleanup = false;
+    const resultListener = (next, prev) => {
+      if (cleanup) {
+        return;
+      }
+      if (prev.state === "done" || next.state === "done") {
+        queueMicrotask(() => setSettledCount((v) => v + 1));
+      }
+    };
+    mapRecords((_queryName, $query) => {
+      $query.addListener(resultListener);
+    }, $queryStates);
+    return () => {
+      cleanup = true;
+      mapRecords((_queryName, $query) => {
+        $query.removeListener(resultListener);
+      }, $queryStates);
+    };
+  }, [$queryStates]);
+  useRenderEffect(
+    (prevDeps) => {
+      if (prevDeps) {
+        const prevWrappedQueries = prevDeps[0];
+        if (!Object.is(prevWrappedQueries, wrappedQueries)) {
+          mapRecords((_queryName, $query) => {
+            $query.reset();
+          }, $queryStates);
+        }
+      }
+      let cleanup = false;
+      const loop = () => __async(this, null, function* () {
+        while (true) {
+          initPlasmicQueriesSync(
+            $queryStates,
+            wrappedQueries,
+            prefetchedCache,
+            swrCache
+          );
+          const loadingQueries = mapRecordEntries((_queryName, $query) => {
+            if ($query.isLoading) {
+              return $query.getDoneResult();
+            } else {
+              return null;
+            }
+          }, $queryStates).filter(notNil);
+          if (loadingQueries.length === 0) {
+            break;
+          }
+          yield Promise.race(loadingQueries);
+          if (cleanup) {
+            break;
+          }
+        }
+      });
+      loop().catch(noopFn);
+      return () => {
+        cleanup = true;
+      };
+    },
+    [wrappedQueries, $queryStates, settledCount]
+  );
+  mapRecordEntries(
+    (_queryName, $query, query) => {
+      usePlasmicServerQuery(
+        query,
+        void 0,
+        {
+          settledCount,
+          onStarted: $query.loadingPromise.bind($query),
+          onResolved: $query.resolvePromise.bind($query),
+          onRejected: $query.rejectPromise.bind($query)
+        }
+      );
+    },
+    $queryStates,
+    wrappedQueries
+  );
+}
+function wrapQueries(queries) {
+  return mapRecords((_queryName, query) => {
+    const wrappedFn = (...args) => {
+      const cacheKey = makeQueryCacheKey(query.id, args);
+      const cached = GLOBAL_CACHE.get(cacheKey);
+      if (cached) {
+        return cached.promise;
+      }
+      const wrapStudioCache = getConfig(
+        "EXECUTE_SERVER_QUERY",
+        (_, fn, ...args2) => fn(...args2)
+      );
+      const promise = wrapLoadingFetcher(wrapStudioCache)(
+        query.id,
+        query.fn,
+        ...args
+      );
+      GLOBAL_CACHE.set(cacheKey, new SyncPromise(promise));
+      return promise;
+    };
+    return {
+      id: query.id,
+      fn: wrappedFn,
+      execParams: query.execParams
+    };
+  }, queries);
+}
+function initPlasmicQueriesSync($queries, queries, prefetchedCache, clientCache) {
+  let anySettled;
+  do {
+    anySettled = false;
+    mapRecords(
+      (_queryName, $query, query) => {
+        if ($query.current.state !== "initial") {
+          return;
+        }
+        const paramsResult = resolveParams(query.execParams);
+        if (paramsResult.status === "error") {
+          $query.rejectPromise(null, paramsResult.error);
+          anySettled = true;
+          return;
+        } else if (paramsResult.status === "blocked") {
+          return;
+        }
+        const cacheKey = makeQueryCacheKey(
+          query.id,
+          paramsResult.resolvedParams
+        );
+        if (cacheKey in prefetchedCache) {
+          $query.resolvePromise(cacheKey, prefetchedCache[cacheKey]);
+          anySettled = true;
+          return;
+        }
+        const clientCacheData = clientCache.get(cacheKey);
+        if (clientCacheData !== void 0) {
+          $query.resolvePromise(cacheKey, clientCacheData);
+          anySettled = true;
+          return;
+        }
+        const clientCachedPromise = GLOBAL_CACHE.get(cacheKey);
+        if (clientCachedPromise == null ? void 0 : clientCachedPromise.result) {
+          if (clientCachedPromise.result.state === "resolved") {
+            $query.resolvePromise(cacheKey, clientCachedPromise.result.value);
+          } else {
+            $query.rejectPromise(cacheKey, clientCachedPromise.result.error);
+          }
+          anySettled = true;
+          return;
+        }
+        $query.loadingPromise(
+          cacheKey,
+          query.fn(...paramsResult.resolvedParams)
+        );
+      },
+      $queries,
+      queries
+    );
+  } while (anySettled);
+}
+function usePlasmicServerQuery(query, fallbackData, opts) {
+  var _a, _b;
+  const paramsResult = React3.useMemo(() => {
+    return resolveParams(query.execParams);
+  }, [query.execParams, opts == null ? void 0 : opts.settledCount]);
+  const { key, fetcher } = React3.useMemo(() => {
+    switch (paramsResult.status) {
+      case "blocked":
+      case "error": {
+        return {
+          key: null,
+          fetcher: () => {
+            throw new Error("fetcher unexpectedly invoked");
+          }
+        };
+      }
+      case "ready": {
+        const cacheKey = makeQueryCacheKey(
+          query.id,
+          paramsResult.resolvedParams
+        );
+        return {
+          key: cacheKey,
+          fetcher: () => {
+            var _a2;
+            const promise = query.fn(...paramsResult.resolvedParams);
+            (_a2 = opts == null ? void 0 : opts.onStarted) == null ? void 0 : _a2.call(opts, cacheKey, promise);
+            return promise.finally(() => {
+              GLOBAL_CACHE.delete(cacheKey);
+            });
+          }
+        };
+      }
+    }
+  }, [query, paramsResult]);
+  const result = useMutablePlasmicQueryData2(key, fetcher, {
+    // 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,
+    // TODO: Remove per-hook fallbackData
+    // Only used in older server query implementation.
+    // New implementation should use prefetchedCache instead.
+    fallbackData
+  });
+  if (!result.isLoading) {
+    if (result.error) {
+      (_a = opts == null ? void 0 : opts.onRejected) == null ? void 0 : _a.call(opts, key, result.error);
+    } else if (key && result.data !== void 0) {
+      (_b = opts == null ? void 0 : opts.onResolved) == null ? void 0 : _b.call(opts, key, result.data);
+    }
+  }
+  return result;
+}
+
+// src/serverQueries/server.ts
+function executePlasmicQueries($queries, queries) {
+  return __async(this, null, function* () {
+    const doneQueryResults = yield Promise.all(
+      mapRecordEntries(
+        (_queryName, $query, query) => {
+          return executePlasmicQuery($query, query);
+        },
+        $queries,
+        queries
+      )
+    );
+    return Object.fromEntries(
+      Object.values(doneQueryResults).map(($query) => [$query.key, $query.data])
+    );
+  });
+}
+function executePlasmicQuery($query, query) {
+  return __async(this, null, function* () {
+    if ($query.current.state === "loading" || $query.current.state === "done") {
+      return $query.getDoneResult();
+    }
+    do {
+      const paramsResult = resolveParams(query.execParams);
+      switch (paramsResult.status) {
+        case "blocked": {
+          try {
+            yield paramsResult.promise;
+          } catch (e) {
+          }
+          continue;
+        }
+        case "ready": {
+          const cacheKey = makeQueryCacheKey(
+            query.id,
+            paramsResult.resolvedParams
+          );
+          $query.loadingPromise(
+            cacheKey,
+            query.fn(...paramsResult.resolvedParams)
+          );
+          return $query.getDoneResult();
+        }
+        case "error": {
+          $query.rejectPromise(null, paramsResult.error);
+          throw paramsResult.error;
+        }
+      }
+    } while (true);
+  });
+}
+var PlasmicUndefinedServerError = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.plasmicType = "PlasmicUndefinedServerError";
+  }
+};
+function isPlasmicUndefinedServerError(x) {
+  return !!x && typeof x === "object" && x.plasmicType === "PlasmicUndefinedServerError";
+}
+function mkPlasmicUndefinedServerProxy() {
+  return {
+    data: new Proxy(
+      {},
+      {
+        get: (_, prop) => {
+          if (prop === "isUndefinedServerProxy") {
+            return true;
+          } else if (prop === "then") {
+            return void 0;
+          }
+          throw new PlasmicUndefinedServerError("Data is not available yet");
+        }
+      }
+    ),
+    isLoading: true
+  };
+}
+function executeServerQuery(query) {
+  return __async(this, null, function* () {
+    const resolvedParams = resolveServerParams(query.execParams);
+    if (isPlasmicUndefinedServerError(resolvedParams)) {
+      return mkPlasmicUndefinedServerProxy();
+    }
+    return { data: yield query.fn(...resolvedParams), isLoading: false };
+  });
+}
+function resolveServerParams(params) {
+  try {
+    return params();
+  } catch (err) {
+    if (isPlasmicUndefinedServerError(err)) {
+      return err;
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/index.tsx
+import { usePlasmicDataConfig as usePlasmicDataConfig4 } from "@plasmicapp/query";
+
+// src/components/Fetcher.tsx
+import React5 from "react";
+
+// src/hooks/usePlasmicDataOp.tsx
+import { usePlasmicDataSourceContext } from "@plasmicapp/data-sources-context";
+import {
+  usePlasmicDataConfig as usePlasmicDataConfig3
+} from "@plasmicapp/query";
+import * as React4 from "react";
+
 // src/executor.tsx
 import fetch from "@plasmicapp/isomorphic-unfetch";
-import { wrapLoadingFetcher } from "@plasmicapp/query";
+import { wrapLoadingFetcher as wrapLoadingFetcher2 } from "@plasmicapp/query";
 import stringify from "fast-stringify";
 
 // src/placeholders.ts
@@ -260,7 +948,7 @@ function executePlasmicDataOp(op, opts) {
       _executePlasmicDataOp
     );
     op.userArgs = addPlaceholdersToUserArgs(op.userArgs);
-    const res = yield wrapLoadingFetcher(func)(op, opts);
+    const res = yield wrapLoadingFetcher2(func)(op, opts);
     return res;
   });
 }
@@ -304,31 +992,6 @@ function getConfig2(key, defaultValue) {
   }
 }
 
-// src/utils.ts
-function swallow(f) {
-  try {
-    return f();
-  } catch (e) {
-    return void 0;
-  }
-}
-function pick(obj, ...keys) {
-  const res = {};
-  for (const key of keys) {
-    if (key in obj) {
-      res[key] = obj[key];
-    }
-  }
-  return res;
-}
-var tuple = (...args) => args;
-function mkIdMap(xs) {
-  return new Map(xs.map((x) => tuple(x.id, x)));
-}
-function withoutNils(xs) {
-  return xs.filter((x) => x != null);
-}
-
 // src/hooks/usePlasmicDataOp.tsx
 function makeCacheKey(dataOp, opts) {
   const queryDependencies = JSON.stringify({
@@ -341,7 +1004,7 @@ function makeCacheKey(dataOp, opts) {
   return dataOp.cacheKey ? `${dataOp.cacheKey}${queryDependencies}` : queryDependencies;
 }
 function usePlasmicInvalidate() {
-  const { cache, fallback, mutate } = usePlasmicDataConfig2();
+  const { cache, fallback, mutate } = usePlasmicDataConfig3();
   return (invalidatedKeys) => __async(this, null, function* () {
     const getKeysToInvalidate = () => {
       var _a, _b;
@@ -436,7 +1099,7 @@ function usePlasmicDataOp(dataOp, opts) {
 function usePlasmicDataMutationOp(dataOp) {
   const ctx = usePlasmicDataSourceContext();
   const userToken = ctx == null ? void 0 : ctx.userAuthToken;
-  const getRealDataOp = React2.useCallback(() => __async(this, null, function* () {
+  const getRealDataOp = React4.useCallback(() => __async(this, null, function* () {
     const tryGetRealDataOp = () => __async(this, null, function* () {
       const resolved = resolveDataOp(dataOp);
       if (!resolved) {
@@ -450,7 +1113,7 @@ function usePlasmicDataMutationOp(dataOp) {
     });
     return yield tryGetRealDataOp();
   }), [dataOp]);
-  return React2.useCallback(() => __async(this, null, function* () {
+  return React4.useCallback(() => __async(this, null, function* () {
     var _a;
     const { sourceId, opId, userArgs } = (_a = yield getRealDataOp()) != null ? _a : {};
     if (!sourceId || !opId) {
@@ -473,7 +1136,7 @@ function Fetcher(props) {
   const data = usePlasmicDataOp(dataOp, __spreadValues({}, !!pageIndex && !!pageSize && {
     paginate: { pageIndex, pageSize }
   }));
-  const $queries = React3.useMemo(
+  const $queries = React5.useMemo(
     () => __spreadProps(__spreadValues({}, props.queries), { [name != null ? name : "data"]: data }),
     [props.queries, name, data]
   );
@@ -515,7 +1178,7 @@ var FetcherMeta = {
 };
 
 // src/helpers.ts
-import { useMemo } from "react";
+import { useMemo as useMemo2 } from "react";
 function normalizeData(rawData) {
   var _a;
   if (!rawData) {
@@ -532,7 +1195,7 @@ function normalizeData(rawData) {
   return { data: dataArray, schema };
 }
 function useNormalizedData(rawData) {
-  return useMemo(() => normalizeData(rawData), [rawData]);
+  return useMemo2(() => normalizeData(rawData), [rawData]);
 }
 function tryGetDataArray(rawData) {
   if (rawData == null || typeof rawData !== "object") {
@@ -626,10 +1289,10 @@ function deriveFieldConfigs(specifiedFieldsPartial, schema, makeDefaultConfig) {
 }
 
 // src/hooks/useDependencyAwareQuery.tsx
-import React4 from "react";
+import React6 from "react";
 function usePrevious(value) {
-  const prevValue = React4.useRef(void 0);
-  React4.useEffect(() => {
+  const prevValue = React6.useRef(void 0);
+  React6.useEffect(() => {
     prevValue.current = value;
     return () => {
       prevValue.current = void 0;
@@ -650,7 +1313,7 @@ function useDependencyAwareQuery({
   }));
   const finalName = name != null ? name : "data";
   const prevName = usePrevious(finalName);
-  React4.useEffect(() => {
+  React6.useEffect(() => {
     if (!(finalName in $queries) || $queries[finalName] !== data) {
       const $queries2 = __spreadProps(__spreadValues({}, $queries), {
         [finalName]: data
@@ -662,101 +1325,6 @@ function useDependencyAwareQuery({
     }
   }, [finalName, prevName, data, $queries, setDollarQueries]);
 }
-
-// src/serverQueries/client.ts
-import {
-  wrapLoadingFetcher as wrapLoadingFetcher2
-} from "@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;
-    }
-    return null;
-  });
-  const key = !resolvedParams || isPlasmicUndefinedDataErrorPromise(resolvedParams) ? null : makeQueryCacheKey(serverQuery.id, resolvedParams);
-  const wrapStudioCache = getConfig(
-    "EXECUTE_SERVER_QUERY",
-    (_, fn, ...args) => fn(...args)
-  );
-  const fetcher = (params) => {
-    return wrapLoadingFetcher2(wrapStudioCache)(
-      serverQuery.id,
-      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) {
-    super(msg);
-    this.plasmicType = "PlasmicUndefinedServerError";
-  }
-};
-function isPlasmicUndefinedServerError(x) {
-  return !!x && typeof x === "object" && x.plasmicType === "PlasmicUndefinedServerError";
-}
-function mkPlasmicUndefinedServerProxy() {
-  return {
-    data: new Proxy(
-      {},
-      {
-        get: (_, prop) => {
-          if (prop === "isUndefinedServerProxy") {
-            return true;
-          } else if (prop === "then") {
-            return void 0;
-          }
-          throw new PlasmicUndefinedServerError("Data is not available yet");
-        }
-      }
-    ),
-    isLoading: true
-  };
-}
-function executeServerQuery(serverQuery) {
-  return __async(this, null, function* () {
-    const resolvedParams = resolveParams(serverQuery.execParams, (err) => {
-      if (isPlasmicUndefinedServerError(err)) {
-        return err;
-      }
-      throw err;
-    });
-    if (isPlasmicUndefinedServerError(resolvedParams)) {
-      return mkPlasmicUndefinedServerProxy();
-    }
-    return { data: yield serverQuery.fn(...resolvedParams), isLoading: false };
-  });
-}
 export {
   Fetcher,
   FetcherMeta,
@@ -767,9 +1335,13 @@ export {
   makeQueryCacheKey,
   mkPlasmicUndefinedServerProxy,
   normalizeData,
+  createDollarQueries as unstable_createDollarQueries,
+  executePlasmicQueries as unstable_executePlasmicQueries,
+  usePlasmicQueries as unstable_usePlasmicQueries,
+  wrapDollarQueriesForMetadata as unstable_wrapDollarQueriesForMetadata,
   useDependencyAwareQuery,
   useNormalizedData,
-  usePlasmicDataConfig3 as usePlasmicDataConfig,
+  usePlasmicDataConfig4 as usePlasmicDataConfig,
   usePlasmicDataMutationOp,
   usePlasmicDataOp,
   usePlasmicInvalidate,