core-services-sdk 1.3.83 → 1.3.85

package/package.json

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

package/src/http/http-method.js

@@ -1,7 +1,8 @@
 export const HTTP_METHODS = Object.freeze({
   GET: 'GET',
-  POST: 'POST',
   PUT: 'PUT',
+  HEAD: 'HEAD',
+  POST: 'POST',
   PATCH: 'PATCH',
   DELETE: 'DELETE',
 })

package/src/http/http.js

@@ -55,6 +55,13 @@
  * @property {ResponseTypeValue} [expectedType] - Expected response type.
  */
 
+/**
+ * @typedef {Object} HttpHeadOptions
+ * @property {string} url - The URL to send the request to.
+ * @property {Record<string, string>} [headers] - Optional HTTP headers.
+ * @property {RequestInit} [extraParams] - Additional fetch options.
+ */
+
 import httpStatus from 'http-status'
 import { parseStringPromise } from 'xml2js'
 
@@ -294,6 +301,25 @@ export const deleteApi = async ({
   return getResponsePayload(response, expectedType)
 }
 
+/**
+ * Sends an HTTP HEAD request.
+ *
+ * @param {HttpHeadOptions} options - The request options.
+ * @returns {Promise<Response>} The raw fetch response (headers only).
+ * @throws {HttpError} If the response status is not successful.
+ */
+export const head = async ({ url, headers = {}, extraParams = {} }) => {
+  const response = await fetch(url, {
+    ...extraParams,
+    method: HTTP_METHODS.HEAD,
+    headers: { ...JSON_HEADER, ...headers },
+  })
+
+  await checkStatus(response)
+
+  return response
+}
+
 /**
  * Consolidated HTTP client with methods for common HTTP operations.
  *
@@ -302,13 +328,16 @@ export const deleteApi = async ({
  *   put: (options: HttpPutOptions) => Promise<any>,
  *   post: (options: HttpPostOptions) => Promise<any>,
  *   patch: (options: HttpPatchOptions) => Promise<any>,
- *   deleteApi: (options: HttpDeleteOptions) => Promise<any>
+ *   deleteApi: (options: HttpDeleteOptions) => Promise<any>,
+ *   head: (options: HttpHeadOptions) => Promise<Response>
  * }}
  */
+
 export const http = {
   get,
   put,
   post,
   patch,
   deleteApi,
+  head,
 }

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/http/http-method.unit.test.js

@@ -6,9 +6,10 @@ import { HTTP_METHODS } from '../../src/http/http-method.js'
 describe('HTTP_METHODS constant', () => {
   it('should include all standard HTTP methods', () => {
     expect(HTTP_METHODS).toEqual({
+      PUT: 'PUT',
       GET: 'GET',
+      HEAD: 'HEAD',
       POST: 'POST',
-      PUT: 'PUT',
       PATCH: 'PATCH',
       DELETE: 'DELETE',
     })

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

@@ -20,6 +20,7 @@ const createMockResponse = ({
     statusText,
     text: vi.fn().mockResolvedValue(body),
     headers: {
+      // @ts-ignore
       get: vi.fn().mockImplementation((k) => headers[k]),
     },
   }
@@ -255,3 +256,143 @@ describe('extraParams support', () => {
     )
   })
 })
+
+describe('HEAD', () => {
+  it('should send a HEAD request and return response object', async () => {
+    const mockResponse = createMockResponse({
+      status: 200,
+      headers: { 'content-length': '1234' },
+    })
+
+    mockFetch.mockResolvedValueOnce(mockResponse)
+
+    const result = await http.head({
+      url: 'http://test.com',
+    })
+
+    expect(result).toBe(mockResponse)
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        method: HTTP_METHODS.HEAD,
+      }),
+    )
+  })
+
+  it('should expose response headers', async () => {
+    const mockResponse = createMockResponse({
+      headers: { etag: 'abc123' },
+    })
+
+    mockFetch.mockResolvedValueOnce(mockResponse)
+
+    const result = await http.head({
+      url: 'http://test.com',
+    })
+
+    expect(result.headers.get('etag')).toBe('abc123')
+  })
+
+  it('should throw HttpError on non-2xx status', async () => {
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({
+        status: 500,
+        body: 'server error',
+      }),
+    )
+
+    await expect(
+      http.head({
+        url: 'http://test.com',
+      }),
+    ).rejects.toThrow(HttpError)
+  })
+})
+
+describe('edge cases', () => {
+  it('should fallback to text when JSON parsing fails', async () => {
+    const invalidJson = '{invalid json'
+
+    mockFetch.mockResolvedValueOnce(createMockResponse({ body: invalidJson }))
+
+    const result = await http.get({
+      url: 'http://test.com',
+      expectedType: ResponseType.json,
+    })
+
+    expect(result).toBe(invalidJson)
+  })
+
+  it('should fallback to text when XML parsing fails', async () => {
+    const invalidXml = '<note><invalid></note>'
+
+    mockFetch.mockResolvedValueOnce(createMockResponse({ body: invalidXml }))
+
+    const result = await http.get({
+      url: 'http://test.com',
+      expectedType: ResponseType.xml,
+    })
+
+    expect(result).toBe(invalidXml)
+  })
+
+  it('should allow overriding headers', async () => {
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.get({
+      url: 'http://test.com',
+      headers: {
+        Authorization: 'Bearer token123',
+      },
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: 'Bearer token123',
+        }),
+      }),
+    )
+  })
+
+  it('should send DELETE request without body', async () => {
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.deleteApi({
+      url: 'http://test.com',
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        method: HTTP_METHODS.DELETE,
+      }),
+    )
+  })
+
+  it('should include default JSON content-type header', async () => {
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.post({
+      url: 'http://test.com',
+      body: { a: 1 },
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'Content-Type': 'application/json',
+        }),
+      }),
+    )
+  })
+})

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/http/http-method.d.ts

