@tanstack/db/dist/esm/query/select.js

A reactive client store for building super fast apps on sync

import { map } from "@electric-sql/d2mini";
import { extractValueFromNamespacedRow, evaluateOperandOnNamespacedRow } from "./extractors.js";
function processSelect(pipeline, query, mainTableAlias, inputs) {
  return pipeline.pipe(
    map(([key, namespacedRow]) => {
      const result = {};
      const isGroupedResult = query.groupBy && Object.keys(namespacedRow).some(
        (namespaceKey) => !Object.keys(inputs).includes(namespaceKey) && typeof namespacedRow[namespaceKey] !== `object`
      );
      if (!query.select) {
        throw new Error(`Cannot process missing SELECT clause`);
      }
      for (const item of query.select) {
        if (typeof item === `function`) {
          const callback = item;
          const callbackResult = callback(namespacedRow);
          if (callbackResult && typeof callbackResult === `object` && !Array.isArray(callbackResult)) {
            Object.assign(result, callbackResult);
          } else {
            console.warn(
              `SelectCallback returned a non-object value. SelectCallbacks should return objects with key-value pairs.`
            );
          }
          continue;
        }
        if (typeof item === `string`) {
          if (item === `@*`) {
            if (isGroupedResult) {
              Object.assign(result, namespacedRow);
            } else {
              Object.assign(
                result,
                extractAllColumnsFromAllTables(namespacedRow)
              );
            }
            continue;
          }
          if (item.startsWith(`@`) && item.endsWith(`.*`)) {
            const tableAlias = item.slice(1, -2);
            if (isGroupedResult) {
              continue;
            } else {
              Object.assign(
                result,
                extractAllColumnsFromTable(namespacedRow, tableAlias)
              );
            }
            continue;
          }
          if (item.startsWith(`@`)) {
            const columnRef = item.substring(1);
            const alias = columnRef;
            if (isGroupedResult && columnRef in namespacedRow) {
              result[alias] = namespacedRow[columnRef];
            } else {
              result[alias] = extractValueFromNamespacedRow(
                namespacedRow,
                columnRef,
                mainTableAlias,
                void 0
              );
            }
            if (alias.includes(`.`)) {
              const columnName = alias.split(`.`)[1];
              result[columnName] = result[alias];
              delete result[alias];
            }
          }
        } else {
          for (const [alias, expr] of Object.entries(item)) {
            if (typeof expr === `string` && expr.startsWith(`@`)) {
              const columnRef = expr.substring(1);
              if (isGroupedResult && columnRef in namespacedRow) {
                result[alias] = namespacedRow[columnRef];
              } else {
                result[alias] = extractValueFromNamespacedRow(
                  namespacedRow,
                  columnRef,
                  mainTableAlias,
                  void 0
                );
              }
            } else if (typeof expr === `object`) {
              if (isGroupedResult && alias in namespacedRow) {
                result[alias] = namespacedRow[alias];
              } else if (expr.ORDER_INDEX) {
                result[alias] = namespacedRow[mainTableAlias][alias];
              } else {
                result[alias] = evaluateOperandOnNamespacedRow(
                  namespacedRow,
                  expr,
                  mainTableAlias,
                  void 0
                );
              }
            }
          }
        }
      }
      return [key, result];
    })
  );
}
function extractAllColumnsFromAllTables(namespacedRow) {
  const result = {};
  for (const [tableAlias, tableData] of Object.entries(namespacedRow)) {
    if (tableData && typeof tableData === `object`) {
      Object.assign(
        result,
        extractAllColumnsFromTable(namespacedRow, tableAlias)
      );
    }
  }
  return result;
}
function extractAllColumnsFromTable(namespacedRow, tableAlias) {
  const result = {};
  const tableData = namespacedRow[tableAlias];
  if (!tableData || typeof tableData !== `object`) {
    return result;
  }
  for (const [columnName, value] of Object.entries(tableData)) {
    result[columnName] = value;
  }
  return result;
}
export {
  processSelect
};
//# sourceMappingURL=select.js.map