@friggframework/core 2.0.0--canary.461.5ebf96a.0 → 2.0.0--canary.461.6c79fb2.0

package/database/prisma.js

@@ -201,6 +201,15 @@ async function disconnectPrisma() {
 
 async function connectPrisma() {
     await getPrismaClient().$connect();
+
+    // Initialize MongoDB schema - ensure all collections exist
+    // Only run for MongoDB/DocumentDB (not PostgreSQL)
+    // This prevents "Cannot create namespace in multi-document transaction" errors
+    if (config.DB_TYPE === 'mongodb') {
+        const { initializeMongoDBSchema } = require('./utils/mongodb-schema-init');
+        await initializeMongoDBSchema();
+    }
+
     return getPrismaClient();
 }
 

package/database/repositories/health-check-repository-mongodb.js

@@ -38,6 +38,9 @@ class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
     }
 
     async createCredential(credentialData) {
+        // Note: Collection existence is ensured at application startup via
+        // initializeMongoDBSchema() in database/utils/mongodb-schema-init.js
+        // This prevents "Cannot create namespace in multi-document transaction" errors
         return await prisma.credential.create({
             data: credentialData,
         });

package/database/utils/mongodb-collection-utils.js

@@ -0,0 +1,91 @@
+/**
+ * MongoDB Collection Utilities
+ *
+ * Provides utilities for managing MongoDB collections, particularly for
+ * handling the constraint that collections cannot be created inside
+ * multi-document transactions.
+ *
+ * @see https://github.com/prisma/prisma/issues/8305
+ * @see https://www.mongodb.com/docs/manual/core/transactions/#transactions-and-operations
+ */
+
+const { mongoose } = require('../mongoose');
+
+/**
+ * Ensures a MongoDB collection exists
+ *
+ * MongoDB doesn't allow creating collections (namespaces) inside multi-document
+ * transactions. This function checks if a collection exists and creates it if needed,
+ * preventing "Cannot create namespace in multi-document transaction" errors.
+ *
+ * @param {string} collectionName - Name of the collection to ensure exists
+ * @returns {Promise<void>}
+ *
+ * @example
+ * ```js
+ * await ensureCollectionExists('Credential');
+ * // Now safe to create documents in Credential collection
+ * await prisma.credential.create({ data: {...} });
+ * ```
+ */
+async function ensureCollectionExists(collectionName) {
+    try {
+        const collections = await mongoose.connection.db
+            .listCollections({ name: collectionName })
+            .toArray();
+
+        if (collections.length === 0) {
+            // Collection doesn't exist, create it outside of any transaction
+            await mongoose.connection.db.createCollection(collectionName);
+            console.log(`Created MongoDB collection: ${collectionName}`);
+        }
+    } catch (error) {
+        // Collection might already exist due to race condition, or other error
+        // Log warning but don't fail - let subsequent operations handle errors
+        if (error.codeName === 'NamespaceExists') {
+            // This is expected in race conditions, silently continue
+            return;
+        }
+        console.warn(`Error ensuring collection ${collectionName} exists:`, error.message);
+    }
+}
+
+/**
+ * Ensures multiple MongoDB collections exist
+ *
+ * @param {string[]} collectionNames - Array of collection names to ensure exist
+ * @returns {Promise<void>}
+ *
+ * @example
+ * ```js
+ * await ensureCollectionsExist(['Credential', 'User', 'Token']);
+ * ```
+ */
+async function ensureCollectionsExist(collectionNames) {
+    await Promise.all(collectionNames.map(name => ensureCollectionExists(name)));
+}
+
+/**
+ * Checks if a collection exists in MongoDB
+ *
+ * @param {string} collectionName - Name of the collection to check
+ * @returns {Promise<boolean>} True if collection exists, false otherwise
+ */
+async function collectionExists(collectionName) {
+    try {
+        const collections = await mongoose.connection.db
+            .listCollections({ name: collectionName })
+            .toArray();
+
+        return collections.length > 0;
+    } catch (error) {
+        console.error(`Error checking if collection ${collectionName} exists:`, error.message);
+        return false;
+    }
+}
+
+module.exports = {
+    ensureCollectionExists,
+    ensureCollectionsExist,
+    collectionExists,
+};

package/database/utils/mongodb-schema-init.js

@@ -0,0 +1,106 @@
+/**
+ * MongoDB Schema Initialization for Prisma
+ *
+ * Dynamically parses the Prisma schema and ensures all collections exist before
+ * the application starts handling requests. This prevents
+ * "Cannot create namespace in multi-document transaction" errors.
+ *
+ * MongoDB does not allow creating collections inside transactions.
+ * By pre-creating all collections at startup, we ensure all Prisma
+ * operations can safely use transactions without namespace creation errors.
+ *
+ * Collection names are extracted dynamically from the Prisma schema file,
+ * ensuring they stay in sync with schema changes without manual updates.
+ *
+ * @see https://github.com/prisma/prisma/issues/8305
+ * @see https://www.mongodb.com/docs/manual/core/transactions/#transactions-and-operations
+ */
+
+const { mongoose } = require('../mongoose');
+const { ensureCollectionsExist } = require('./mongodb-collection-utils');
+const { getCollectionsFromSchemaSync } = require('./prisma-schema-parser');
+const config = require('../config');
+
+/**
+ * Initialize MongoDB schema by ensuring all collections exist
+ *
+ * This should be called once at application startup, after the database
+ * connection is established but before handling any requests.
+ *
+ * Dynamically parses the Prisma schema to extract collection names,
+ * ensuring automatic sync with schema changes.
+ *
+ * Benefits:
+ * - Prevents transaction namespace creation errors
+ * - Fails fast if there are database connection issues
+ * - Ensures consistent state across all instances
+ * - Idempotent - safe to run multiple times
+ * - Automatically syncs with Prisma schema changes
+ *
+ * @returns {Promise<void>}
+ *
+ * @example
+ * ```js
+ * await connectPrisma();
+ * await initializeMongoDBSchema(); // Run after connection
+ * // Now safe to handle requests
+ * ```
+ */
+async function initializeMongoDBSchema() {
+    // Only run for MongoDB
+    if (config.DB_TYPE !== 'mongodb') {
+        console.log('Schema initialization skipped - not using MongoDB');
+        return;
+    }
+
+    // Check if database is connected
+    if (mongoose.connection.readyState !== 1) {
+        throw new Error(
+            'Cannot initialize MongoDB schema - database not connected. ' +
+            'Call connectPrisma() before initializeMongoDBSchema()'
+        );
+    }
+
+    console.log('Initializing MongoDB schema - ensuring all collections exist...');
+    const startTime = Date.now();
+
+    try {
+        // Dynamically parse Prisma schema to get collection names
+        const collections = getCollectionsFromSchemaSync();
+
+        if (collections.length === 0) {
+            console.warn('No collections found in Prisma schema - skipping initialization');
+            return;
+        }
+
+        await ensureCollectionsExist(collections);
+
+        const duration = Date.now() - startTime;
+        console.log(
+            `MongoDB schema initialization complete - ${collections.length} collections verified (${duration}ms)`
+        );
+    } catch (error) {
+        console.error('Failed to initialize MongoDB schema:', error.message);
+        throw error;
+    }
+}
+
+/**
+ * Get list of Prisma collection names by parsing the schema
+ * Useful for testing and introspection
+ *
+ * @returns {string[]} Array of collection names from Prisma schema
+ */
+function getPrismaCollections() {
+    try {
+        return getCollectionsFromSchemaSync();
+    } catch (error) {
+        console.warn('Could not parse Prisma collections:', error.message);
+        return [];
+    }
+}
+
+module.exports = {
+    initializeMongoDBSchema,
+    getPrismaCollections,
+};

package/database/utils/prisma-schema-parser.js

@@ -0,0 +1,182 @@
+/**
+ * Prisma Schema Parser for MongoDB Collections
+ *
+ * Dynamically parses the Prisma schema file to extract MongoDB collection names.
+ * This ensures collection names stay in sync with the schema without hardcoding.
+ *
+ * Handles:
+ * - @@map() directives (custom collection names)
+ * - Models without @@map() (uses model name)
+ * - Comments and whitespace
+ * - Multiple schema file locations
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse Prisma schema file to extract collection names
+ *
+ * Reads the schema.prisma file and extracts all model definitions,
+ * returning the actual MongoDB collection names (from @@map directives).
+ *
+ * @param {string} schemaPath - Path to schema.prisma file
+ * @returns {Promise<string[]>} Array of collection names
+ *
+ * @example
+ * ```js
+ * const collections = await parseCollectionsFromSchema('./prisma/schema.prisma');
+ * // Returns: ['User', 'Token', 'Credential', ...]
+ * ```
+ */
+async function parseCollectionsFromSchema(schemaPath) {
+    try {
+        const schemaContent = await fs.promises.readFile(schemaPath, 'utf-8');
+        return extractCollectionNames(schemaContent);
+    } catch (error) {
+        throw new Error(
+            `Failed to parse Prisma schema at ${schemaPath}: ${error.message}`
+        );
+    }
+}
+
+/**
+ * Synchronous version of parseCollectionsFromSchema
+ *
+ * @param {string} schemaPath - Path to schema.prisma file
+ * @returns {string[]} Array of collection names
+ */
+function parseCollectionsFromSchemaSync(schemaPath) {
+    try {
+        const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+        return extractCollectionNames(schemaContent);
+    } catch (error) {
+        throw new Error(
+            `Failed to parse Prisma schema at ${schemaPath}: ${error.message}`
+        );
+    }
+}
+
+/**
+ * Extract collection names from Prisma schema content
+ *
+ * Parses the schema content to find:
+ * 1. All model definitions
+ * 2. Their @@map() directives (if present)
+ * 3. Falls back to model name if no @@map()
+ *
+ * @param {string} schemaContent - Content of schema.prisma file
+ * @returns {string[]} Array of collection names
+ * @private
+ */
+function extractCollectionNames(schemaContent) {
+    const collections = [];
+
+    // Match model blocks: "model ModelName { ... }"
+    // Using non-greedy match to handle multiple models
+    const modelRegex = /model\s+(\w+)\s*\{([^}]+)\}/g;
+
+    let match;
+    while ((match = modelRegex.exec(schemaContent)) !== null) {
+        const modelName = match[1];
+        const modelBody = match[2];
+
+        // Look for @@map("CollectionName") directive
+        const mapMatch = modelBody.match(/@@map\s*\(\s*["'](\w+)["']\s*\)/);
+
+        if (mapMatch) {
+            // Use mapped collection name
+            collections.push(mapMatch[1]);
+        } else {
+            // Use model name as collection name (Prisma default)
+            collections.push(modelName);
+        }
+    }
+
+    return collections;
+}
+
+/**
+ * Find Prisma MongoDB schema file
+ *
+ * Searches for the schema.prisma file in common locations:
+ * 1. prisma-mongodb/schema.prisma (Frigg convention)
+ * 2. prisma/schema.prisma (Prisma default)
+ * 3. schema.prisma (root)
+ *
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} Path to schema file, or null if not found
+ */
+function findMongoDBSchemaFile(startDir = __dirname) {
+    // Start from database directory and work up
+    const baseDir = path.resolve(startDir, '../..');
+
+    const searchPaths = [
+        path.join(baseDir, 'prisma-mongodb', 'schema.prisma'),
+        path.join(baseDir, 'prisma', 'schema.prisma'),
+        path.join(baseDir, 'schema.prisma'),
+    ];
+
+    for (const schemaPath of searchPaths) {
+        if (fs.existsSync(schemaPath)) {
+            return schemaPath;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Get MongoDB collection names from Prisma schema
+ *
+ * Convenience function that finds and parses the schema automatically.
+ *
+ * @returns {Promise<string[]>} Array of collection names
+ * @throws {Error} If schema file not found or parsing fails
+ *
+ * @example
+ * ```js
+ * const collections = await getCollectionsFromSchema();
+ * await ensureCollectionsExist(collections);
+ * ```
+ */
+async function getCollectionsFromSchema() {
+    const schemaPath = findMongoDBSchemaFile();
+
+    if (!schemaPath) {
+        throw new Error(
+            'Could not find Prisma MongoDB schema file. ' +
+            'Searched: prisma-mongodb/schema.prisma, prisma/schema.prisma, schema.prisma'
+        );
+    }
+
+    return await parseCollectionsFromSchema(schemaPath);
+}
+
+/**
+ * Synchronous version of getCollectionsFromSchema
+ *
+ * @returns {string[]} Array of collection names
+ * @throws {Error} If schema file not found or parsing fails
+ */
+function getCollectionsFromSchemaSync() {
+    const schemaPath = findMongoDBSchemaFile();
+
+    if (!schemaPath) {
+        throw new Error(
+            'Could not find Prisma MongoDB schema file. ' +
+            'Searched: prisma-mongodb/schema.prisma, prisma/schema.prisma, schema.prisma'
+        );
+    }
+
+    return parseCollectionsFromSchemaSync(schemaPath);
+}
+
+module.exports = {
+    parseCollectionsFromSchema,
+    parseCollectionsFromSchemaSync,
+    extractCollectionNames,
+    findMongoDBSchemaFile,
+    getCollectionsFromSchema,
+    getCollectionsFromSchemaSync,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.461.5ebf96a.0",
+    "version": "2.0.0--canary.461.6c79fb2.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -38,9 +38,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.461.5ebf96a.0",
-        "@friggframework/prettier-config": "2.0.0--canary.461.5ebf96a.0",
-        "@friggframework/test": "2.0.0--canary.461.5ebf96a.0",
+        "@friggframework/eslint-config": "2.0.0--canary.461.6c79fb2.0",
+        "@friggframework/prettier-config": "2.0.0--canary.461.6c79fb2.0",
+        "@friggframework/test": "2.0.0--canary.461.6c79fb2.0",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -80,5 +80,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "5ebf96a4b08d18a165c8451176b92705a1dcbb4f"
+    "gitHead": "6c79fb214a75cd9bfec200a5a5cde9a2ebc51513"
 }