core-services-sdk 1.3.71 → 1.3.73

package/package.json

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

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

@@ -1,19 +1,45 @@
 import { getTableNameFromQuery } from '../core/get-table-name.js'
 
 /**
- * Applies ORDER BY clause.
+ * @typedef {Object} OrderByItem
+ * @property {string} column - Column name to order by
+ * @property {'asc' | 'desc'} [direction='asc'] - Order direction
+ */
+
+const ALLOWED_DIRECTIONS = ['asc', 'desc']
+
+/**
+ * Applies ORDER BY clause(s) to a Knex query builder.
+ *
+ * Supports a single orderBy object or an array of orderBy objects.
+ * Validates order direction to prevent invalid SQL.
  *
  * @param {Object} params
- * @param {import('knex').Knex.QueryBuilder} params.query
- * @param {{ column: string, direction?: 'asc'|'desc' }} params.orderBy
+ * @param {import('knex').Knex.QueryBuilder} params.query - Knex query builder instance
+ * @param {OrderByItem | OrderByItem[]} params.orderBy - Order by definition(s)
+ * @returns {import('knex').Knex.QueryBuilder} The modified query builder
  */
 export function applyOrderBy({ query, orderBy }) {
-  if (!orderBy?.column) {
+  if (!orderBy) {
     return query
   }
 
   const tableName = getTableNameFromQuery(query)
-  const column = tableName ? `${tableName}.${orderBy.column}` : orderBy.column
+  const orderByArray = [].concat(orderBy)
+
+  return orderByArray.reduce((query, item) => {
+    if (!item?.column) {
+      return query
+    }
+
+    const direction = item.direction || 'asc'
+
+    if (!ALLOWED_DIRECTIONS.includes(direction)) {
+      throw new Error(`Invalid order direction: ${direction}`)
+    }
+
+    const column = tableName ? `${tableName}.${item.column}` : item.column
 
-  return query.orderBy(column, orderBy.direction || 'asc')
+    return query.orderBy(column, direction)
+  }, query)
 }

package/src/postgresql/validate-schema.js

@@ -35,24 +35,33 @@ export async function validateSchema({
   connection,
   log = { info: console.info },
 }) {
-  const db = connectToPg(connection)
+  const db = connectToPg(connection, {
+    pool: {
+      min: 0,
+      max: 1,
+    },
+  })
 
-  const missingTables = []
+  try {
+    const missingTables = []
 
-  for (const table of tables) {
-    const exists = await db.schema.hasTable(table)
-    if (!exists) {
-      missingTables.push(table)
+    for (const table of tables) {
+      const exists = await db.schema.hasTable(table)
+      if (!exists) {
+        missingTables.push(table)
+      }
     }
-  }
 
-  if (missingTables.length > 0) {
-    throw new Error(
-      `Missing the following tables: ${missingTables.join(', ')}. Did you run migrations?`,
-    )
-  }
+    if (missingTables.length > 0) {
+      throw new Error(
+        `Missing the following tables: ${missingTables.join(', ')}. Did you run migrations?`,
+      )
+    }
 
-  if (tables.length) {
-    log.info(`All required tables are exists: ${tables.join(', ')}`)
+    if (tables.length) {
+      log.info(`All required tables are exists: ${tables.join(', ')}`)
+    }
+  } finally {
+    await db.destroy()
   }
 }

package/tests/postgresql/modifiers/apply-order-by.integration.test.js

@@ -0,0 +1,152 @@
+// @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 { applyOrderBy } from '../../../src/postgresql/modifiers/apply-order-by.js'
+
+const PG_OPTIONS = {
+  port: 5447,
+  db: 'testdb',
+  user: 'testuser',
+  pass: 'testpass',
+  containerName: 'postgres-apply-order-by-test-5447',
+}
+
+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('applyOrderBy (integration)', () => {
+  it('orders by column ascending by default', async () => {
+    const query = db('tenants')
+
+    applyOrderBy({
+      query,
+      orderBy: { column: 'age' },
+    })
+
+    const ages = (await query.select('*')).map((r) => r.age)
+    expect(ages).toEqual([2, 5, 7])
+  })
+
+  it('orders by column descending', async () => {
+    const query = db('tenants')
+
+    applyOrderBy({
+      query,
+      orderBy: { column: 'age', direction: 'desc' },
+    })
+
+    const ages = (await query.select('*')).map((r) => r.age)
+    expect(ages).toEqual([7, 5, 2])
+  })
+
+  it('supports multiple ORDER BY clauses', async () => {
+    const query = db('tenants')
+
+    applyOrderBy({
+      query,
+      orderBy: [
+        { column: 'type', direction: 'asc' },
+        { column: 'age', direction: 'desc' },
+      ],
+    })
+
+    const result = await query.select('*')
+
+    expect(result.map((r) => `${r.type}-${r.age}`)).toEqual([
+      'business-5',
+      'business-2',
+      'cpa-7',
+    ])
+  })
+
+  it('does nothing when orderBy is missing', async () => {
+    const query = db('tenants')
+
+    applyOrderBy({ query })
+
+    const rows = await query.select('*')
+    expect(rows.length).toBe(3)
+  })
+
+  it('throws error for invalid order direction', async () => {
+    const query = db('tenants')
+
+    expect(() =>
+      applyOrderBy({
+        query,
+        orderBy: { column: 'age', direction: 'sideways' },
+      }),
+    ).toThrow('Invalid order direction: sideways')
+  })
+
+  it('does not execute query when invalid direction is provided', async () => {
+    const query = db('tenants')
+
+    try {
+      applyOrderBy({
+        query,
+        orderBy: { column: 'age', direction: 'up' },
+      })
+    } catch {}
+
+    const rows = await db('tenants').select('*')
+    expect(rows.length).toBe(3)
+  })
+})

package/tests/postgresql/modifiers/{apply-order-by.test.js → apply-order-by.unit.test.js}

@@ -51,6 +51,73 @@ describe('applyOrderBy', () => {
     expect(query.orderBy).toHaveBeenCalledWith('assets.created_at', 'desc')
   })
 
+  it('throws an error for invalid order direction', () => {
+    const query = {
+      orderBy: vi.fn(),
+      _single: { table: 'assets' },
+    }
+
+    expect(() =>
+      applyOrderBy({
+        query,
+        orderBy: { column: 'created_at', direction: 'up' },
+      }),
+    ).toThrow('Invalid order direction: up')
+
+    expect(query.orderBy).not.toHaveBeenCalled()
+  })
+
+  it('falls back to asc when direction is undefined', () => {
+    const query = {
+      orderBy: vi.fn(() => query),
+      _single: { table: 'assets' },
+    }
+
+    applyOrderBy({
+      query,
+      orderBy: { column: 'created_at', direction: undefined },
+    })
+
+    expect(query.orderBy).toHaveBeenCalledWith('assets.created_at', 'asc')
+  })
+
+  it('applies multiple ORDER BY clauses from array', () => {
+    const query = {
+      orderBy: vi.fn(() => query),
+      _single: { table: 'assets' },
+    }
+
+    applyOrderBy({
+      query,
+      orderBy: [{ column: 'created_at', direction: 'desc' }, { column: 'id' }],
+    })
+
+    expect(query.orderBy).toHaveBeenNthCalledWith(
+      1,
+      'assets.created_at',
+      'desc',
+    )
+
+    expect(query.orderBy).toHaveBeenNthCalledWith(2, 'assets.id', 'asc')
+  })
+
+  it('throws on invalid direction inside orderBy array', () => {
+    const query = {
+      orderBy: vi.fn(() => query),
+      _single: { table: 'assets' },
+    }
+
+    expect(() =>
+      applyOrderBy({
+        query,
+        orderBy: [
+          { column: 'created_at', direction: 'desc' },
+          { column: 'id', direction: 'sideways' },
+        ],
+      }),
+    ).toThrow('Invalid order direction: sideways')
+  })
+
   it('uses unqualified column when table name cannot be resolved', () => {
     const query = {
       orderBy: vi.fn(() => query),