@adobe/spacecat-shared-data-access 4.18.0 → 4.20.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [@adobe/spacecat-shared-data-access-v4.20.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-data-access-v4.19.0...@adobe/spacecat-shared-data-access-v4.20.0) (2026-08-12)
+
+### Features
+
+* **data-access:** compound AND filter and orderBy column for postgrest queries ([#1874](https://github.com/adobe/spacecat-shared/issues/1874)) ([620b37e](https://github.com/adobe/spacecat-shared/commit/620b37eb1bc252c9bdd01661037de6fd7e0bfe35))
+
+## [@adobe/spacecat-shared-data-access-v4.19.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-data-access-v4.18.0...@adobe/spacecat-shared-data-access-v4.19.0) (2026-08-11)
+
+### Features
+
+* add support for searching trial users by external user id ([#1869](https://github.com/adobe/spacecat-shared/issues/1869)) ([ec48340](https://github.com/adobe/spacecat-shared/commit/ec483403ac2b118abea814309079716fc516042a))
+
 ## [@adobe/spacecat-shared-data-access-v4.18.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-data-access-v4.17.0...@adobe/spacecat-shared-data-access-v4.18.0) (2026-08-11)
 
 ### Features

package/CLAUDE.md

@@ -178,7 +178,7 @@ This is the same client instance used internally by entity collections — same
 async findByStatus(status) {
   return this.all(
     (attrs, op) => op.eq(attrs.status, status),
-    { limit: 100, order: { field: 'createdAt', direction: 'desc' } }
+    { limit: 100, orderBy: { attribute: 'createdAt', direction: 'desc' } }
   );
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-data-access",
-  "version": "4.18.0",
+  "version": "4.20.0",
   "description": "Shared modules of the Spacecat Services - Data Access",
   "type": "module",
   "engines": {

package/src/models/base/base.collection.js

@@ -428,8 +428,25 @@ class BaseCollection {
       this.#logAndThrowError(`Failed to query [${this.entityName}]: query proxy [${options.index}] not found`);
     }
 
-    const orderFields = this.#getOrderFields(indexName, keys);
-    const ascending = options.order === 'asc';
+    const hasExplicitOrderBy = isObject(options.orderBy) && hasText(options.orderBy.attribute);
+    let explicitAscending;
+    if (hasExplicitOrderBy) {
+      const { toDbMap } = this.fieldMaps;
+      if (!Object.prototype.hasOwnProperty.call(toDbMap, options.orderBy.attribute)) {
+        this.#logAndThrowError(`Failed to query [${this.entityName}]: unknown orderBy attribute [${options.orderBy.attribute}]`);
+      }
+      const direction = options.orderBy.direction === undefined
+        ? 'asc'
+        : String(options.orderBy.direction).toLowerCase();
+      if (direction !== 'asc' && direction !== 'desc') {
+        this.#logAndThrowError(`Failed to query [${this.entityName}]: invalid orderBy direction [${options.orderBy.direction}]`);
+      }
+      explicitAscending = direction === 'asc';
+    }
+    const orderFields = hasExplicitOrderBy
+      ? [this.#toDbField(options.orderBy.attribute)]
+      : this.#getOrderFields(indexName, keys);
+    const ascending = hasExplicitOrderBy ? explicitAscending : options.order === 'asc';
     let query = this.postgrestService
       .from(this.tableName)
       .select(select);

package/src/models/base/index.d.ts

@@ -33,6 +33,7 @@ export interface QueryOptions {
   index?: string;
   limit?: number;
   order?: string;
+  orderBy?: { attribute: string; direction?: 'asc' | 'desc' };
   attributes?: string[];
   cursor?: string;
   /**

package/src/models/trial-user/trial-user.schema.js

@@ -52,6 +52,10 @@ const schema = new SchemaBuilder(TrialUser, TrialUserCollection)
   .addIndex(
     { composite: ['organizationId'] },
     { composite: ['updatedAt'] },
+  )
+  .addIndex(
+    { composite: ['externalUserId'] },
+    { composite: ['updatedAt'] },
   );
 
 export default schema.build();

package/src/util/postgrest.utils.js

@@ -152,6 +152,7 @@ const applyWhere = (query, whereFn, toDbMap) => {
     like: (field, value) => ({ type: 'like', field, value }),
     ilike: (field, value) => ({ type: 'ilike', field, value }),
     contains: (field, value) => ({ type: 'contains', field, value }),
+    and: (...conditions) => ({ type: 'and', conditions: conditions.filter(Boolean) }),
   };
 
   const expression = whereFn(attrs, op);
@@ -159,37 +160,43 @@ const applyWhere = (query, whereFn, toDbMap) => {
     return query;
   }
 
-  switch (expression.type) {
-    case 'eq':
-      return query.eq(expression.field, expression.value);
-    case 'ne':
-      return query.neq(expression.field, expression.value);
-    case 'gt':
-      return query.gt(expression.field, expression.value);
-    case 'gte':
-      return query.gte(expression.field, expression.value);
-    case 'lt':
-      return query.lt(expression.field, expression.value);
-    case 'lte':
-      return query.lte(expression.field, expression.value);
-    case 'in':
-      return query.in(
-        expression.field,
-        Array.isArray(expression.value) ? expression.value : [expression.value],
-      );
-    case 'is':
-      return query.is(expression.field, expression.value);
-    case 'like':
-      return query.like(expression.field, expression.value);
-    case 'ilike':
-      return query.ilike(expression.field, expression.value);
-    case 'contains': {
-      const value = Array.isArray(expression.value) ? expression.value : [expression.value];
-      return query.contains(expression.field, value);
+  const applyExpr = (q, expr) => {
+    switch (expr.type) {
+      case 'and':
+        return (expr.conditions || []).reduce((acc, cond) => applyExpr(acc, cond), q);
+      case 'eq':
+        return q.eq(expr.field, expr.value);
+      case 'ne':
+        return q.neq(expr.field, expr.value);
+      case 'gt':
+        return q.gt(expr.field, expr.value);
+      case 'gte':
+        return q.gte(expr.field, expr.value);
+      case 'lt':
+        return q.lt(expr.field, expr.value);
+      case 'lte':
+        return q.lte(expr.field, expr.value);
+      case 'in':
+        return q.in(
+          expr.field,
+          Array.isArray(expr.value) ? expr.value : [expr.value],
+        );
+      case 'is':
+        return q.is(expr.field, expr.value);
+      case 'like':
+        return q.like(expr.field, expr.value);
+      case 'ilike':
+        return q.ilike(expr.field, expr.value);
+      case 'contains': {
+        const value = Array.isArray(expr.value) ? expr.value : [expr.value];
+        return q.contains(expr.field, value);
+      }
+      default:
+        throw new Error(`Unsupported where operator: ${expr.type}`);
     }
-    default:
-      throw new Error(`Unsupported where operator: ${expression.type}`);
-  }
+  };
+
+  return applyExpr(query, expression);
 };
 
 export {