core-services-sdk 1.3.84 → 1.3.85

package/package.json

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

package/src/postgresql/pagination/paginate.js

@@ -73,6 +73,7 @@ export async function sqlPaginate({
   page = 1,
   baseQuery,
   limit = 10,
+  columns = '*',
   filter = {},
   snakeCase = true,
   distinctOn,
@@ -89,7 +90,7 @@ export async function sqlPaginate({
   applyPagination({ query: listQuery, page, limit })
 
   const [rows, countResult] = await Promise.all([
-    listQuery.select('*'),
+    listQuery.select(columns),
     distinctOn
       ? countQuery.countDistinct(`${distinctOn} as count`).first()
       : countQuery.count('* as count').first(),

package/src/postgresql/repositories/BaseRepository.js

@@ -14,13 +14,14 @@ import { toSnakeCase } from '../../core/case-mapper.js'
  */
 
 export class BaseRepository {
-  constructor({ db, log, baseQueryBuilder } = {}) {
+  constructor({ db, log, columns, baseQueryBuilder } = {}) {
     if (!db) {
       throw new Error('BaseRepository requires db instance')
     }
 
     this.db = db
     this.log = log
+    this._columns = columns ?? '*'
     this._baseQueryBuilder = baseQueryBuilder
   }
 
@@ -48,7 +49,7 @@ export class BaseRepository {
 
     if (this._baseQueryBuilder) {
       // Pass full params for optional dynamic shaping
-      return this._baseQueryBuilder(qb, params)
+      this._baseQueryBuilder(qb, params)
     }
 
     return qb
@@ -59,11 +60,12 @@ export class BaseRepository {
    */
   async find({
     page = 1,
+    columns,
     limit = 10,
     filter = {},
-    orderBy = { column: 'created_at', direction: 'desc' },
     options = {},
     mapRow = (row) => row,
+    orderBy = { column: 'created_at', direction: 'desc' },
     ...restParams
   }) {
     try {
@@ -79,10 +81,11 @@ export class BaseRepository {
       return await sqlPaginate({
         page,
         limit,
+        mapRow,
         orderBy,
         baseQuery: qb,
-        mapRow,
         filter: toSnakeCase(filter),
+        columns: columns ?? this._columns,
       })
     } catch (error) {
       if (this.log) {

package/tests/repositories/BaseRepository.int.test.js

@@ -0,0 +1,172 @@
+// @ts-nocheck
+import { describe, it, beforeAll, afterAll, beforeEach, expect } from 'vitest'
+import knex from 'knex'
+
+import {
+  stopPostgres,
+  startPostgres,
+  buildPostgresUri,
+} from '../../src/postgresql/start-stop-postgres-docker.js'
+
+import { BaseRepository } from '../../src/postgresql/repositories/BaseRepository.js'
+
+const PG_OPTIONS = {
+  port: 5445,
+  db: 'testdb',
+  user: 'testuser',
+  pass: 'testpass',
+  containerName: 'postgres-base-repo-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('customers', (table) => {
+    table.uuid('id').primary()
+    table.string('name').notNullable()
+    table.timestamp('created_at').notNullable()
+  })
+
+  await db.schema.createTable('orders', (table) => {
+    table.uuid('id').primary()
+    table.uuid('customer_id').notNullable()
+    table.decimal('amount', 10, 2)
+    table.timestamp('created_at').notNullable()
+  })
+})
+
+afterAll(async () => {
+  if (db) {
+    await db.destroy()
+  }
+
+  stopPostgres(PG_OPTIONS.containerName)
+})
+
+beforeEach(async () => {
+  await db('orders').truncate()
+  await db('customers').truncate()
+
+  await db('customers').insert([
+    {
+      id: '00000000-0000-0000-0000-000000000001',
+      name: 'Alice',
+      created_at: new Date('2024-01-01'),
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000002',
+      name: 'Bob',
+      created_at: new Date('2024-01-02'),
+    },
+  ])
+
+  await db('orders').insert([
+    {
+      id: '00000000-0000-0000-0000-000000000101',
+      customer_id: '00000000-0000-0000-0000-000000000001',
+      amount: 100,
+      created_at: new Date('2024-01-10'),
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000102',
+      customer_id: '00000000-0000-0000-0000-000000000001',
+      amount: 200,
+      created_at: new Date('2024-01-11'),
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000103',
+      customer_id: '00000000-0000-0000-0000-000000000002',
+      amount: 300,
+      created_at: new Date('2024-01-12'),
+    },
+  ])
+})
+
+class OrdersRepository extends BaseRepository {
+  static tableName = 'orders'
+
+  constructor(deps) {
+    super({
+      ...deps,
+      baseQueryBuilder(qb) {
+        qb.innerJoin('customers', 'customers.id', 'orders.customer_id')
+      },
+    })
+  }
+}
+
+describe('BaseRepository integration', () => {
+  it('baseQueryBuilder applies JOIN correctly', async () => {
+    const repo = new OrdersRepository({ db })
+
+    const qb = repo.baseQuery()
+
+    const rows = await qb.select('orders.id', 'customers.name')
+
+    expect(rows).toHaveLength(3)
+    expect(rows[0]).toHaveProperty('name')
+  })
+
+  it('find returns joined data using columns', async () => {
+    const repo = new OrdersRepository({ db })
+
+    const result = await repo.find({
+      columns: ['orders.id', 'orders.amount', 'customers.name'],
+      limit: 10,
+    })
+
+    expect(result.list.length).toBe(3)
+
+    const row = result.list[0]
+
+    expect(row).toHaveProperty('amount')
+    expect(row).toHaveProperty('name')
+  })
+
+  it('pagination works with joins', async () => {
+    const repo = new OrdersRepository({ db })
+
+    const result = await repo.find({
+      columns: ['orders.id', 'customers.name'],
+      limit: 2,
+      page: 1,
+    })
+
+    expect(result.list.length).toBe(2)
+    expect(result.totalCount).toBe(3)
+    expect(result.pages).toBe(2)
+  })
+
+  it('constructor default columns are used', async () => {
+    class RepoWithColumns extends BaseRepository {
+      static tableName = 'orders'
+
+      constructor(deps) {
+        super({
+          ...deps,
+          columns: ['orders.id'],
+          baseQueryBuilder(qb) {
+            qb.innerJoin('customers', 'customers.id', 'orders.customer_id')
+          },
+        })
+      }
+    }
+
+    const repo = new RepoWithColumns({ db })
+
+    const result = await repo.find({})
+
+    const row = result.list[0]
+
+    expect(Object.keys(row)).toEqual(['id'])
+  })
+})

package/tests/repositories/BaseRepository.test.js

@@ -1,21 +1,14 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { BaseRepository } from '../../src/postgresql/repositories/BaseRepository.js'
 
-// 🔥 mock dependencies
+// mock paginate
 vi.mock('../../src/postgresql/pagination/paginate.js', () => ({
-  sqlPaginate: vi.fn().mockResolvedValue({ page: 1 }),
+  sqlPaginate: vi.fn(),
 }))
 
-vi.mock('../../filters/apply-filter-snake-case.js', () => ({
-  applyFilterSnakeCase: vi.fn(),
-}))
-
-vi.mock('../../filters/apply-filter.js', () => ({
-  applyFilter: vi.fn(),
-}))
-
-vi.mock('../../core/normalize-premitives-types-or-default.js', () => ({
-  normalizeNumberOrDefault: vi.fn((v) => Number(v)),
+// mock snakeCase mapper
+vi.mock('../../src/core/case-mapper.js', () => ({
+  toSnakeCase: vi.fn((v) => v),
 }))
 
 // import AFTER mocks
@@ -24,6 +17,7 @@ import { toSnakeCase } from '../../src/core/case-mapper.js'
 
 describe('BaseRepository', () => {
   let dbMock
+  let qbMock
   let logMock
 
   class TestRepo extends BaseRepository {
@@ -31,13 +25,21 @@ describe('BaseRepository', () => {
   }
 
   beforeEach(() => {
-    dbMock = vi.fn(() => ({
-      clone: vi.fn(),
-    }))
+    qbMock = {
+      clone: vi.fn().mockReturnThis(),
+    }
+
+    dbMock = vi.fn(() => qbMock)
 
     logMock = {
       error: vi.fn(),
     }
+
+    sqlPaginate.mockResolvedValue({ page: 1 })
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
   })
 
   it('throws if db not provided', () => {
@@ -58,7 +60,7 @@ describe('BaseRepository', () => {
   })
 
   it('baseQuery uses trx when provided', () => {
-    const trxMock = vi.fn()
+    const trxMock = vi.fn(() => qbMock)
     const repo = new TestRepo({ db: dbMock })
 
     repo.baseQuery({ trx: trxMock })
@@ -68,7 +70,8 @@ describe('BaseRepository', () => {
   })
 
   it('baseQuery applies baseQueryBuilder', () => {
-    const builderMock = vi.fn((qb) => qb)
+    const builderMock = vi.fn()
+
     const repo = new TestRepo({
       db: dbMock,
       baseQueryBuilder: builderMock,
@@ -76,7 +79,7 @@ describe('BaseRepository', () => {
 
     repo.baseQuery({}, { some: 'param' })
 
-    expect(builderMock).toHaveBeenCalled()
+    expect(builderMock).toHaveBeenCalledWith(qbMock, { some: 'param' })
   })
 
   it('find calls sqlPaginate with correct params', async () => {
@@ -88,17 +91,65 @@ describe('BaseRepository', () => {
       filter: { a: 1 },
     })
 
-    expect(sqlPaginate).toHaveBeenCalled()
+    expect(toSnakeCase).toHaveBeenCalledWith({ a: 1 })
+
+    expect(sqlPaginate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        page: 2,
+        limit: 5,
+        baseQuery: qbMock,
+      }),
+    )
   })
 
   it('logs error if sqlPaginate throws', async () => {
-    // @ts-ignore
     sqlPaginate.mockRejectedValueOnce(new Error('fail'))
 
     const repo = new TestRepo({ db: dbMock, log: logMock })
 
-    await expect(repo.find({ filter: {} })).rejects.toThrow()
+    await expect(repo.find({ filter: {} })).rejects.toThrow('fail')
 
     expect(logMock.error).toHaveBeenCalled()
   })
+
+  it('find uses columns passed to find()', async () => {
+    const repo = new TestRepo({ db: dbMock })
+
+    await repo.find({
+      columns: ['id', 'name'],
+    })
+
+    expect(sqlPaginate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        columns: ['id', 'name'],
+      }),
+    )
+  })
+
+  it('find falls back to constructor columns', async () => {
+    const repo = new TestRepo({
+      db: dbMock,
+      columns: ['id', 'email'],
+    })
+
+    await repo.find({})
+
+    expect(sqlPaginate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        columns: ['id', 'email'],
+      }),
+    )
+  })
+
+  it('find falls back to "*" when no columns provided', async () => {
+    const repo = new TestRepo({ db: dbMock })
+
+    await repo.find({})
+
+    expect(sqlPaginate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        columns: '*',
+      }),
+    )
+  })
 })

package/tests/repositories/TenantScopedRepository.int.test.js

@@ -0,0 +1,173 @@
+// @ts-nocheck
+import { describe, it, beforeAll, afterAll, beforeEach, expect } from 'vitest'
+import knex from 'knex'
+
+import {
+  stopPostgres,
+  startPostgres,
+  buildPostgresUri,
+} from '../../src/postgresql/start-stop-postgres-docker.js'
+
+import { TenantScopedRepository } from '../../src/postgresql/repositories/TenantScopedRepository.js'
+
+const PG_OPTIONS = {
+  port: 5446,
+  db: 'testdb',
+  user: 'testuser',
+  pass: 'testpass',
+  containerName: 'postgres-tenant-repo-test-5446',
+}
+
+const DATABASE_URI = buildPostgresUri(PG_OPTIONS)
+
+const TENANT_A = '00000000-0000-0000-0000-000000000010'
+const TENANT_B = '00000000-0000-0000-0000-000000000020'
+
+let db
+
+beforeAll(async () => {
+  startPostgres(PG_OPTIONS)
+
+  db = knex({
+    client: 'pg',
+    connection: DATABASE_URI,
+  })
+
+  await db.schema.createTable('customers', (table) => {
+    table.uuid('id').primary()
+    table.uuid('tenant_id').notNullable()
+    table.string('name')
+    table.timestamp('created_at').notNullable()
+  })
+
+  await db.schema.createTable('orders', (table) => {
+    table.uuid('id').primary()
+    table.uuid('tenant_id').notNullable()
+    table.uuid('customer_id')
+    table.decimal('amount', 10, 2)
+    table.timestamp('created_at').notNullable()
+  })
+})
+
+afterAll(async () => {
+  if (db) {
+    await db.destroy()
+  }
+
+  stopPostgres(PG_OPTIONS.containerName)
+})
+
+beforeEach(async () => {
+  await db('orders').truncate()
+  await db('customers').truncate()
+
+  await db('customers').insert([
+    {
+      id: '00000000-0000-0000-0000-000000000001',
+      tenant_id: TENANT_A,
+      name: 'Alice',
+      created_at: new Date('2024-01-01'),
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000002',
+      tenant_id: TENANT_B,
+      name: 'Bob',
+      created_at: new Date('2024-01-02'),
+    },
+  ])
+
+  await db('orders').insert([
+    {
+      id: '00000000-0000-0000-0000-000000000101',
+      tenant_id: TENANT_A,
+      customer_id: '00000000-0000-0000-0000-000000000001',
+      amount: 100,
+      created_at: new Date('2024-01-10'),
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000102',
+      tenant_id: TENANT_A,
+      customer_id: '00000000-0000-0000-0000-000000000001',
+      amount: 200,
+      created_at: new Date('2024-01-11'),
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000103',
+      tenant_id: TENANT_B,
+      customer_id: '00000000-0000-0000-0000-000000000002',
+      amount: 300,
+      created_at: new Date('2024-01-12'),
+    },
+  ])
+})
+
+class OrdersRepository extends TenantScopedRepository {
+  static tableName = 'orders'
+
+  constructor(deps) {
+    super({
+      ...deps,
+      baseQueryBuilder(qb) {
+        qb.innerJoin('customers', 'customers.id', 'orders.customer_id')
+      },
+    })
+  }
+}
+
+describe('TenantScopedRepository integration', () => {
+  it('throws if tenantId missing', async () => {
+    const repo = new OrdersRepository({ db })
+
+    await expect(
+      repo.find({
+        filter: {},
+      }),
+    ).rejects.toThrow('tenantId is required')
+  })
+
+  it('returns only rows for tenant', async () => {
+    const repo = new OrdersRepository({ db })
+
+    const result = await repo.find({
+      filter: {
+        tenantId: TENANT_A,
+      },
+      columns: ['orders.id', 'orders.amount'],
+    })
+
+    expect(result.list.length).toBe(2)
+  })
+
+  it('works with join and columns', async () => {
+    const repo = new OrdersRepository({ db })
+
+    const result = await repo.find({
+      filter: {
+        tenantId: TENANT_A,
+      },
+      columns: ['orders.id', 'orders.amount', 'customers.name'],
+    })
+
+    const row = result.list[0]
+
+    expect(row).toHaveProperty('amount')
+    expect(row).toHaveProperty('name')
+  })
+
+  it('pagination respects tenant scope', async () => {
+    const repo = new OrdersRepository({ db })
+
+    const result = await repo.find({
+      filter: {
+        tenantId: TENANT_A,
+      },
+      limit: 1,
+      page: 1,
+      columns: ['orders.id'],
+    })
+
+    expect(result.list.length).toBe(1)
+    expect(result.totalCount).toBe(2)
+    expect(result.pages).toBe(2)
+  })
+})

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

@@ -67,6 +67,7 @@ export function sqlPaginate({
   page,
   baseQuery,
   limit,
+  columns,
   filter,
   snakeCase,
   distinctOn,

package/types/postgresql/repositories/BaseRepository.d.ts

@@ -10,9 +10,10 @@
  * Does NOT enforce tenant isolation.
  */
 export class BaseRepository {
-  constructor({ db, log, baseQueryBuilder }?: {})
+  constructor({ db, log, columns, baseQueryBuilder }?: {})
   db: any
   log: any
+  _columns: any
   _baseQueryBuilder: any
   /**
    * Each concrete repository must define:
@@ -29,22 +30,24 @@ export class BaseRepository {
    */
   find({
     page,
+    columns,
     limit,
     filter,
-    orderBy,
     options,
     mapRow,
+    orderBy,
     ...restParams
   }: {
     [x: string]: any
     page?: number
+    columns: any
     limit?: number
     filter?: {}
+    options?: {}
+    mapRow?: (row: any) => any
     orderBy?: {
       column: string
       direction: string
     }
-    options?: {}
-    mapRow?: (row: any) => any
   }): Promise<any>
 }