core-services-sdk 1.3.81 → 1.3.82

package/package.json

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

package/src/postgresql/index.js

@@ -5,4 +5,6 @@ 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 './repositories/BaseRepository.js'
 export * from './filters/apply-filter-snake-case.js'
+export * from './repositories/TenantScopedRepository.js'

package/src/postgresql/pagination/paginate.js

@@ -75,6 +75,7 @@ export async function sqlPaginate({
   limit = 10,
   filter = {},
   snakeCase = true,
+  distinctOn,
 }) {
   const listQuery = baseQuery.clone()
   const countQuery = baseQuery.clone()
@@ -89,7 +90,9 @@ export async function sqlPaginate({
 
   const [rows, countResult] = await Promise.all([
     listQuery.select('*'),
-    countQuery.count('* as count').first(),
+    distinctOn
+      ? countQuery.countDistinct(`${distinctOn} as count`).first()
+      : countQuery.count('* as count').first(),
   ])
 
   const totalCount = normalizeNumberOrDefault(countResult?.count || 0)

package/src/postgresql/repositories/BaseRepository.js

@@ -0,0 +1,95 @@
+import { sqlPaginate } from '../pagination/paginate.js'
+import { toSnakeCase } from '../../core/case-mapper.js'
+
+/**
+ * BaseRepository
+ *
+ * Provides:
+ * - tableName getter (static + instance support)
+ * - baseQuery(options)
+ * - constructor-level query shaping (optional)
+ * - generic find() with pagination
+ *
+ * Does NOT enforce tenant isolation.
+ */
+
+export class BaseRepository {
+  constructor({ db, log, baseQueryBuilder } = {}) {
+    if (!db) {
+      throw new Error('BaseRepository requires db instance')
+    }
+
+    this.db = db
+    this.log = log
+    this._baseQueryBuilder = baseQueryBuilder
+  }
+
+  /**
+   * Each concrete repository must define:
+   * static tableName = 'table_name'
+   */
+  get tableName() {
+    if (!this.constructor.tableName) {
+      throw new Error(`tableName not defined for ${this.constructor.name}`)
+    }
+
+    return this.constructor.tableName
+  }
+
+  /**
+   * Builds the base knex query.
+   * Applies constructor-level baseQueryBuilder if provided.
+   */
+  baseQuery(options = {}, params) {
+    const { trx } = options
+    const connection = trx || this.db
+
+    const qb = connection(this.tableName)
+
+    if (this._baseQueryBuilder) {
+      // Pass full params for optional dynamic shaping
+      return this._baseQueryBuilder(qb, params)
+    }
+
+    return qb
+  }
+
+  /**
+   * Generic paginated find
+   */
+  async find({
+    page = 1,
+    limit = 10,
+    filter = {},
+    orderBy = { column: 'created_at', direction: 'desc' },
+    options = {},
+    mapRow = (row) => row,
+    ...restParams
+  }) {
+    try {
+      const qb = this.baseQuery(options, {
+        page,
+        limit,
+        filter,
+        orderBy,
+        options,
+        ...restParams,
+      })
+
+      return await sqlPaginate({
+        page,
+        limit,
+        orderBy,
+        baseQuery: qb,
+        mapRow,
+        filter: toSnakeCase(filter),
+      })
+    } catch (error) {
+      if (this.log) {
+        this.log.error({ error }, `Error finding from ${this.tableName}`)
+      }
+
+      throw error
+    }
+  }
+}

package/src/postgresql/repositories/TenantScopedRepository.js

@@ -0,0 +1,40 @@
+/**
+ * TenantScopedRepository
+ *
+ * Extends BaseRepository
+ * Enforces tenantId presence inside filter.
+ *
+ * Does NOT modify filter.
+ * Does NOT rebuild filter.
+ * Only validates existence.
+ */
+
+import { BaseRepository } from './BaseRepository.js'
+
+export class TenantScopedRepository extends BaseRepository {
+  /**
+   * Extracts and validates tenantId from filter
+   */
+  getRequiredTenantId(filter = {}) {
+    const { tenantId } = filter
+
+    if (!tenantId) {
+      throw new Error(
+        `Scoped repository (${this.tableName}), tenantId is required`,
+      )
+    }
+
+    return tenantId
+  }
+
+  /**
+   * Overrides find to enforce tenant presence
+   */
+  async find(params = {}) {
+    const { filter = {} } = params
+
+    this.getRequiredTenantId(filter)
+
+    return super.find(params)
+  }
+}

package/tests/repositories/BaseRepository.test.js

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { BaseRepository } from '../../src/postgresql/repositories/BaseRepository.js'
+
+// 🔥 mock dependencies
+vi.mock('../../src/postgresql/pagination/paginate.js', () => ({
+  sqlPaginate: vi.fn().mockResolvedValue({ page: 1 }),
+}))
+
+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)),
+}))
+
+// import AFTER mocks
+import { sqlPaginate } from '../../src/postgresql/pagination/paginate.js'
+import { toSnakeCase } from '../../src/core/case-mapper.js'
+
+describe('BaseRepository', () => {
+  let dbMock
+  let logMock
+
+  class TestRepo extends BaseRepository {
+    static tableName = 'test_table'
+  }
+
+  beforeEach(() => {
+    dbMock = vi.fn(() => ({
+      clone: vi.fn(),
+    }))
+
+    logMock = {
+      error: vi.fn(),
+    }
+  })
+
+  it('throws if db not provided', () => {
+    expect(() => new BaseRepository()).toThrow()
+  })
+
+  it('returns correct tableName', () => {
+    const repo = new TestRepo({ db: dbMock })
+    expect(repo.tableName).toBe('test_table')
+  })
+
+  it('baseQuery uses db when no trx', () => {
+    const repo = new TestRepo({ db: dbMock })
+
+    repo.baseQuery()
+
+    expect(dbMock).toHaveBeenCalledWith('test_table')
+  })
+
+  it('baseQuery uses trx when provided', () => {
+    const trxMock = vi.fn()
+    const repo = new TestRepo({ db: dbMock })
+
+    repo.baseQuery({ trx: trxMock })
+
+    expect(trxMock).toHaveBeenCalledWith('test_table')
+    expect(dbMock).not.toHaveBeenCalled()
+  })
+
+  it('baseQuery applies baseQueryBuilder', () => {
+    const builderMock = vi.fn((qb) => qb)
+    const repo = new TestRepo({
+      db: dbMock,
+      baseQueryBuilder: builderMock,
+    })
+
+    repo.baseQuery({}, { some: 'param' })
+
+    expect(builderMock).toHaveBeenCalled()
+  })
+
+  it('find calls sqlPaginate with correct params', async () => {
+    const repo = new TestRepo({ db: dbMock })
+
+    await repo.find({
+      page: 2,
+      limit: 5,
+      filter: { a: 1 },
+    })
+
+    expect(sqlPaginate).toHaveBeenCalled()
+  })
+
+  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()
+
+    expect(logMock.error).toHaveBeenCalled()
+  })
+})

