core-services-sdk 1.3.66 → 1.3.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.66",
+  "version": "1.3.68",
   "main": "src/index.js",
   "type": "module",
   "types": "types/index.d.ts",

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

@@ -12,5 +12,6 @@ export function applyFilterSnakeCase({ query, filter }) {
   return applyFilter({
     query,
     filter: toSnakeCase(filter),
+    snakeCase: true,
   })
 }

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

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

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

@@ -0,0 +1,39 @@
+import { snakeCase } from 'lodash-es'
+
+import { OPERATORS } from './operators.js'
+import { applyFilterObject } from './apply-filter-object.js'
+
+/**
+ * Applies OR filters.
+ *
+ * @param {import('knex').Knex.QueryBuilder} query
+ * @param {Array<Object>} orFilters
+ * @param {string | null} tableName
+ * @returns {import('knex').Knex.QueryBuilder}
+ */
+export function applyOrFilter(
+  query,
+  orFilters,
+  tableName,
+  snakeCaseFields = false,
+) {
+  return query.where(function () {
+    orFilters.forEach((filterObj, index) => {
+      this[index === 0 ? 'where' : 'orWhere'](function () {
+        Object.entries(filterObj).forEach(([key, value]) => {
+          const qualifiedKey = tableName
+            ? `${tableName}.${snakeCaseFields ? snakeCase(key) : key}`
+            : key
+
+          if (value && typeof value === 'object' && !Array.isArray(value)) {
+            applyFilterObject(this, qualifiedKey, value)
+          } else if (Array.isArray(value)) {
+            OPERATORS.in(this, qualifiedKey, value)
+          } else {
+            OPERATORS.eq(this, qualifiedKey, value)
+          }
+        })
+      })
+    })
+  })
+}

package/src/postgresql/pagination/paginate.js

