core-services-sdk 1.3.64 → 1.3.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.64",
+  "version": "1.3.66",
   "main": "src/index.js",
   "type": "module",
   "types": "types/index.d.ts",
@@ -31,6 +31,7 @@
     "@aws-sdk/credential-provider-node": "^3.862.0",
     "@sendgrid/mail": "^8.1.5",
     "amqplib": "^0.10.8",
+    "date-fns": "^4.1.0",
     "dot": "^1.1.3",
     "fastify": "^5.4.0",
     "google-libphonenumber": "^3.2.42",

package/src/postgresql/core/get-table-name.js

@@ -0,0 +1,10 @@
+/**
+ * Extracts base table name from Knex QueryBuilder.
+ * Relies on Knex internal structure.
+ *
+ * @param {import('knex').Knex.QueryBuilder} query
+ * @returns {string|undefined}
+ */
+export function getTableNameFromQuery(query) {
+  return query?._single?.table
+}

package/src/postgresql/filters/apply-filter-object.js

@@ -0,0 +1,19 @@
+import { OPERATORS } from './operators.js'
+
+/**
+ * Applies multiple operators on the same column.
+ *
+ * @param {import('knex').Knex.QueryBuilder} query
+ * @param {string} qualifiedKey
+ * @param {Object<string, *>} value
+ * @returns {import('knex').Knex.QueryBuilder}
+ */
+export function applyFilterObject(query, qualifiedKey, value) {
+  return Object.entries(value).reduce((q, [operator, val]) => {
+    if (!OPERATORS[operator]) {
+      return q
+    }
+
+    return OPERATORS[operator](q, qualifiedKey, val)
+  }, query)
+}

package/src/postgresql/filters/apply-filter-snake-case.js

@@ -0,0 +1,16 @@
+import { toSnakeCase } from '../../core/case-mapper.js'
+import { applyFilter } from './apply-filter.js'
+
+/**
+ * Applies filters with automatic camelCase to snake_case conversion.
+ *
+ * @param {Object} params
+ * @param {import('knex').Knex.QueryBuilder} params.query
+ * @param {Object} params.filter
+ */
+export function applyFilterSnakeCase({ query, filter }) {
+  return applyFilter({
+    query,
+    filter: toSnakeCase(filter),
+  })
+}

package/src/postgresql/filters/apply-filter.js

@@ -0,0 +1,33 @@
+import { getTableNameFromQuery } from '../core/get-table-name.js'
+import { OPERATORS } from './operators.js'
+import { applyFilterObject } from './apply-filter-object.js'
+
+/**
+ * Applies MongoDB-style filters to a Knex QueryBuilder.
+ *
+ * @param {Object} params
+ * @param {import('knex').Knex.QueryBuilder} params.query
+ * @param {Object} [params.filter]
+ * @returns {import('knex').Knex.QueryBuilder}
+ */
+export function applyFilter({ query, filter = {} }) {
+  const tableName = getTableNameFromQuery(query)
+
+  if (!filter || Object.keys(filter).length === 0) {
+    return query
+  }
+
+  return Object.entries(filter).reduce((q, [key, value]) => {
+    const qualifiedKey = tableName ? `${tableName}.${key}` : key
+
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      return applyFilterObject(q, qualifiedKey, value)
+    }
+
+    if (Array.isArray(value)) {
+      return OPERATORS.in(q, qualifiedKey, value)
+    }
+
+    return OPERATORS.eq(q, qualifiedKey, value)
+  }, query)
+}

package/src/postgresql/filters/operators.js

@@ -0,0 +1,32 @@
+/**
+ * @typedef {Function} OperatorFunction
+ * @param {import('knex').Knex.QueryBuilder} q
+ * @param {string} key
+ * @param {*} value
+ * @returns {import('knex').Knex.QueryBuilder}
+ */
+
+/**
+ * @type {Object<string, OperatorFunction>}
+ */
+export const OPERATORS = {
+  in: (q, key, value) => q.whereIn(key, value),
+  nin: (q, key, value) => q.whereNotIn(key, value),
+
+  eq: (q, key, value) => q.where(key, '=', value),
+  ne: (q, key, value) => q.where(key, '!=', value),
+  neq: (q, key, value) => q.where(key, '!=', value),
+
+  gt: (q, key, value) => q.where(key, '>', value),
+  gte: (q, key, value) => q.where(key, '>=', value),
+  lt: (q, key, value) => q.where(key, '<', value),
+  lte: (q, key, value) => q.where(key, '<=', value),
+
+  like: (q, key, value) => q.where(key, 'like', value),
+  ilike: (q, key, value) => q.where(key, 'ilike', value),
+
+  isNull: (q, key, value) => (value ? q.whereNull(key) : q.whereNotNull(key)),
+
+  isNotNull: (q, key, value) =>
+    value ? q.whereNotNull(key) : q.whereNull(key),
+}

