@taruvi/refine-providers 1.3.4-beta.0 → 1.3.4-beta.2

package/README.md

@@ -108,7 +108,12 @@ mutate({ resource: "posts", id: 1 });
 
 ### Filtering
 
-List requests send **JSON `filters`** (`Database.filters(tree)` in the SDK): `convertRefineFiltersToBackendTree` maps Refine `CrudFilter[]` to the platform tree (nested `and` / `or` preserved). Bracket query keys from `convertRefineFilters` remain for helpers / Storage flatten mode.
+List `getList` filters use an explicit **`TaruviListFilters`** shape:
+
+- **`FlatFilterLeaf[]`** (array of `{ field, operator, value }`) → top-level **`field__op`** query params via `Database.filters(field, op, value)` (including FK traversal like `department_id.name`).
+- **`LogicalCrudFilter`** (object `{ operator: "and" | "or", value: [...] }`) → JSON **`filters`** tree via `Database.filters(tree)`.
+
+Legacy Refine **`CrudFilter[]`** is still accepted: all field leaves → flat array; a single root `and`/`or` object → logical object; mixed lists fall back to the JSON tree. Bracket keys from `convertRefineFilters` remain for helpers / Storage flatten mode.
 
 Full support for Refine filter operators:
 
@@ -126,15 +131,7 @@ const { data } = useList({
 
 **Refine → backend operator mapping (important):**
 
-| Refine operator | Backend / JSON leaf operator | Meaning on platform |
-|-----------------|------------------------------|------------------------|
-| `containss` | `contains` | Case-insensitive substring (ILIKE-style) |
-| `contains` | `containss` | Case-sensitive substring |
-| `startswith`, `endswith` | same name | Case-insensitive |
-| `startswiths`, `endswiths` | same name | Case-sensitive |
-| `icontains` / `nicontains` | pass-through | Aliases; platform normalizes `icontains` → `contains` |
-
-Other operators (`eq`, `in`, `between`, array/range ops, etc.) follow `REFINE_OPERATOR_MAP` in [`src/utils.ts`](src/utils.ts).
+Wire suffixes match the platform (`contains` = case-insensitive, `containss` = case-sensitive). Refine aliases map to the same tokens, e.g. `icontains` → `contains`. See `REFINE_OPERATOR_MAP` in [`src/utils.ts`](src/utils.ts).
 
 **More operators:**
 
@@ -143,8 +140,8 @@ Other operators (`eq`, `in`, `between`, array/range ops, etc.) follow `REFINE_OP
 | `eq` | Equal | `status = "active"` |
 | `ne` | Not equal | `status != "deleted"` |
 | `lt`, `gt`, `lte`, `gte` | Comparison | `age >= 18` |
-| `containss`, `ncontainss` | Case-insensitive contains / not | Prefer for “search” UX |
-| `contains`, `ncontains` | Case-sensitive contains / not | |
+| `contains`, `ncontains` | Case-insensitive contains / not | FK traversal, search UX |
+| `containss`, `ncontainss` | Case-sensitive contains / not | |
 | `startswith`, `endswith` | Case-insensitive prefix/suffix | |
 | `startswiths`, `endswiths` | Case-sensitive prefix/suffix | |
 | `in`, `nin`, `ina`, `nina` | Array membership | |

package/dist/index.cjs

@@ -11,7 +11,7 @@ var DataLoader__default = /*#__PURE__*/_interopDefault(DataLoader);
 
 // package.json
 var package_default = {
-  version: "1.3.4-beta.0"};
+  version: "1.3.4-beta.2"};
 
 // src/utils.ts
 var REFINE_OPERATOR_MAP = {
@@ -24,23 +24,26 @@ var REFINE_OPERATOR_MAP = {
   gt: "gt",
   lte: "lte",
   gte: "gte",
-  // String operators mapped to backend-safe case-sensitive LIKE variants.
-  contains: "containss",
-  ncontains: "ncontainss",
+  // String matching — Taruvi wire suffix matches platform filter_translator.
+  contains: "contains",
+  ncontains: "ncontains",
   containss: "containss",
   ncontainss: "ncontainss",
-  // String operators mapped to backend-safe case-sensitive prefix/suffix LIKE.
-  startswith: "startswiths",
-  nstartswith: "nstartswiths",
-  endswith: "endswiths",
-  nendswith: "nendswiths",
+  startswith: "startswith",
+  nstartswith: "nstartswith",
+  endswith: "endswith",
+  nendswith: "nendswith",
   startswiths: "startswiths",
   nstartswiths: "nstartswiths",
   endswiths: "endswiths",
   nendswiths: "nendswiths",
-  // Aliases mapped to backend-safe case-sensitive LIKE variants.
-  icontains: "containss",
-  nicontains: "ncontainss",
+  // Refine aliases → platform insensitive tokens
+  icontains: "contains",
+  nicontains: "ncontains",
+  istartswith: "startswith",
+  nistartswith: "nstartswith",
+  iendswith: "endswith",
+  niendswith: "nendswith",
   // Array / membership
   in: "in",
   nin: "nin",
@@ -101,6 +104,66 @@ function isLogicalFilter(filter) {
 function isFieldFilter(filter) {
   return typeof filter === "object" && filter !== null && "field" in filter && "operator" in filter && typeof filter.field === "string" && typeof filter.operator === "string";
 }
+function isFlatFilterList(filters) {
+  if (!Array.isArray(filters)) return false;
+  return filters.every((f) => {
+    if (!isFieldFilter(f)) return false;
+    const leaf = f;
+    if (leaf.value === void 0 || leaf.value === null && leaf.operator !== "null") {
+      return false;
+    }
+    if (REFINE_OPERATOR_MAP[leaf.operator] === void 0) {
+      return false;
+    }
+    return true;
+  });
+}
+function isLogicalCrudFilter(filters) {
+  return typeof filters === "object" && filters !== null && !Array.isArray(filters) && isLogicalFilter(filters);
+}
+function normalizeTaruviListFilters(filters) {
+  if (filters === void 0 || filters === null) return void 0;
+  if (isLogicalCrudFilter(filters)) return filters;
+  if (isFlatFilterList(filters)) return filters;
+  if (!Array.isArray(filters) || filters.length === 0) return void 0;
+  if (filters.length === 1 && isLogicalFilter(filters[0])) {
+    return filters[0];
+  }
+  if (filters.every(isFieldFilter)) {
+    return filters;
+  }
+  return void 0;
+}
+function collectFlatLeaves(filters) {
+  if (!filters?.length) return [];
+  const leaves = [];
+  const walk = (group) => {
+    for (const filter of group) {
+      if (isLogicalFilter(filter)) {
+        if (filter.operator === "or") return false;
+        if (!walk(filter.value)) return false;
+        continue;
+      }
+      if (!isFieldFilter(filter)) return false;
+      const leaf = filter;
+      if (leaf.value === void 0 || leaf.value === null && leaf.operator !== "null") {
+        continue;
+      }
+      if (REFINE_OPERATOR_MAP[leaf.operator] === void 0) {
+        console.warn(`Unknown Refine operator: ${leaf.operator}`);
+        return false;
+      }
+      leaves.push({
+        field: leaf.field,
+        operator: leaf.operator,
+        value: leaf.value
+      });
+    }
+    return true;
+  };
+  if (!walk(filters)) return null;
+  return leaves;
+}
 function refineOperatorToBackendKey(operator) {
   const suffix = REFINE_OPERATOR_MAP[operator];
   if (suffix === void 0) return operator;
@@ -194,6 +257,18 @@ function convertRefineFiltersToBackendTree(filters) {
   }
   return [{ operator: "and", value: nodes }];
 }
+function convertLogicalFilterToBackendTree(filter) {
+  const node = crudFilterToBackendNodeOrNull(filter);
+  if (!node || !isLogicalBackendNode(node)) return null;
+  return [node];
+}
+function encodeFlatFilterListToParams(leaves) {
+  const params = {};
+  for (const leaf of leaves) {
+    encodeLeafFlat(leaf.field, leaf.operator, leaf.value, params);
+  }
+  return params;
+}
 function convertRefineFiltersFlattened(filters) {
   if (!filters || filters.length === 0) return {};
   const params = {};
@@ -336,11 +411,38 @@ function applyAggregations(query, meta) {
   }
   return result;
 }
+function applyFlatFilterList(query, leaves) {
+  let result = query;
+  for (const { field, operator, value } of leaves) {
+    const backendOp = refineOperatorToBackendKey(operator);
+    const formatted = formatRefineLeafValue(operator, value);
+    result = result.filters(
+      field,
+      backendOp,
+      formatted
+    );
+  }
+  return result;
+}
 function applyFilters(query, filters) {
-  if (!filters || filters.length === 0) return query;
-  const tree = convertRefineFiltersToBackendTree(filters);
-  if (!tree) return query;
-  return query.filters(tree);
+  const normalized = normalizeTaruviListFilters(filters);
+  if (normalized === void 0) {
+    if (Array.isArray(filters) && filters.length > 0) {
+      const tree = convertRefineFiltersToBackendTree(filters);
+      if (tree) return query.filters(tree);
+    }
+    return query;
+  }
+  if (isFlatFilterList(normalized)) {
+    if (normalized.length === 0) return query;
+    return applyFlatFilterList(query, normalized);
+  }
+  if (isLogicalCrudFilter(normalized)) {
+    const tree = convertLogicalFilterToBackendTree(normalized);
+    if (!tree) return query;
+    return query.filters(tree);
+  }
+  return query;
 }
 function applySorters(query, sorters) {
   const ordering = convertRefineSorters(sorters);
@@ -362,6 +464,16 @@ function applyAllowedActions(query, meta) {
   if (!meta?.allowedActions?.length) return query;
   return query.allowedActions(meta.allowedActions);
 }
+function applySearchAndFields(query, meta) {
+  if (!meta) return query;
+  let result = query;
+  const search = meta.search?.trim();
+  if (search) result = result.search(search);
+  const select = meta.select;
+  const fields = typeof select === "string" ? select.trim() : Array.isArray(select) ? select.map(String).join(",") : "";
+  if (fields) result = result.fields(fields);
+  return result;
+}
 function isGraphQuery(meta) {
   return !!(meta?.format || meta?.graph_types || meta?.include || meta?.depth);
 }
@@ -399,6 +511,7 @@ function dataProvider(client) {
       query = applyPagination(query, pagination);
       query = applyPopulate(query, taruviMeta);
       query = applyAggregations(query, taruviMeta);
+      query = applySearchAndFields(query, taruviMeta);
       query = applyAllowedActions(query, taruviMeta);
       const response = await query.execute();
       return { data: response.data, total: response.total };
@@ -1249,15 +1362,21 @@ exports.applyRefineQueryParamsToDatabase = applyRefineQueryParamsToDatabase;
 exports.authProvider = authProvider;
 exports.buildQueryString = buildQueryString;
 exports.buildRefineQueryParams = buildRefineQueryParams;
+exports.collectFlatLeaves = collectFlatLeaves;
+exports.convertLogicalFilterToBackendTree = convertLogicalFilterToBackendTree;
 exports.convertRefineFilters = convertRefineFilters;
 exports.convertRefineFiltersToBackendTree = convertRefineFiltersToBackendTree;
 exports.convertRefinePagination = convertRefinePagination;
 exports.convertRefineSorters = convertRefineSorters;
 exports.dataProvider = dataProvider;
 exports.encodeCrudFilterBracket = encodeCrudFilterBracket;
+exports.encodeFlatFilterListToParams = encodeFlatFilterListToParams;
 exports.formatRefineLeafValue = formatRefineLeafValue;
 exports.functionsDataProvider = functionsDataProvider;
 exports.handleError = handleError;
+exports.isFlatFilterList = isFlatFilterList;
+exports.isLogicalCrudFilter = isLogicalCrudFilter;
+exports.normalizeTaruviListFilters = normalizeTaruviListFilters;
 exports.refineOperatorToBackendKey = refineOperatorToBackendKey;
 exports.storageDataProvider = storageDataProvider;
 exports.userDataProvider = userDataProvider;