@friggframework/core 2.0.0-next.12 → 2.0.0-next.121

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

@@ -0,0 +1,406 @@
+const { prisma } = require('../../database/prisma');
+const { MappingAlreadyExistsError } = require('../../errors');
+const {
+    toObjectId,
+    fromObjectId,
+    findMany,
+    findOne,
+    insertOne,
+    updateOne,
+    deleteOne,
+    deleteMany,
+    aggregate,
+    aggregateDrained,
+} = require('../../database/documentdb-utils');
+const {
+    IntegrationMappingRepositoryInterface,
+} = require('./integration-mapping-repository-interface');
+const {
+    DocumentDBEncryptionService,
+} = require('../../database/documentdb-encryption-service');
+const {
+    assertMappingWrittenUnencrypted,
+} = require('../../database/encryption/integration-mapping-encryption');
+const { validateMappingQuery } = require('./integration-mapping-query');
+const {
+    buildMappingQueryStages,
+} = require('./integration-mapping-query-pipeline');
+
+function storedIntegrationId(id) {
+    if (!['string', 'number'].includes(typeof id) || id === '') {
+        throw new TypeError(`Invalid ID: ${id}`);
+    }
+    return String(id);
+}
+
+class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+        this.encryptionService = new DocumentDBEncryptionService();
+    }
+
+    /**
+     * integrationId is stored as a string in DocumentDB, so ids are matched as
+     * strings (an ObjectId $in would never match). Drains the grouped cursor so
+     * a deployment-wide count is not truncated at the first batch.
+     */
+    async countByIntegrationIds(ids = []) {
+        const counts = new Map();
+        if (!ids || ids.length === 0) return counts;
+
+        const stringIds = ids.map(String);
+        const rows = await aggregateDrained(this.prisma, 'IntegrationMapping', [
+            { $match: { integrationId: { $in: stringIds } } },
+            { $group: { _id: '$integrationId', count: { $sum: 1 } } },
+        ]);
+
+        for (const row of rows) {
+            counts.set(String(row?._id), row?.count ?? 0);
+        }
+        return counts;
+    }
+
+    async findMappingBy(integrationId, sourceId) {
+        const filter = this._compositeFilter(integrationId, sourceId);
+        const doc = await findOne(this.prisma, 'IntegrationMapping', filter);
+        if (!doc) return null;
+
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            doc
+        );
+        return this._mapMapping(decryptedMapping);
+    }
+
+    async upsertMapping(integrationId, sourceId, mapping) {
+        const filter = this._compositeFilter(integrationId, sourceId);
+        const existing = await findOne(
+            this.prisma,
+            'IntegrationMapping',
+            filter
+        );
+        const now = new Date();
+
+        if (existing) {
+            const decryptedExisting =
+                await this.encryptionService.decryptFields(
+                    'IntegrationMapping',
+                    existing
+                );
+
+            const updateDocument = {
+                mapping,
+                updatedAt: now,
+            };
+
+            const encryptedUpdate = await this.encryptionService.encryptFields(
+                'IntegrationMapping',
+                { mapping: updateDocument.mapping }
+            );
+
+            await updateOne(
+                this.prisma,
+                'IntegrationMapping',
+                { _id: existing._id },
+                {
+                    $set: {
+                        mapping: encryptedUpdate.mapping,
+                        updatedAt: updateDocument.updatedAt,
+                    },
+                }
+            );
+
+            const updated = await findOne(this.prisma, 'IntegrationMapping', {
+                _id: existing._id,
+            });
+            if (!updated) {
+                console.error(
+                    '[IntegrationMappingRepositoryDocumentDB] Mapping not found after update',
+                    {
+                        mappingId: fromObjectId(existing._id),
+                        integrationId,
+                        sourceId,
+                    }
+                );
+                throw new Error(
+                    'Failed to update mapping: Document not found after update. ' +
+                        'This indicates a database consistency issue.'
+                );
+            }
+            const decryptedMapping = await this.encryptionService.decryptFields(
+                'IntegrationMapping',
+                updated
+            );
+            return this._mapMapping(decryptedMapping);
+        }
+
+        const plainDocument = {
+            integrationId: integrationId,
+            sourceId:
+                sourceId === null || sourceId === undefined
+                    ? null
+                    : String(sourceId),
+            mapping,
+            createdAt: now,
+            updatedAt: now,
+        };
+
+        const encryptedDocument = await this.encryptionService.encryptFields(
+            'IntegrationMapping',
+            plainDocument
+        );
+
+        const insertedId = await insertOne(
+            this.prisma,
+            'IntegrationMapping',
+            encryptedDocument
+        );
+
+        const created = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: insertedId,
+        });
+        if (!created) {
+            console.error(
+                '[IntegrationMappingRepositoryDocumentDB] Mapping not found after insert',
+                {
+                    insertedId: fromObjectId(insertedId),
+                    integrationId,
+                    sourceId,
+                }
+            );
+            throw new Error(
+                'Failed to create mapping: Document not found after insert. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            created
+        );
+        return this._mapMapping(decryptedMapping);
+    }
+
+    async createMapping(integrationId, sourceId, mapping) {
+        const now = new Date();
+        const encryptedDocument = await this.encryptionService.encryptFields(
+            'IntegrationMapping',
+            {
+                integrationId,
+                sourceId:
+                    sourceId === null || sourceId === undefined
+                        ? null
+                        : String(sourceId),
+                mapping,
+                createdAt: now,
+                updatedAt: now,
+            }
+        );
+
+        let insertedId;
+        try {
+            insertedId = await insertOne(
+                this.prisma,
+                'IntegrationMapping',
+                encryptedDocument
+            );
+        } catch (error) {
+            if (error.code === 11000) {
+                throw new MappingAlreadyExistsError(integrationId, sourceId, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+
+        const created = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: insertedId,
+        });
+        if (!created) {
+            throw new Error(
+                'Failed to create mapping: Document not found after insert. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        return this._mapMapping(
+            await this.encryptionService.decryptFields(
+                'IntegrationMapping',
+                created
+            )
+        );
+    }
+
+    async findMappingsByIntegration(integrationId) {
+        const filter = {};
+        if (integrationId) filter.integrationId = integrationId;
+        const docs = await findMany(this.prisma, 'IntegrationMapping', filter);
+
+        const decryptedDocs = await Promise.all(
+            docs.map((doc) =>
+                this.encryptionService.decryptFields('IntegrationMapping', doc)
+            )
+        );
+
+        return decryptedDocs.map((doc) => this._mapMapping(doc));
+    }
+
+    /**
+     * @param {string} integrationId
+     * @param {Object} query - See IntegrationMappingRepositoryInterface.queryMappings
+     * @returns {Promise<{mappings: Array<Object>, total: number}>}
+     */
+    async queryMappings(integrationId, query) {
+        const validated = validateMappingQuery(query);
+        const stored = storedIntegrationId(integrationId);
+        assertMappingWrittenUnencrypted();
+        const { match, page, sort } = buildMappingQueryStages(
+            stored,
+            validated
+        );
+
+        const [docs, counts] = await Promise.all([
+            aggregateDrained(
+                this.prisma,
+                'IntegrationMapping',
+                [match, ...page, sort],
+                { allowDiskUse: true }
+            ),
+            aggregate(this.prisma, 'IntegrationMapping', [
+                match,
+                { $count: 'total' },
+            ]),
+        ]);
+        const decryptedDocs = await Promise.all(
+            docs.map((doc) =>
+                this.encryptionService.decryptFields('IntegrationMapping', doc)
+            )
+        );
+
+        return {
+            mappings: decryptedDocs.map((doc) => this._mapMapping(doc)),
+            total: counts[0]?.total ?? 0,
+        };
+    }
+
+    async deleteMapping(integrationId, sourceId) {
+        const filter = this._compositeFilter(integrationId, sourceId);
+        const result = await deleteOne(
+            this.prisma,
+            'IntegrationMapping',
+            filter
+        );
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    async deleteMappingsByIntegration(integrationId) {
+        if (!integrationId) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        const result = await deleteMany(this.prisma, 'IntegrationMapping', {
+            integrationId: integrationId,
+        });
+        const deleted = result?.n ?? 0;
+        return { acknowledged: true, deletedCount: deleted };
+    }
+
+    async findMappingById(id) {
+        const objectId = toObjectId(id);
+        if (!objectId) return null;
+        const doc = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: objectId,
+        });
+        if (!doc) return null;
+
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            doc
+        );
+        return this._mapMapping(decryptedMapping);
+    }
+
+    async updateMapping(id, updates) {
+        const objectId = toObjectId(id);
+        if (!objectId) return null;
+
+        const existing = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: objectId,
+        });
+        if (!existing) return null;
+
+        const decryptedExisting = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            existing
+        );
+
+        const mergedMapping =
+            updates.mapping !== undefined
+                ? updates.mapping
+                : decryptedExisting.mapping;
+
+        const updateDocument = {
+            ...updates,
+            updatedAt: new Date(),
+        };
+
+        if (mergedMapping !== undefined) {
+            const encryptedUpdate = await this.encryptionService.encryptFields(
+                'IntegrationMapping',
+                { mapping: mergedMapping }
+            );
+            updateDocument.mapping = encryptedUpdate.mapping;
+        }
+
+        await updateOne(
+            this.prisma,
+            'IntegrationMapping',
+            { _id: objectId },
+            {
+                $set: updateDocument,
+            }
+        );
+
+        const updated = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: objectId,
+        });
+        if (!updated) {
+            console.error(
+                '[IntegrationMappingRepositoryDocumentDB] Mapping not found after update',
+                {
+                    mappingId: fromObjectId(objectId),
+                }
+            );
+            throw new Error(
+                'Failed to update mapping: Document not found after update. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            updated
+        );
+        return this._mapMapping(decryptedMapping);
+    }
+
+    _compositeFilter(integrationId, sourceId) {
+        const filter = {};
+        if (integrationId) filter.integrationId = integrationId;
+        if (sourceId !== undefined) {
+            filter.sourceId = sourceId === null ? null : String(sourceId);
+        }
+        return filter;
+    }
+
+    _mapMapping(doc) {
+        return {
+            id: fromObjectId(doc?._id),
+            integrationId: doc?.integrationId ?? null,
+            sourceId: doc?.sourceId ?? null,
+            mapping: doc?.mapping ?? null,
+            createdAt: doc?.createdAt,
+            updatedAt: doc?.updatedAt,
+        };
+    }
+}
+
+module.exports = { IntegrationMappingRepositoryDocumentDB };

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

