@levi-gemcommerce/analytics 3.0.1-dev.2 → 3.0.1-dev.3

package/src/core/gemxql/builder/clauses/time-query.ts

@@ -0,0 +1,67 @@
+import type { GemXQlFilters, GemXQlOverrideFilters } from '../../types';
+import type { AnalyticDateFilter } from '@/components';
+
+import { dayjsTz } from '@/utils';
+import { getDateRangeForQuery } from '../helpers/date-query-helpers';
+
+export interface IBuildTimeQueryParams {
+  dateRange?: AnalyticDateFilter;
+  compareDateRange?: AnalyticDateFilter;
+  overrideFilters?: GemXQlOverrideFilters;
+  timeDimension?: string;
+}
+
+export type IParseTimeQueryResult = {
+  dateRange?: Pick<AnalyticDateFilter, 'startDate' | 'endDate'>;
+  compareDateRange?: Pick<AnalyticDateFilter, 'startDate' | 'endDate'>;
+  timeDimension?: string;
+  overrideFilters?: GemXQlFilters;
+};
+
+const buildOverrideTimeQuery = (key: string, value: string) => `DURING (${value}, ${key})`;
+
+const build = (data: IBuildTimeQueryParams) => {
+  const { dateRange, compareDateRange, overrideFilters, timeDimension } = data;
+  const overrideTimeValue = timeDimension
+    ? (overrideFilters as Record<string, string | undefined>)?.[timeDimension]
+    : undefined;
+
+  if (timeDimension && overrideTimeValue) {
+    return buildOverrideTimeQuery(timeDimension, overrideTimeValue);
+  }
+  if (!dateRange) return '';
+
+  const { dateGTE, dateLTE } = getDateRangeForQuery(dateRange);
+  const { dateGTE: compareDateGTE, dateLTE: compareDateLTE } = compareDateRange
+    ? getDateRangeForQuery(compareDateRange)
+    : {};
+  const compareToClause = compareDateRange ? `COMPARE TO ${compareDateGTE} UNTIL ${compareDateLTE}` : '';
+
+  return `SINCE ${dateGTE} UNTIL ${dateLTE} ${compareToClause}`;
+};
+
+const parse = (query: string): IParseTimeQueryResult => {
+  const duringMatch = query.match(/\bDURING\s+\(([^,]+),\s*([^)]+)\)/i);
+  if (duringMatch) {
+    const value = duringMatch[1] ?? '';
+    const key = duringMatch[2] ?? '';
+    return {
+      timeDimension: key.trim(),
+      overrideFilters: { [key.trim()]: value.trim() } as GemXQlFilters,
+    };
+  }
+
+  const sinceMatch = query.match(/\bSINCE\s+(\S+)\s+UNTIL\s+(\S+)/i);
+  if (!sinceMatch) return {};
+
+  const dateRange = { startDate: dayjsTz(sinceMatch[1] ?? ''), endDate: dayjsTz(sinceMatch[2] ?? '') };
+
+  const compareMatch = query.match(/\bCOMPARE TO\s+(\S+)\s+UNTIL\s+(\S+)/i);
+  const compareDateRange = compareMatch
+    ? { startDate: dayjsTz(compareMatch[1] ?? ''), endDate: dayjsTz(compareMatch[2] ?? '') }
+    : undefined;
+
+  return { dateRange, compareDateRange };
+};
+
+export { build as buildTimeQuery, parse as parseTimeQuery };

package/src/core/gemxql/builder/clauses/time-series-query.ts

@@ -0,0 +1,15 @@
+export interface IBuildTimeSeriesQueryParams {
+  timeDimension?: string;
+}
+
+const build = (time?: string) => {
+  if (!time) return '';
+  return `TIMESERIES ${time}`;
+};
+
+const parse = (query: string): string | undefined => {
+  const match = query.match(/\bTIMESERIES\s+(\S+)/i);
+  return match?.[1];
+};
+
+export { build as buildTimeSeriesQuery, parse as parseTimeSeriesQuery };

package/src/core/gemxql/builder/clauses/timezone-query.ts

@@ -0,0 +1,17 @@
+import { getInitialTimezone } from '@/utils';
+
+export interface IBuildTimezoneQueryParams {
+  timezone?: string;
+}
+
+const build = (timezone?: string) => {
+  const tz = timezone ?? getInitialTimezone();
+  return tz ? `TIMEZONE ${tz}` : '';
+};
+
+const parse = (query: string): string | undefined => {
+  const match = query.match(/\bTIMEZONE\s+(\S+)/i);
+  return match?.[1];
+};
+
+export { build as buildTimezoneQuery, parse as parseTimezoneQuery };