package/src/postgresql/index.js

@@ -1,5 +1,8 @@
-export * from './paginate.js'
-export * from './apply-filter.js'
 export * from './connect-to-pg.js'
 export * from './validate-schema.js'
+export * from './pagination/paginate.js'
+export * from './filters/apply-filter.js'
+export * from './modifiers/apply-order-by.js'
 export * from './start-stop-postgres-docker.js'
+export * from './modifiers/apply-pagination.js'
+export * from './filters/apply-filter-snake-case.js'

package/src/postgresql/modifiers/apply-order-by.js

@@ -0,0 +1,19 @@
+import { getTableNameFromQuery } from '../core/get-table-name.js'
+
+/**
+ * Applies ORDER BY clause.
+ *
+ * @param {Object} params
+ * @param {import('knex').Knex.QueryBuilder} params.query
+ * @param {{ column: string, direction?: 'asc'|'desc' }} params.orderBy
+ */
+export function applyOrderBy({ query, orderBy }) {
+  if (!orderBy?.column) {
+    return query
+  }
+
+  const tableName = getTableNameFromQuery(query)
+  const column = tableName ? `${tableName}.${orderBy.column}` : orderBy.column
+
+  return query.orderBy(column, orderBy.direction || 'asc')
+}

package/src/postgresql/modifiers/apply-pagination.js

@@ -0,0 +1,12 @@
+/**
+ * Applies LIMIT and OFFSET.
+ *
+ * @param {Object} params
+ * @param {import('knex').Knex.QueryBuilder} params.query
+ * @param {number} [params.page=1]
+ * @param {number} [params.limit=10]
+ */
+export function applyPagination({ query, page = 1, limit = 10 }) {
+  const offset = (page - 1) * limit
+  return query.limit(limit).offset(offset)
+}

package/src/postgresql/pagination/paginate.js

@@ -0,0 +1,48 @@
+import { applyFilter } from '../filters/apply-filter.js'
+import { applyFilterSnakeCase } from '../filters/apply-filter-snake-case.js'
+import { applyOrderBy } from '../modifiers/apply-order-by.js'
+import { applyPagination } from '../modifiers/apply-pagination.js'
+import { normalizeNumberOrDefault } from '../../core/normalize-premitives-types-or-default.js'
+
+/**
+ * Executes paginated query.
+ *
+ * @async
+ */
+export async function sqlPaginate({
+  mapRow,
+  orderBy,
+  page = 1,
+  baseQuery,
+  limit = 10,
+  filter = {},
+  snakeCase = true,
+}) {
+  const listQuery = baseQuery.clone()
+  const countQuery = baseQuery.clone()
+
+  const applyFilterFn = snakeCase ? applyFilterSnakeCase : applyFilter
+
+  applyFilterFn({ query: listQuery, filter })
+  applyFilterFn({ query: countQuery, filter })
+
+  applyOrderBy({ query: listQuery, orderBy })
+  applyPagination({ query: listQuery, page, limit })
+
+  const [rows, countResult] = await Promise.all([
+    listQuery.select('*'),
+    countQuery.count('* as count').first(),
+  ])
+
+  const totalCount = normalizeNumberOrDefault(countResult?.count || 0)
+  const pages = Math.ceil(totalCount / limit)
+
+  return {
+    page,
+    pages,
+    totalCount,
+    hasPrevious: page > 1,
+    hasNext: page < pages,
+    list: mapRow ? rows.map(mapRow) : rows,
+  }
+}

package/tests/core/normalize-phone-number.unit.test.js

@@ -81,7 +81,7 @@ describe('phone normalization', () => {
       })
 
       it('returns identical normalized data when defaultRegion is provided', () => {
-        const out = normalizePhoneOrThrow('+972523443413', {
+        const out = normalizePhoneOrThrow('0523443413', {
           defaultRegion: 'IL',
         })