@@ -0,0 +1,57 @@
+const {
+    IntegrationMappingRepositoryMongo,
+} = require('./integration-mapping-repository-mongo');
+const {
+    IntegrationMappingRepositoryPostgres,
+} = require('./integration-mapping-repository-postgres');
+const {
+    IntegrationMappingRepositoryDocumentDB,
+} = require('./integration-mapping-repository-documentdb');
+const config = require('../../database/config');
+
+/**
+ * Integration Mapping Repository Factory
+ * Creates the appropriate repository adapter based on database type
+ *
+ * Database-specific implementations:
+ * - MongoDB: Uses String IDs (ObjectId), no conversion needed
+ * - PostgreSQL: Uses Int IDs, converts String ↔ Int
+ *
+ * All repository methods return String IDs regardless of database type,
+ * ensuring application layer consistency.
+ *
+ * Usage:
+ * ```javascript
+ * const repository = createIntegrationMappingRepository();
+ * const mapping = await repository.findMappingBy(integrationId, sourceId);
+ * ```
+ *
+ * @returns {IntegrationMappingRepositoryInterface} Configured repository adapter
+ */
+function createIntegrationMappingRepository() {
+    const dbType = config.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new IntegrationMappingRepositoryMongo();
+
+        case 'postgresql':
+            return new IntegrationMappingRepositoryPostgres();
+
+        case 'documentdb':
+            return new IntegrationMappingRepositoryDocumentDB();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createIntegrationMappingRepository,
+    // Export adapters for direct testing
+    IntegrationMappingRepositoryMongo,
+    IntegrationMappingRepositoryPostgres,
+    IntegrationMappingRepositoryDocumentDB,
+};

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

