@friggframework/core 2.0.0--canary.651.4e19d0f.0 → 2.0.0--canary.651.87132bf.0

package/integrations/repositories/integration-mapping-query.js

@@ -9,6 +9,8 @@
 
 const SEGMENT_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const MAX_TAKE = 500;
+const MAX_IN_VALUES = 500;
+const MAX_CONDITIONS = 20;
 const SQL_DIRECTIONS = { asc: 'ASC', desc: 'DESC' };
 
 const OPS_BY_FIELD = {
@@ -41,8 +43,19 @@ function validateMappingQuery(query) {
         );
     }
 
+    const whereEntries = where.map(toWhereEntry);
+    const conditionCount = whereEntries.reduce(
+        (count, entry) => count + (entry.anyOf ? entry.anyOf.length : 1),
+        0
+    );
+    if (conditionCount > MAX_CONDITIONS) {
+        throw new Error(
+            `queryMappings: where must have at most ${MAX_CONDITIONS} conditions, anyOf members included`
+        );
+    }
+
     return {
-        where: where.map(toWhereEntry),
+        where: whereEntries,
         orderBy: orderBy === undefined ? null : toOrderBy(orderBy),
         skip,
         take,
@@ -118,6 +131,11 @@ function toCondition({ path, op, value }) {
                 `queryMappings: 'in' value must be a non-empty array of strings on '${path}'`
             );
         }
+        if (value.length > MAX_IN_VALUES) {
+            throw new Error(
+                `queryMappings: 'in' value must have at most ${MAX_IN_VALUES} strings on '${path}'`
+            );
+        }
         return { field, segments, op, value };
     }
 

package/integrations/repositories/integration-mapping-repository-interface.js