package/src/core/gemxql/builder/configs/date-formats.ts

@@ -0,0 +1 @@
+export const DATE_QUERY_FORMAT = 'YYYY-MM-DDTHH:mm:ss';

package/src/core/gemxql/builder/configs/keywords.ts

@@ -0,0 +1,16 @@
+export const CLAUSE_KEYWORDS = [
+  'MODE',
+  'FROM',
+  'SHOW',
+  'GROUP BY',
+  'TIMESERIES',
+  'SINCE',
+  'DURING',
+  'TIMEZONE',
+  'WHERE',
+  'ORDER BY',
+  'LIMIT',
+  'OFFSET',
+] as const;
+
+export const CLAUSE_KEYWORD_BOUNDARY = CLAUSE_KEYWORDS.join('|');

package/src/core/gemxql/builder/configs/query-defaults.ts

@@ -0,0 +1 @@
+export const DEFAULT_QUERY_LIMIT = 1000;

package/src/core/gemxql/builder/filters/build-extra-conditions.ts

@@ -0,0 +1,69 @@
+import type {
+  IExtraCondition,
+  IExtraConditionEq,
+  IExtraConditionGroup,
+  IExtraConditionIn,
+  IExtraConditionLike,
+} from '../../types';
+
+import { EComparisonOperator, EGroupOperator } from '../../types';
+
+const DEFAULT_GROUP_OPERATOR = EGroupOperator.OR;
+
+// Serializes a value as a single-quoted DSL string literal. Numbers are passed through unquoted.
+const quoteValue = (v: string | number): string =>
+  typeof v === 'number' ? String(v) : `'${String(v).replace(/'/g, "''")}'`;
+
+const joinFieldClauses = (parts: string[], groupOperator: EGroupOperator = DEFAULT_GROUP_OPERATOR): string => {
+  if (!parts.length) return '';
+  if (parts.length === 1) return parts[0] ?? '';
+  return `(${parts.join(` ${groupOperator} `)})`;
+};
+
+const buildEq = ({ fields, value, groupOperator }: IExtraConditionEq) => {
+  if (!fields.length) return '';
+  return joinFieldClauses(
+    fields.map((field) => `${field} = ${quoteValue(value)}`),
+    groupOperator,
+  );
+};
+
+const buildIn = ({ fields, values, groupOperator }: IExtraConditionIn) => {
+  if (!fields.length || !values.length) return '';
+  return joinFieldClauses(
+    fields.map((field) => `${field} IN (${values.map(quoteValue).join(', ')})`),
+    groupOperator,
+  );
+};
+
+const buildLike = ({ fields, value, groupOperator }: IExtraConditionLike) => {
+  const trimmed = value.trim();
+  if (!trimmed || !fields.length) return '';
+  return joinFieldClauses(
+    fields.map((field) => `${field} LIKE '%${trimmed.replace(/'/g, "''")}%'`),
+    groupOperator,
+  );
+};
+
+const buildGroup = ({ conditions, groupOperator }: IExtraConditionGroup): string => {
+  const parts = conditions.map(buildExtraCondition).filter(Boolean);
+  return joinFieldClauses(parts, groupOperator);
+};
+
+export const buildExtraCondition = (condition: IExtraCondition): string => {
+  switch (condition.operator) {
+    case EComparisonOperator.EQ:
+      return buildEq(condition);
+    case EComparisonOperator.IN:
+      return buildIn(condition);
+    case EComparisonOperator.LIKE:
+      return buildLike(condition);
+    case EComparisonOperator.GROUP:
+      return buildGroup(condition);
+  }
+};
+
+export const buildExtraConditions = (conditions?: IExtraCondition[]): string[] => {
+  if (!conditions?.length) return [];
+  return conditions.map(buildExtraCondition).filter(Boolean);
+};

package/src/core/gemxql/builder/filters/build-filter-conditions.ts

