core-services-sdk 1.3.64 → 1.3.66

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)
+  })
+})

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

@@ -8,14 +8,15 @@ import {
   buildPostgresUri,
 } from '../../src/postgresql/start-stop-postgres-docker.js'
 
-import { sqlPaginate } from '../../src/postgresql/paginate.js'
+import { sqlPaginate } from '../../src/postgresql/pagination/paginate.js'
+import { sub } from 'date-fns'
 
 const PG_OPTIONS = {
   port: 5442,
-  containerName: 'postgres-paginate-test-5442',
+  db: 'testdb',
   user: 'testuser',
   pass: 'testpass',
-  db: 'testdb',
+  containerName: 'postgres-paginate-test-5442',
 }
 
 const DATABASE_URI = buildPostgresUri(PG_OPTIONS)
@@ -34,6 +35,7 @@ beforeAll(async () => {
     table.uuid('id').primary()
     table.string('name').notNullable()
     table.string('type').notNullable()
+    table.bigInteger('age').notNullable()
     table.timestamp('created_at').notNullable()
   })
 })
@@ -47,70 +49,88 @@ afterAll(async () => {
 
 beforeEach(async () => {
   await db('tenants').truncate()
-
-  await db('tenants').insert([
+  const records = [
     {
       id: '00000000-0000-0000-0000-000000000001',
       name: 'Tenant A',
       type: 'business',
-      created_at: new Date('2024-01-01'),
+      age: 2,
+      created_at: new Date('2025-01-01'),
     },
     {
       id: '00000000-0000-0000-0000-000000000002',
       name: 'Tenant B',
+      age: 3,
       type: 'business',
       created_at: new Date('2024-01-02'),
     },
     {
       id: '00000000-0000-0000-0000-000000000003',
       name: 'Tenant C',
+      age: 1,
+      type: 'cpa',
+      created_at: new Date('2023-01-03'),
+    },
+
+    {
+      id: '00000000-0000-0000-0000-000000000004',
+      name: 'Tenant D',
+      age: 7,
+      type: 'cpa',
+      created_at: new Date('2022-01-03'),
+    },
+
+    {
+      id: '00000000-0000-0000-0000-000000000005',
+      name: 'Tenant E',
+      age: 0,
       type: 'cpa',
-      created_at: new Date('2024-01-03'),
+      created_at: new Date('2021-01-03'),
     },
-  ])
+  ]
+  await db('tenants').insert(records)
 })
 
 describe('paginate integration', () => {
   it('returns first page without ordering guarantees', async () => {
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
-      page: 1,
+      baseQuery: db('tenants'),
+      page: 2,
       limit: 2,
     })
 
-    expect(result.totalCount).toBe(3)
-    expect(result.totalPages).toBe(2)
-    expect(result.currentPage).toBe(1)
-    expect(result.hasPrevious).toBe(false)
+    expect(result.totalCount).toBe(5)
+    expect(result.pages).toBe(3)
+    expect(result.page).toBe(2)
+    expect(result.hasPrevious).toBe(true)
     expect(result.hasNext).toBe(true)
-
     expect(result.list).toHaveLength(2)
   })
 
   it('returns second page without ordering guarantees', async () => {
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
+      baseQuery: db('tenants'),
       page: 2,
       limit: 2,
     })
 
-    expect(result.totalCount).toBe(3)
-    expect(result.totalPages).toBe(2)
-    expect(result.currentPage).toBe(2)
+    expect(result.totalCount).toBe(5)
+    expect(result.pages).toBe(3)
+    expect(result.page).toBe(2)
     expect(result.hasPrevious).toBe(true)
-    expect(result.hasNext).toBe(false)
-
-    expect(result.list).toHaveLength(1)
+    expect(result.hasNext).toBe(true)
+    expect(result.list).toHaveLength(2)
   })
 