package/tests/repositories/TenantScopedRepository.test.js

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi } from 'vitest'
+import { TenantScopedRepository } from '../../src/postgresql/repositories/TenantScopedRepository.js'
+
+class TestTenantRepo extends TenantScopedRepository {
+  static tableName = 'tenant_table'
+}
+
+describe('TenantScopedRepository', () => {
+  const dbMock = vi.fn(() => ({}))
+
+  it('throws if tenantId missing', async () => {
+    const repo = new TestTenantRepo({ db: dbMock })
+
+    await expect(repo.find({ filter: {} })).rejects.toThrow()
+  })
+
+  it('does not throw if tenantId exists', async () => {
+    const repo = new TestTenantRepo({ db: dbMock })
+
+    // Spy on BaseRepository.find instead of overriding repo.find
+    const superSpy = vi
+      .spyOn(Object.getPrototypeOf(TenantScopedRepository.prototype), 'find')
+      .mockResolvedValue(true)
+
+    const result = await repo.find({
+      filter: { tenantId: 'abc' },
+    })
+
+    expect(result).toBe(true)
+    expect(superSpy).toHaveBeenCalled()
+
+    superSpy.mockRestore()
+  })
+
+  it('getRequiredTenantId returns tenantId', () => {
+    const repo = new TestTenantRepo({ db: dbMock })
+
+    const id = repo.getRequiredTenantId({
+      tenantId: 'tenant-1',
+    })
+
+    expect(id).toBe('tenant-1')
+  })
+})