@plasmicapp/data-sources 0.1.125 → 0.1.127

package/dist/index.js

@@ -1,8 +1,625 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
-'use strict'
+// src/index.tsx
+var src_exports = {};
+__export(src_exports, {
+  Fetcher: () => Fetcher,
+  FetcherMeta: () => FetcherMeta,
+  deriveFieldConfigs: () => deriveFieldConfigs,
+  executePlasmicDataOp: () => executePlasmicDataOp,
+  makeCacheKey: () => makeCacheKey,
+  normalizeData: () => normalizeData,
+  useDependencyAwareQuery: () => useDependencyAwareQuery,
+  usePlasmicDataConfig: () => import_query3.usePlasmicDataConfig,
+  usePlasmicDataMutationOp: () => usePlasmicDataMutationOp,
+  usePlasmicDataOp: () => usePlasmicDataOp,
+  usePlasmicInvalidate: () => usePlasmicInvalidate
+});
+module.exports = __toCommonJS(src_exports);
+var import_query3 = require("@plasmicapp/query");
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./data-sources.cjs.production.min.js')
-} else {
-  module.exports = require('./data-sources.cjs.development.js')
+// src/components/Fetcher.tsx
+var import_react2 = __toESM(require("react"));
+
+// src/hooks/usePlasmicDataOp.tsx
+var import_data_sources_context = require("@plasmicapp/data-sources-context");
+var ph = __toESM(require("@plasmicapp/host"));
+var import_query2 = require("@plasmicapp/query");
+var import_react = __toESM(require("react"));
+
+// src/executor.tsx
+var import_isomorphic_unfetch = __toESM(require("@plasmicapp/isomorphic-unfetch"));
+var import_query = require("@plasmicapp/query");
+var import_fast_stringify = __toESM(require("fast-stringify"));
+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 = getConfig(
+      "__PLASMIC_EXECUTE_DATA_OP",
+      _executePlasmicDataOp
+    );
+    const res = yield (0, import_query.wrapLoadingFetcher)(func)(op, opts);
+    return res;
+  });
+}
+function _executePlasmicDataOp(op, opts) {
+  return __async(this, null, function* () {
+    var _a;
+    if (op.roleId) {
+      if (!(opts == null ? void 0 : opts.user) || !opts.user.roleIds.includes(op.roleId)) {
+        console.error(UNAUTHORIZED_MESSAGE);
+        throw new Error(UNAUTHORIZED_MESSAGE);
+      }
+    }
+    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",
+      headers: __spreadValues({
+        "Content-Type": "application/json"
+      }, (opts == null ? void 0 : opts.userAuthToken) && {
+        "x-plasmic-data-user-auth-token": opts.userAuthToken
+      }),
+      body: (0, import_fast_stringify.default)({
+        opId: op.opId,
+        userArgs: (_a = op.userArgs) != null ? _a : {},
+        paginate: opts == null ? void 0 : opts.paginate
+      })
+    });
+    if (resp.status !== 200) {
+      const text = yield resp.text();
+      throw new Error(text);
+    }
+    return yield resp.json();
+  });
+}
+function getConfig(key, defaultValue) {
+  var _a;
+  if (typeof globalThis === "undefined") {
+    return defaultValue;
+  } else {
+    return (_a = globalThis[key]) != null ? _a : 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({
+    sourceId: dataOp.sourceId,
+    opId: dataOp.opId,
+    args: dataOp.userArgs,
+    userAuthToken: opts == null ? void 0 : opts.userAuthToken,
+    paginate: opts == null ? void 0 : opts.paginate
+  });
+  return dataOp.cacheKey ? `${dataOp.cacheKey}${queryDependencies}` : queryDependencies;
+}
+function usePlasmicInvalidate() {
+  const { cache, fallback, mutate } = (0, import_query2.usePlasmicDataConfig)();
+  return (invalidatedKeys) => __async(this, null, function* () {
+    const getKeysToInvalidate = () => {
+      if (!invalidatedKeys) {
+        return [];
+      }
+      const allKeys = Array.from(
+        /* @__PURE__ */ new Set([
+          ...Array.from(cache.keys()),
+          ...fallback ? Object.keys(fallback) : []
+        ])
+      ).filter((key) => typeof key === "string");
+      if (invalidatedKeys.includes("plasmic_refresh_all")) {
+        return allKeys;
+      }
+      return allKeys.filter(
+        (key) => invalidatedKeys.some((k) => key.includes(`.$.${k}.$.`))
+      );
+    };
+    const keys = getKeysToInvalidate();
+    if (keys.length === 0) {
+      return;
+    }
+    const invalidateKey = (key) => __async(this, null, function* () {
+      const studioInvalidate = globalThis.__PLASMIC_MUTATE_DATA_OP;
+      if (studioInvalidate) {
+        yield studioInvalidate(key);
+      }
+      return mutate(key);
+    });
+    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 = +import_react.default.version.split(".")[0];
+function resolveDataOp(dataOp) {
+  if (typeof dataOp === "function") {
+    try {
+      return dataOp();
+    } catch (err) {
+      if (isPlasmicUndefinedDataErrorPromise(err)) {
+        return err;
+      }
+      return null;
+    }
+  } else {
+    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 } = (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 = 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 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 = 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.get(key);
+      if (cached) {
+        return Promise.resolve(cached);
+      }
+      const cachedError = cache.get(`$swr$${key}`);
+      if (cachedError) {
+        return Promise.reject(cachedError.error);
+      }
+      const fetcherPromise = new Promise((resolve, reject) => {
+        setTimeout(() => {
+          fetcher().then(resolve, reject);
+        }, 1);
+      });
+      fetcherPromise.then((data2) => {
+        mutate(key, data2);
+      }).catch((err) => {
+        var _a2;
+        const keyInfo = key ? "$swr$" + key : "";
+        cache.set(keyInfo, __spreadProps(__spreadValues({}, (_a2 = 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 import_react.default.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);
+    }
+    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 = import_react.default.useCallback(() => __async(this, null, function* () {
+    const tryGetRealDataOp = () => __async(this, null, function* () {
+      const resolved = resolveDataOp(dataOp);
+      if (!resolved) {
+        return null;
+      } else if (isPlasmicUndefinedDataErrorPromise(resolved)) {
+        yield resolved;
+        return tryGetRealDataOp();
+      } else {
+        return resolved;
+      }
+    });
+    return yield tryGetRealDataOp();
+  }), [dataOp]);
+  return import_react.default.useCallback(() => __async(this, null, function* () {
+    var _a;
+    const { sourceId, opId, userArgs } = (_a = yield getRealDataOp()) != null ? _a : {};
+    if (!sourceId || !opId) {
+      return void 0;
+    }
+    return executePlasmicDataOp(
+      { sourceId, opId, userArgs },
+      {
+        userAuthToken: userToken || void 0,
+        user: ctx == null ? void 0 : ctx.user
+      }
+    );
+  }), [getRealDataOp, userToken]);
+}
+
+// src/components/Fetcher.tsx
+function Fetcher(props) {
+  var _a;
+  const { dataOp, children, name, pageIndex, pageSize } = props;
+  const data = usePlasmicDataOp(dataOp, __spreadValues({}, !!pageIndex && !!pageSize && {
+    paginate: { pageIndex, pageSize }
+  }));
+  const $queries = import_react2.default.useMemo(
+    () => __spreadProps(__spreadValues({}, props.queries), { [name != null ? name : "data"]: data }),
+    [props.queries, name, data]
+  );
+  return (_a = children == null ? void 0 : children($queries)) != null ? _a : null;
+}
+var FetcherMeta = {
+  name: "plasmic-data-source-fetcher",
+  displayName: "Data Fetcher",
+  props: {
+    dataOp: {
+      type: "dataSourceOp",
+      displayName: "Data"
+    },
+    name: {
+      type: "string",
+      displayName: "Variable name"
+    },
+    children: {
+      type: "slot",
+      renderPropParams: ["$queries"]
+    },
+    pageSize: {
+      type: "number",
+      advanced: true,
+      displayName: "Page size",
+      description: "Only fetch in batches of this size; for pagination"
+    },
+    pageIndex: {
+      type: "number",
+      advanced: true,
+      displayName: "Page index",
+      description: "0-based index of the paginated page to fetch"
+    }
+  },
+  importPath: "@plasmicapp/react-web/lib/data-sources",
+  importName: "Fetcher",
+  alwaysAutoName: true,
+  styleSections: false
+};
+
+// src/helpers.ts
+function normalizeData(rawData) {
+  var _a;
+  if (!rawData) {
+    return void 0;
+  }
+  const dataArray = tryGetDataArray(rawData);
+  if (!dataArray) {
+    return void 0;
+  }
+  const schema = (_a = rawData.schema) != null ? _a : tryGetSchema(dataArray);
+  if (!schema) {
+    return void 0;
+  }
+  return { data: dataArray, schema };
+}
+function tryGetDataArray(rawData) {
+  if (rawData == null || typeof rawData !== "object") {
+    return void 0;
+  }
+  if (Array.isArray(rawData)) {
+    if (isArrayOfObjects(rawData)) {
+      return rawData;
+    } else {
+      return void 0;
+    }
+  }
+  if (rawData == null) {
+    return void 0;
+  }
+  if ("data" in rawData && typeof rawData.data === "object") {
+    if (Array.isArray(rawData.data) && isArrayOfObjects(rawData.data)) {
+      return rawData.data;
+    } else if (rawData.data != null) {
+      return [rawData.data];
+    } else {
+      return void 0;
+    }
+  }
+  if ("isLoading" in rawData || "error" in rawData) {
+    return void 0;
+  }
+  return [rawData];
+}
+function isArrayOfObjects(arr) {
+  return arr.every((x) => typeof x === "object" && !Array.isArray(x));
+}
+function tryGetSchema(data) {
+  const fieldMap = {};
+  data.forEach((entry) => {
+    if (entry && typeof entry === "object") {
+      Array.from(Object.entries(entry)).forEach(([k, v]) => {
+        const inferredType = typeof v === "string" ? "string" : typeof v === "boolean" ? "boolean" : typeof v === "number" ? "number" : "unknown";
+        if (fieldMap[k] && fieldMap[k] !== inferredType) {
+          fieldMap[k] = "unknown";
+        } else {
+          fieldMap[k] = inferredType;
+        }
+      });
+    }
+  });
+  return {
+    id: "inferred",
+    fields: Object.entries(fieldMap).map(([f, t]) => ({
+      id: f,
+      type: t,
+      readOnly: false
+    }))
+  };
+}
+var mkShortId = () => `${Math.random()}`;
+function deriveFieldConfigs(specifiedFieldsPartial, schema, makeDefaultConfig) {
+  var _a;
+  const schemaFields = (_a = schema == null ? void 0 : schema.fields) != null ? _a : [];
+  const fieldById = mkIdMap(schemaFields);
+  const specifiedFieldIds = new Set(
+    withoutNils(specifiedFieldsPartial.map((f) => f.fieldId))
+  );
+  const keptSpecifiedFields = specifiedFieldsPartial.flatMap((f) => {
+    if (!f.fieldId) {
+      return [
+        __spreadValues(__spreadValues({ key: mkShortId() }, makeDefaultConfig(void 0)), f)
+      ];
+    }
+    const field = fieldById.get(f.fieldId);
+    if (!field) {
+      return [];
+    }
+    return [
+      __spreadValues(__spreadValues({
+        key: mkShortId()
+      }, makeDefaultConfig(field)), f)
+    ];
+  });
+  const newVirtualFields = schemaFields.filter((f) => !specifiedFieldIds.has(f.id)).map(
+    (f) => __spreadValues({
+      key: mkShortId()
+    }, makeDefaultConfig(f))
+  );
+  const mergedFields = [...keptSpecifiedFields, ...newVirtualFields];
+  const minimalFullLengthFields = [
+    ...specifiedFieldsPartial,
+    ...newVirtualFields.map((f) => ({ key: f.key, fieldId: f.fieldId }))
+  ];
+  return { mergedFields, minimalFullLengthFields };
+}
+
+// src/hooks/useDependencyAwareQuery.tsx
+var import_react3 = __toESM(require("react"));
+function usePrevious(value) {
+  const prevValue = import_react3.default.useRef(void 0);
+  import_react3.default.useEffect(() => {
+    prevValue.current = value;
+    return () => {
+      prevValue.current = void 0;
+    };
+  });
+  return prevValue.current;
+}
+function useDependencyAwareQuery({
+  $queries,
+  getDataOp,
+  setDollarQueries,
+  name,
+  pageIndex,
+  pageSize
+}) {
+  const data = usePlasmicDataOp(swallow(getDataOp), __spreadValues({}, !!pageIndex && !!pageSize && {
+    paginate: { pageIndex, pageSize }
+  }));
+  const finalName = name != null ? name : "data";
+  const prevName = usePrevious(finalName);
+  import_react3.default.useEffect(() => {
+    if (!(finalName in $queries) || $queries[finalName] !== data) {
+      const $queries2 = __spreadProps(__spreadValues({}, $queries), {
+        [finalName]: data
+      });
+      if (prevName && finalName !== prevName && prevName in $queries) {
+        delete $queries2[prevName];
+      }
+      setDollarQueries($queries2);
+    }
+  }, [finalName, prevName, data, $queries, setDollarQueries]);
 }
+//# sourceMappingURL=index.js.map