-  it('applies filters correctly without ordering guarantees', async () => {
+  it('applies filters correctly', async () => {
+    const minDate = sub(new Date(), { years: 2 })
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
-      filter: { type: 'business' },
+      baseQuery: db('tenants'),
+      filter: {
+        createdAt: { lte: new Date(), gte: minDate },
+      },
       limit: 10,
+      page: 1,
     })
 
     expect(result.totalCount).toBe(2)
@@ -121,10 +141,9 @@ describe('paginate integration', () => {
 
   it('supports custom ordering', async () => {
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
+      baseQuery: db('tenants'),
       orderBy: {
-        column: 'created_at',
+        column: 'name',
         direction: 'asc',
       },
     })
@@ -133,13 +152,14 @@ describe('paginate integration', () => {
       'Tenant A',
       'Tenant B',
       'Tenant C',
+      'Tenant D',
+      'Tenant E',
     ])
   })
 
   it('supports row mapping', async () => {
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
+      baseQuery: db('tenants'),
       mapRow: (row) => ({
         ...row,
         mapped: true,
@@ -152,13 +172,12 @@ describe('paginate integration', () => {
 
   it('returns empty list when no records match filter', async () => {
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
+      baseQuery: db('tenants'),
       filter: { type: 'non-existing' },
     })
 
     expect(result.totalCount).toBe(0)
-    expect(result.totalPages).toBe(0)
+    expect(result.pages).toBe(0)
     expect(result.list).toEqual([])
     expect(result.hasNext).toBe(false)
     expect(result.hasPrevious).toBe(false)

package/tests/postgresql/pagination/paginate.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+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 {
+    totalCount,
+    pages,
+    currentPage: page,
+    hasPrevious: page > 1,
+    hasNext: page < pages,
+    list: mapRow ? rows.map(mapRow) : rows,
+  }
+}

package/tests/postgresql/validate-schema.integration.test.js

@@ -5,20 +5,21 @@ import {
   stopPostgres,
   buildPostgresUri,
 } from '../../src/postgresql/start-stop-postgres-docker.js'
+
 import { connectToPg } from '../../src/postgresql/connect-to-pg.js'
 import { validateSchema } from '../../src/postgresql/validate-schema.js'
 
 const PG_OPTIONS = {
   port: 5431,
-  containerName: 'postgres-validate-schema-test-5431',
+  db: 'testdb',
   user: 'testuser',
   pass: 'testpass',
-  db: 'testdb',
+  containerName: 'postgres-validate-schema-test-5431',
 }
 
 const DATABASE_URI = buildPostgresUri(PG_OPTIONS)
 
-describe('validateSchema', () => {
+describe('validateSchema integration', () => {
   beforeAll(async () => {
     startPostgres(PG_OPTIONS)
 
@@ -32,13 +33,16 @@ describe('validateSchema', () => {
     await db.destroy()
   })
 
-  afterAll(() => {
+  afterAll(async () => {
     stopPostgres(PG_OPTIONS.containerName)
   })
 
   it('does not throw when all required tables exist', async () => {
     await expect(
-      validateSchema({ connection: DATABASE_URI, tables: ['files'] }),
+      validateSchema({
+        connection: DATABASE_URI,
+        tables: ['files'],
+      }),
     ).resolves.not.toThrow()
   })
 

package/types/postgresql/core/get-table-name.d.ts

@@ -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: import('knex').Knex.QueryBuilder,
+): string | undefined

package/types/postgresql/filters/apply-filter-object.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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: import('knex').Knex.QueryBuilder,
+  qualifiedKey: string,
+  value: {
+    [x: string]: any
+  },
+): import('knex').Knex.QueryBuilder

package/types/postgresql/filters/apply-filter-snake-case.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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,
+}: {
+  query: import('knex').Knex.QueryBuilder
+  filter: any
+}): import('knex').Knex.QueryBuilder<any, any>

package/types/postgresql/filters/apply-filter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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,
+}: {
+  query: import('knex').Knex.QueryBuilder
+  filter?: any
+}): import('knex').Knex.QueryBuilder

package/types/postgresql/filters/operators.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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: {
+  [x: string]: Function
+}
+export type OperatorFunction = Function

package/types/postgresql/index.d.ts

@@ -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/types/postgresql/modifiers/apply-order-by.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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,
+}: {
+  query: import('knex').Knex.QueryBuilder
+  orderBy: {
+    column: string
+    direction?: 'asc' | 'desc'
+  }
+}): import('knex').Knex.QueryBuilder<any, any>

package/types/postgresql/modifiers/apply-pagination.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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,
+  limit,
+}: {
+  query: import('knex').Knex.QueryBuilder
+  page?: number
+  limit?: number
+}): import('knex').Knex.QueryBuilder<any, any>

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

@@ -0,0 +1,29 @@
+/**
+ * Executes paginated query.
+ *
+ * @async
+ */
+export function sqlPaginate({
+  mapRow,
+  orderBy,
+  page,
+  baseQuery,
+  limit,
+  filter,
+  snakeCase,
+}: {
+  mapRow: any
+  orderBy: any
+  page?: number
+  baseQuery: any
+  limit?: number
+  filter?: {}
+  snakeCase?: boolean
+}): Promise<{
+  totalCount: number
+  totalPages: number
+  currentPage: number
+  hasPrevious: boolean
+  hasNext: boolean
+  list: any
+}>