@jskit-ai/crud-core 0.1.63 → 0.1.64

package/src/server/listFilters.js

@@ -1,18 +1,17 @@
-import { Type } from "typebox";
 import {
   normalizeObjectInput,
-  mergeObjectSchemas,
   RECORD_ID_PATTERN
 } from "@jskit-ai/kernel/shared/validators";
+import { createSchema } from "json-rest-schema";
 import {
-  normalizeBoolean,
-  normalizeCanonicalRecordIdText,
+  isRecord as isPlainObject,
   normalizeObject,
-  normalizeText,
-  normalizeUniqueTextList
+  normalizeText
 } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   defineCrudListFilters,
+  CRUD_LIST_FILTER_INVALID_VALUES_REJECT,
+  CRUD_LIST_FILTER_INVALID_VALUES_DISCARD,
   CRUD_LIST_FILTER_TYPE_FLAG,
   CRUD_LIST_FILTER_TYPE_ENUM,
   CRUD_LIST_FILTER_TYPE_ENUM_MANY,
@@ -21,127 +20,109 @@ import {
   CRUD_LIST_FILTER_TYPE_DATE,
   CRUD_LIST_FILTER_TYPE_DATE_RANGE,
   CRUD_LIST_FILTER_TYPE_NUMBER_RANGE,
-  CRUD_LIST_FILTER_TYPE_PRESENCE
+  CRUD_LIST_FILTER_TYPE_PRESENCE,
+  INVALID_CRUD_LIST_FILTER_QUERY_VALUE,
+  normalizeCrudListFilterInvalidValues,
+  parseCrudListFilterQueryValue
 } from "@jskit-ai/kernel/shared/support/crudListFilters";
 
