core-services-sdk 1.3.60 → 1.3.62

package/package.json

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

package/src/postgresql/apply-filter.js

@@ -0,0 +1,275 @@
+import { toSnakeCase } from '../core/case-mapper.js'
+
+/**
+ * @typedef {Object} OperatorFunction
+ * @property {import('knex').Knex.QueryBuilder} query - Knex query builder instance
+ * @property {string} key - Column name (qualified with table name)
+ * @property {*} value - Value to compare against
+ * @returns {import('knex').Knex.QueryBuilder} Modified query builder
+ */
+
+/**
+ * Map of filter operators to their corresponding Knex query builder methods.
+ * Each operator function applies a WHERE condition to the query.
+ *
+ * @type {Object<string, OperatorFunction>}
+ * @private
+ */
+const OPERATORS = {
+  /**
+   * Array membership operator. Checks if column value is in the provided array.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {Array<*>} value - Array of values to match
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE IN clause
+   */
+  in: (q, key, value) => q.whereIn(key, value),
+
+  /**
+   * Not in array operator. Checks if column value is NOT in the provided array.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {Array<*>} value - Array of values to exclude
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE NOT IN clause
+   */
+  nin: (q, key, value) => q.whereNotIn(key, value),
+
+  /**
+   * Equality operator. Checks if column value equals the provided value.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {*} value - Value to match
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE = clause
+   */
+  eq: (q, key, value) => q.where(key, '=', value),
+
+  /**
+   * Not equal operator. Checks if column value does not equal the provided value.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {*} value - Value to exclude
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE != clause
+   */
+  ne: (q, key, value) => q.where(key, '!=', value),
+
+  /**
+   * Not equal operator (alias for `ne`). Checks if column value does not equal the provided value.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {*} value - Value to exclude
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE != clause
+   */
+  neq: (q, key, value) => q.where(key, '!=', value),
+
+  /**
+   * Greater than operator. Checks if column value is greater than the provided value.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {number|string|Date} value - Value to compare against
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE > clause
+   */
+  gt: (q, key, value) => q.where(key, '>', value),
+
+  /**
+   * Greater than or equal operator. Checks if column value is greater than or equal to the provided value.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {number|string|Date} value - Value to compare against
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE >= clause
+   */
+  gte: (q, key, value) => q.where(key, '>=', value),
+
+  /**
+   * Less than operator. Checks if column value is less than the provided value.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {number|string|Date} value - Value to compare against
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE < clause
+   */
+  lt: (q, key, value) => q.where(key, '<', value),
+
+  /**
+   * Less than or equal operator. Checks if column value is less than or equal to the provided value.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {number|string|Date} value - Value to compare against
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE <= clause
+   */
+  lte: (q, key, value) => q.where(key, '<=', value),
+
+  /**
+   * Case-sensitive pattern matching operator. Uses SQL LIKE for pattern matching.
+   * Supports wildcards: `%` (any sequence) and `_` (single character).
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {string} value - Pattern to match (e.g., '%invoice%')
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE LIKE clause
+   */
+  like: (q, key, value) => q.where(key, 'like', value),
+
+  /**
+   * Case-insensitive pattern matching operator. Uses PostgreSQL ILIKE for pattern matching.
+   * Supports wildcards: `%` (any sequence) and `_` (single character).
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {string} value - Pattern to match (e.g., '%invoice%')
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE ILIKE clause
+   */
+  ilike: (q, key, value) => q.where(key, 'ilike', value),
+
+  /**
+   * Null check operator. Checks if column value is NULL or NOT NULL based on the boolean value.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {boolean} value - If true, checks for NULL; if false, checks for NOT NULL
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE NULL or WHERE NOT NULL clause
+   */
+  isNull: (q, key, value) => (value ? q.whereNull(key) : q.whereNotNull(key)),
+
+  /**
+   * Not null check operator. Checks if column value is NOT NULL or NULL based on the boolean value.
+   * @param {import('knex').Knex.QueryBuilder} q - Query builder
+   * @param {string} key - Column name
+   * @param {boolean} value - If true, checks for NOT NULL; if false, checks for NULL
+   * @returns {import('knex').Knex.QueryBuilder} Query with WHERE NOT NULL or WHERE NULL clause
+   */
+  isNotNull: (q, key, value) =>
+    value ? q.whereNotNull(key) : q.whereNull(key),
+}
+
+/**
+ * Applies filter operators from an object to a Knex query.
+ * Processes each operator in the value object and applies the corresponding WHERE clause.
+ * Unknown operators are silently ignored.
+ *
+ * @param {import('knex').Knex.QueryBuilder} q - Knex query builder instance
+ * @param {string} qualifiedKey - Fully qualified column name (e.g., "table.column")
+ * @param {Object<string, *>} value - Object containing operator-value pairs
+ * @returns {import('knex').Knex.QueryBuilder} Modified query builder with applied filters
+ * @private
+ *
+ * @example
+ * // Apply multiple operators on the same field
+ * applyFilterObject(query, 'assets.price', { gte: 100, lte: 200 })
+ * // Results in: WHERE assets.price >= 100 AND assets.price <= 200
+ */
+const applyFilterObject = (q, qualifiedKey, value) => {
+  return Object.entries(value).reduce(
+    (q, [operator, val]) =>
+      OPERATORS[operator] ? OPERATORS[operator](q, qualifiedKey, val) : q,
+    q,
+  )
+}
+
+/**
+ * Builds a Knex query with MongoDB-style filter operators.
+ * Pure utility function that can be used across repositories.
+ *
+ * This function converts camelCase filter keys to snake_case and applies
+ * various filter operators to build SQL WHERE clauses. All column names
+ * are automatically qualified with the provided table name.
+ *
+ * **Supported Operators:**
+ * - `eq` - Equality (default for simple values)
+ * - `ne` / `neq` - Not equal
+ * - `in` - Array membership (or pass array directly)
+ * - `nin` - Not in array
+ * - `gt` - Greater than
+ * - `gte` - Greater than or equal
+ * - `lt` - Less than
+ * - `lte` - Less than or equal
+ * - `like` - Case-sensitive pattern matching (SQL LIKE)
+ * - `ilike` - Case-insensitive pattern matching (PostgreSQL ILIKE)
+ * - `isNull` - Check if field is NULL
+ * - `isNotNull` - Check if field is NOT NULL
+ *
+ * **Key Features:**
+ * - Automatic camelCase to snake_case conversion for filter keys
+ * - Qualified column names (table.column format)
+ * - Multiple operators can be applied to the same field
+ * - Unknown operators are silently ignored
+ * - Arrays are automatically converted to IN clauses
+ *
+ * @param {Object} params - Function parameters
+ * @param {import('knex').Knex.QueryBuilder} params.query - Knex query builder instance to apply filters to
+ * @param {Object<string, *>} params.filter - Filter object with camelCase keys (will be converted to snake_case)
+ *   Filter values can be:
+ *   - Simple values (string, number, boolean) → treated as equality
+ *   - Arrays → treated as IN operator
+ *   - Objects with operator keys → apply specific operators
+ * @param {string} params.tableName - Table name used to qualify column names (e.g., "assets" → "assets.column_name")
+ * @returns {import('knex').Knex.QueryBuilder} Modified query builder with applied WHERE clauses
+ *
+ * @throws {TypeError} If query is not a valid Knex QueryBuilder instance
+ *
+ * @example
+ * // Simple equality - converts to WHERE assets.status = 'active'
+ * const query = db('assets').select('*')
+ * applyFilter({ query, filter: { status: 'active' }, tableName: 'assets' })
+ *
+ * @example
+ * // Not equal - converts to WHERE assets.status != 'deleted'
+ * applyFilter({ query, filter: { status: { ne: 'deleted' } }, tableName: 'assets' })
+ *
+ * @example
+ * // Array/IN operator - converts to WHERE assets.status IN ('active', 'pending')
+ * applyFilter({ query, filter: { status: ['active', 'pending'] }, tableName: 'assets' })
+ *
+ * @example
+ * // Explicit IN operator
+ * applyFilter({ query, filter: { status: { in: ['active', 'pending'] } }, tableName: 'assets' })
+ *
+ * @example
+ * // Not in array - converts to WHERE assets.status NOT IN ('deleted', 'archived')
+ * applyFilter({ query, filter: { status: { nin: ['deleted', 'archived'] } }, tableName: 'assets' })
+ *
+ * @example
+ * // Range operators - converts to WHERE assets.price >= 100 AND assets.price <= 200
+ * applyFilter({ query, filter: { price: { gte: 100, lte: 200 } }, tableName: 'assets' })
+ *
+ * @example
+ * // Pattern matching (case-sensitive) - converts to WHERE assets.name LIKE '%invoice%'
+ * applyFilter({ query, filter: { name: { like: '%invoice%' } }, tableName: 'assets' })
+ *
+ * @example
+ * // Pattern matching (case-insensitive) - converts to WHERE assets.name ILIKE '%invoice%'
+ * applyFilter({ query, filter: { name: { ilike: '%invoice%' } }, tableName: 'assets' })
+ *
+ * @example
+ * // Null checks - converts to WHERE assets.deleted_at IS NULL
+ * applyFilter({ query, filter: { deletedAt: { isNull: true } }, tableName: 'assets' })
+ *
+ * @example
+ * // Multiple filters - converts to WHERE assets.status = 'active' AND assets.type = 'invoice' AND assets.price >= 100
+ * applyFilter({
+ *   query,
+ *   filter: {
+ *     status: 'active',
+ *     type: 'invoice',
+ *     price: { gte: 100 }
+ *   },
+ *   tableName: 'assets'
+ * })
+ *
+ * @example
+ * // camelCase conversion - deletedAt converts to deleted_at
+ * applyFilter({ query, filter: { deletedAt: { isNull: true } }, tableName: 'assets' })
+ * // SQL: WHERE assets.deleted_at IS NULL
+ */
+export function applyFilter({ query, filter, tableName }) {
+  const convertedFilter = toSnakeCase(filter)
+
+  return Object.entries(convertedFilter).reduce((q, [key, value]) => {
+    const qualifiedKey = `${tableName}.${key}`
+
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      return applyFilterObject(q, qualifiedKey, value)
+    }
+
+    if (Array.isArray(value)) {
+      return OPERATORS.in(q, qualifiedKey, value)
+    }
+
+    return OPERATORS.eq(q, qualifiedKey, value)
+  }, query)
+}