@@ -0,0 +1,161 @@
+import type { GemXQlFilters, GemXQlOverrideFilters, GemXQlVersionIds, OrderByFields } from '../../types';
+
+import { OPERATOR_IS, OPERATOR_IS_ONE_OF } from '../../constants';
+import { EFilterField, EOperatorField } from '../../types';
+
+export interface IBuildFilterConditionsParams {
+  filters: GemXQlFilters;
+  overrideFilters?: GemXQlOverrideFilters;
+}
+
+export interface IBuildVersionIdConditionParams {
+  versionIds?: GemXQlVersionIds;
+}
+
+interface FilterConfig {
+  operator?: EOperatorField;
+  operatorVal?: string;
+  singleField: EFilterField;
+  multiField: EFilterField;
+  condition?: EFilterField;
+  fieldName?: EFilterField;
+}
+
+export const filterConfigs: FilterConfig[] = [
+  {
+    operator: EOperatorField.DEVICE_OPERATOR,
+    singleField: EFilterField.DEVICE,
+    multiField: EFilterField.DEVICES,
+    fieldName: EFilterField.DEVICE,
+  },
+  {
+    operator: EOperatorField.VISITOR_OPERATOR,
+    singleField: EFilterField.VISITOR,
+    multiField: EFilterField.VISITORS,
+    fieldName: EFilterField.VISITOR,
+  },
+  {
+    operator: EOperatorField.TRAFFIC_SOURCE_OPERATOR,
+    singleField: EFilterField.TRAFFIC_SOURCE,
+    multiField: EFilterField.TRAFFIC_SOURCES,
+    fieldName: EFilterField.TRAFFIC_SOURCE,
+  },
+  {
+    operator: EOperatorField.VERSION_OPERATOR,
+    singleField: EFilterField.VERSION,
+    multiField: EFilterField.VERSIONS,
+    fieldName: EFilterField.VERSION,
+  },
+  {
+    operator: EOperatorField.PAGE_OPERATOR,
+    singleField: EFilterField.SINGLE_PAGE,
+    multiField: EFilterField.LIST_PAGE,
+    fieldName: EFilterField.SINGLE_PAGE,
+  },
+  {
+    operator: EOperatorField.CAMPAIGN_ITEM_OPERATOR,
+    singleField: EFilterField.GROUP_CAMPAIGN_ITEM,
+    multiField: EFilterField.GROUP_CAMPAIGN_ITEMS,
+    condition: EFilterField.GROUP_CAMPAIGN,
+    fieldName: EFilterField.SINGLE_CAMPAIGN,
+  },
+  {
+    operatorVal: OPERATOR_IS,
+    singleField: EFilterField.SINGLE_CAMPAIGN,
+    multiField: EFilterField.GROUP_CAMPAIGN,
+  },
+];
+
+const quoteStr = (v: string): string => `'${v.replace(/'/g, "''")}'`;
+
+const buildCondition = (data: {
+  operatorValue: string | undefined;
+  singleValue?: string;
+  multiValue?: string[];
+  fieldName: string;
+}) => {
+  const { operatorValue, singleValue, multiValue, fieldName } = data;
+  if (operatorValue === OPERATOR_IS && singleValue) {
+    return `${fieldName} = ${quoteStr(singleValue)}`;
+  } else if (operatorValue === OPERATOR_IS_ONE_OF && Array.isArray(multiValue) && multiValue.length > 0) {
+    return `${fieldName} IN (${multiValue.map(quoteStr).join(', ')})`;
+  }
+  return '';
+};
+
+const buildOverrideFilterConditions = (overrideFilters?: GemXQlOverrideFilters) => {
+  if (!overrideFilters) return {};
+
+  return Object.fromEntries(
+    Object.entries(overrideFilters)
+      .filter(([, value]) => value !== undefined)
+      .map(([key, value]) => {
+        const condition = Array.isArray(value)
+          ? `${key} IN (${value.map(quoteStr).join(', ')})`
+          : `${key} = ${quoteStr(String(value))}`;
+        return [key, condition];
+      }),
+  );
+};
+
+export const generateFilterConditions = (filters: GemXQlFilters, overrideFilters?: GemXQlOverrideFilters) => {
+  const conditions: string[] = [];
+
+  const hasFilters = Object.keys(filters).length > 0;
+  const hasOverride = !!overrideFilters && Object.keys(overrideFilters).length > 0;
+  if (!hasFilters && !hasOverride) return conditions;
+
+  const overrideConditionsMap = buildOverrideFilterConditions(overrideFilters);
+
+  filterConfigs.forEach(({ operator, operatorVal, singleField, multiField, condition, fieldName }) => {
+    if (overrideConditionsMap[singleField]) {
+      conditions.push(overrideConditionsMap[singleField]);
+      return;
+    }
+
+    const operatorValue = operator ? filters[operator] : operatorVal;
+    let singleValue = filters[singleField];
+    const multiValue = filters[multiField];
+    const conditionValue = condition && filters[condition];
+
+    if (condition && !conditionValue) {
+      return;
+    }
+
+    const resolvedFieldName = fieldName ?? (singleValue ? singleField : multiField);
+
+    if (operatorVal && !singleValue) {
+      singleValue = filters[multiField] as string | undefined;
+    }
+
+    const result = buildCondition({
+      operatorValue,
+      singleValue: Array.isArray(singleValue) ? undefined : singleValue,
+      multiValue: Array.isArray(multiValue) ? multiValue : undefined,
+      fieldName: resolvedFieldName,
+    });
+    if (result) conditions.push(result);
+  });
+
+  return conditions;
+};
+
+export const buildVersionIdCondition = (versionIds?: GemXQlVersionIds) => {
+  const conditions: string[] = [];
+
+  if (!versionIds) return conditions;
+
+  Object.entries(versionIds).forEach(([key, value]) => {
+    if (!value) return;
+    conditions.push(`${key} = ${quoteStr(value)}`);
+  });
+
+  return conditions;
+};
+
+export const getFirstMetricInOrderBy = (orderBy: OrderByFields | undefined, metrics: string[]) => {
+  if (!orderBy || metrics.length === 0) return [];
+
+  const metric = metrics.find((metric) => orderBy[metric]);
+  return metric ? [metric] : [];
+};