-const DATE_FILTER_PATTERN_SOURCE = "^\\d{4}-\\d{2}-\\d{2}$";
-const DATE_FILTER_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
-const NUMBER_FILTER_PATTERN_SOURCE = "^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?$";
-const CRUD_LIST_FILTER_INVALID_VALUES_REJECT = "reject";
-const CRUD_LIST_FILTER_INVALID_VALUES_DISCARD = "discard";
-const CRUD_LIST_FILTER_INVALID_VALUES_MODES = Object.freeze([
-  CRUD_LIST_FILTER_INVALID_VALUES_REJECT,
-  CRUD_LIST_FILTER_INVALID_VALUES_DISCARD
-]);
-const looseTextInputSchema = Type.String({ minLength: 0 });
-const strictNumberInputSchema = Type.Union([
-  Type.String({ pattern: NUMBER_FILTER_PATTERN_SOURCE }),
-  Type.Number()
-]);
-const looseStringOrNumberSchema = Type.Union([
-  looseTextInputSchema,
-  Type.Number()
-]);
-const recordIdInputSchema = Type.Union([
-  Type.String({ pattern: RECORD_ID_PATTERN }),
-  Type.Number({ minimum: 1 })
-]);
-const flagInputSchema = Type.Union([
-  Type.String({ minLength: 0 }),
-  Type.Boolean(),
-  Type.Number()
-]);
-
-function normalizeCrudListFilterInvalidValues(value = "") {
-  const normalized = normalizeText(value).toLowerCase();
-  if (CRUD_LIST_FILTER_INVALID_VALUES_MODES.includes(normalized)) {
-    return normalized;
-  }
-
-  throw new TypeError(
-    `Unsupported CRUD list filter invalidValues mode "${value}". Expected one of: ${CRUD_LIST_FILTER_INVALID_VALUES_MODES.join(", ")}.`
-  );
-}
-
-function createSingleOrMultiValueSchema(itemSchema) {
-  return Type.Optional(
-    Type.Union([
-      itemSchema,
-      Type.Array(itemSchema, {
-        minItems: 1
-      })
-    ])
-  );
-}
+const DATE_FILTER_VALUE_PATTERN_SOURCE = "\\d{4}-\\d{2}-\\d{2}";
+const DATE_FILTER_PATTERN_SOURCE = `^${DATE_FILTER_VALUE_PATTERN_SOURCE}$`;
+const DATE_RANGE_FILTER_PATTERN_SOURCE =
+  `^(?:${DATE_FILTER_VALUE_PATTERN_SOURCE}(?:\\.\\.(?:${DATE_FILTER_VALUE_PATTERN_SOURCE})?)?|\\.\\.${DATE_FILTER_VALUE_PATTERN_SOURCE})$`;
+const NUMBER_FILTER_VALUE_PATTERN_SOURCE = "[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?";
+const NUMBER_RANGE_FILTER_PATTERN_SOURCE =
+  `^(?:${NUMBER_FILTER_VALUE_PATTERN_SOURCE}(?:\\.\\.(?:${NUMBER_FILTER_VALUE_PATTERN_SOURCE})?)?|\\.\\.${NUMBER_FILTER_VALUE_PATTERN_SOURCE})$`;
+const CRUD_LIST_FILTER_QUERY_TYPE = "crudListFilterQuery";
+const crudListFilterSchemaFactory = createSchema.createFactory();
+const looseTextTransportSchema = Object.freeze({
+  type: "string",
+  minLength: 0
+});
+const strictNumberRangeTransportSchema = Object.freeze({
+  anyOf: [
+    {
+      type: "string",
+      pattern: NUMBER_RANGE_FILTER_PATTERN_SOURCE
+    },
+    {
+      type: "number"
+    }
+  ]
+});
+const looseStringOrNumberTransportSchema = Object.freeze({
+  anyOf: [
+    looseTextTransportSchema,
+    {
+      type: "number"
+    }
+  ]
+});
+const recordIdTransportSchema = Object.freeze({
+  anyOf: [
+    {
+      type: "string",
+      pattern: RECORD_ID_PATTERN
+    },
+    {
+      type: "number",
+      minimum: 1
+    }
+  ]
+});
+const flagTransportSchema = Object.freeze({
+  anyOf: [
+    {
+      type: "string",
+      minLength: 0
+    },
+    {
+      type: "boolean"
+    },
+    {
+      type: "number"
+    }
+  ]
+});
 
