@plasmicapp/data-sources 0.1.204 → 0.1.206

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { CodeComponentMeta } from '@plasmicapp/host/registerComponent';
 import { PlasmicDataSourceContextValue } from '@plasmicapp/data-sources-context';
 import { default as React_2 } from 'react';
+import { SWRResponse } from '@plasmicapp/query';
 import { usePlasmicDataConfig } from '@plasmicapp/query';
 
 export declare type BaseFieldConfig = {
@@ -79,13 +80,6 @@ declare interface ExecuteOpts {
 
 export declare function executePlasmicDataOp<T extends SingleRowResult | ManyRowsResult>(op: DataOp, opts?: ExecuteOpts): Promise<T>;
 
-/**
- * Executes a server query, returning either the result of the query or a
- * PlasmicUndefinedServerProxy if the query depends on data that is not yet ready
- * @deprecated
- */
-export declare function executeServerQuery<F extends (...args: any[]) => any>(query: PlasmicQuery<F>): Promise<ServerQueryResult<ReturnType<F>>>;
-
 export declare function Fetcher(props: FetcherProps): React_2.ReactElement | null;
 
 export declare const FetcherMeta: CodeComponentMeta<FetcherProps>;
@@ -111,9 +105,6 @@ export declare interface ManyRowsResult<T = any> {
     paginate?: Pagination;
 }
 
-/** @deprecated */
-export declare function mkPlasmicUndefinedServerProxy<T>(): ServerQueryResult<T>;
-
 export declare function normalizeData(rawData: unknown): NormalizedData | undefined;
 
 export declare interface NormalizedData {
@@ -158,10 +149,17 @@ export declare type QueryResult = Partial<ManyRowsResult<any>> & {
 
 declare type ResolvableDataOp = DataOp | undefined | null | (() => DataOp | undefined | null);
 
-/** @deprecated */
-export declare interface ServerQueryResult<T = any> {
-    data: T;
-    isLoading: boolean;
+/**
+ * Wraps a Promise so that it can be easily resolved/rejected
+ * outside the executor param of the Promise constructor.
+ */
+declare class SettablePromise<T> {
+    readonly promise: Promise<T>;
+    private _resolve;
+    private _reject;
+    constructor();
+    resolve(value: T): void;
+    reject(error: unknown): void;
 }
 
 export declare interface SingleRowResult<T = any> {
@@ -169,6 +167,60 @@ export declare interface SingleRowResult<T = any> {
     schema: TableSchema;
 }
 
+/** @internal */
+export declare class _StatefulQueryResult<T = unknown> implements PlasmicQueryResult<T> {
+    current: _StatefulQueryState<T>;
+    settable: SettablePromise<T>;
+    private readonly listeners;
+    constructor();
+    private transitionState;
+    addListener(listener: _StateListener<T>): void;
+    removeListener(listener: _StateListener<T>): void;
+    private notifyListeners;
+    reset(): void;
+    loadingPromise(key: string, promise: Promise<T>): void;
+    /**
+     * 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: string, data: T): void;
+    /**
+     * 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: string | null, error: unknown): void;
+    get key(): string | null;
+    get data(): T;
+    get isLoading(): boolean;
+    getDoneResult(): Promise<PlasmicQueryResult<T> & {
+        current: {
+            state: "done";
+        };
+    }>;
+}
+
+/** @internal */
+export declare type _StatefulQueryState<T = unknown> = {
+    state: "initial";
+    key: null;
+} | {
+    state: "loading";
+    key: string;
+} | {
+    state: "done";
+    key: string;
+    data: T;
+} | {
+    state: "done";
+    key: string | null;
+    error: unknown;
+};
+
+/** @internal */
+export declare type _StateListener<T = unknown> = (state: _StatefulQueryState<T>, prevState: _StatefulQueryState<T>) => void;
+
 export declare interface TableFieldSchema {
     id: string;
     label?: string;
@@ -284,7 +336,7 @@ export declare function unstable_executePlasmicQueries<QueryName extends string>
  *   return <div>{$queries.result.data}</div> // $queries.result.data may suspend
  * }
  */
-export declare function unstable_usePlasmicQueries<QueryName extends string>($queries: Record<QueryName, PlasmicQueryResult>, queries: Record<QueryName, PlasmicQuery>): void;
+export declare function unstable_usePlasmicQueries<QueryName extends string>($queries: Record<QueryName, PlasmicQueryResult>, queries: Record<QueryName, PlasmicQuery>): Record<QueryName, ReturnType<typeof usePlasmicQuery>>;
 
 /**
  * Wraps each PlasmicQueryResult so that they return a hardcoded string for
@@ -314,18 +366,8 @@ export declare function usePlasmicDataOp<T extends SingleRowResult | ManyRowsRes
 export declare function usePlasmicInvalidate(): (invalidatedKeys: string[] | null | undefined) => Promise<any[] | undefined>;
 
 /**
- * @deprecated
- * This export will be deleted before RSC release.
- * TODO: Rename to usePlasmicQuery
- * TODO: Reference $query directly.
  * TODO: Use paramsResult from usePlasmicQueries
  */
-export declare function usePlasmicServerQuery<T, F extends (...args: any[]) => Promise<T>>(query: PlasmicQuery<F>, fallbackData?: T, opts?: {
-    noUndefinedDataProxy?: boolean;
-    settledCount?: number;
-    onStarted?: (key: string, promise: Promise<T>) => void;
-    onResolved?: (key: string, data: T) => void;
-    onRejected?: (key: string | null, error: unknown) => void;
-}): Partial<PlasmicQueryResult<T>>;
+declare function usePlasmicQuery<T, F extends (...args: any[]) => Promise<T>>($query: PlasmicQueryResult<T>, query: PlasmicQuery<F>, settledCount?: number): SWRResponse<T, unknown>;
 
 export { }

package/dist/index.esm.js

@@ -46,6 +46,61 @@ import {
 } from "@plasmicapp/query";
 import * as React3 from "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
+import React2 from "react";
+
 // src/common.ts
 import {
   useMutablePlasmicQueryData,
@@ -224,69 +279,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
-import React2 from "react";
 function createDollarQueries(queryNames) {
   return Object.fromEntries(
     queryNames.map((queryName) => {
@@ -652,18 +646,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
@@ -677,15 +662,7 @@ function wrapQueries(queries) {
       if (cached) {
         return cached.promise;
       }
-      const wrapStudioCache = getConfig(
-        "EXECUTE_SERVER_QUERY",
-        (_, fn, ...args2) => fn(...args2)
-      );
-      const promise = wrapLoadingFetcher(wrapStudioCache)(
-        query.id,
-        query.fn,
-        ...args
-      );
+      const promise = wrapLoadingFetcher(query.fn)(...args);
       GLOBAL_CACHE.set(cacheKey, new SyncPromise(promise));
       return promise;
     };
@@ -748,11 +725,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":
@@ -772,9 +749,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);
             });
@@ -790,17 +766,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;
@@ -857,53 +829,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
 import { usePlasmicDataConfig as usePlasmicDataConfig4 } from "@plasmicapp/query";
@@ -943,7 +868,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
     );
@@ -961,7 +886,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 fetch(url, {
       method: "POST",
@@ -983,7 +908,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;
@@ -1328,12 +1253,11 @@ function useDependencyAwareQuery({
 export {
   Fetcher,
   FetcherMeta,
+  StatefulQueryResult as _StatefulQueryResult,
   deriveFieldConfigs,
   executePlasmicDataOp,
-  executeServerQuery,
   makeCacheKey,
   makeQueryCacheKey,
-  mkPlasmicUndefinedServerProxy,
   normalizeData,
   createDollarQueries as unstable_createDollarQueries,
   executePlasmicQueries as unstable_executePlasmicQueries,
@@ -1344,7 +1268,6 @@ export {
   usePlasmicDataConfig4 as usePlasmicDataConfig,
   usePlasmicDataMutationOp,
   usePlasmicDataOp,
-  usePlasmicInvalidate,
-  usePlasmicServerQuery
+  usePlasmicInvalidate
 };
 //# sourceMappingURL=index.esm.js.map