@taruvi/refine-providers 1.3.3 → 1.3.4-beta.1

package/README.md

@@ -108,6 +108,13 @@ mutate({ resource: "posts", id: 1 });
 
 ### Filtering
 
+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:
 
 ```tsx
@@ -116,25 +123,33 @@ const { data } = useList({
   filters: [
     { field: "status", operator: "eq", value: "published" },
     { field: "views", operator: "gte", value: 100 },
-    { field: "title", operator: "contains", value: "refine" },
+    { field: "title", operator: "containss", value: "refine" },
     { field: "category", operator: "in", value: ["tech", "news"] },
   ],
 });
 ```
 
-**Supported Operators:**
+**Refine → backend operator mapping (important):**
+
+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:**
 
 | Operator | Description | Example |
 |----------|-------------|---------|
 | `eq` | Equal | `status = "active"` |
 | `ne` | Not equal | `status != "deleted"` |
 | `lt`, `gt`, `lte`, `gte` | Comparison | `age >= 18` |
-| `contains`, `ncontains` | Contains (case-sensitive) | `title contains "hello"` |
-| `containss`, `ncontainss` | Contains (case-insensitive) | `title icontains "hello"` |
-| `startswith`, `endswith` | String matching | `email endswith "@gmail.com"` |
-| `in`, `nin` | Array membership | `status in ["active", "pending"]` |
-| `null`, `nnull` | Null checks | `deleted_at is null` |
-| `between`, `nbetween` | Range | `price between [10, 100]` |
+| `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 | |
+| `null`, `nnull` | Null checks | |
+| `between`, `nbetween` | Range | |
+| `acontains`, … `aelement`, `naelement` | PostgreSQL array ops | |
+| `rcontains`, … `rstrictright` | PostgreSQL range ops | |
+| `like`, `ilike`, `search` | Pattern / FTS | |
 
 ### Sorting & Pagination
 

package/dist/index.cjs

@@ -11,7 +11,7 @@ var DataLoader__default = /*#__PURE__*/_interopDefault(DataLoader);
 
 // package.json
 var package_default = {
-  version: "1.3.3"};
+  version: "1.3.4-beta.1"};
 
 // src/utils.ts
 var REFINE_OPERATOR_MAP = {
@@ -24,65 +24,306 @@ var REFINE_OPERATOR_MAP = {
   gt: "gt",
   lte: "lte",
   gte: "gte",
-  // String operations (case-sensitive)
+  // String matching — Taruvi wire suffix matches platform filter_translator.
   contains: "contains",
   ncontains: "ncontains",
+  containss: "containss",
+  ncontainss: "ncontainss",
   startswith: "startswith",
   nstartswith: "nstartswith",
   endswith: "endswith",
   nendswith: "nendswith",
-  // String operations (case-insensitive)
-  containss: "icontains",
-  ncontainss: "nicontains",
-  startswiths: "istartswith",
-  nstartswiths: "nistartswith",
-  endswiths: "iendswith",
-  nendswiths: "niendswith",
-  // Array operations
+  startswiths: "startswiths",
+  nstartswiths: "nstartswiths",
+  endswiths: "endswiths",
+  nendswiths: "nendswiths",
+  // Refine aliases → platform insensitive tokens
+  icontains: "contains",
+  nicontains: "ncontains",
+  istartswith: "startswith",
+  nistartswith: "nstartswith",
+  iendswith: "endswith",
+  niendswith: "nendswith",
+  // Array / membership
   in: "in",
   nin: "nin",
+  ina: "ina",
+  nina: "nina",
   // Null checks
   null: "null",
   nnull: "nnull",
   // Range
   between: "between",
-  nbetween: "nbetween"
+  nbetween: "nbetween",
+  // PostgreSQL array ops (pass-through suffix names)
+  acontains: "acontains",
+  nacontains: "nacontains",
+  acontainedby: "acontainedby",
+  nacontainedby: "nacontainedby",
+  aoverlap: "aoverlap",
+  naoverlap: "naoverlap",
+  aelement: "aelement",
+  naelement: "naelement",
+  // PostgreSQL range column ops
+  rcontains: "rcontains",
+  rcontainedby: "rcontainedby",
+  roverlaps: "roverlaps",
+  radjacent: "radjacent",
+  rstrictleft: "rstrictleft",
+  rstrictright: "rstrictright",
+  // Raw pattern / field search
+  like: "like",
+  ilike: "ilike",
+  search: "search"
 };
-function convertRefineFilters(filters) {
+var COMMA_VALUE_OPERATORS = /* @__PURE__ */ new Set([
+  "in",
+  "nin",
+  "ina",
+  "nina",
+  "between",
+  "nbetween",
+  "acontains",
+  "nacontains",
+  "acontainedby",
+  "nacontainedby",
+  "aoverlap",
+  "naoverlap",
+  "aelement",
+  "naelement",
+  "rcontains",
+  "rcontainedby",
+  "roverlaps",
+  "radjacent",
+  "rstrictleft",
+  "rstrictright"
+]);
+function isLogicalFilter(filter) {
+  return typeof filter === "object" && filter !== null && "operator" in filter && (filter.operator === "and" || filter.operator === "or") && "value" in filter && Array.isArray(filter.value);
+}
+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;
+  return suffix === "" ? "eq" : suffix;
+}
+function formatRefineLeafValue(operator, value) {
+  if (COMMA_VALUE_OPERATORS.has(operator)) {
+    return Array.isArray(value) ? value.join(",") : String(value);
+  }
+  if (operator === "null" || operator === "nnull") {
+    return "true";
+  }
+  return String(value);
+}
+function encodeLeafFlat(field, operator, value, params) {
+  if (value === void 0 || value === null && operator !== "null") {
+    return;
+  }
+  const suffix = REFINE_OPERATOR_MAP[operator];
+  if (suffix === void 0) {
+    console.warn(`Unknown Refine operator: ${operator}`);
+    return;
+  }
+  const paramKey = suffix ? `${field}__${suffix}` : String(field);
+  params[paramKey] = formatRefineLeafValue(operator, value);
+}
+function encodeCrudFilterBracket(filter, path, out) {
+  if (isLogicalFilter(filter)) {
+    const op = filter.operator;
+    out[`${path}[operator]`] = op;
+    const children = filter.value;
+    children.forEach((child, i) => {
+      encodeCrudFilterBracket(child, `${path}[value][${i}]`, out);
+    });
+    return;
+  }
+  if (!isFieldFilter(filter)) {
+    return;
+  }
+  const leaf = filter;
+  const { field, operator, value } = leaf;
+  if (value === void 0 || value === null && operator !== "null") {
+    return;
+  }
+  const suffix = REFINE_OPERATOR_MAP[operator];
+  if (suffix === void 0) {
+    console.warn(`Unknown Refine operator: ${operator}`);
+    return;
+  }
+  out[`${path}[field]`] = field;
+  out[`${path}[operator]`] = refineOperatorToBackendKey(operator);
+  out[`${path}[value]`] = formatRefineLeafValue(operator, value);
+}
+function isLogicalBackendNode(n) {
+  return !("field" in n) && (n.operator === "and" || n.operator === "or");
+}
+function jsonLeafValue(operator, value) {
+  if (operator === "null" || operator === "nnull") return true;
+  return value;
+}
+function crudFilterToBackendNodeOrNull(filter) {
+  if (isLogicalFilter(filter)) {
+    const children = filter.value.map(crudFilterToBackendNodeOrNull).filter((n) => n !== null);
+    if (children.length === 0) return null;
+    return { operator: filter.operator, value: children };
+  }
+  if (isFieldFilter(filter)) {
+    const leaf = filter;
+    if (leaf.value === void 0 || leaf.value === null && leaf.operator !== "null") {
+      return null;
+    }
+    if (REFINE_OPERATOR_MAP[leaf.operator] === void 0) {
+      console.warn(`Unknown Refine operator: ${leaf.operator}`);
+      return null;
+    }
+    const backendOp = refineOperatorToBackendKey(leaf.operator);
+    return {
+      field: leaf.field,
+      operator: backendOp,
+      value: jsonLeafValue(leaf.operator, leaf.value)
+    };
+  }
+  return null;
+}
+function convertRefineFiltersToBackendTree(filters) {
+  if (!filters?.length) return null;
+  const nodes = filters.map(crudFilterToBackendNodeOrNull).filter((n) => n !== null);
+  if (nodes.length === 0) return null;
+  if (nodes.length === 1 && isLogicalBackendNode(nodes[0])) {
+    return [nodes[0]];
+  }
+  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 = {};
   for (const filter of filters) {
-    if ("operator" in filter && (filter.operator === "and" || filter.operator === "or")) {
+    if (isLogicalFilter(filter)) {
       if (filter.value && Array.isArray(filter.value)) {
-        const nested = convertRefineFilters(filter.value);
+        const nested = convertRefineFiltersFlattened(
+          filter.value
+        );
         Object.assign(params, nested);
       }
       continue;
     }
-    if ("field" in filter && filter.field && filter.operator) {
-      const { field, operator, value } = filter;
-      if (value === void 0 || value === null && operator !== "null") {
-        continue;
-      }
-      const suffix = REFINE_OPERATOR_MAP[operator];
-      if (suffix === void 0) {
-        console.warn(`Unknown Refine operator: ${operator}`);
-        continue;
-      }
-      const paramKey = suffix ? `${field}__${suffix}` : String(field);
-      if (operator === "in" || operator === "nin") {
-        params[paramKey] = Array.isArray(value) ? value.join(",") : String(value);
-      } else if (operator === "between" || operator === "nbetween") {
-        params[paramKey] = Array.isArray(value) ? value.join(",") : String(value);
-      } else if (operator === "null" || operator === "nnull") {
-        params[paramKey] = "true";
-      } else {
-        params[paramKey] = String(value);
-      }
+    if (isFieldFilter(filter)) {
+      const leaf = filter;
+      encodeLeafFlat(leaf.field, leaf.operator, leaf.value, params);
     }
   }
   return params;
 }
+function convertRefineFilters(filters, options) {
+  if (!filters || filters.length === 0) return {};
+  if (options?.logicalEncoding === "flatten") {
+    return convertRefineFiltersFlattened(filters);
+  }
+  const hasLogical = filters.some(isLogicalFilter);
+  if (!hasLogical) {
+    const params = {};
+    for (const filter of filters) {
+      if (isFieldFilter(filter)) {
+        const leaf = filter;
+        encodeLeafFlat(leaf.field, leaf.operator, leaf.value, params);
+      }
+    }
+    return params;
+  }
+  if (filters.length === 1 && isLogicalFilter(filters[0])) {
+    const out2 = {};
+    encodeCrudFilterBracket(filters[0], "filters[0]", out2);
+    return out2;
+  }
+  const out = {};
+  out["filters[0][operator]"] = "and";
+  filters.forEach((f, i) => {
+    encodeCrudFilterBracket(f, `filters[0][value][${i}]`, out);
+  });
+  return out;
+}
+function applyRefineQueryParamsToDatabase(query, params) {
+  let result = query;
+  for (const [key, val] of Object.entries(params)) {
+    result = result.filters(key, "eq", val);
+  }
+  return result;
+}
 function convertRefineSorters(sorters) {
   if (!sorters || sorters.length === 0) return void 0;
   return sorters.map((sort) => sort.order === "desc" ? `-${sort.field}` : sort.field).join(",");
@@ -138,16 +379,7 @@ function formatHaving(having) {
         continue;
       }
       const paramKey = suffix ? `${field}__${suffix}` : String(field);
-      let paramValue;
-      if (operator === "in" || operator === "nin") {
-        paramValue = Array.isArray(value) ? value.join(",") : String(value);
-      } else if (operator === "between" || operator === "nbetween") {
-        paramValue = Array.isArray(value) ? value.join(",") : String(value);
-      } else if (operator === "null" || operator === "nnull") {
-        paramValue = "true";
-      } else {
-        paramValue = String(value);
-      }
+      const paramValue = formatRefineLeafValue(operator, value);
       params.push(`${paramKey}=${paramValue}`);
     }
   }
@@ -179,45 +411,42 @@ function applyAggregations(query, meta) {
   }
   return result;
 }
-function applyFilters(query, filters) {
-  if (!filters || filters.length === 0) return query;
+function applyFlatFilterList(query, leaves) {
   let result = query;
-  for (const filter of filters) {
-    if ("operator" in filter && (filter.operator === "and" || filter.operator === "or")) {
-      if (filter.value && Array.isArray(filter.value)) {
-        result = applyFilters(result, filter.value);
-      }
-      continue;
-    }
-    if ("field" in filter && filter.field && filter.operator) {
-      const { field, operator, value } = filter;
-      if (value === void 0 || value === null && operator !== "null") continue;
-      const suffix = REFINE_OPERATOR_MAP[operator];
-      if (suffix === void 0) {
-        console.warn(`Unknown Refine operator: ${operator}`);
-        continue;
-      }
-      const paramKey = suffix ? `${field}__${suffix}` : String(field);
-      let paramValue;
-      if (operator === "in" || operator === "nin" || operator === "between" || operator === "nbetween") {
-        paramValue = Array.isArray(value) ? value.join(",") : String(value);
-      } else if (operator === "null" || operator === "nnull") {
-        paramValue = "true";
-      } else {
-        paramValue = String(value);
-      }
-      result = result.filter(paramKey, "eq", paramValue);
-    }
+  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 applySorters(query, sorters) {
-  if (!sorters || sorters.length === 0) return query;
-  let result = query;
-  for (const sorter of sorters) {
-    result = result.sort(sorter.field, sorter.order === "desc" ? "desc" : "asc");
+function applyFilters(query, filters) {
+  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;
   }
-  return result;
+  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);
+  return ordering ? query.orderBy(ordering) : query;
 }
 function applyPagination(query, pagination) {
   if (!pagination || pagination.mode === "off") return query;
@@ -305,7 +534,7 @@ function dataProvider(client) {
       }
       const idColumn = getIdColumn(taruviMeta);
       let query = new sdk.Database(client).from(tableName);
-      query = query.filter(idColumn, "in", ids.map(String));
+      query = query.filters(idColumn, "in", ids.map(String));
       query = applyPopulate(query, taruviMeta);
       const response = await query.execute();
       return { data: response.data };
@@ -422,7 +651,7 @@ function storageDataProvider(client) {
   const getBucketName = (resource, meta) => meta?.bucketName ?? resource;
   const buildFilters = (params) => {
     const filters = {
-      ...convertRefineFilters(params.filters),
+      ...convertRefineFilters(params.filters, { logicalEncoding: "flatten" }),
       ...convertRefinePagination(params.pagination)
     };
     const ordering = convertRefineSorters(params.sorters);
@@ -930,20 +1159,27 @@ function analyticsDataProvider(client) {
 exports._cachedUser = null;
 function authProvider(client) {
   const auth = new sdk.Auth(client);
-  function redirectToLogin() {
-    exports._cachedUser = null;
-    auth.login();
-  }
   return {
-    login: async () => {
-      if (auth.hasToken()) {
+    login: async (params = {}) => {
+      const { callbackUrl, redirect = true } = params;
+      if (auth.isUserAuthenticated()) {
+        return {
+          success: true,
+          redirectTo: callbackUrl || "/"
+        };
+      }
+      if (redirect) {
+        auth.login(callbackUrl);
         return {
           success: true
         };
       }
-      redirectToLogin();
       return {
-        success: true
+        success: false,
+        error: {
+          name: "LoginError",
+          message: "Login failed. Please try again."
+        }
       };
     },
     logout: async (params = {}) => {
@@ -956,20 +1192,19 @@ function authProvider(client) {
       };
     },
     check: async () => {
-      if (!auth.hasToken()) {
-        return { authenticated: false };
-      }
-      const isValid = await auth.isUserAuthenticated();
-      if (!isValid) {
-        return { authenticated: false };
+      if (!auth.isUserAuthenticated()) {
+        return { authenticated: false, redirectTo: "/login" };
       }
       return { authenticated: true };
     },
     onError: async (error) => {
       const status = error?.statusCode || error?.status || error?.response?.status;
       if (status === 401) {
-        redirectToLogin();
-        return { error };
+        return {
+          logout: true,
+          redirectTo: "/login",
+          error
+        };
       }
       if (status === 403) {
         return { error };
@@ -1112,15 +1347,26 @@ exports.REFINE_OPERATOR_MAP = REFINE_OPERATOR_MAP;
 exports.accessControlProvider = accessControlProvider;
 exports.analyticsDataProvider = analyticsDataProvider;
 exports.appDataProvider = appDataProvider;
+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;
 //# sourceMappingURL=index.cjs.map