core-services-sdk 1.3.80 → 1.3.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.80",
+  "version": "1.3.82",
   "main": "src/index.js",
   "type": "module",
   "types": "types/index.d.ts",
@@ -49,14 +49,14 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^3.2.4",
-    "eslint": "^9.30.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^10.0.1",
     "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-prettier": "^5.5.1",
     "path": "^0.12.7",
     "prettier": "^3.6.2",
     "typescript": "^5.9.2",
     "url": "^0.11.4",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.18"
   }
 }

package/src/http/http.js

@@ -7,6 +7,50 @@
  * @module http
  */
 
+/**
+ * @typedef {'json' | 'xml' | 'text' | 'raw' | 'file'} ResponseTypeValue
+ */
+
+/**
+ * @typedef {Object} HttpGetOptions
+ * @property {string} url - The URL to send the request to.
+ * @property {Record<string, string>} [headers] - Optional HTTP headers.
+ * @property {RequestInit} [extraParams] - Additional fetch options.
+ * @property {ResponseTypeValue} [expectedType] - Expected response type.
+ */
+
+/**
+ * @typedef {Object} HttpPostOptions
+ * @property {string} url - The URL to send the request to.
+ * @property {any} body - The request body to send.
+ * @property {Record<string, string>} [headers] - Optional HTTP headers.
+ * @property {ResponseTypeValue} [expectedType] - Expected response type.
+ */
+
+/**
+ * @typedef {Object} HttpPutOptions
+ * @property {string} url - The URL to send the request to.
+ * @property {any} body - The request body to send.
+ * @property {Record<string, string>} [headers] - Optional HTTP headers.
+ * @property {ResponseTypeValue} [expectedType] - Expected response type.
+ */
+
+/**
+ * @typedef {Object} HttpPatchOptions
+ * @property {string} url - The URL to send the request to.
+ * @property {any} body - The request body to send.
+ * @property {Record<string, string>} [headers] - Optional HTTP headers.
+ * @property {ResponseTypeValue} [expectedType] - Expected response type.
+ */
+
+/**
+ * @typedef {Object} HttpDeleteOptions
+ * @property {string} url - The URL to send the request to.
+ * @property {any} [body] - Optional request body to send.
+ * @property {Record<string, string>} [headers] - Optional HTTP headers.
+ * @property {ResponseTypeValue} [expectedType] - Expected response type.
+ */
+
 import httpStatus from 'http-status'
 import { parseStringPromise } from 'xml2js'
 