package/src/core/gemxql/builder/helpers/date-query-helpers.ts

@@ -0,0 +1,41 @@
+import type { Dayjs } from '@/utils';
+import type { AnalyticDateFilter } from '@/components';
+
+import { dayjsTz } from '@/utils';
+import { DATE_QUERY_FORMAT } from '../configs';
+
+const toDate = (value: Dayjs | string): Dayjs => (typeof value === 'string' ? dayjsTz(value) : value);
+
+const isMidnight = (date: Dayjs) => date.hour() === 0 && date.minute() === 0;
+
+const formatDateForQuery = (date: Dayjs, isEndDay = false) => {
+  if (isEndDay && isMidnight(date)) {
+    return date.endOf('day').format(DATE_QUERY_FORMAT);
+  }
+  return date.format(DATE_QUERY_FORMAT);
+};
+
+const getEndOfDayForQuery = (value?: string | Dayjs) => {
+  if (!value) {
+    return formatDateForQuery(dayjsTz().endOf('day'));
+  }
+  return formatDateForQuery(dayjsTz(value).endOf('day'));
+};
+
+export const getDateRangeForQuery = (dateRange: AnalyticDateFilter) => {
+  const startDate = toDate(dateRange.startDate);
+  const endDate = toDate(dateRange.endDate);
+  const isInTheDay = startDate.isSame(endDate);
+
+  if (isInTheDay) {
+    return {
+      dateGTE: formatDateForQuery(startDate),
+      dateLTE: getEndOfDayForQuery(endDate),
+    };
+  }
+
+  return {
+    dateGTE: formatDateForQuery(startDate),
+    dateLTE: formatDateForQuery(endDate, true),
+  };
+};

package/src/core/gemxql/builder/helpers/is-valid-query-input.ts

@@ -0,0 +1,8 @@
+export function isValidQueryInput(query: string) {
+  if (typeof query !== 'string') return false;
+
+  const q = query.trim();
+  const pattern = /^MODE\b[\s\S]*\bFROM\b[\s\S]*\bSHOW\b[\s\S]*$/;
+
+  return pattern.test(q);
+}

package/src/core/gemxql/builder/parse-gemxql-query.ts