@@ -1,13 +1,71 @@
 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 { applyFilterSnakeCase } from '../filters/apply-filter-snake-case.js'
 import { normalizeNumberOrDefault } from '../../core/normalize-premitives-types-or-default.js'
 
 /**
- * Executes paginated query.
+ * Executes a paginated SQL query using a Knex query builder.
+ *
+ * This helper clones the provided base query twice:
+ * one query is used to fetch the paginated list of rows,
+ * and the second query is used to calculate the total count
+ * of records matching the same filters.
+ *
+ * Filters are applied consistently to both queries.
+ * Ordering and pagination are applied only to the list query.
+ *
+ * The function supports both camelCase and snake_case filters,
+ * controlled by the `snakeCase` flag.
  *
  * @async
+ * @param {Object} params
+ * @param {import('knex').Knex.QueryBuilder} params.baseQuery
+ *   A prepared Knex query builder representing the base query.
+ *   It should not include pagination or ordering.
+ *
+ * @param {Object} [params.filter={}]
+ *   An object describing filter conditions to apply.
+ *   The structure is expected to be compatible with `applyFilter`
+ *   or `applyFilterSnakeCase`.
+ *
+ * @param {boolean} [params.snakeCase=true]
+ *   When true, applies filters assuming database columns
+ *   are in snake_case. When false, camelCase is assumed.
+ *
+ * @param {Object|Array} [params.orderBy]
+ *   Ordering definition passed directly to `applyOrderBy`.
+ *   Can be a single order definition or an array of them.
+ *
+ * @param {number} [params.page=1]
+ *   The current page number. Pages are 1-based.
+ *
+ * @param {number} [params.limit=10]
+ *   The maximum number of rows per page.
+ *
+ * @param {Function} [params.mapRow]
+ *   Optional mapping function applied to each returned row.
+ *   Useful for transforming DB rows into domain entities.
+ *
+ * @returns {Promise<Object>} Pagination result object
+ * @returns {number} return.page
+ *   The current page number.
+ *
+ * @returns {number} return.pages
+ *   Total number of available pages.
+ *
+ * @returns {number} return.totalCount
+ *   Total number of records matching the filters.
+ *
+ * @returns {boolean} return.hasPrevious
+ *   Indicates whether a previous page exists.
+ *
+ * @returns {boolean} return.hasNext
+ *   Indicates whether a next page exists.
+ *
+ * @returns {Array<Object>} return.list
+ *   The list of records for the current page.
+ *   Rows are mapped using `mapRow` if provided.
  */
 export async function sqlPaginate({
   mapRow,

package/tests/postgresql/filters/apply-or-filter.integration.test.js

@@ -0,0 +1,104 @@
+// @ts-nocheck
+import { describe, it, beforeAll, afterAll, beforeEach, expect } from 'vitest'
+import knex from 'knex'
+
+import {
+  startPostgres,
+  stopPostgres,
+  buildPostgresUri,
+} from '../../../src/postgresql/start-stop-postgres-docker.js'
+
+import { applyOrFilter } from '../../../src/postgresql/filters/apply-or-filter.js'
+
+const PG_OPTIONS = {
+  port: 5445,
+  db: 'testdb',
+  user: 'testuser',
+  pass: 'testpass',
+  containerName: 'postgres-or-filter-test-5445',
+}
+
+const DATABASE_URI = buildPostgresUri(PG_OPTIONS)
+
+let db
+
+beforeAll(async () => {
+  startPostgres(PG_OPTIONS)
+
+  db = knex({
+    client: 'pg',
+    connection: DATABASE_URI,
+  })
+
+  await db.schema.createTable('tenants', (table) => {
+    table.uuid('id').primary()
+    table.string('name').notNullable()
+    table.string('type').notNullable()
+    table.integer('age').notNullable()
+  })
+})
+
+afterAll(async () => {
+  if (db) {
+    await db.destroy()
+  }
+  stopPostgres(PG_OPTIONS.containerName)
+})
+
+beforeEach(async () => {
+  await db('tenants').truncate()
+
+  await db('tenants').insert([
+    {
+      id: '00000000-0000-0000-0000-000000000001',
+      name: 'Tenant A',
+      type: 'business',
+      age: 2,
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000002',
+      name: 'Tenant B',
+      type: 'business',
+      age: 5,
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000003',
+      name: 'Tenant C',
+      type: 'cpa',
+      age: 7,
+    },
+  ])
+})
+
+describe('applyOrFilter (integration)', () => {
+  it('returns records matching OR conditions', async () => {
+    const query = db('tenants')
+
+    applyOrFilter(query, [{ type: 'cpa' }, { age: { gte: 5 } }], 'tenants')
+
+    const rows = await query.select('*')
+
+    const names = rows.map((r) => r.name).sort()
+    expect(names).toEqual(['Tenant B', 'Tenant C'])
+  })
+
+  it('returns empty result when no OR conditions match', async () => {
+    const query = db('tenants')
+
+    applyOrFilter(query, [{ age: { gt: 100 } }], 'tenants')
+
+    const rows = await query.select('*')
+    expect(rows).toEqual([])
+  })
+
+  it('supports array IN operator inside OR', async () => {
+    const query = db('tenants')
+
+    applyOrFilter(query, [{ name: ['Tenant A', 'Tenant C'] }], 'tenants')
+
+    const rows = await query.select('*')
+    const names = rows.map((r) => r.name).sort()
+
+    expect(names).toEqual(['Tenant A', 'Tenant C'])
+  })
+})

package/tests/postgresql/filters/apply-or-filter.unit.test.js

@@ -0,0 +1,112 @@
+// @ts-nocheck
+import { describe, it, expect, vi } from 'vitest'
+
+import { OPERATORS } from '../../../src/postgresql/filters/operators.js'
+import { applyOrFilter } from '../../../src/postgresql/filters/apply-or-filter.js'
+import * as applyFilterObjectModule from '../../../src/postgresql/filters/apply-filter-object.js'
+
+describe('applyOrFilter (unit)', () => {
+  it('applies eq operator for primitive values', () => {
+    const query = {
+      where: vi.fn(function (cb) {
+        // @ts-ignore
+        cb.call(this)
+
+        // @ts-ignore
+        return this
+      }),
+      orWhere: vi.fn(function (cb) {
+        // @ts-ignore
+        cb.call(this)
+
+        // @ts-ignore
+        return this
+      }),
+    }
+
+    // @ts-ignore
+    const eqSpy = vi.spyOn(OPERATORS, 'eq').mockImplementation(() => query)
+
+    // @ts-ignore
+    applyOrFilter(query, [{ name: 'A' }, { name: 'B' }], null)
+
+    expect(eqSpy).toHaveBeenCalledTimes(2)
+    expect(eqSpy).toHaveBeenCalledWith(expect.anything(), 'name', 'A')
+    expect(eqSpy).toHaveBeenCalledWith(expect.anything(), 'name', 'B')
+  })
+
+  it('applies IN operator for array values', () => {
+    const query = {
+      where: vi.fn(function (cb) {
+        // @ts-ignore
+        cb.call(this)
+
+        // @ts-ignore
+        return this
+      }),
+      orWhere: vi.fn(function (cb) {
+        // @ts-ignore
+        cb.call(this)
+
+        // @ts-ignore
+        return this
+      }),
+    }
+
+    // @ts-ignore
+    const inSpy = vi.spyOn(OPERATORS, 'in').mockImplementation(() => query)
+
+    // @ts-ignore
+    applyOrFilter(query, [{ id: [1, 2, 3] }], null)
+
+    expect(inSpy).toHaveBeenCalledWith(expect.anything(), 'id', [1, 2, 3])
+  })
+
+  it('delegates object values to applyFilterObject', () => {
+    const query = {
+      where: vi.fn(function (cb) {
+        cb.call(this)
+        return this
+      }),
+      orWhere: vi.fn(function (cb) {
+        cb.call(this)
+        return this
+      }),
+    }
+
+    const spy = vi
+      .spyOn(applyFilterObjectModule, 'applyFilterObject')
+      .mockImplementation(() => query)
+
+    applyOrFilter(query, [{ age: { gte: 18 } }], null)
+
+    expect(spy).toHaveBeenCalledWith(expect.anything(), 'age', { gte: 18 })
+  })
+
+  it('applies snake_case when enabled', () => {
+    const query = {
+      where: vi.fn(function (cb) {
+        // @ts-ignore
+        cb.call(this)
+
+        // @ts-ignore
+        return this
+      }),
+      orWhere: vi.fn(function (cb) {
+        // @ts-ignore
+        cb.call(this)
+
+        // @ts-ignore
+        return this
+      }),
+    }
+
+    // @ts-ignore
+    const eqSpy = vi.spyOn(OPERATORS, 'eq').mockImplementation(() => query)
+
+    // @ts-ignore
+    applyOrFilter(query, [{ createdAt: 1 }], 't', true)
+
+    expect(eqSpy).toHaveBeenCalledWith(expect.anything(), 't.created_at', 1)
+  })
+})

package/tests/postgresql/paginate.integration.test.js

@@ -9,7 +9,6 @@ import {
 } from '../../src/postgresql/start-stop-postgres-docker.js'
 
 import { sqlPaginate } from '../../src/postgresql/pagination/paginate.js'
-import { sub } from 'date-fns'
 
 const PG_OPTIONS = {
   port: 5442,
@@ -123,7 +122,7 @@ describe('paginate integration', () => {
   })
 
   it('applies filters correctly', async () => {
-    const minDate = sub(new Date(), { years: 2 })
+    const minDate = new Date('2024-01-01')
     const result = await sqlPaginate({
       baseQuery: db('tenants'),
       filter: {

package/types/postgresql/pagination/paginate.d.ts

@@ -1,7 +1,65 @@
 /**
- * Executes paginated query.
+ * Executes a paginated SQL query using a Knex query builder.
+ *
+ * This helper clones the provided base query twice:
+ * one query is used to fetch the paginated list of rows,
+ * and the second query is used to calculate the total count
+ * of records matching the same filters.
+ *
+ * Filters are applied consistently to both queries.
+ * Ordering and pagination are applied only to the list query.
+ *
+ * The function supports both camelCase and snake_case filters,
+ * controlled by the `snakeCase` flag.
  *
  * @async
+ * @param {Object} params
+ * @param {import('knex').Knex.QueryBuilder} params.baseQuery
+ *   A prepared Knex query builder representing the base query.
+ *   It should not include pagination or ordering.
+ *
+ * @param {Object} [params.filter={}]
+ *   An object describing filter conditions to apply.
+ *   The structure is expected to be compatible with `applyFilter`
+ *   or `applyFilterSnakeCase`.
+ *
+ * @param {boolean} [params.snakeCase=true]
+ *   When true, applies filters assuming database columns
+ *   are in snake_case. When false, camelCase is assumed.
+ *
+ * @param {Object|Array} [params.orderBy]
+ *   Ordering definition passed directly to `applyOrderBy`.
+ *   Can be a single order definition or an array of them.
+ *
+ * @param {number} [params.page=1]
+ *   The current page number. Pages are 1-based.
+ *
+ * @param {number} [params.limit=10]
+ *   The maximum number of rows per page.
+ *
+ * @param {Function} [params.mapRow]
+ *   Optional mapping function applied to each returned row.
+ *   Useful for transforming DB rows into domain entities.
+ *
+ * @returns {Promise<Object>} Pagination result object
+ * @returns {number} return.page
+ *   The current page number.
+ *
+ * @returns {number} return.pages
+ *   Total number of available pages.
+ *
+ * @returns {number} return.totalCount
+ *   Total number of records matching the filters.
+ *
+ * @returns {boolean} return.hasPrevious
+ *   Indicates whether a previous page exists.
+ *
+ * @returns {boolean} return.hasNext
+ *   Indicates whether a next page exists.
+ *
+ * @returns {Array<Object>} return.list
+ *   The list of records for the current page.
+ *   Rows are mapped using `mapRow` if provided.
  */
 export function sqlPaginate({
   mapRow,
@@ -12,18 +70,11 @@ export function sqlPaginate({
   filter,
   snakeCase,
 }: {
-  mapRow: any
-  orderBy: any
+  baseQuery: import('knex').Knex.QueryBuilder
+  filter?: any
+  snakeCase?: boolean
+  orderBy?: any | any[]
   page?: number
-  baseQuery: any
   limit?: number
-  filter?: {}
-  snakeCase?: boolean
-}): Promise<{
-  totalCount: number
-  totalPages: number
-  currentPage: number
-  hasPrevious: boolean
-  hasNext: boolean
-  list: any
-}>
+  mapRow?: Function
+}): Promise<any>