@plasmicapp/data-sources 0.1.204 → 0.1.206

package/dist/index.js

@@ -69,12 +69,11 @@ var src_exports = {};
 __export(src_exports, {
   Fetcher: () => Fetcher,
   FetcherMeta: () => FetcherMeta,
+  _StatefulQueryResult: () => StatefulQueryResult,
   deriveFieldConfigs: () => deriveFieldConfigs,
   executePlasmicDataOp: () => executePlasmicDataOp,
-  executeServerQuery: () => executeServerQuery,
   makeCacheKey: () => makeCacheKey,
   makeQueryCacheKey: () => makeQueryCacheKey,
-  mkPlasmicUndefinedServerProxy: () => mkPlasmicUndefinedServerProxy,
   normalizeData: () => normalizeData,
   unstable_createDollarQueries: () => createDollarQueries,
   unstable_executePlasmicQueries: () => executePlasmicQueries,
@@ -85,8 +84,7 @@ __export(src_exports, {
   usePlasmicDataConfig: () => import_query5.usePlasmicDataConfig,
   usePlasmicDataMutationOp: () => usePlasmicDataMutationOp,
   usePlasmicDataOp: () => usePlasmicDataOp,
-  usePlasmicInvalidate: () => usePlasmicInvalidate,
-  usePlasmicServerQuery: () => usePlasmicServerQuery
+  usePlasmicInvalidate: () => usePlasmicInvalidate
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -94,6 +92,61 @@ module.exports = __toCommonJS(src_exports);
 var import_query2 = require("@plasmicapp/query");
 var React3 = __toESM(require("react"));
 
+// 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
+var import_react2 = __toESM(require("react"));
+
 // src/common.ts
 var import_query = require("@plasmicapp/query");
 var ph = __toESM(require("@plasmicapp/host"));
@@ -269,69 +322,8 @@ function usePlasmicFetch(key, resolvedParams, fetcherFn, resultMapper, undefined
     fetchAndUpdateCache
   ]);
 }
-function getConfig(key, defaultValue) {
-  var _a, _b;
-  if (typeof globalThis === "undefined") {
-    return defaultValue;
-  } else {
-    return (_b = (_a = globalThis.__PLASMIC__) == null ? void 0 : _a[key]) != null ? _b : 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
-var import_react2 = __toESM(require("react"));
 function createDollarQueries(queryNames) {
   return Object.fromEntries(
     queryNames.map((queryName) => {
@@ -697,18 +689,9 @@ function usePlasmicQueries($queries, queries) {
     },
     [wrappedQueries, $queryStates, settledCount]
   );
-  mapRecordEntries(
+  return mapRecords(
     (_queryName, $query, query) => {
-      usePlasmicServerQuery(
-        query,
-        void 0,
-        {
-          settledCount,
-          onStarted: $query.loadingPromise.bind($query),
-          onResolved: $query.resolvePromise.bind($query),
-          onRejected: $query.rejectPromise.bind($query)
-        }
-      );
+      return usePlasmicQuery($query, query, settledCount);
     },
     $queryStates,
     wrappedQueries
@@ -722,15 +705,7 @@ function wrapQueries(queries) {
       if (cached) {
         return cached.promise;
       }
-      const wrapStudioCache = getConfig(
-        "EXECUTE_SERVER_QUERY",
-        (_, fn, ...args2) => fn(...args2)
-      );
-      const promise = (0, import_query2.wrapLoadingFetcher)(wrapStudioCache)(
-        query.id,
-        query.fn,
-        ...args
-      );
+      const promise = (0, import_query2.wrapLoadingFetcher)(query.fn)(...args);
       GLOBAL_CACHE.set(cacheKey, new SyncPromise(promise));
       return promise;
     };
@@ -793,11 +768,11 @@ function initPlasmicQueriesSync($queries, queries, prefetchedCache, clientCache)
     );
   } while (anySettled);
 }
-function usePlasmicServerQuery(query, fallbackData, opts) {
-  var _a, _b;
+function usePlasmicQuery($query, query, settledCount) {
+  const $queryState = $query;
   const paramsResult = React3.useMemo(() => {
     return resolveParams(query.execParams);
-  }, [query.execParams, opts == null ? void 0 : opts.settledCount]);
+  }, [query.execParams, settledCount]);
   const { key, fetcher } = React3.useMemo(() => {
     switch (paramsResult.status) {
       case "blocked":
@@ -817,9 +792,8 @@ function usePlasmicServerQuery(query, fallbackData, opts) {
         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);
+            $queryState.loadingPromise(cacheKey, promise);
             return promise.finally(() => {
               GLOBAL_CACHE.delete(cacheKey);
             });
@@ -835,17 +809,13 @@ function usePlasmicServerQuery(query, fallbackData, opts) {
     // 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
+    revalidateIfStale: false
   });
   if (!result.isLoading) {
     if (result.error) {
-      (_a = opts == null ? void 0 : opts.onRejected) == null ? void 0 : _a.call(opts, key, result.error);
+      $queryState.rejectPromise(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);
+      $queryState.resolvePromise(key, result.data);
     }
   }
   return result;
@@ -902,53 +872,6 @@ function executePlasmicQuery($query, query) {
     } 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
 var import_query5 = require("@plasmicapp/query");
@@ -986,7 +909,7 @@ var DEFAULT_HOST = "https://data.plasmic.app";
 var UNAUTHORIZED_MESSAGE = "You do not have permission to perform this operation. Login to get access or contact the app owner to get access.";
 function executePlasmicDataOp(op, opts) {
   return __async(this, null, function* () {
-    const func = getConfig2(
+    const func = getConfig(
       "__PLASMIC_EXECUTE_DATA_OP",
       _executePlasmicDataOp
     );
@@ -1004,7 +927,7 @@ function _executePlasmicDataOp(op, opts) {
         throw new Error(UNAUTHORIZED_MESSAGE);
       }
     }
-    const host = getConfig2("__PLASMIC_DATA_HOST", DEFAULT_HOST);
+    const host = getConfig("__PLASMIC_DATA_HOST", DEFAULT_HOST);
     const url = `${host}/api/v1/server-data/sources/${op.sourceId}/execute`;
     const resp = yield (0, import_isomorphic_unfetch.default)(url, {
       method: "POST",
@@ -1026,7 +949,7 @@ function _executePlasmicDataOp(op, opts) {
     return yield resp.json();
   });
 }
-function getConfig2(key, defaultValue) {
+function getConfig(key, defaultValue) {
   var _a;
   if (typeof globalThis === "undefined") {
     return defaultValue;