@@ -0,0 +1,43 @@
+import type { AnalyticDateFilter } from '@/components';
+import type { IBuildGemXQlQueryParams } from './build-gemxql-query';
+
+import { parseConditionQuery } from './clauses/condition-query';
+import { parseFromQuery } from './clauses/from-query';
+import { parseGroupQuery } from './clauses/group-query';
+import { parseLimitQuery } from './clauses/limit-query';
+import { parseModeQuery } from './clauses/mode-query';
+import { parseOffsetQuery } from './clauses/offset-query';
+import { parseOrderByQuery } from './clauses/order-by-query';
+import { parseShowQuery } from './clauses/show-query';
+import { parseTimeQuery } from './clauses/time-query';
+import { parseTimeSeriesQuery } from './clauses/time-series-query';
+import { parseTimezoneQuery } from './clauses/timezone-query';
+
+export type IParsedGemXQlQuery = Partial<IBuildGemXQlQueryParams>;
+
+const parse = (query: string): IParsedGemXQlQuery => {
+  const { dateRange, compareDateRange, timeDimension: overrideTimeDimension, overrideFilters } = parseTimeQuery(query);
+  const timeDimension = overrideTimeDimension ?? parseTimeSeriesQuery(query);
+  const { dimensions, groupWithClause } = parseGroupQuery(query);
+  const { filters, versionIds } = parseConditionQuery(query);
+
+  return {
+    mode: parseModeQuery(query),
+    sources: parseFromQuery(query),
+    metrics: parseShowQuery(query),
+    dimensions,
+    groupWithClause,
+    timeDimension,
+    dateRange: dateRange as AnalyticDateFilter,
+    compareDateRange: compareDateRange as AnalyticDateFilter,
+    overrideFilters,
+    filters,
+    versionIds,
+    timezone: parseTimezoneQuery(query),
+    orderBy: parseOrderByQuery(query),
+    limit: parseLimitQuery(query),
+    offset: parseOffsetQuery(query),
+  };
+};
+
+export { parse as parseGemXQlQuery };

package/src/core/gemxql/constants/analytic-data.ts

@@ -0,0 +1,2 @@
+export const NONE_VALUE = 'None';
+export const PLACEHOLDER_VALUE = '-';

package/src/core/gemxql/constants/column-keys.ts

@@ -0,0 +1,4 @@
+export const TOTALS_SUFFIX = '___totals';
+export const COMPARE_PREFIX = 'comparison___';
+export const COMPARE_SUFFIX = '___previous_period';
+export const COMPARE_TOTALS_SUFFIX = `${COMPARE_SUFFIX}${TOTALS_SUFFIX}`;

package/src/core/gemxql/constants/operators.ts

@@ -0,0 +1,2 @@
+export const OPERATOR_IS = 'is';
+export const OPERATOR_IS_ONE_OF = 'is_one_of';

package/src/core/gemxql/constants/row-reader-mode.ts

@@ -0,0 +1,9 @@
+import { ERowReaderMode } from '../types';
+import { COMPARE_PREFIX, COMPARE_SUFFIX, COMPARE_TOTALS_SUFFIX, TOTALS_SUFFIX } from './column-keys';
+
+export const ROW_READER_MODE_CONFIG: Record<ERowReaderMode, { prefix: string; suffix: string }> = {
+  [ERowReaderMode.DEFAULT]: { prefix: '', suffix: '' },
+  [ERowReaderMode.COMPARISON]: { prefix: COMPARE_PREFIX, suffix: COMPARE_SUFFIX },
+  [ERowReaderMode.TOTALS]: { prefix: '', suffix: TOTALS_SUFFIX },
+  [ERowReaderMode.COMPARISON_TOTALS]: { prefix: COMPARE_PREFIX, suffix: COMPARE_TOTALS_SUFFIX },
+};

package/src/core/gemxql/graphql/fragments/gemxql.generated.ts

@@ -0,0 +1,80 @@
+export type Maybe<T> = T | null | undefined;
+
+export type TableDataType =
+  | 'ARRAY'
+  | 'CURRENCY'
+  | 'DATE'
+  | 'DAY_TIMESTAMP'
+  | 'DURATION'
+  | 'HOUR_TIMESTAMP'
+  | 'INTEGER'
+  | 'MONTH_TIMESTAMP'
+  | 'OBJECT'
+  | 'PERCENT'
+  | 'QUARTER_TIMESTAMP'
+  | 'STRING'
+  | 'WEEK_TIMESTAMP'
+  | 'YEAR_TIMESTAMP';
+
+export interface IColumn {
+  dataType: TableDataType;
+  displayName?: Maybe<string>;
+  name: string;
+}
+
+export type Scalars = {
+  ID: { input: string; output: string };
+  String: { input: string; output: string };
+  Boolean: { input: boolean; output: boolean };
+  Int: { input: number; output: number };
+  Float: { input: number; output: number };
+  Any: { input: any; output: any };
+  Cursor: { input: string; output: string };
+  Decimal: { input: any; output: any };
+  Map: { input: any; output: any };
+  Time: { input: string; output: string };
+  Uint: { input: string; output: string };
+  Upload: { input: any; output: any };
+};
+
+export interface ITableData {
+  rows: Maybe<Array<Maybe<Scalars['Map']['output']>>>;
+  columns?: Maybe<Array<Maybe<IColumn>>>;
+}
+
+export type ColumnSelectFragment = Pick<IColumn, 'dataType' | 'displayName' | 'name'>;
+
+export type TableDataSelectFragment = Pick<ITableData, 'rows'> & {
+  columns?: Maybe<Array<Maybe<Pick<IColumn, 'dataType' | 'displayName' | 'name'>>>>;
+};
+
+export type GemXqlResultSelectFragment = {
+  tableData?: Maybe<
+    Pick<ITableData, 'rows'> & {
+      columns?: Maybe<Array<Maybe<Pick<IColumn, 'dataType' | 'displayName' | 'name'>>>>;
+    }
+  >;
+};
+
+export const ColumnSelectFragmentDoc = `
+    fragment ColumnSelect on Column {
+  dataType
+  displayName
+  name
+}
+    `;
+export const TableDataSelectFragmentDoc = `
+    fragment TableDataSelect on TableData {
+  columns {
+    ...ColumnSelect
+  }
+  rows
+}
+    `;
+export const GemXqlResultSelectFragmentDoc = `
+    fragment GemXQLResultSelect on GemxQLResult {
+  tableData {
+    ...TableDataSelect
+  }
+}
+    `;