@@ -56,24 +56,32 @@ class IntegrationMappingRepositoryInterface {
      * Query one filtered, ordered page of an integration's mappings without
      * loading every row. Rows have the same shape as findMappingsByIntegration.
      *
+     * Cost: each call is O(rows of the integration × mapping size) in the
+     * database, because JSON paths are evaluated per row and no JSON index
+     * exists. That is fine at ~10⁴ rows per integration and takes seconds per
+     * call at 10⁵+.
+     *
      * Paths address the `mapping` JSON by identifier-only segments
      * (`'mapping.c2h.lastStatus'`), or the `sourceId` column. Conditions:
      * - `{ path: 'mapping.…', op: 'exists' | 'notExists' }` — JSON null counts
      *   as absent; notExists is the exact negation of exists.
-     * - `{ path: 'mapping.…', op: 'in', value: string[] }` — matches JSON strings.
+     * - `{ path: 'mapping.…', op: 'in', value: string[] }` — matches JSON
+     *   strings; 1–500 values.
      * - `{ path: 'sourceId', op: 'notStartsWith', value: string }` — a NULL
      *   sourceId matches.
      *
-     * Only rows whose `mapping` is a JSON object can match, so rows still
-     * holding ciphertext from before an encryption opt-out never do. Adapters
-     * refuse to run while field-level encryption is enabled and still encrypts
-     * `mapping` on write; opt out with
-     * `appDefinition.encryption.disable = { IntegrationMapping: ['mapping'] }`.
+     * Only rows whose `mapping` is a JSON object can match, so rows whose
+     * whole `mapping` is still ciphertext from before an encryption opt-out
+     * never do. Adapters refuse to run while field-level encryption is enabled
+     * and still encrypts `mapping`, or a path inside it, on write; opt out with
+     * `appDefinition.encryption.disable = { IntegrationMapping: ['mapping'] }`
+     * plus any nested `mapping.…` path a custom schema encrypts.
      *
      * @param {string|number} integrationId - The integration ID
      * @param {Object} query
      * @param {Array<Object>} [query.where=[]] - Conditions ANDed together; an
-     *   entry may be `{ anyOf: Condition[] }` (one level, ORed)
+     *   entry may be `{ anyOf: Condition[] }` (one level, ORed). At most 20
+     *   conditions, anyOf members included.
      * @param {{path: string, direction: 'asc'|'desc'}} [query.orderBy] - A
      *   mapping path; nulls last, ties broken by id in the same direction.
      *   Without it rows are ordered by id ascending.

package/integrations/repositories/integration-mapping-repository-postgres.js

@@ -9,6 +9,11 @@ const {
 const { strictIntId } = require('./report-id');
 const { validateMappingQuery } = require('./integration-mapping-query');
 
+const encryptedMappingFields = () =>
+    getFieldsToEncryptOnWrite('IntegrationMapping').filter(
+        (field) => field === 'mapping' || field.startsWith('mapping.')
+    );
+
 /**
  * PostgreSQL Integration Mapping Repository Adapter
  * Handles persistence of integration mappings used for data transformation
@@ -222,8 +227,10 @@ class IntegrationMappingRepositoryPostgres extends IntegrationMappingRepositoryI
     }
 
     /**
-     * Query one page of an integration's mappings in a single round trip,
-     * filtering and ordering inside Postgres instead of loading every row.
+     * Query one page of an integration's mappings, filtering and ordering
+     * inside Postgres instead of loading every row. The total rides on the
+     * page as a window count, so one statement reads the matching rows once;
+     * only an empty page after the first needs a second, count-only statement.
      *
      * The SQL text is fixed: every caller value, JSON paths included (as
      * text[]), is a positional parameter, and the sort direction comes from
@@ -259,47 +266,70 @@ class IntegrationMappingRepositoryPostgres extends IntegrationMappingRepositoryI
         const orderSql = orderBy ? this._orderSql(orderBy, bind) : `"id" ASC`;
 
         const pageSql = `
-            SELECT "id", "integrationId", "sourceId", ${mappingSql}, "createdAt", "updatedAt"
+            SELECT "id", "integrationId", "sourceId", ${mappingSql}, "createdAt", "updatedAt",
+                (COUNT(*) OVER ())::int AS "__total"
             FROM "IntegrationMapping"
             WHERE ${whereSql}
             ORDER BY ${orderSql}
             OFFSET ${bind(skip)}::bigint
             LIMIT ${bind(take)}::int
         `;
-        const countSql = `
-            SELECT COUNT(*)::int AS "total"
-            FROM "IntegrationMapping"
-            WHERE ${whereSql}
-        `;
-
-        const [rows, countRows] = await Promise.all([
-            this.prisma.$queryRawUnsafe(pageSql, ...params),
-            this.prisma.$queryRawUnsafe(countSql, ...whereParams),
-        ]);
+        const rows = await this.prisma.$queryRawUnsafe(pageSql, ...params);
 
         return {
-            mappings: rows.map((row) => this._convertMappingIds(row)),
-            total: countRows[0].total,
+            mappings: rows.map((row) => {
+                const mapping = this._convertMappingIds(row);
+                delete mapping.__total;
+                return mapping;
+            }),
+            total: await this._totalMatches(rows, skip, whereSql, whereParams),
         };
     }
 
     /**
-     * queryMappings reads the stored JSON, so it needs `mapping` written as
-     * plain JSON. The app's opt-out (`encryption.disable`) is registered
-     * lazily, when the Prisma client is created, so load it before deciding.
+     * An empty page is either past the end (count again) or, at skip 0,
+     * proof that nothing matches.
+     * @private
+     */
+    async _totalMatches(pageRows, skip, whereSql, whereParams) {
+        if (pageRows.length > 0) return pageRows[0].__total;
+        if (skip === 0) return 0;
+
+        const [{ total }] = await this.prisma.$queryRawUnsafe(
+            `SELECT COUNT(*)::int AS "total" FROM "IntegrationMapping" WHERE ${whereSql}`,
+            ...whereParams
+        );
+        return total;
+    }
+
+    /**
+     * queryMappings reads the stored JSON, so it needs `mapping`, and every
+     * path inside it, written as plain JSON. The app's opt-out
+     * (`encryption.disable`) is registered lazily, when the Prisma client is
+     * created, so load it before deciding. The stage, the keys and the app
+     * definition do not change at runtime, so a passed check is kept.
      * @private
      */
     _assertMappingWrittenUnencrypted() {
-        if (!getEncryptionConfig().enabled) return;
-
-        const encryptsMapping = () =>
-            getFieldsToEncryptOnWrite('IntegrationMapping').includes('mapping');
-        if (encryptsMapping()) loadCustomEncryptionSchema();
-        if (encryptsMapping()) {
-            throw new Error(
-                "queryMappings: field-level encryption still encrypts IntegrationMapping.mapping on write, so it cannot be queried. Opt out with appDefinition.encryption.disable = { IntegrationMapping: ['mapping'] }."
-            );
+        if (this._mappingWrittenUnencrypted) return;
+
+        if (getEncryptionConfig().enabled) {
+            if (encryptedMappingFields().length > 0) {
+                loadCustomEncryptionSchema();
+            }
+            const fields = encryptedMappingFields();
+            if (fields.length > 0) {
+                const encrypted = fields
+                    .map((field) => `IntegrationMapping.${field}`)
+                    .join(', ');
+                const optOut = fields.map((field) => `'${field}'`).join(', ');
+                throw new Error(
+                    `queryMappings: field-level encryption still encrypts ${encrypted} on write, so it cannot be queried. Opt out by adding ${optOut} to appDefinition.encryption.disable.IntegrationMapping.`
+                );
+            }
         }
+
+        this._mappingWrittenUnencrypted = true;
     }
 
     /**

package/integrations/repositories/integration-mapping-repository.js

@@ -82,6 +82,17 @@ class IntegrationMappingRepository extends IntegrationMappingRepositoryInterface
         });
     }
 
+    /**
+     * Not implemented on this legacy repository; the adapters from
+     * createIntegrationMappingRepository() support it.
+     * @throws {Error} Always
+     */
+    async queryMappings() {
+        throw new Error(
+            'queryMappings is not supported on the legacy IntegrationMappingRepository; use createIntegrationMappingRepository()'
+        );
+    }
+
     /**
      * Delete a mapping by integration and source ID
      * Replaces: IntegrationMapping.deleteOne({ integration, sourceId })

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.651.4e19d0f.0",
+    "version": "2.0.0--canary.651.87132bf.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -48,9 +48,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.651.4e19d0f.0",
-        "@friggframework/prettier-config": "2.0.0--canary.651.4e19d0f.0",
-        "@friggframework/test": "2.0.0--canary.651.4e19d0f.0",
+        "@friggframework/eslint-config": "2.0.0--canary.651.87132bf.0",
+        "@friggframework/prettier-config": "2.0.0--canary.651.87132bf.0",
+        "@friggframework/test": "2.0.0--canary.651.87132bf.0",
         "@prisma/client": "^6.19.3",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -90,5 +90,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "4e19d0f11b1d80079f6bf39531050ca23f5684a9"
+    "gitHead": "87132bf8f734ff6733c582630a606170e86a5dc2"
 }