@general-dexterity/cube-records/dist/index.cjs

Opinionated wrapper around @cubejs-client/react

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  useCubeRecordQuery: () => useCubeRecordQuery
});
module.exports = __toCommonJS(index_exports);

// src/use-cube-record-query.ts
var import_react = require("@cubejs-client/react");
var formatFilters = (filters, cubeRecordName) => {
  return filters.map((filter) => {
    const member = filter.member.includes(".") ? filter.member : `${cubeRecordName}.${filter.member}`;
    if ("values" in filter && filter.values) {
      return {
        member,
        operator: filter.operator,
        values: filter.values
      };
    }
    return {
      member,
      operator: filter.operator
    };
  });
};
var formatResultSet = (resultSet, cubeRecordName, strip) => {
  if (!resultSet) {
    return [];
  }
  const data = resultSet.tablePivot();
  if (!strip) {
    return data;
  }
  return data.map((row) => {
    const formattedRow = {};
    for (const key in row) {
      if (Object.hasOwn(row, key)) {
        const cleanKey = key.startsWith(`${cubeRecordName}.`) ? key.substring(cubeRecordName.length + 1) : key;
        formattedRow[cleanKey] = row[key];
      }
    }
    return formattedRow;
  });
};
function useCubeRecordQuery({
  model: cubeRecordName,
  query,
  options
}) {
  const cubeQuery = {
    measures: query.measures?.map(
      (measure) => measure.includes(".") ? measure : `${cubeRecordName}.${measure}`
    ),
    dimensions: query.dimensions?.map(
      (dimension) => dimension.includes(".") ? dimension : `${cubeRecordName}.${dimension}`
    ),
    filters: query.filters ? formatFilters(query.filters, cubeRecordName) : void 0,
    segments: query.segments,
    timeDimensions: query.timeDimensions?.map((td) => ({
      ...td,
      dimension: td.dimension.includes(".") ? td.dimension : `${cubeRecordName}.${td.dimension}`
    })),
    limit: query.limit,
    offset: query.offset,
    order: query.order ? Object.entries(query.order).reduce(
      (acc, [key, direction]) => {
        const member = key.includes(".") ? key : `${cubeRecordName}.${key}`;
        acc[member] = direction;
        return acc;
      },
      {}
    ) : void 0,
    timezone: query.timezone,
    renewQuery: query.renewQuery,
    ungrouped: query.ungrouped,
    total: query.total
  };
  const hasStripFlag = options != null && Object.hasOwn(options, "stripModelPrefix");
  const { stripModelPrefix = true, ...coreOptions } = options ?? {};
  const forwardedOptions = hasStripFlag ? coreOptions : options;
  const { resultSet, isLoading, error, refetch } = (0, import_react.useCubeQuery)(
    cubeQuery,
    forwardedOptions
  );
  const formattedData = formatResultSet(resultSet, cubeRecordName, stripModelPrefix);
  const totalResultCount = resultSet?.totalRows() ?? null;
  const data = formattedData;
  return {
    isLoading,
    error,
    resultSet,
    refetch,
    data,
    totalResultCount
  };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  useCubeRecordQuery
});
//# sourceMappingURL=index.cjs.map