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

package/dist/index.js

@@ -5,7 +5,7 @@ import DataLoader from 'dataloader';
 
 // package.json
 var package_default = {
-  version: "1.3.3"};
+  version: "1.3.4-beta.1"};
 
 // src/utils.ts
 var REFINE_OPERATOR_MAP = {
@@ -18,65 +18,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(",");
@@ -132,16 +373,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}`);
     }
   }
@@ -173,45 +405,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;
@@ -299,7 +528,7 @@ function dataProvider(client) {
       }
       const idColumn = getIdColumn(taruviMeta);
       let query = new 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 };
@@ -416,7 +645,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);
@@ -924,20 +1153,27 @@ function analyticsDataProvider(client) {
 var _cachedUser = null;
 function authProvider(client) {
   const auth = new Auth(client);
-  function redirectToLogin() {
-    _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 = {}) => {
@@ -950,20 +1186,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 };
@@ -1102,6 +1337,6 @@ function accessControlProvider(client, options) {
   };
 }
 
-export { REFINE_OPERATOR_MAP, _cachedUser, accessControlProvider, analyticsDataProvider, appDataProvider, authProvider, buildQueryString, buildRefineQueryParams, convertRefineFilters, convertRefinePagination, convertRefineSorters, dataProvider, functionsDataProvider, handleError, storageDataProvider, userDataProvider };
+export { REFINE_OPERATOR_MAP, _cachedUser, accessControlProvider, analyticsDataProvider, appDataProvider, applyRefineQueryParamsToDatabase, authProvider, buildQueryString, buildRefineQueryParams, collectFlatLeaves, convertLogicalFilterToBackendTree, convertRefineFilters, convertRefineFiltersToBackendTree, convertRefinePagination, convertRefineSorters, dataProvider, encodeCrudFilterBracket, encodeFlatFilterListToParams, formatRefineLeafValue, functionsDataProvider, handleError, isFlatFilterList, isLogicalCrudFilter, normalizeTaruviListFilters, refineOperatorToBackendKey, storageDataProvider, userDataProvider };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map