@friggframework/core 2.0.0--canary.690.08cd07e.0 → 2.0.0--canary.694.f66a64a.0

package/database/documentdb-utils.js

@@ -25,6 +25,8 @@ async function findMany(client, collection, filter = {}, options = {}) {
     if (options.projection) command.projection = options.projection;
     if (options.sort) command.sort = options.sort;
     if (options.limit) command.limit = options.limit;
+    // The first batch holds 101 documents unless asked for more; a page wants all of its rows.
+    if (options.batchSize) command.batchSize = options.batchSize;
     const result = await client.$runCommandRaw(command);
     return result?.cursor?.firstBatch || [];
 }
@@ -58,8 +60,6 @@ async function insertOne(client, collection, document) {
 
         // Provide helpful context for common errors
         if (error.code === 11000) {
-            // `code` lets callers recognise a lost race without parsing text
-            // (see database/unique-violation.js).
             throw Object.assign(
                 new Error(`${errorMsg} - Duplicate key violation`),
                 { code: 11000 }

package/database/encryption/encryption-schema-registry.js

@@ -39,12 +39,6 @@ const CORE_ENCRYPTION_SCHEMA = {
     Token: {
         fields: ['token'],
     },
-
-    // Multi-step authorization (Management API v2): earlier steps can collect
-    // emails, usernames or one-time codes.
-    AuthorizationSession: {
-        fields: ['stepData'],
-    },
 };
 
 let customSchema = {};
@@ -180,13 +174,6 @@ function loadModuleEncryptionSchemas(integrations) {
         return;
     }
 
-    // NOTE: this path does not exist ('../integrations' resolves to
-    // database/integrations), so today this function throws MODULE_NOT_FOUND,
-    // loadCustomEncryptionSchema swallows it, and module credentialFields are
-    // effectively NOT registered. Fixing it changes which fields are encrypted
-    // and needs a decrypt that tolerates plaintext, so it ships separately:
-    // branch claude/internal-mcp-03b-module-credential-encryption. Left as is
-    // here on purpose (ADR-059 must not change what gets encrypted).
     const { getModulesDefinitionFromIntegrationClasses } = require('../integrations/utils/map-integration-dto');
 
     const moduleDefinitions = getModulesDefinitionFromIntegrationClasses(integrations);
@@ -218,80 +205,22 @@ function loadModuleEncryptionSchemas(integrations) {
  *
  * Used by both Prisma (MongoDB/PostgreSQL) and DocumentDB encryption services.
  */
-/**
- * Registers encryption schemas declared by app-level extensions
- * (`appDefinition.coreExtensions[].encryption`), e.g. the db-credentials
- * extension's `OAuthAppCredential.clientSecret`.
- *
- * @param {Array<Object>} extensions - Normalized extensions (extension-loader)
- */
-function loadExtensionEncryptionSchemas(extensions) {
-    if (!extensions || !Array.isArray(extensions) || extensions.length === 0) {
-        return;
-    }
-
-    for (const ext of extensions) {
-        if (!ext.encryption || typeof ext.encryption !== 'object') {
-            continue;
-        }
-
-        const schema = {};
-        for (const [modelName, config] of Object.entries(ext.encryption)) {
-            if (config && Array.isArray(config.fields) && config.fields.length > 0) {
-                schema[modelName] = { fields: config.fields };
-            }
-        }
+function loadCustomEncryptionSchema() {
+    try {
+        // Lazy require to avoid circular dependency issues
+        const path = require('node:path');
+        const { findNearestBackendPackageJson } = require('../../utils');
 
-        if (Object.keys(schema).length > 0) {
-            logger.info(
-                `Registering encryption schema from extension "${ext.name}" for models: ${Object.keys(schema).join(', ')}`
-            );
-            // registerCustomSchema replaces the registered schema, so merge:
-            // an extension adds its models to the app's encryption.schema
-            // rather than dropping it.
-            const merged = { ...customSchema };
-            for (const [modelName, config] of Object.entries(schema)) {
-                const existing = merged[modelName]?.fields || [];
-                merged[modelName] = {
-                    ...merged[modelName],
-                    fields: [...new Set([...existing, ...config.fields])],
-                };
-            }
-            registerCustomSchema(merged);
+        const backendPackagePath = findNearestBackendPackageJson();
+        if (!backendPackagePath) {
+            return; // No backend found, skip custom schema
         }
-    }
-}
 
-function readAppDefinitionForEncryption() {
-    // Lazy require to avoid circular dependency issues
-    const {
-        getPresetAppDefinition,
-    } = require('../../handlers/app-definition-loader');
-    // A definition preset with setAppDefinition() (provider-netlify's
-    // preamble) wins: on Netlify process.cwd() cannot find the backend.
-    const preset = getPresetAppDefinition();
-    if (preset) {
-        return preset;
-    }
-
-    const path = require('node:path');
-    const { findNearestBackendPackageJson } = require('../../utils');
-
-    const backendPackagePath = findNearestBackendPackageJson();
-    if (!backendPackagePath) {
-        return null; // No backend found, skip custom schema
-    }
+        const backendDir = path.dirname(backendPackagePath);
+        const backendIndexPath = path.join(backendDir, 'index.js');
 
-    const backendDir = path.dirname(backendPackagePath);
-    const backendIndexPath = path.join(backendDir, 'index.js');
-
-    const backendModule = require(backendIndexPath);
-    return backendModule?.Definition || null;
-}
-
-function loadCustomEncryptionSchema() {
-    try {
-        const appDefinition = readAppDefinitionForEncryption();
+        const backendModule = require(backendIndexPath);
+        const appDefinition = backendModule?.Definition;
 
         if (!appDefinition) {
             return; // No app definition found
@@ -311,15 +240,6 @@ function loadCustomEncryptionSchema() {
             registerEncryptionOptOut(disable);
         }
 
-        // Load app-level extension encryption schemas. Before the module
-        // schemas: loadModuleEncryptionSchemas currently throws (see the
-        // NOTE inside it) and the throw would skip anything after it.
-        const { loadExtensions } = require('../../extensions/extension-loader');
-        const extensions = loadExtensions(appDefinition);
-        if (extensions.length > 0) {
-            loadExtensionEncryptionSchemas(extensions);
-        }
-
         // Load module-level encryption schemas from integrations
         const integrations = appDefinition.integrations;
         if (integrations && Array.isArray(integrations)) {
@@ -476,7 +396,6 @@ module.exports = {
     registerEncryptionOptOut,
     loadCustomEncryptionSchema,
     loadModuleEncryptionSchemas,
-    loadExtensionEncryptionSchemas,
     extractCredentialFieldsFromModules,
     validateCustomSchema,
     validateOptOut,

package/database/prisma.js

@@ -67,15 +67,13 @@ const prismaClientSingleton = () => {
         const paths = [
             // Lambda layer location (when using Prisma Lambda layer)
             `/opt/nodejs/node_modules/generated/prisma-${dbType}`,
-            // __dirname-based absolute path (Netlify functions and bundlers)
-            require('node:path').resolve(__dirname, `../generated/prisma-${dbType}`),
             // Local development location (relative to core package)
             `../generated/prisma-${dbType}`,
         ];
 
-        for (const candidate of paths) {
+        for (const path of paths) {
             try {
-                return require(candidate).PrismaClient;
+                return require(path).PrismaClient;
             } catch (err) {
                 // Continue to next path
             }

package/errors/index.js

@@ -6,6 +6,9 @@ const {
     ParameterTypeError,
 } = require('./validation-errors');
 const { ClientSafeError } = require('./client-safe-error');
+const {
+    MappingAlreadyExistsError,
+} = require('./mapping-already-exists-error');
 
 module.exports = {
     BaseError,
@@ -14,4 +17,5 @@ module.exports = {
     RequiredPropertyError,
     ParameterTypeError,
     ClientSafeError,
+    MappingAlreadyExistsError,
 };

package/errors/mapping-already-exists-error.js

@@ -0,0 +1,14 @@
+const { BaseError } = require('./base-error');
+
+class MappingAlreadyExistsError extends BaseError {
+    constructor(integrationId, sourceId, ...errorOptions) {
+        super(
+            `Mapping already exists for integration ${integrationId} and sourceId ${sourceId}`,
+            ...errorOptions
+        );
+        this.integrationId = integrationId;
+        this.sourceId = sourceId;
+    }
+}
+
+module.exports = { MappingAlreadyExistsError };