package/src/postgresql/index.js

@@ -1,4 +1,5 @@
 export * from './paginate.js'
+export * from './apply-filter.js'
 export * from './connect-to-pg.js'
 export * from './validate-schema.js'
 export * from './start-stop-postgres-docker.js'

package/tests/instant-messages/message-unified-mapper-telegram.unit.test.js

@@ -1,11 +1,11 @@
+import { fileURLToPath } from 'url'
 import { describe, it, expect } from 'vitest'
+import { dirname, join, extname } from 'path'
 import { readFileSync, readdirSync } from 'fs'
-import { join, extname } from 'path'
-import { fileURLToPath } from 'url'
-import { dirname } from 'path'
-import { mapMessageTelegram } from '../../src/instant-messages/message-unified-mapper.js'
 
+import { writeFilesReceiveMapped } from '../resources/create-im-mapp-diff.js'
 import { getTelegramMessageType } from '../../src/instant-messages/message-type.js'
+import { mapMessageTelegram } from '../../src/instant-messages/message-unified-mapper.js'
 
 import {
   MESSAGE_MEDIA_TYPE,
@@ -24,7 +24,6 @@ describe('Telegram unified message mapper – all mock samples', () => {
   if (files.length === 0) {
     throw new Error('No Telegram mock message files found in directory.')
   }
-
   for (const file of files) {
     const filePath = join(MOCK_DIR_TELEGRAM, file)
     const raw = JSON.parse(readFileSync(filePath, 'utf8'))
@@ -36,7 +35,7 @@ describe('Telegram unified message mapper – all mock samples', () => {
         const unifiedMessage = mapMessageTelegram({
           imMessage: raw,
         })
-
+        writeFilesReceiveMapped({ raw, prefix: 'telegram', unifiedMessage })
         expect(unifiedMessage).toBeTypeOf('object')
         expect(unifiedType).toBeTypeOf('string')
         expect(unifiedMessage.type).toBe(

package/tests/instant-messages/message-unified-mapper-whatsapp.unit.test.js

@@ -7,7 +7,7 @@ import {
   getMessageType,
   mapMessageWhatsApp,
 } from '../../src/instant-messages/message-unified-mapper.js'
-
+import { writeFilesReceiveMapped } from '../resources/create-im-mapp-diff.js'
 import {
   MESSAGE_MEDIA_TYPE,
   MESSAGE_MEDIA_TYPE_MAPPER,
@@ -38,7 +38,7 @@ describe('WhatsApp unified message mapper – all mock samples', () => {
         const unifiedMessage = mapMessageWhatsApp({
           imMessage: raw,
         })
-
+        writeFilesReceiveMapped({ raw, prefix: 'whatsapp', unifiedMessage })
         expect(unifiedMessage).toBeTypeOf('object')
         expect(unifiedType).toBeTypeOf('string')
 

package/tests/postgresql/apply-filter.integration.test.js

@@ -0,0 +1,549 @@
+// @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 { applyFilter } from '../../src/postgresql/apply-filter.js'
+
+const PG_OPTIONS = {
+  port: 5444,
+  containerName: 'postgres-apply-filter-test',
+  user: 'testuser',
+  pass: 'testpass',
+  db: 'testdb',
+}
+
+const DATABASE_URI = buildPostgresUri(PG_OPTIONS)
+
+let db
+
+beforeAll(async () => {
+  startPostgres(PG_OPTIONS)
+
+  db = knex({
+    client: 'pg',
+    connection: DATABASE_URI,
+  })
+
+  await db.schema.createTable('assets', (table) => {
+    table.uuid('id').primary()
+    table.string('name').notNullable()
+    table.string('status')
+    table.string('type')
+    table.decimal('price', 10, 2)
+    table.timestamp('created_at').notNullable()
+    table.timestamp('deleted_at')
+  })
+
+  await db.schema.createTable('invoices', (table) => {
+    table.uuid('id').primary()
+    table.string('invoice_number').notNullable()
+    table.decimal('amount', 10, 2).notNullable()
+    table.string('status')
+    table.uuid('customer_id')
+    table.timestamp('created_at').notNullable()
+    table.timestamp('paid_at')
+    table.timestamp('deleted_at')
+  })
+})
+
+afterAll(async () => {
+  if (db) {
+    await db.destroy()
+  }
+  stopPostgres(PG_OPTIONS.containerName)
+})
+
+beforeEach(async () => {
+  await db('assets').truncate()
+  await db('invoices').truncate()
+
+  await db('assets').insert([
+    {
+      id: '00000000-0000-0000-0000-000000000001',
+      name: 'Asset One',
+      status: 'active',
+      type: 'invoice',
+      price: 100.0,
+      created_at: new Date('2024-01-01'),
+      deleted_at: null,
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000002',
+      name: 'Asset Two',
+      status: 'active',
+      type: 'receipt',
+      price: 200.0,
+      created_at: new Date('2024-01-02'),
+      deleted_at: null,
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000003',
+      name: 'Asset Three',
+      status: 'pending',
+      type: 'invoice',
+      price: 150.0,
+      created_at: new Date('2024-01-03'),
+      deleted_at: null,
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000004',
+      name: 'Deleted Asset',
+      status: 'deleted',
+      type: 'receipt',
+      price: 50.0,
+      created_at: new Date('2024-01-04'),
+      deleted_at: new Date('2024-01-05'),
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000005',
+      name: 'Expensive Asset',
+      status: 'active',
+      type: 'invoice',
+      price: 500.0,
+      created_at: new Date('2024-01-05'),
+      deleted_at: null,
+    },
+  ])
+
+  await db('invoices').insert([
+    {
+      id: '00000000-0000-0000-0000-000000000101',
+      invoice_number: 'INV-001',
+      amount: 1000.0,
+      status: 'paid',
+      customer_id: '00000000-0000-0000-0000-000000000201',
+      created_at: new Date('2024-01-01'),
+      paid_at: new Date('2024-01-02'),
+      deleted_at: null,
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000102',
+      invoice_number: 'INV-002',
+      amount: 2500.0,
+      status: 'pending',
+      customer_id: '00000000-0000-0000-0000-000000000202',
+      created_at: new Date('2024-01-02'),
+      paid_at: null,
+      deleted_at: null,
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000103',
+      invoice_number: 'INV-003',
+      amount: 500.0,
+      status: 'paid',
+      customer_id: '00000000-0000-0000-0000-000000000201',
+      created_at: new Date('2024-01-03'),
+      paid_at: new Date('2024-01-04'),
+      deleted_at: null,
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000104',
+      invoice_number: 'INV-004',
+      amount: 3000.0,
+      status: 'overdue',
+      customer_id: '00000000-0000-0000-0000-000000000203',
+      created_at: new Date('2024-01-04'),
+      paid_at: null,
+      deleted_at: null,
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000105',
+      invoice_number: 'INV-005',
+      amount: 750.0,
+      status: 'cancelled',
+      customer_id: '00000000-0000-0000-0000-000000000201',
+      created_at: new Date('2024-01-05'),
+      paid_at: null,
+      deleted_at: new Date('2024-01-06'),
+    },
+  ])
+})
+
+describe('applyFilter integration', () => {
+  it('applies simple equality filter (eq)', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: 'active' },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(3)
+    expect(results.every((r) => r.status === 'active')).toBe(true)
+  })
+
+  it('converts camelCase keys to snake_case', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { deletedAt: { isNull: true }, name: 'Asset One' },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(1)
+    expect(results[0].name).toBe('Asset One')
+  })
+
+  it('applies not equal filter (ne)', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: { ne: 'deleted' } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(4)
+    expect(results.every((r) => r.status !== 'deleted')).toBe(true)
+  })
+
+  it('applies not equal filter (neq alias)', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: { neq: 'deleted' } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(4)
+    expect(results.every((r) => r.status !== 'deleted')).toBe(true)
+  })
+
+  it('applies IN filter with array directly', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: ['active', 'pending'] },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(4)
+    expect(
+      results.every((r) => r.status === 'active' || r.status === 'pending'),
+    ).toBe(true)
+  })
+
+  it('applies IN filter with operator', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: { in: ['active', 'pending'] } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(4)
+    expect(
+      results.every((r) => r.status === 'active' || r.status === 'pending'),
+    ).toBe(true)
+  })
+
+  it('applies NOT IN filter (nin)', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: { nin: ['deleted', 'archived'] } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(4)
+    expect(
+      results.every((r) => r.status !== 'deleted' && r.status !== 'archived'),
+    ).toBe(true)
+  })
+
+  it('applies greater than filter (gt)', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { price: { gt: 150 } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(2)
+    expect(results.every((r) => parseFloat(r.price) > 150)).toBe(true)
+  })
+
+  it('applies greater than or equal filter (gte)', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { price: { gte: 150 } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(3)
+    expect(results.every((r) => parseFloat(r.price) >= 150)).toBe(true)
+  })
+
+  it('applies less than filter (lt)', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { price: { lt: 150 } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(2)
+    expect(results.every((r) => parseFloat(r.price) < 150)).toBe(true)
+  })
+
+  it('applies less than or equal filter (lte)', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { price: { lte: 150 } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(3)
+    expect(results.every((r) => parseFloat(r.price) <= 150)).toBe(true)
+  })
+
+  it('applies range filter with gte and lte', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { price: { gte: 100, lte: 200 } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(3)
+    expect(
+      results.every(
+        (r) => parseFloat(r.price) >= 100 && parseFloat(r.price) <= 200,
+      ),
+    ).toBe(true)
+  })
+
+  it('applies case-sensitive LIKE filter', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { name: { like: '%Asset%' } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results.length).toBeGreaterThan(0)
+    expect(results.every((r) => r.name.includes('Asset'))).toBe(true)
+  })
+
+  it('applies case-insensitive ILIKE filter', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { name: { ilike: '%asset%' } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results.length).toBeGreaterThan(0)
+    expect(
+      results.every((r) =>
+        r.name.toLowerCase().includes('asset'.toLowerCase()),
+      ),
+    ).toBe(true)
+  })
+
+  it('applies isNull filter when value is true', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { deletedAt: { isNull: true } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(4)
+    expect(results.every((r) => r.deleted_at === null)).toBe(true)
+  })
+
+  it('applies isNotNull filter when isNull value is false', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { deletedAt: { isNull: false } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(1)
+    expect(results[0].deleted_at).not.toBe(null)
+  })
+
+  it('applies isNotNull filter when value is true', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { deletedAt: { isNotNull: true } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(1)
+    expect(results[0].deleted_at).not.toBe(null)
+  })
+
+  it('applies isNull filter when isNotNull value is false', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { deletedAt: { isNotNull: false } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(4)
+    expect(results.every((r) => r.deleted_at === null)).toBe(true)
+  })
+
+  it('applies multiple filters together', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: {
+        status: 'active',
+        type: 'invoice',
+        price: { gte: 100 },
+      },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(2)
+    expect(results.every((r) => r.status === 'active')).toBe(true)
+    expect(results.every((r) => r.type === 'invoice')).toBe(true)
+    expect(results.every((r) => parseFloat(r.price) >= 100)).toBe(true)
+  })
+
+  it('returns empty results when filter matches nothing', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: 'non-existing' },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(0)
+  })
+
+  it('uses qualified column names with tableName', async () => {
+    const query = db('assets').select('assets.*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: 'active' },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(3)
+    expect(results.every((r) => r.status === 'active')).toBe(true)
+  })
+
+  it('ignores unknown operators', async () => {
+    const query = db('assets').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: { unknownOperator: 'value' } },
+      tableName: 'assets',
+    })
+
+    const results = await filteredQuery
+
+    // Should return all records since unknown operator is ignored
+    expect(results).toHaveLength(5)
+  })
+
+  it('works with invoices table', async () => {
+    const query = db('invoices').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: 'paid', deletedAt: { isNull: true } },
+      tableName: 'invoices',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(2)
+    expect(results.every((r) => r.status === 'paid')).toBe(true)
+    expect(results.every((r) => r.deleted_at === null)).toBe(true)
+  })
+
+  it('works with invoices table using camelCase conversion', async () => {
+    const query = db('invoices').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: {
+        customerId: '00000000-0000-0000-0000-000000000201',
+        amount: { gte: 500 },
+      },
+      tableName: 'invoices',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(3)
+    expect(
+      results.every(
+        (r) =>
+          r.customer_id === '00000000-0000-0000-0000-000000000201' &&
+          parseFloat(r.amount) >= 500,
+      ),
+    ).toBe(true)
+  })
+
+  it('works with invoices table using IN filter', async () => {
+    const query = db('invoices').select('*')
+    const filteredQuery = applyFilter({
+      query,
+      filter: { status: ['paid', 'pending'] },
+      tableName: 'invoices',
+    })
+
+    const results = await filteredQuery
+
+    expect(results).toHaveLength(3)
+    expect(
+      results.every((r) => r.status === 'paid' || r.status === 'pending'),
+    ).toBe(true)
+  })
+})

package/tests/resources/create-im-mapp-diff.js

@@ -0,0 +1,15 @@
+import { writeFileSync } from 'fs'
+// @ts-ignore
+export const writeFilesReceiveMapped = ({ prefix, raw, unifiedMessage }) => {
+  writeFileSync(
+    `./.exclude/${prefix}.${unifiedMessage.type}.json`,
+    JSON.stringify(
+      {
+        received: raw,
+        mapped: unifiedMessage,
+      },
+      null,
+      2,
+    ),
+  )
+}

package/types/core/index.d.ts

@@ -4,6 +4,7 @@ export * from './otp-generators.js'
 export * from './sanitize-objects.js'
 export * from './normalize-min-max.js'
 export * from './normalize-to-array.js'
+export * from './parse-json-if-string.js'
 export * from './combine-unique-arrays.js'
 export * from './normalize-phone-number.js'
 export * from './normalize-array-operators.js'

package/types/core/parse-json-if-string.d.ts

@@ -0,0 +1 @@
+export function parseJsonIfString(value: any): any

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:*)"
-    ]
-  }
-}