@@ -25,7 +69,7 @@ const JSON_HEADER = {
  * @returns {boolean}
  */
 const isOkStatus = ({ status }) =>
-  status >= httpStatus.OK && status < httpStatus.MULTIPLE_CHOICES
+  status >= httpStatus.OK && status < httpStatus.BAD_REQUEST
 
 /**
  * Ensures the response has a successful status, otherwise throws HttpError.
@@ -121,6 +165,8 @@ const getResponsePayload = async (response, responseType) => {
       return tryGetJsonResponse(response)
     case ResponseType.xml:
       return tryGetXmlResponse(response)
+    case ResponseType.raw:
+      return response
     default:
       return getTextResponse(response)
   }
@@ -128,13 +174,19 @@ const getResponsePayload = async (response, responseType) => {
 
 /**
  * Sends an HTTP GET request.
+ *
+ * @param {HttpGetOptions} options - The request options.
+ * @returns {Promise<any>} The parsed response based on expectedType.
+ * @throws {HttpError} If the response status is not successful.
  */
 export const get = async ({
   url,
   headers = {},
+  extraParams = {},
   expectedType = ResponseType.json,
 }) => {
   const response = await fetch(url, {
+    ...extraParams,
     method: HTTP_METHODS.GET,
     headers: { ...JSON_HEADER, ...headers },
   })
@@ -144,6 +196,10 @@ export const get = async ({
 
 /**
  * Sends an HTTP POST request.
+ *
+ * @param {HttpPostOptions} options - The request options.
+ * @returns {Promise<any>} The parsed response based on expectedType.
+ * @throws {HttpError} If the response status is not successful.
  */
 export const post = async ({
   url,
@@ -162,6 +218,10 @@ export const post = async ({
 
 /**
  * Sends an HTTP PUT request.
+ *
+ * @param {HttpPutOptions} options - The request options.
+ * @returns {Promise<any>} The parsed response based on expectedType.
+ * @throws {HttpError} If the response status is not successful.
  */
 export const put = async ({
   url,
@@ -172,7 +232,7 @@ export const put = async ({
   const response = await fetch(url, {
     method: HTTP_METHODS.PUT,
     headers: { ...JSON_HEADER, ...headers },
-    body: JSON.stringify(body),
+    body: expectedType === ResponseType.json ? JSON.stringify(body) : body,
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -180,6 +240,10 @@ export const put = async ({
 
 /**
  * Sends an HTTP PATCH request.
+ *
+ * @param {HttpPatchOptions} options - The request options.
+ * @returns {Promise<any>} The parsed response based on expectedType.
+ * @throws {HttpError} If the response status is not successful.
  */
 export const patch = async ({
   url,
@@ -198,6 +262,10 @@ export const patch = async ({
 
 /**
  * Sends an HTTP DELETE request.
+ *
+ * @param {HttpDeleteOptions} options - The request options.
+ * @returns {Promise<any>} The parsed response based on expectedType.
+ * @throws {HttpError} If the response status is not successful.
  */
 export const deleteApi = async ({
   url,
@@ -215,7 +283,15 @@ export const deleteApi = async ({
 }
 
 /**
- * Consolidated HTTP client.
+ * Consolidated HTTP client with methods for common HTTP operations.
+ *
+ * @type {{
+ *   get: (options: HttpGetOptions) => Promise<any>,
+ *   put: (options: HttpPutOptions) => Promise<any>,
+ *   post: (options: HttpPostOptions) => Promise<any>,
+ *   patch: (options: HttpPatchOptions) => Promise<any>,
+ *   deleteApi: (options: HttpDeleteOptions) => Promise<any>
+ * }}
  */
 export const http = {
   get,

package/src/http/responseType.js

@@ -10,6 +10,7 @@
  */
 export const ResponseType = Object.freeze({
   xml: 'xml',
+  raw: 'raw',
   json: 'json',
   text: 'text',
   file: 'file',

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/env/env-validation.demo.js

@@ -77,7 +77,6 @@ for (const scenario of scenarios) {
 
   const result = prepareEnvValidation(definition, scenario.values, { mask })
 
-  // פה הבחירה שלך מה לעשות עם זה
   console.log(result.table)
 
   if (!result.success) {

package/tests/http/http.unit.test.js

@@ -149,5 +149,39 @@ describe('http client (native fetch)', () => {
 
       expect(result).toHaveProperty('note')
     })
+
+    it('should return raw response object if expectedType is raw', async () => {
+      const mockResponse = createMockResponse({ body: 'raw data', status: 200 })
+      mockFetch.mockResolvedValueOnce(mockResponse)
+
+      const result = await http.get({
+        url: 'http://test.com',
+        expectedType: ResponseType.raw,
+      })
+
+      expect(result).toBe(mockResponse)
+      expect(result.status).toBe(200)
+    })
+  })
+
+  describe('PUT with non-JSON body', () => {
+    it('should not stringify body when expectedType is not json', async () => {
+      const rawBody = 'plain text body'
+      mockFetch.mockResolvedValueOnce(createMockResponse({ body: 'OK' }))
+
+      await http.put({
+        url: 'http://test.com',
+        body: rawBody,
+        expectedType: ResponseType.text,
+      })
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.com',
+        expect.objectContaining({
+          method: 'PUT',
+          body: rawBody,
+        }),
+      )
+    })
   })
 })

package/tests/http/responseType.unit.test.js

@@ -7,6 +7,7 @@ describe('ResponseType', () => {
   it('should contain correct response type mappings', () => {
     expect(ResponseType).toEqual({
       xml: 'xml',
+      raw: 'raw',
       json: 'json',
       text: 'text',
       file: 'file',
@@ -32,7 +33,7 @@ describe('ResponseType', () => {
 
   it('should include expected keys', () => {
     const keys = Object.keys(ResponseType)
-    expect(keys).toEqual(['xml', 'json', 'text', 'file'])
+    expect(keys).toEqual(['xml', 'raw', 'json', 'text', 'file'])
   })
 
   it('should include expected values', () => {
@@ -41,5 +42,6 @@ describe('ResponseType', () => {
     expect(values).toContain('xml')
     expect(values).toContain('text')
     expect(values).toContain('file')
+    expect(values).toContain('raw')
   })
 })

package/tests/mailer/mailer.unit.test.js

@@ -17,9 +17,9 @@ vi.mock('../../src/mailer/transport.factory.js', async () => {
 
 // Mock Mailer class
 vi.mock('../../src/mailer/mailer.service.js', async () => {
-  const Mailer = vi.fn().mockImplementation((transport) => ({
-    send: vi.fn((opts) => transport.sendMail(opts)),
-  }))
+  const Mailer = vi.fn(function (transport) {
+    this.send = vi.fn((opts) => transport.sendMail(opts))
+  })
   return { Mailer }
 })
 

package/tests/mailer/transport.factory.unit.test.js

@@ -30,8 +30,12 @@ vi.mock('@sendgrid/mail', () => {
 // ---------------- Mock AWS SESv2 ----------------
 vi.mock('@aws-sdk/client-sesv2', () => {
   const mockSesInstance = { mocked: true }
-  const SESv2Client = vi.fn(() => mockSesInstance)
-  const SendEmailCommand = vi.fn(() => 'mocked-command')
+  const SESv2Client = vi.fn(function () {
+    Object.assign(this, mockSesInstance)
+  })
+  const SendEmailCommand = vi.fn(function () {
+    return 'mocked-command'
+  })
 
   globalThis.__mockedSesv2Client__ = SESv2Client
   globalThis.__mockedSesv2Instance__ = mockSesInstance
@@ -137,12 +141,10 @@ describe('TransportFactory', () => {
     })
 
     const args = nodemailer.createTransport.mock.calls[0][0]
-    expect(args).toEqual({
-      SES: {
-        sesClient: globalThis.__mockedSesv2Instance__,
-        SendEmailCommand: globalThis.__mockedSendEmailCommand__,
-      },
-    })
+    expect(args.SES.sesClient).toBeInstanceOf(globalThis.__mockedSesv2Client__)
+    expect(args.SES.SendEmailCommand).toBe(
+      globalThis.__mockedSendEmailCommand__,
+    )
 
     expect(transport.type).toBe('mock-transport')
   })
@@ -162,12 +164,10 @@ describe('TransportFactory', () => {
     })
 
     const args = nodemailer.createTransport.mock.calls[0][0]
-    expect(args).toEqual({
-      SES: {
-        sesClient: globalThis.__mockedSesv2Instance__,
-        SendEmailCommand: globalThis.__mockedSendEmailCommand__,
-      },
-    })
+    expect(args.SES.sesClient).toBeInstanceOf(globalThis.__mockedSesv2Client__)
+    expect(args.SES.SendEmailCommand).toBe(
+      globalThis.__mockedSendEmailCommand__,
+    )
 
     expect(transport.type).toBe('mock-transport')
   })

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

package/types/http/http.d.ts

@@ -1,10 +1,12 @@
 export function get({
   url,
   headers,
+  extraParams,
   expectedType,
 }: {
   url: any
   headers?: {}
+  extraParams?: {}
   expectedType?: 'json'
 }): Promise<any>
 export function post({

package/types/http/responseType.d.ts

@@ -14,6 +14,7 @@ export type ResponseType = string
  */
 export const ResponseType: Readonly<{
   xml: 'xml'
+  raw: 'raw'
   json: 'json'
   text: 'text'
   file: 'file'

package/.claude/settings.local.json

@@ -1,22 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm test:*)",
-      "Bash(docker rm:*)",
-      "Bash(docker run:*)",
-      "Bash(mongosh:*)",
-      "Bash(for:*)",
-      "Bash(do if mongosh --port 27099 --eval \"db.runCommand({ ping: 1 })\")",
-      "Bash(then echo \"Connected after $i attempts\")",
-      "Bash(break)",
-      "Bash(fi)",
-      "Bash(echo:*)",
-      "Bash(done)",
-      "Bash(docker logs:*)",
-      "Bash(docker system:*)",
-      "Bash(docker volume prune:*)",
-      "Bash(docker image prune:*)",
-      "Bash(docker builder prune:*)"
-    ]
-  }
-}