@@ -1,7 +1,8 @@
 export const HTTP_METHODS: Readonly<{
   GET: 'GET'
-  POST: 'POST'
   PUT: 'PUT'
+  HEAD: 'HEAD'
+  POST: 'POST'
   PATCH: 'PATCH'
   DELETE: 'DELETE'
 }>

package/types/http/http.d.ts

@@ -32,6 +32,11 @@ export function deleteApi({
   extraParams,
   expectedType,
 }: HttpDeleteOptions): Promise<any>
+export function head({
+  url,
+  headers,
+  extraParams,
+}: HttpHeadOptions): Promise<Response>
 /**
  * Consolidated HTTP client with methods for common HTTP operations.
  *
@@ -40,7 +45,8 @@ export function deleteApi({
  *   put: (options: HttpPutOptions) => Promise<any>,
  *   post: (options: HttpPostOptions) => Promise<any>,
  *   patch: (options: HttpPatchOptions) => Promise<any>,
- *   deleteApi: (options: HttpDeleteOptions) => Promise<any>
+ *   deleteApi: (options: HttpDeleteOptions) => Promise<any>,
+ *   head: (options: HttpHeadOptions) => Promise<Response>
  * }}
  */
 export const http: {
@@ -49,6 +55,7 @@ export const http: {
   post: (options: HttpPostOptions) => Promise<any>
   patch: (options: HttpPatchOptions) => Promise<any>
   deleteApi: (options: HttpDeleteOptions) => Promise<any>
+  head: (options: HttpHeadOptions) => Promise<Response>
 }
 export type ResponseTypeValue = 'json' | 'xml' | 'text' | 'raw' | 'file'
 export type HttpGetOptions = {
@@ -157,3 +164,17 @@ export type HttpDeleteOptions = {
    */
   expectedType?: ResponseTypeValue
 }
+export type HttpHeadOptions = {
+  /**
+   * - The URL to send the request to.
+   */
+  url: string
+  /**
+   * - Optional HTTP headers.
+   */
+  headers?: Record<string, string>
+  /**
+   * - Additional fetch options.
+   */
+  extraParams?: RequestInit
+}

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