core-services-sdk 1.3.63 → 1.3.65

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

@@ -3,15 +3,15 @@ import { describe, it, beforeAll, afterAll, beforeEach, expect } from 'vitest'
 import knex from 'knex'
 
 import {
-  stopPostgres,
   startPostgres,
+  stopPostgres,
   buildPostgresUri,
 } from '../../src/postgresql/start-stop-postgres-docker.js'
 
-import { applyFilter } from '../../src/postgresql/apply-filter.js'
+import { applyFilter } from '../../src/postgresql/filters/apply-filter.js'
 
 const PG_OPTIONS = {
-  port: 5444,
+  port: 5443,
   containerName: 'postgres-apply-filter-test',
   user: 'testuser',
   pass: 'testpass',
@@ -69,7 +69,7 @@ beforeEach(async () => {
       name: 'Asset One',
       status: 'active',
       type: 'invoice',
-      price: 100.0,
+      price: 100,
       created_at: new Date('2024-01-01'),
       deleted_at: null,
     },
@@ -78,7 +78,7 @@ beforeEach(async () => {
       name: 'Asset Two',
       status: 'active',
       type: 'receipt',
-      price: 200.0,
+      price: 200,
       created_at: new Date('2024-01-02'),
       deleted_at: null,
     },
@@ -87,7 +87,7 @@ beforeEach(async () => {
       name: 'Asset Three',
       status: 'pending',
       type: 'invoice',
-      price: 150.0,
+      price: 150,
       created_at: new Date('2024-01-03'),
       deleted_at: null,
     },
@@ -96,7 +96,7 @@ beforeEach(async () => {
       name: 'Deleted Asset',
       status: 'deleted',
       type: 'receipt',
-      price: 50.0,
+      price: 50,
       created_at: new Date('2024-01-04'),
       deleted_at: new Date('2024-01-05'),
     },
@@ -105,7 +105,7 @@ beforeEach(async () => {
       name: 'Expensive Asset',
       status: 'active',
       type: 'invoice',
-      price: 500.0,
+      price: 500,
       created_at: new Date('2024-01-05'),
       deleted_at: null,
     },
@@ -115,7 +115,7 @@ beforeEach(async () => {
     {
       id: '00000000-0000-0000-0000-000000000101',
       invoice_number: 'INV-001',
-      amount: 1000.0,
+      amount: 1000,
       status: 'paid',
       customer_id: '00000000-0000-0000-0000-000000000201',
       created_at: new Date('2024-01-01'),
@@ -125,7 +125,7 @@ beforeEach(async () => {
     {
       id: '00000000-0000-0000-0000-000000000102',
       invoice_number: 'INV-002',
-      amount: 2500.0,
+      amount: 2500,
       status: 'pending',
       customer_id: '00000000-0000-0000-0000-000000000202',
       created_at: new Date('2024-01-02'),
@@ -135,7 +135,7 @@ beforeEach(async () => {
     {
       id: '00000000-0000-0000-0000-000000000103',
       invoice_number: 'INV-003',
-      amount: 500.0,
+      amount: 500,
       status: 'paid',
       customer_id: '00000000-0000-0000-0000-000000000201',
       created_at: new Date('2024-01-03'),
@@ -145,7 +145,7 @@ beforeEach(async () => {
     {
       id: '00000000-0000-0000-0000-000000000104',
       invoice_number: 'INV-004',
-      amount: 3000.0,
+      amount: 3000,
       status: 'overdue',
       customer_id: '00000000-0000-0000-0000-000000000203',
       created_at: new Date('2024-01-04'),
@@ -155,7 +155,7 @@ beforeEach(async () => {
     {
       id: '00000000-0000-0000-0000-000000000105',
       invoice_number: 'INV-005',
-      amount: 750.0,
+      amount: 750,
       status: 'cancelled',
       customer_id: '00000000-0000-0000-0000-000000000201',
       created_at: new Date('2024-01-05'),
@@ -165,385 +165,66 @@ beforeEach(async () => {
   ])
 })
 
-describe('applyFilter integration', () => {
-  it('applies simple equality filter (eq)', async () => {
+describe('applyFilter integration (snake_case only)', () => {
+  it('applies equality filter', async () => {
     const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
+
+    applyFilter({
       query,
       filter: { status: 'active' },
-      tableName: 'assets',
     })
 
-    const results = await filteredQuery
-
+    const results = await query
     expect(results).toHaveLength(3)
-    expect(results.every((r) => r.status === 'active')).toBe(true)
-  })
-
-  it('converts camelCase keys to snake_case', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { deletedAt: { isNull: true }, name: 'Asset One' },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(1)
-    expect(results[0].name).toBe('Asset One')
   })
 
-  it('applies not equal filter (ne)', async () => {
+  it('applies IN filter', async () => {
     const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { status: { ne: 'deleted' } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(4)
-    expect(results.every((r) => r.status !== 'deleted')).toBe(true)
-  })
-
-  it('applies not equal filter (neq alias)', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { status: { neq: 'deleted' } },
-      tableName: 'assets',
-    })
 
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(4)
-    expect(results.every((r) => r.status !== 'deleted')).toBe(true)
-  })
-
-  it('applies IN filter with array directly', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
+    applyFilter({
       query,
       filter: { status: ['active', 'pending'] },
-      tableName: 'assets',
     })
 
-    const results = await filteredQuery
-
+    const results = await query
     expect(results).toHaveLength(4)
-    expect(
-      results.every((r) => r.status === 'active' || r.status === 'pending'),
-    ).toBe(true)
   })
 
-  it('applies IN filter with operator', async () => {
+  it('applies numeric range filter', async () => {
     const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { status: { in: ['active', 'pending'] } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
 
-    expect(results).toHaveLength(4)
-    expect(
-      results.every((r) => r.status === 'active' || r.status === 'pending'),
-    ).toBe(true)
-  })
-
-  it('applies NOT IN filter (nin)', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { status: { nin: ['deleted', 'archived'] } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(4)
-    expect(
-      results.every((r) => r.status !== 'deleted' && r.status !== 'archived'),
-    ).toBe(true)
-  })
-
-  it('applies greater than filter (gt)', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { price: { gt: 150 } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(2)
-    expect(results.every((r) => parseFloat(r.price) > 150)).toBe(true)
-  })
-
-  it('applies greater than or equal filter (gte)', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { price: { gte: 150 } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(3)
-    expect(results.every((r) => parseFloat(r.price) >= 150)).toBe(true)
-  })
-
-  it('applies less than filter (lt)', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { price: { lt: 150 } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(2)
-    expect(results.every((r) => parseFloat(r.price) < 150)).toBe(true)
-  })
-
-  it('applies less than or equal filter (lte)', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { price: { lte: 150 } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(3)
-    expect(results.every((r) => parseFloat(r.price) <= 150)).toBe(true)
-  })
-
-  it('applies range filter with gte and lte', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
+    applyFilter({
       query,
       filter: { price: { gte: 100, lte: 200 } },
-      tableName: 'assets',
     })
 
-    const results = await filteredQuery
-
+    const results = await query
     expect(results).toHaveLength(3)
-    expect(
-      results.every(
-        (r) => parseFloat(r.price) >= 100 && parseFloat(r.price) <= 200,
-      ),
-    ).toBe(true)
-  })
-
-  it('applies case-sensitive LIKE filter', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { name: { like: '%Asset%' } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results.length).toBeGreaterThan(0)
-    expect(results.every((r) => r.name.includes('Asset'))).toBe(true)
-  })
-
-  it('applies case-insensitive ILIKE filter', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { name: { ilike: '%asset%' } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results.length).toBeGreaterThan(0)
-    expect(
-      results.every((r) =>
-        r.name.toLowerCase().includes('asset'.toLowerCase()),
-      ),
-    ).toBe(true)
-  })
-
-  it('applies isNull filter when value is true', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { deletedAt: { isNull: true } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(4)
-    expect(results.every((r) => r.deleted_at === null)).toBe(true)
-  })
-
-  it('applies isNotNull filter when isNull value is false', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { deletedAt: { isNull: false } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(1)
-    expect(results[0].deleted_at).not.toBe(null)
   })
 
-  it('applies isNotNull filter when value is true', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { deletedAt: { isNotNull: true } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(1)
-    expect(results[0].deleted_at).not.toBe(null)
-  })
-
-  it('applies isNull filter when isNotNull value is false', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { deletedAt: { isNotNull: false } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(4)
-    expect(results.every((r) => r.deleted_at === null)).toBe(true)
-  })
+  it('works with invoices table', async () => {
+    const query = db('invoices').select('*')
 
-  it('applies multiple filters together', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
+    applyFilter({
       query,
       filter: {
-        status: 'active',
-        type: 'invoice',
-        price: { gte: 100 },
+        status: 'paid',
+        deleted_at: { isNull: true },
       },
-      tableName: 'assets',
     })
 
-    const results = await filteredQuery
-
+    const results = await query
     expect(results).toHaveLength(2)
-    expect(results.every((r) => r.status === 'active')).toBe(true)
-    expect(results.every((r) => r.type === 'invoice')).toBe(true)
-    expect(results.every((r) => parseFloat(r.price) >= 100)).toBe(true)
   })
 
-  it('returns empty results when filter matches nothing', async () => {
+  it('throws when using camelCase keys', async () => {
     const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { status: 'non-existing' },
-      tableName: 'assets',
-    })
 
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(0)
-  })
-
-  it('uses qualified column names with tableName', async () => {
-    const query = db('assets').select('assets.*')
-    const filteredQuery = applyFilter({
+    applyFilter({
       query,
-      filter: { status: 'active' },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(3)
-    expect(results.every((r) => r.status === 'active')).toBe(true)
-  })
-
-  it('ignores unknown operators', async () => {
-    const query = db('assets').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { status: { unknownOperator: 'value' } },
-      tableName: 'assets',
-    })
-
-    const results = await filteredQuery
-
-    // Should return all records since unknown operator is ignored
-    expect(results).toHaveLength(5)
-  })
-
-  it('works with invoices table', async () => {
-    const query = db('invoices').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { status: 'paid', deletedAt: { isNull: true } },
-      tableName: 'invoices',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(2)
-    expect(results.every((r) => r.status === 'paid')).toBe(true)
-    expect(results.every((r) => r.deleted_at === null)).toBe(true)
-  })
-
-  it('works with invoices table using camelCase conversion', async () => {
-    const query = db('invoices').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: {
-        customerId: '00000000-0000-0000-0000-000000000201',
-        amount: { gte: 500 },
-      },
-      tableName: 'invoices',
-    })
-
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(3)
-    expect(
-      results.every(
-        (r) =>
-          r.customer_id === '00000000-0000-0000-0000-000000000201' &&
-          parseFloat(r.amount) >= 500,
-      ),
-    ).toBe(true)
-  })
-
-  it('works with invoices table using IN filter', async () => {
-    const query = db('invoices').select('*')
-    const filteredQuery = applyFilter({
-      query,
-      filter: { status: ['paid', 'pending'] },
-      tableName: 'invoices',
+      filter: { deletedAt: { isNull: true } },
     })
 
-    const results = await filteredQuery
-
-    expect(results).toHaveLength(3)
-    expect(
-      results.every((r) => r.status === 'paid' || r.status === 'pending'),
-    ).toBe(true)
+    await expect(query).rejects.toThrow(/deletedat/i)
   })
 })

package/tests/postgresql/core/get-table-name.unit.test.js

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest'
+import { getTableNameFromQuery } from '../../../src/postgresql/core/get-table-name.js'
+
+describe('getTableNameFromQuery', () => {
+  it('extracts table name from knex query mock', () => {
+    const mockQuery = {
+      _single: {
+        table: 'assets',
+      },
+    }
+
+    // @ts-ignore
+    expect(getTableNameFromQuery(mockQuery)).toBe('assets')
+  })
+
+  it('returns undefined when table is missing', () => {
+    // @ts-ignore
+    expect(getTableNameFromQuery({})).toBeUndefined()
+  })
+})

package/tests/postgresql/filters/apply-filter-object.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect, vi } from 'vitest'
+import { applyFilterObject } from '../../../src/postgresql/filters/apply-filter-object.js'
+import { OPERATORS } from '../../../src/postgresql/filters/operators.js'
+
+describe('applyFilterObject', () => {
+  it('applies multiple operators', () => {
+    const q = {}
+    // @ts-ignore
+    const spy = vi.spyOn(OPERATORS, 'gte').mockReturnValue(q)
+
+    // @ts-ignore
+    applyFilterObject(q, 'price', { gte: 100 })
+
+    expect(spy).toHaveBeenCalledWith(q, 'price', 100)
+  })
+
+  it('ignores unknown operators', () => {
+    const q = {}
+    // @ts-ignore
+    const result = applyFilterObject(q, 'x', { unknown: 1 })
+    expect(result).toBe(q)
+  })
+})

package/tests/postgresql/filters/operators.unit.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect, vi } from 'vitest'
+
+import { OPERATORS } from '../../../src/postgresql/filters/operators.js'
+
+describe('OPERATORS', () => {
+  it('eq calls where with "="', () => {
+    const q = { where: vi.fn(() => q) }
+    OPERATORS.eq(q, 'a', 1)
+    expect(q.where).toHaveBeenCalledWith('a', '=', 1)
+  })
+
+  it('in calls whereIn', () => {
+    const q = { whereIn: vi.fn(() => q) }
+    OPERATORS.in(q, 'a', [1, 2])
+    expect(q.whereIn).toHaveBeenCalledWith('a', [1, 2])
+  })
+
+  it('isNull true calls whereNull', () => {
+    const q = { whereNull: vi.fn(() => q) }
+    OPERATORS.isNull(q, 'a', true)
+    expect(q.whereNull).toHaveBeenCalledWith('a')
+  })
+})

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

@@ -0,0 +1,80 @@
+// @ts-nocheck
+import { describe, it, expect, vi } from 'vitest'
+import { applyOrderBy } from '../../../src/postgresql/modifiers/apply-order-by.js'
+
+describe('applyOrderBy', () => {
+  it('does nothing when orderBy is not provided', () => {
+    const query = {}
+
+    // @ts-ignore
+    const result = applyOrderBy({ query })
+
+    expect(result).toBe(query)
+  })
+
+  it('does nothing when orderBy.column is missing', () => {
+    const query = {}
+
+    const result = applyOrderBy({
+      query,
+      orderBy: {},
+    })
+
+    expect(result).toBe(query)
+  })
+
+  it('applies ORDER BY with default direction asc', () => {
+    const query = {
+      orderBy: vi.fn(() => query),
+      _single: { table: 'assets' },
+    }
+
+    applyOrderBy({
+      query,
+      orderBy: { column: 'created_at' },
+    })
+
+    expect(query.orderBy).toHaveBeenCalledWith('assets.created_at', 'asc')
+  })
+
+  it('applies ORDER BY with explicit direction', () => {
+    const query = {
+      orderBy: vi.fn(() => query),
+      _single: { table: 'assets' },
+    }
+
+    applyOrderBy({
+      query,
+      orderBy: { column: 'created_at', direction: 'desc' },
+    })
+
+    expect(query.orderBy).toHaveBeenCalledWith('assets.created_at', 'desc')
+  })
+
+  it('uses unqualified column when table name cannot be resolved', () => {
+    const query = {
+      orderBy: vi.fn(() => query),
+    }
+
+    applyOrderBy({
+      query,
+      orderBy: { column: 'created_at' },
+    })
+
+    expect(query.orderBy).toHaveBeenCalledWith('created_at', 'asc')
+  })
+
+  it('returns the same query instance for chaining', () => {
+    const query = {
+      orderBy: vi.fn(() => query),
+      _single: { table: 'assets' },
+    }
+
+    const result = applyOrderBy({
+      query,
+      orderBy: { column: 'id' },
+    })
+
+    expect(result).toBe(query)
+  })
+})

package/tests/postgresql/modifiers/apply-pagination.unit.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect, vi } from 'vitest'
+
+import { applyPagination } from '../../../src/postgresql/modifiers/apply-pagination.js'
+
+describe('applyPagination', () => {
+  it('applies limit and offset', () => {
+    const q = {
+      limit: vi.fn(() => q),
+      offset: vi.fn(() => q),
+    }
+
+    // @ts-ignore
+    applyPagination({ query: q, page: 2, limit: 10 })
+
+    expect(q.limit).toHaveBeenCalledWith(10)
+    expect(q.offset).toHaveBeenCalledWith(10)
+  })
+})