@@ -0,0 +1,183 @@
+/**
+ * Integration Mapping Repository Interface
+ * Abstract base class defining the contract for integration mapping persistence adapters
+ *
+ * This follows the Port in Hexagonal Architecture:
+ * - Domain layer depends on this abstraction
+ * - Concrete adapters implement this interface
+ * - Use cases receive repositories via dependency injection
+ *
+ * Note: Currently, IntegrationMapping model has identical structure across MongoDB and PostgreSQL,
+ * so IntegrationMappingRepository serves both. This interface exists for consistency and
+ * future-proofing if database-specific implementations become needed.
+ *
+ * @abstract
+ */
+class IntegrationMappingRepositoryInterface {
+    /**
+     * Find mapping by integration ID and source ID
+     *
+     * @param {string|number} integrationId - The integration ID
+     * @param {string} sourceId - The source ID for lookup
+     * @returns {Promise<Object|null>} The mapping object or null
+     * @abstract
+     */
+    async findMappingBy(integrationId, sourceId) {
+        throw new Error('Method findMappingBy must be implemented by subclass');
+    }
+
+    /**
+     * Create or update a mapping
+     *
+     * @param {string|number} integrationId - The integration ID
+     * @param {string} sourceId - The source ID for lookup
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created or updated mapping document
+     * @abstract
+     */
+    async upsertMapping(integrationId, sourceId, mapping) {
+        throw new Error('Method upsertMapping must be implemented by subclass');
+    }
+
+    /**
+     * Insert a mapping, failing if one already exists for the
+     * (integrationId, sourceId) pair. Atomic: usable as a claim/lock row.
+     *
+     * @param {string|number} integrationId - The integration ID
+     * @param {string} sourceId - The source ID for lookup
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created mapping document
+     * @throws {MappingAlreadyExistsError} If the pair already exists
+     * @abstract
+     */
+    async createMapping(integrationId, sourceId, mapping) {
+        throw new Error('createMapping must be implemented by subclass');
+    }
+
+    /**
+     * Find all mappings for an integration
+     *
+     * @param {string|number} integrationId - The integration ID
+     * @returns {Promise<Array>} Array of mapping objects
+     * @abstract
+     */
+    async findMappingsByIntegration(integrationId) {
+        throw new Error(
+            'Method findMappingsByIntegration must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Query one filtered, ordered page of an integration's mappings without
+     * loading every row. Rows have the same shape as findMappingsByIntegration
+     * and are decrypted the same way.
+     *
+     * Paths address the `mapping` JSON by identifier-only segments
+     * (`'mapping.outbound.status'`), 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; 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 whose
+     * whole `mapping` is still ciphertext from before an encryption opt-out
+     * never do. A nested path still encrypted from before its opt-out comes
+     * back plain, but conditions and orderBy on it see the ciphertext.
+     * 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). 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.
+     *   Values order string < number < boolean < array < object. Strings
+     *   compare by the database collation on PostgreSQL and by code point on
+     *   MongoDB and DocumentDB; arrays and objects order among themselves
+     *   only on PostgreSQL. Without it rows are ordered by id ascending.
+     * @param {number} [query.skip=0] - Rows to skip (integer ≥ 0)
+     * @param {number} query.take - Page size (integer 1–500)
+     * @param {string[]} [query.omit=[]] - Top-level mapping keys to leave out of
+     *   the returned rows; such projected rows must not be written back
+     * @returns {Promise<{mappings: Array<Object>, total: number}>} The page, and
+     *   the number of rows matching `where` (counted by a separate command on
+     *   DocumentDB, so not from the page's snapshot)
+     */
+    async queryMappings(integrationId, query) {
+        throw new Error(
+            'queryMappings is not supported by this database adapter yet'
+        );
+    }
+
+    /**
+     * Delete a specific mapping
+     *
+     * @param {string|number} integrationId - The integration ID
+     * @param {string} sourceId - The source ID
+     * @returns {Promise<Object>} Deletion result
+     * @abstract
+     */
+    async deleteMapping(integrationId, sourceId) {
+        throw new Error('Method deleteMapping must be implemented by subclass');
+    }
+
+    /**
+     * Delete all mappings for an integration
+     *
+     * @param {string|number} integrationId - The integration ID
+     * @returns {Promise<Object>} Deletion result
+     * @abstract
+     */
+    async deleteMappingsByIntegration(integrationId) {
+        throw new Error(
+            'Method deleteMappingsByIntegration must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Count mappings grouped by integration id, for a bounded set of ids.
+     * Adapters must drain the full grouped result (a deployment can have more
+     * than one first-batch of distinct integration ids).
+     *
+     * @returns {Promise<Map<string, number>>} Map of integrationId (string) → count
+     * @abstract
+     */
+    async countByIntegrationIds(ids) {
+        throw new Error(
+            'Method countByIntegrationIds must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find mapping by ID
+     *
+     * @param {string|number} id - The mapping ID
+     * @returns {Promise<Object|null>} The mapping object or null
+     * @abstract
+     */
+    async findMappingById(id) {
+        throw new Error(
+            'Method findMappingById must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Update a mapping by ID
+     *
+     * @param {string|number} id - The mapping ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Updated mapping object
+     * @abstract
+     */
+    async updateMapping(id, updates) {
+        throw new Error('Method updateMapping must be implemented by subclass');
+    }
+}
+
+module.exports = { IntegrationMappingRepositoryInterface };