core-services-sdk 1.3.64 → 1.3.65

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,7 +8,7 @@ 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'
 
 const PG_OPTIONS = {
   port: 5442,
@@ -73,8 +73,7 @@ beforeEach(async () => {
 describe('paginate integration', () => {
   it('returns first page without ordering guarantees', async () => {
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
+      baseQuery: db('tenants'),
       page: 1,
       limit: 2,
     })
@@ -84,14 +83,12 @@ describe('paginate integration', () => {
     expect(result.currentPage).toBe(1)
     expect(result.hasPrevious).toBe(false)
     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,
     })
@@ -101,14 +98,12 @@ describe('paginate integration', () => {
     expect(result.currentPage).toBe(2)
     expect(result.hasPrevious).toBe(true)
     expect(result.hasNext).toBe(false)
-
     expect(result.list).toHaveLength(1)
   })
 
-  it('applies filters correctly without ordering guarantees', async () => {
+  it('applies filters correctly', async () => {
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
+      baseQuery: db('tenants'),
       filter: { type: 'business' },
       limit: 10,
     })
@@ -121,8 +116,7 @@ describe('paginate integration', () => {
 
   it('supports custom ordering', async () => {
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
+      baseQuery: db('tenants'),
       orderBy: {
         column: 'created_at',
         direction: 'asc',
@@ -138,8 +132,7 @@ describe('paginate integration', () => {
 
   it('supports row mapping', async () => {
     const result = await sqlPaginate({
-      db,
-      tableName: 'tenants',
+      baseQuery: db('tenants'),
       mapRow: (row) => ({
         ...row,
         mapped: true,
@@ -152,8 +145,7 @@ 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' },
     })
 

package/tests/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 totalPages = Math.ceil(totalCount / limit)
+
+  return {
+    totalCount,
+    totalPages,
+    currentPage: page,
+    hasPrevious: page > 1,
+    hasNext: page < totalPages,
+    list: mapRow ? rows.map(mapRow) : rows,
+  }
+}

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

@@ -5,6 +5,7 @@ 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'
 
@@ -18,7 +19,7 @@ const PG_OPTIONS = {
 
 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
+}>