-function firstValue(value) {
+function cloneTransportSchema(value) {
   if (Array.isArray(value)) {
-    return value[0];
-  }
-
-  return value;
-}
-
-function normalizeDateFilterValue(value) {
-  const normalized = normalizeText(firstValue(value));
-  if (!normalized || !DATE_FILTER_PATTERN.test(normalized)) {
-    return "";
+    return value.map((entry) => cloneTransportSchema(entry));
   }
 
-  return normalized;
-}
-
-function normalizeNumberFilterValue(value) {
-  if (value == null || value === "") {
-    return null;
+  if (!value || typeof value !== "object") {
+    return value;
   }
 
-  const normalized = typeof value === "number"
-    ? value
-    : Number(normalizeText(firstValue(value)));
-  return Number.isFinite(normalized) ? normalized : null;
-}
-
-function normalizeRecordIdFilterValue(value) {
-  return normalizeCanonicalRecordIdText(firstValue(value), {
-    fallback: ""
-  }) || "";
-}
-
-function normalizeRecordIdFilterValues(value) {
-  return normalizeUniqueTextList(value, {
-    acceptSingle: true
-  })
-    .map((entry) => normalizeCanonicalRecordIdText(entry, { fallback: "" }))
-    .filter(Boolean);
-}
-
-function resolveAllowedOptionValues(filter = {}) {
-  return new Set(
-    (Array.isArray(filter.options) ? filter.options : [])
-      .map((entry) => normalizeText(entry?.value))
-      .filter(Boolean)
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [key, cloneTransportSchema(entry)])
   );
 }
 
-function normalizeAllowedTextValue(value, allowedValues = new Set()) {
-  const normalized = normalizeText(firstValue(value));
-  if (!normalized || !allowedValues.has(normalized)) {
-    return "";
-  }
-
-  return normalized;
-}
-
-function normalizeAllowedTextValues(value, allowedValues = new Set()) {
-  return normalizeUniqueTextList(value, {
-    acceptSingle: true
-  }).filter((entry) => allowedValues.has(entry));
+function buildSingleOrMultiTransportSchema(itemSchema) {
+  return {
+    anyOf: [
+      cloneTransportSchema(itemSchema),
+      {
+        type: "array",
+        items: cloneTransportSchema(itemSchema),
+        minItems: 1
+      }
+    ]
+  };
 }
 
 function addDaysToDateFilterValue(value = "", days = 0) {
-  const normalizedValue = normalizeDateFilterValue(value);
-  if (!normalizedValue || !Number.isInteger(days)) {
+  const normalizedValue = parseCrudListFilterQueryValue(
+    { type: CRUD_LIST_FILTER_TYPE_DATE },
+    value,
+    { invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_REJECT }
+  );
+  if (
+    normalizedValue === INVALID_CRUD_LIST_FILTER_QUERY_VALUE ||
+    !normalizedValue ||
+    !Number.isInteger(days)
+  ) {
     return "";
   }
 
@@ -157,216 +138,312 @@ function addDaysToDateFilterValue(value = "", days = 0) {
   return `${year}-${month}-${day}`;
 }
 
-function createFilterQuerySchema(filter = {}, { invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {}) {
-  const invalidValueMode = normalizeCrudListFilterInvalidValues(invalidValues);
-  const discardInvalidValues = invalidValueMode === CRUD_LIST_FILTER_INVALID_VALUES_DISCARD;
-  const allowedValues = (Array.isArray(filter.options) ? filter.options : []).map((entry) => entry.value);
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_FLAG) {
-    return Type.Object(
-      {
-        [filter.queryKey]: Type.Optional(flagInputSchema)
-      },
-      { additionalProperties: false }
-    );
-  }
+const FILTER_TYPE_SERVER_HANDLERS = Object.freeze({
+  [CRUD_LIST_FILTER_TYPE_FLAG]: Object.freeze({
+    buildTransportSchema() {
+      return cloneTransportSchema(flagTransportSchema);
+    },
+    applyQuery(queryBuilder, value, column = "") {
+      if (column && value === true) {
+        queryBuilder.where(column, true);
+      }
+      return queryBuilder;
+    }
+  }),
+  [CRUD_LIST_FILTER_TYPE_ENUM]: Object.freeze({
+    buildTransportSchema({ discardInvalidValues, allowedValues }) {
+      return discardInvalidValues
+        ? cloneTransportSchema(looseTextTransportSchema)
+        : {
+            type: "string",
+            enum: allowedValues
+          };
+    },
+    applyQuery(queryBuilder, value, column = "") {
+      if (column && value !== undefined) {
+        queryBuilder.where(column, value);
+      }
+      return queryBuilder;
+    }
+  }),
+  [CRUD_LIST_FILTER_TYPE_ENUM_MANY]: Object.freeze({
+    buildTransportSchema({ discardInvalidValues, allowedValues }) {
+      return buildSingleOrMultiTransportSchema(
+        discardInvalidValues
+          ? looseTextTransportSchema
+          : {
+              type: "string",
+              enum: allowedValues
+            }
+      );
+    },
+    applyQuery(queryBuilder, value, column = "") {
+      if (column && Array.isArray(value) && value.length > 0) {
+        queryBuilder.whereIn(column, value);
+      }
+      return queryBuilder;
+    }
+  }),
+  [CRUD_LIST_FILTER_TYPE_RECORD_ID]: Object.freeze({
+    buildTransportSchema({ discardInvalidValues }) {
+      return discardInvalidValues
+        ? cloneTransportSchema(looseStringOrNumberTransportSchema)
+        : cloneTransportSchema(recordIdTransportSchema);
+    },
+    applyQuery(queryBuilder, value, column = "") {
+      if (column && value !== undefined) {
+        queryBuilder.where(column, value);
+      }
+      return queryBuilder;
+    }
+  }),
+  [CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY]: Object.freeze({
+    buildTransportSchema({ discardInvalidValues }) {
+      return buildSingleOrMultiTransportSchema(
+        discardInvalidValues
+          ? looseStringOrNumberTransportSchema
+          : recordIdTransportSchema
+      );
+    },
+    applyQuery(queryBuilder, value, column = "") {
+      if (column && Array.isArray(value) && value.length > 0) {
+        queryBuilder.whereIn(column, value);
+      }
+      return queryBuilder;
+    }
+  }),
+  [CRUD_LIST_FILTER_TYPE_DATE]: Object.freeze({
+    buildTransportSchema({ discardInvalidValues }) {
+      return discardInvalidValues
+        ? cloneTransportSchema(looseTextTransportSchema)
+        : {
+            type: "string",
+            pattern: DATE_FILTER_PATTERN_SOURCE
+          };
+    },
+    applyQuery(queryBuilder, value, column = "") {
+      if (!column || !value) {
+        return queryBuilder;
+      }
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM || filter.type === CRUD_LIST_FILTER_TYPE_PRESENCE) {
-    return Type.Object(
-      {
-        [filter.queryKey]: Type.Optional(
-          discardInvalidValues
-            ? looseTextInputSchema
-            : Type.String({ enum: allowedValues })
-        )
-      },
-      { additionalProperties: false }
-    );
-  }
+      const nextDate = addDaysToDateFilterValue(value, 1);
+      queryBuilder.where(column, ">=", `${value} 00:00:00`);
+      if (nextDate) {
+        queryBuilder.where(column, "<", `${nextDate} 00:00:00`);
+      }
+      return queryBuilder;
+    }
+  }),
+  [CRUD_LIST_FILTER_TYPE_DATE_RANGE]: Object.freeze({
+    buildTransportSchema({ discardInvalidValues }) {
+      return discardInvalidValues
+        ? cloneTransportSchema(looseTextTransportSchema)
+        : {
+            type: "string",
+            pattern: DATE_RANGE_FILTER_PATTERN_SOURCE
+          };
+    },
+    applyQuery(queryBuilder, value, column = "") {
+      if (!column) {
+        return queryBuilder;
+      }
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY) {
-    return Type.Object(
-      {
-        [filter.queryKey]: createSingleOrMultiValueSchema(
-          discardInvalidValues
-            ? looseTextInputSchema
-            : Type.String({ enum: allowedValues })
-        )
-      },
-      { additionalProperties: false }
-    );
-  }
+      if (value?.from) {
+        queryBuilder.where(column, ">=", `${value.from} 00:00:00`);
+      }
+      if (value?.to) {
+        const nextDate = addDaysToDateFilterValue(value.to, 1);
+        if (nextDate) {
+          queryBuilder.where(column, "<", `${nextDate} 00:00:00`);
+        }
+      }
+      return queryBuilder;
+    }
+  }),
+  [CRUD_LIST_FILTER_TYPE_NUMBER_RANGE]: Object.freeze({
+    buildTransportSchema({ discardInvalidValues }) {
+      return discardInvalidValues
+        ? cloneTransportSchema(looseStringOrNumberTransportSchema)
+        : cloneTransportSchema(strictNumberRangeTransportSchema);
+    },
+    applyQuery(queryBuilder, value, column = "") {
+      if (!column) {
+        return queryBuilder;
+      }
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID) {
-    return Type.Object(
-      {
-        [filter.queryKey]: Type.Optional(
-          discardInvalidValues
-            ? looseStringOrNumberSchema
-            : recordIdInputSchema
-        )
-      },
-      { additionalProperties: false }
-    );
-  }
+      if (value?.min != null) {
+        queryBuilder.where(column, ">=", value.min);
+      }
+      if (value?.max != null) {
+        queryBuilder.where(column, "<=", value.max);
+      }
+      return queryBuilder;
+    }
+  }),
+  [CRUD_LIST_FILTER_TYPE_PRESENCE]: Object.freeze({
+    buildTransportSchema({ discardInvalidValues, allowedValues }) {
+      return discardInvalidValues
+        ? cloneTransportSchema(looseTextTransportSchema)
+        : {
+            type: "string",
+            enum: allowedValues
+          };
+    },
+    applyQuery(queryBuilder, value, column = "") {
+      if (!column) {
+        return queryBuilder;
+      }
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY) {
-    return Type.Object(
-      {
-        [filter.queryKey]: createSingleOrMultiValueSchema(
-          discardInvalidValues
-            ? looseStringOrNumberSchema
-            : recordIdInputSchema
-        )
-      },
-      { additionalProperties: false }
-    );
-  }
+      if (value === "present") {
+        queryBuilder.whereNotNull(column);
+      }
+      if (value === "missing") {
+        queryBuilder.whereNull(column);
+      }
+      return queryBuilder;
+    }
+  })
+});
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE) {
-    return Type.Object(
-      {
-        [filter.queryKey]: Type.Optional(
-          discardInvalidValues
-            ? looseTextInputSchema
-            : Type.String({ pattern: DATE_FILTER_PATTERN_SOURCE })
-        )
-      },
-      { additionalProperties: false }
-    );
+function normalizeCrudListFilterQueryFieldInput(filterDefinition = null) {
+  if (!filterDefinition || typeof filterDefinition !== "object" || Array.isArray(filterDefinition)) {
+    throw new TypeError("createCrudListFilterQueryField requires a normalized filter definition object.");
   }
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE) {
-    return Type.Object(
-      {
-        [filter.fromKey]: Type.Optional(
-          discardInvalidValues
-            ? looseTextInputSchema
-            : Type.String({ pattern: DATE_FILTER_PATTERN_SOURCE })
-        ),
-        [filter.toKey]: Type.Optional(
-          discardInvalidValues
-            ? looseTextInputSchema
-            : Type.String({ pattern: DATE_FILTER_PATTERN_SOURCE })
-        )
-      },
-      { additionalProperties: false }
+  const key = normalizeText(filterDefinition.key);
+  const type = normalizeText(filterDefinition.type);
+  const queryKey = normalizeText(filterDefinition.queryKey);
+  if (!key || !type || !queryKey) {
+    throw new TypeError(
+      "createCrudListFilterQueryField requires a normalized filter definition from defineCrudListFilters(...)."
     );
   }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-    return Type.Object(
-      {
-        [filter.minKey]: Type.Optional(
-          discardInvalidValues
-            ? looseStringOrNumberSchema
-            : strictNumberInputSchema
-        ),
-        [filter.maxKey]: Type.Optional(
-          discardInvalidValues
-            ? looseStringOrNumberSchema
-            : strictNumberInputSchema
-        )
-      },
-      { additionalProperties: false }
-    );
+  if (!FILTER_TYPE_SERVER_HANDLERS[type]) {
+    throw new TypeError(`Unsupported CRUD list filter type "${type}".`);
   }
 
-  return Type.Object({}, { additionalProperties: false });
+  return filterDefinition;
 }
 
-function normalizeFilterValue(filter = {}, source = {}) {
-  const allowedValues = resolveAllowedOptionValues(filter);
+function createCrudListFilterQueryField(filterDefinition = {}, {
+  invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT
+} = {}) {
+  const invalidValueMode = normalizeCrudListFilterInvalidValues(invalidValues);
+  const filter = normalizeCrudListFilterQueryFieldInput(filterDefinition);
+  const filterContract = Object.freeze({
+    filter,
+    invalidValues: invalidValueMode
+  });
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_FLAG) {
-    if (!Object.hasOwn(source, filter.queryKey)) {
-      return undefined;
-    }
+  return Object.freeze({
+    type: CRUD_LIST_FILTER_QUERY_TYPE,
+    filterContract
+  });
+}
 
-    const sourceValue = source[filter.queryKey];
-    if (sourceValue === null || sourceValue === "") {
-      return true;
-    }
+function buildFilterQueryFieldDefinition(filterDefinition = {}, { invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {}) {
+  const filter = normalizeCrudListFilterQueryFieldInput(filterDefinition);
+  return {
+    [filter.queryKey]: createCrudListFilterQueryField(filter, {
+      invalidValues
+    })
+  };
+}
 
-    try {
-      return normalizeBoolean(firstValue(sourceValue));
-    } catch {
-      return undefined;
-    }
-  }
+function buildFilterQueryTransportSchema(filter = {}, { invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {}) {
+  const invalidValueMode = normalizeCrudListFilterInvalidValues(invalidValues);
+  const discardInvalidValues = invalidValueMode === CRUD_LIST_FILTER_INVALID_VALUES_DISCARD;
+  const allowedValues = (Array.isArray(filter.options) ? filter.options : []).map((entry) => entry.value);
+  const handler = FILTER_TYPE_SERVER_HANDLERS[filter.type];
+  return handler
+    ? handler.buildTransportSchema({ discardInvalidValues, allowedValues })
+    : {};
+}
+
+crudListFilterSchemaFactory.addType(CRUD_LIST_FILTER_QUERY_TYPE, Object.assign(
+  (context) => {
+    const contract = isPlainObject(context.definition.filterContract)
+      ? context.definition.filterContract
+      : null;
+    const filter = contract?.filter;
+    const invalidValues = contract?.invalidValues;
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM || filter.type === CRUD_LIST_FILTER_TYPE_PRESENCE) {
-    if (!Object.hasOwn(source, filter.queryKey)) {
-      return undefined;
+    if (!filter || !invalidValues) {
+      context.throwTypeError();
     }
 
-    const normalizedValue = normalizeAllowedTextValue(source[filter.queryKey], allowedValues);
-    return normalizedValue || undefined;
-  }
+    const parsedValue = parseCrudListFilterQueryValue(filter, context.value, {
+      invalidValues
+    });
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY) {
-    if (!Object.hasOwn(source, filter.queryKey)) {
-      return undefined;
+    if (parsedValue === INVALID_CRUD_LIST_FILTER_QUERY_VALUE) {
+      context.throwTypeError();
     }
 
-    const normalizedValues = normalizeAllowedTextValues(source[filter.queryKey], allowedValues);
-    return normalizedValues.length > 0 ? normalizedValues : undefined;
-  }
+    return parsedValue;
+  },
+  {
+    toJsonSchema({ definition }) {
+      const contract = isPlainObject(definition?.filterContract)
+        ? definition.filterContract
+        : null;
+      const filter = contract?.filter;
+      const invalidValues = contract?.invalidValues;
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID) {
-    if (!Object.hasOwn(source, filter.queryKey)) {
-      return undefined;
-    }
+      if (!filter || !invalidValues) {
+        throw new Error(`Type "${CRUD_LIST_FILTER_QUERY_TYPE}" requires definition.filterContract for transport export.`);
+      }
 
-    const normalizedValue = normalizeRecordIdFilterValue(source[filter.queryKey]);
-    return normalizedValue || undefined;
+      return buildFilterQueryTransportSchema(filter, {
+        invalidValues
+      });
+    }
   }
+));
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY) {
-    if (!Object.hasOwn(source, filter.queryKey)) {
-      return undefined;
-    }
+function createCrudListFilterQuerySchema(structure = {}) {
+  return crudListFilterSchemaFactory(structure);
+}
+
+function buildFilterQuerySchemaDefinition(filterEntries = [], {
+  invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT
+} = {}) {
+  const structure = {};
 
-    const normalizedValues = normalizeRecordIdFilterValues(source[filter.queryKey]);
-    return normalizedValues.length > 0 ? normalizedValues : undefined;
+  for (const filter of filterEntries) {
+    Object.assign(structure, buildFilterQueryFieldDefinition(filter, {
+      invalidValues
+    }));
   }
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE) {
-    if (!Object.hasOwn(source, filter.queryKey)) {
-      return undefined;
-    }
+  return Object.freeze({
+    schema: createCrudListFilterQuerySchema(structure),
+    mode: "patch"
+  });
+}
 
-    const normalizedValue = normalizeDateFilterValue(source[filter.queryKey]);
-    return normalizedValue || undefined;
-  }
+function projectNormalizedFilterValues(filterEntries = [], source = {}, errors = {}) {
+  const normalizedSource = normalizeObjectInput(source);
+  const errorFieldKeys = new Set(Object.keys(normalizeObject(errors)));
+  const normalized = {};
 
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE) {
-    const from = normalizeDateFilterValue(source[filter.fromKey]);
-    const to = normalizeDateFilterValue(source[filter.toKey]);
-    if (!from && !to) {
-      return undefined;
+  for (const filter of filterEntries) {
+    if (errorFieldKeys.has(filter.queryKey)) {
+      continue;
+    }
+    if (!Object.hasOwn(normalizedSource, filter.queryKey)) {
+      continue;
     }
 
-    return Object.freeze({
-      ...(from ? { from } : {}),
-      ...(to ? { to } : {})
-    });
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-    const min = normalizeNumberFilterValue(source[filter.minKey]);
-    const max = normalizeNumberFilterValue(source[filter.maxKey]);
-    if (min == null && max == null) {
-      return undefined;
+    const value = normalizedSource[filter.queryKey];
+    if (value === null || value === undefined) {
+      continue;
     }
 
-    return Object.freeze({
-      ...(min != null ? { min } : {}),
-      ...(max != null ? { max } : {})
-    });
+    normalized[filter.key] = value;
   }
 
-  return undefined;
+  return Object.freeze(normalized);
 }
 
 function normalizeColumnsMap(columns = {}) {
@@ -386,124 +463,41 @@ function normalizeColumnsMap(columns = {}) {
 }
 
 function applyDefaultFilterQuery(queryBuilder, filter = {}, value, column = "") {
-  if (!column) {
-    return queryBuilder;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_FLAG) {
-    if (value === true) {
-      queryBuilder.where(column, true);
-    }
-    return queryBuilder;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM || filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID) {
-    if (value !== undefined) {
-      queryBuilder.where(column, value);
-    }
-    return queryBuilder;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_ENUM_MANY || filter.type === CRUD_LIST_FILTER_TYPE_RECORD_ID_MANY) {
-    if (Array.isArray(value) && value.length > 0) {
-      queryBuilder.whereIn(column, value);
-    }
-    return queryBuilder;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_PRESENCE) {
-    if (value === "present") {
-      queryBuilder.whereNotNull(column);
-    }
-    if (value === "missing") {
-      queryBuilder.whereNull(column);
-    }
-    return queryBuilder;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE) {
-    if (value) {
-      const nextDate = addDaysToDateFilterValue(value, 1);
-      queryBuilder.where(column, ">=", `${value} 00:00:00`);
-      if (nextDate) {
-        queryBuilder.where(column, "<", `${nextDate} 00:00:00`);
-      }
-    }
-    return queryBuilder;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_DATE_RANGE) {
-    if (value?.from) {
-      queryBuilder.where(column, ">=", `${value.from} 00:00:00`);
-    }
-    if (value?.to) {
-      const nextDate = addDaysToDateFilterValue(value.to, 1);
-      if (nextDate) {
-        queryBuilder.where(column, "<", `${nextDate} 00:00:00`);
-      }
-    }
-    return queryBuilder;
-  }
-
-  if (filter.type === CRUD_LIST_FILTER_TYPE_NUMBER_RANGE) {
-    if (value?.min != null) {
-      queryBuilder.where(column, ">=", value.min);
-    }
-    if (value?.max != null) {
-      queryBuilder.where(column, "<=", value.max);
-    }
-    return queryBuilder;
-  }
-
-  return queryBuilder;
+  const handler = FILTER_TYPE_SERVER_HANDLERS[filter.type];
+  return handler
+    ? handler.applyQuery(queryBuilder, value, column)
+    : queryBuilder;
 }
 
 function createCrudListFilters(definitions = {}, { columns = {}, apply = {} } = {}) {
   const normalizedFilters = defineCrudListFilters(definitions);
   const normalizedColumns = normalizeColumnsMap(columns);
   const filterEntries = Object.values(normalizedFilters);
-
-  function normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-    const normalized = {};
-
-    for (const filter of filterEntries) {
-      const value = normalizeFilterValue(filter, source);
-      if (value === undefined) {
-        continue;
-      }
-
-      normalized[filter.key] = value;
-    }
-
-    return Object.freeze(normalized);
-  }
-
-  const queryValidators = Object.freeze({
+  const queryValidatorsByInvalidValueMode = Object.freeze({
     [CRUD_LIST_FILTER_INVALID_VALUES_REJECT]: Object.freeze({
-      schema: mergeObjectSchemas(
-        filterEntries.map((filter) => createFilterQuerySchema(filter, {
-          invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_REJECT
-        }))
-      ),
-      normalize
+      ...buildFilterQuerySchemaDefinition(filterEntries, {
+        invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_REJECT
+      })
     }),
     [CRUD_LIST_FILTER_INVALID_VALUES_DISCARD]: Object.freeze({
-      schema: mergeObjectSchemas(
-        filterEntries.map((filter) => createFilterQuerySchema(filter, {
-          invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_DISCARD
-        }))
-      ),
-      normalize
+      ...buildFilterQuerySchemaDefinition(filterEntries, {
+        invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_DISCARD
+      })
     })
   });
 
+  function parseFilterPayload(payload = {}) {
+    const discardValidator = queryValidatorsByInvalidValueMode[CRUD_LIST_FILTER_INVALID_VALUES_DISCARD];
+    const result = discardValidator.schema.patch(normalizeObjectInput(payload));
+    return projectNormalizedFilterValues(filterEntries, result.validatedObject, result.errors);
+  }
+
   function applyQuery(queryBuilder, payload = {}) {
     if (!queryBuilder || typeof queryBuilder.where !== "function") {
       throw new TypeError("createCrudListFilters.applyQuery requires query builder.");
     }
 
-    const normalized = normalize(payload);
+    const normalized = parseFilterPayload(payload);
     for (const filter of filterEntries) {
       if (!Object.hasOwn(normalized, filter.key)) {
         continue;
@@ -529,13 +523,12 @@ function createCrudListFilters(definitions = {}, { columns = {}, apply = {} } =
 
   function createQueryValidator({ invalidValues } = {}) {
     const invalidValueMode = normalizeCrudListFilterInvalidValues(invalidValues);
-    return queryValidators[invalidValueMode];
+    return queryValidatorsByInvalidValueMode[invalidValueMode];
   }
 
   return Object.freeze({
     filters: normalizedFilters,
     createQueryValidator,
-    normalize,
     applyQuery
   });
 }
@@ -543,5 +536,7 @@ function createCrudListFilters(definitions = {}, { columns = {}, apply = {} } =
 export {
   CRUD_LIST_FILTER_INVALID_VALUES_REJECT,
   CRUD_LIST_FILTER_INVALID_VALUES_DISCARD,
+  createCrudListFilterQueryField,
+  createCrudListFilterQuerySchema,
   createCrudListFilters
 };