472 lines
15 KiB
JavaScript
472 lines
15 KiB
JavaScript
import { Kind, parse, print, visit } from "graphql";
|
|
import client from "./GraphQLClient";
|
|
import { gql } from "@apollo/client";
|
|
|
|
/* eslint-disable no-loop-func */
|
|
|
|
/**
|
|
* The available operators for filtering (string)
|
|
* @type {[{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},null,null,null]}
|
|
*/
|
|
const STRING_OPERATORS = [
|
|
{ value: "_eq", label: "equals" },
|
|
{ value: "_neq", label: "does not equal" },
|
|
{ value: "_like", label: "contains" },
|
|
{ value: "_nlike", label: "does not contain" },
|
|
{ value: "_ilike", label: "contains case-insensitive" },
|
|
{ value: "_nilike", label: "does not contain case-insensitive" },
|
|
{ value: "_in", label: "in", type: "array" },
|
|
{ value: "_nin", label: "not in", type: "array" }
|
|
];
|
|
|
|
/**
|
|
* The available operators for filtering (dates)
|
|
* @type {[{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},null,null,null]}
|
|
*/
|
|
const DATE_OPERATORS = [
|
|
{ value: "_eq", label: "equals" },
|
|
{ value: "_neq", label: "does not equal" },
|
|
{ value: "_gt", label: "greater than" },
|
|
{ value: "_lt", label: "less than" },
|
|
{ value: "_gte", label: "greater than or equal" },
|
|
{ value: "_lte", label: "less than or equal" },
|
|
{ value: "_in", label: "in", type: "array" },
|
|
{ value: "_nin", label: "not in", type: "array" }
|
|
];
|
|
|
|
/**
|
|
* The available operators for filtering (booleans)
|
|
* @type {[{label: string, value: string},{label: string, value: string}]}
|
|
*/
|
|
const BOOLEAN_OPERATORS = [
|
|
{ value: "_eq", label: "equals" },
|
|
{ value: "_neq", label: "does not equal" }
|
|
];
|
|
|
|
/**
|
|
* The available operators for filtering (numbers)
|
|
* @type {[{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},null,null,null]}
|
|
*/
|
|
const NUMBER_OPERATORS = [
|
|
{ value: "_eq", label: "equals" },
|
|
{ value: "_neq", label: "does not equal" },
|
|
{ value: "_gt", label: "greater than" },
|
|
{ value: "_lt", label: "less than" },
|
|
{ value: "_gte", label: "greater than or equal" },
|
|
{ value: "_lte", label: "less than or equal" },
|
|
{ value: "_in", label: "in", type: "array" },
|
|
{ value: "_nin", label: "not in", type: "array" }
|
|
];
|
|
|
|
/**
|
|
* The available operators for sorting
|
|
* @type {[{label: string, value: string},{label: string, value: string}]}
|
|
*/
|
|
const ORDER_BY_OPERATORS = [
|
|
{ value: "asc", label: "ascending" },
|
|
{ value: "desc", label: "descending" }
|
|
];
|
|
|
|
/**
|
|
* Get the available operators for filtering
|
|
* @returns {[{label: string, value: string},{label: string, value: string}]}
|
|
*/
|
|
export function getOrderOperatorsByType() {
|
|
return ORDER_BY_OPERATORS;
|
|
}
|
|
|
|
/**
|
|
* Get the available operators for filtering
|
|
* @param type
|
|
* @returns {[{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},null]}
|
|
*/
|
|
export function getWhereOperatorsByType(type = "string") {
|
|
const operators = {
|
|
string: STRING_OPERATORS,
|
|
number: NUMBER_OPERATORS,
|
|
boolean: BOOLEAN_OPERATORS,
|
|
bool: BOOLEAN_OPERATORS,
|
|
date: DATE_OPERATORS
|
|
};
|
|
return operators[type];
|
|
}
|
|
|
|
/**
|
|
* Parse a GraphQL query into an AST
|
|
* @param query
|
|
* @returns {DocumentNode}
|
|
*/
|
|
export function parseQuery(query) {
|
|
return parse(query);
|
|
}
|
|
|
|
/**
|
|
* Print an AST back into a GraphQL query
|
|
* @param query
|
|
* @returns {string}
|
|
*/
|
|
export function printQuery(query) {
|
|
return print(query);
|
|
}
|
|
|
|
/**
|
|
* Generate a template based on the query and object
|
|
* @param templateQueryToExecute
|
|
* @param templateObject
|
|
* @param useShopSpecificTemplate
|
|
* @returns {Promise<{contextData: {}, useShopSpecificTemplate}>}
|
|
*/
|
|
export async function generateTemplate(templateQueryToExecute, templateObject, useShopSpecificTemplate) {
|
|
// Advanced Filtering and Sorting modifications start here
|
|
|
|
// Parse the query and apply the filters and sorters
|
|
const ast = parseQuery(templateQueryToExecute);
|
|
|
|
if (templateObject?.filters && templateObject?.filters?.length) {
|
|
applyFilters(ast, templateObject.filters);
|
|
}
|
|
|
|
if (templateObject?.sorters && templateObject?.sorters?.length) {
|
|
applySorters(ast, templateObject.sorters);
|
|
} else if (templateObject?.defaultSorters && templateObject?.defaultSorters?.length) {
|
|
applySorters(ast, templateObject.defaultSorters);
|
|
}
|
|
|
|
const finalQuery = printQuery(ast);
|
|
|
|
// commented out for future revision debugging
|
|
// console.log('Modified Query');
|
|
// console.log(finalQuery);
|
|
|
|
let contextData = {};
|
|
if (templateQueryToExecute) {
|
|
const { data } = await client.query({
|
|
query: gql(finalQuery),
|
|
variables: { ...templateObject.variables }
|
|
});
|
|
contextData = data;
|
|
}
|
|
|
|
return { contextData, useShopSpecificTemplate };
|
|
}
|
|
|
|
/**
|
|
* Apply sorters to the AST
|
|
* @param ast
|
|
* @param sorters
|
|
*/
|
|
export function applySorters(ast, sorters) {
|
|
sorters.forEach((sorter) => {
|
|
const fieldPath = sorter.field.split(".");
|
|
visit(ast, {
|
|
OperationDefinition: {
|
|
enter(node) {
|
|
// Loop through each sorter to apply it
|
|
// noinspection DuplicatedCode
|
|
|
|
let currentSelection = node; // Start with the root operation
|
|
|
|
// Navigate down the field path to the correct location
|
|
for (let i = 0; i < fieldPath.length - 1; i++) {
|
|
let found = false;
|
|
visit(currentSelection, {
|
|
Field: {
|
|
enter(node) {
|
|
if (node.name.value === fieldPath[i]) {
|
|
currentSelection = node; // Move down to the next level
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
if (!found) break; // Stop if we can't find the next field in the path
|
|
}
|
|
|
|
// Apply the sorter at the correct level
|
|
if (currentSelection) {
|
|
const targetFieldName = fieldPath[fieldPath.length - 1];
|
|
let orderByArg = currentSelection.arguments.find((arg) => arg.name.value === "order_by");
|
|
if (!orderByArg) {
|
|
orderByArg = {
|
|
kind: Kind.ARGUMENT,
|
|
name: { kind: Kind.NAME, value: "order_by" },
|
|
value: { kind: Kind.OBJECT, fields: [] }
|
|
};
|
|
currentSelection.arguments.push(orderByArg);
|
|
}
|
|
|
|
const sorterField = {
|
|
kind: Kind.OBJECT_FIELD,
|
|
name: { kind: Kind.NAME, value: targetFieldName },
|
|
value: { kind: Kind.ENUM, value: sorter.direction } // Adjust if your schema uses a different type for sorting directions
|
|
};
|
|
|
|
// Add the new sorter condition
|
|
orderByArg.value.fields.push(sorterField);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Apply Top Level Sub to the AST
|
|
* @param node
|
|
* @param fieldPath
|
|
* @param filterField
|
|
*/
|
|
function applyTopLevelSub(node, fieldPath, filterField) {
|
|
// Find or create the where argument for the top-level subfield
|
|
let whereArg = node.selectionSet.selections
|
|
.find((selection) => selection.name.value === fieldPath[0])
|
|
?.arguments.find((arg) => arg.name.value === "where");
|
|
|
|
if (!whereArg) {
|
|
whereArg = {
|
|
kind: Kind.ARGUMENT,
|
|
name: { kind: Kind.NAME, value: "where" },
|
|
value: { kind: Kind.OBJECT, fields: [] }
|
|
};
|
|
const topLevelSubSelection = node.selectionSet.selections.find(
|
|
(selection) => selection.name.value === fieldPath[0]
|
|
);
|
|
if (topLevelSubSelection) {
|
|
topLevelSubSelection.arguments = topLevelSubSelection.arguments || [];
|
|
topLevelSubSelection.arguments.push(whereArg);
|
|
}
|
|
}
|
|
|
|
// Correctly position the nested filter without an extra 'where'
|
|
if (fieldPath.length > 2) {
|
|
// More than one level deep
|
|
let currentField = whereArg.value;
|
|
fieldPath.slice(1, -1).forEach((path, index) => {
|
|
let existingField = currentField.fields.find((f) => f.name.value === path);
|
|
if (!existingField) {
|
|
existingField = {
|
|
kind: Kind.OBJECT_FIELD,
|
|
name: { kind: Kind.NAME, value: path },
|
|
value: { kind: Kind.OBJECT, fields: [] }
|
|
};
|
|
currentField.fields.push(existingField);
|
|
}
|
|
currentField = existingField.value;
|
|
});
|
|
currentField.fields.push(filterField);
|
|
} else {
|
|
// Directly under the top level
|
|
whereArg.value.fields.push(filterField);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Apply filters to the AST
|
|
* @param ast
|
|
* @param filters
|
|
* @returns {ASTNode}
|
|
*/
|
|
export function applyFilters(ast, filters) {
|
|
return visit(ast, {
|
|
OperationDefinition: {
|
|
enter(node) {
|
|
filters.forEach((filter) => {
|
|
const fieldPath = filter.field.split(".");
|
|
let topLevel = false;
|
|
let topLevelSub = false;
|
|
|
|
// Determine if the filter should be applied at the top level
|
|
if (fieldPath.length === 2) {
|
|
topLevel = true;
|
|
}
|
|
|
|
if (fieldPath.length > 2 && fieldPath[0].startsWith("[") && fieldPath[0].endsWith("]")) {
|
|
fieldPath[0] = fieldPath[0].substring(1, fieldPath[0].length - 1); // Strip the brackets
|
|
topLevelSub = true;
|
|
}
|
|
|
|
// Construct the filter for a top-level application
|
|
const targetFieldName = fieldPath[fieldPath.length - 1];
|
|
|
|
let filterValue = createFilterValue(filter);
|
|
let filterField = createFilterField(targetFieldName, filter, filterValue);
|
|
|
|
if (topLevel) {
|
|
applyTopLevelFilter(node, fieldPath, filterField);
|
|
} else if (topLevelSub) {
|
|
applyTopLevelSub(node, fieldPath, filterField);
|
|
} else {
|
|
applyNestedFilter(node, fieldPath, filterField);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create a filter value based on the filter
|
|
* @param filter
|
|
* @returns {{kind: (Kind|Kind.INT), value}|{kind: Kind.LIST, values: *}}
|
|
*/
|
|
function createFilterValue(filter) {
|
|
if (Array.isArray(filter.value)) {
|
|
// If it's an array, create a list value with the array items
|
|
return {
|
|
kind: Kind.LIST,
|
|
values: filter.value.map((item) => ({
|
|
kind: getGraphQLKind(item),
|
|
value: item
|
|
}))
|
|
};
|
|
} else {
|
|
// If it's not an array, use the existing logic
|
|
return {
|
|
kind: getGraphQLKind(filter.value),
|
|
value: filter.value
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a filter field based on the target field and filter
|
|
* @param targetFieldName
|
|
* @param filter
|
|
* @param filterValue
|
|
* @returns {{kind: Kind.OBJECT_FIELD, name: {kind: Kind.NAME, value}, value: {kind: Kind.OBJECT, fields: [{kind: Kind.OBJECT_FIELD, name: {kind: Kind.NAME, value}, value}]}}}
|
|
*/
|
|
function createFilterField(targetFieldName, filter, filterValue) {
|
|
return {
|
|
kind: Kind.OBJECT_FIELD,
|
|
name: { kind: Kind.NAME, value: targetFieldName },
|
|
value: {
|
|
kind: Kind.OBJECT,
|
|
fields: [
|
|
{
|
|
kind: Kind.OBJECT_FIELD,
|
|
name: { kind: Kind.NAME, value: filter.operator },
|
|
value: filterValue
|
|
}
|
|
]
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Apply a top-level filter to the AST
|
|
* @param node
|
|
* @param fieldPath
|
|
* @param filterField
|
|
*/
|
|
function applyTopLevelFilter(node, fieldPath, filterField) {
|
|
// Find or create the where argument for the top-level field
|
|
let whereArg = node.selectionSet.selections
|
|
.find((selection) => selection.name.value === fieldPath[0])
|
|
?.arguments.find((arg) => arg.name.value === "where");
|
|
|
|
if (!whereArg) {
|
|
whereArg = {
|
|
kind: Kind.ARGUMENT,
|
|
name: { kind: Kind.NAME, value: "where" },
|
|
value: { kind: Kind.OBJECT, fields: [] }
|
|
};
|
|
const topLevelSelection = node.selectionSet.selections.find((selection) => selection.name.value === fieldPath[0]);
|
|
if (topLevelSelection) {
|
|
topLevelSelection.arguments = topLevelSelection.arguments || [];
|
|
topLevelSelection.arguments.push(whereArg);
|
|
}
|
|
}
|
|
|
|
// Correctly position the nested filter without an extra 'where'
|
|
if (fieldPath.length > 2) {
|
|
// More than one level deep
|
|
let currentField = whereArg.value;
|
|
fieldPath.slice(1, -1).forEach((path, index) => {
|
|
let existingField = currentField.fields.find((f) => f.name.value === path);
|
|
if (!existingField) {
|
|
existingField = {
|
|
kind: Kind.OBJECT_FIELD,
|
|
name: { kind: Kind.NAME, value: path },
|
|
value: { kind: Kind.OBJECT, fields: [] }
|
|
};
|
|
currentField.fields.push(existingField);
|
|
}
|
|
currentField = existingField.value;
|
|
});
|
|
currentField.fields.push(filterField);
|
|
} else {
|
|
// Directly under the top level
|
|
whereArg.value.fields.push(filterField);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Apply a nested filter to the AST
|
|
* @param node
|
|
* @param fieldPath
|
|
* @param filterField
|
|
*/
|
|
function applyNestedFilter(node, fieldPath, filterField) {
|
|
// Initialize a reference to the current selection to traverse down the AST
|
|
let currentSelection = node;
|
|
|
|
// Iterate over the fieldPath, except for the last entry, to navigate the structure
|
|
for (let i = 0; i < fieldPath.length - 1; i++) {
|
|
const fieldName = fieldPath[i];
|
|
let fieldFound = false;
|
|
|
|
// Check if the current selection has a selectionSet and selections
|
|
if (currentSelection.selectionSet && currentSelection.selectionSet.selections) {
|
|
// Look for the field in the current selection's selections
|
|
const selection = currentSelection.selectionSet.selections.find((sel) => sel.name.value === fieldName);
|
|
if (selection) {
|
|
// Move down the AST to the found selection
|
|
currentSelection = selection;
|
|
fieldFound = true;
|
|
}
|
|
}
|
|
|
|
// If the field was not found in the current path, it's an issue
|
|
if (!fieldFound) {
|
|
console.error(`Field ${fieldName} not found in the current selection.`);
|
|
return; // Exit the loop and function due to error
|
|
}
|
|
}
|
|
|
|
// At this point, currentSelection should be the parent field where the filter needs to be applied
|
|
// Check if the 'where' argument already exists in the current selection
|
|
const whereArg = currentSelection.arguments.find((arg) => arg.name.value === "where");
|
|
if (!whereArg) {
|
|
// If not found, create a new 'where' argument for the current selection
|
|
currentSelection.arguments.push({
|
|
kind: Kind.ARGUMENT,
|
|
name: { kind: Kind.NAME, value: "where" },
|
|
value: { kind: Kind.OBJECT, fields: [] } // Empty fields array to be populated with the filter
|
|
});
|
|
}
|
|
|
|
// Add the filter field to the 'where' clause of the current selection
|
|
currentSelection.arguments.find((arg) => arg.name.value === "where").value.fields.push(filterField);
|
|
}
|
|
|
|
/**
|
|
* Get the GraphQL kind for a value
|
|
* @param value
|
|
* @returns {Kind|Kind.INT}
|
|
*/
|
|
function getGraphQLKind(value) {
|
|
if (Array.isArray(value)) {
|
|
return Kind.LIST;
|
|
} else if (typeof value === "number") {
|
|
return value % 1 === 0 ? Kind.INT : Kind.FLOAT;
|
|
} else if (typeof value === "boolean") {
|
|
return Kind.BOOLEAN;
|
|
} else if (typeof value === "string") {
|
|
return Kind.STRING;
|
|
} else if (value instanceof Date) {
|
|
return Kind.STRING; // GraphQL does not have a Date type, so we return it as a string
|
|
}
|
|
}
|
|
|
|
/* eslint-enable no-loop-func */
|