package/src/core/gemxql/graphql/fragments/gemxql.gql

@@ -0,0 +1,18 @@
+fragment ColumnSelect on Column {
+  dataType
+  displayName
+  name
+}
+
+fragment TableDataSelect on TableData {
+  columns {
+    ...ColumnSelect
+  }
+  rows
+}
+
+fragment GemXQLResultSelect on GemxQLResult {
+  tableData {
+    ...TableDataSelect
+  }
+}

package/src/core/gemxql/graphql/queries/gemxql.generated.ts

@@ -0,0 +1,26 @@
+import type { Maybe } from '../fragments/gemxql.generated';
+
+import {
+  ColumnSelectFragmentDoc,
+  GemXqlResultSelectFragmentDoc,
+  TableDataSelectFragmentDoc,
+  type GemXqlResultSelectFragment,
+} from '../fragments/gemxql.generated';
+
+export type GemxQlQueryVariables = {
+  input: string;
+};
+
+export type GemxQlQueryResponse = {
+  gemxQLQuery?: Maybe<GemXqlResultSelectFragment>;
+};
+
+export const GemxQlDocument = `
+    query GemxQL($input: String!) {
+  gemxQLQuery(query: $input) {
+    ...GemXQLResultSelect
+  }
+}
+    ${GemXqlResultSelectFragmentDoc}
+${TableDataSelectFragmentDoc}
+${ColumnSelectFragmentDoc}`;

package/src/core/gemxql/graphql/queries/gemxql.gql

@@ -0,0 +1,5 @@
+query GemxQL($input: String!) {
+  gemxQLQuery(query: $input) {
+    ...GemXQLResultSelect
+  }
+}

package/src/core/gemxql/helpers/columnKeys.ts

@@ -0,0 +1,8 @@
+import { COMPARE_PREFIX, COMPARE_SUFFIX, TOTALS_SUFFIX } from '../constants';
+
+export const getTotalsKey = (metric: string): string => `${metric}${TOTALS_SUFFIX}`;
+
+export const getComparisonKey = (metric: string): string => `${COMPARE_PREFIX}${metric}${COMPARE_SUFFIX}`;
+
+export const getComparisonTotalsKey = (metric: string): string =>
+  `${COMPARE_PREFIX}${metric}${COMPARE_SUFFIX}${TOTALS_SUFFIX}`;

package/src/core/gemxql/helpers/extractQueryData.ts

@@ -0,0 +1,18 @@
+import type { GemxQlQueryResponse, TableDataType } from '../graphql';
+
+export type ColumnTypesMap = Record<string, TableDataType>;
+
+export const extractQueryRows = (response?: GemxQlQueryResponse): Record<string, unknown>[] =>
+  (response?.gemxQLQuery?.tableData?.rows as Record<string, unknown>[]) ?? [];
+
+export const extractQueryColumns = (response?: GemxQlQueryResponse) => response?.gemxQLQuery?.tableData?.columns ?? [];
+
+export const extractColumnTypes = (response?: GemxQlQueryResponse): ColumnTypesMap => {
+  const columns = extractQueryColumns(response);
+  const columnTypes: ColumnTypesMap = {};
+
+  for (const column of columns) {
+    if (column?.name) columnTypes[column.name] = column.dataType;
+  }
+  return columnTypes;
+};