@envkit/nextjs/dist/server.js

Environment variable management for Next.js applications

"use strict";
/**
 * Server-only exports for Next.js integration
 * IMPORTANT: This file should only be imported in server components or API routes
 */
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.createEnvApiHandler = void 0;
exports.loadEnvVars = loadEnvVars;
exports.writeEnvVars = writeEnvVars;
// Import server-only package at the top to ensure this file is never included in client bundles
require("server-only");
// Ensure we're on the server
if (typeof window !== 'undefined') {
    throw new Error('This module should only be imported in server components or API routes');
}
// Import the API handler to use in the default export
const createEnvApiHandler_1 = require("./api/createEnvApiHandler");
// Export the API handler creator (dynamically imported to prevent bundling)
var createEnvApiHandler_2 = require("./api/createEnvApiHandler");
Object.defineProperty(exports, "createEnvApiHandler", { enumerable: true, get: function () { return createEnvApiHandler_2.createEnvApiHandler; } });
/**
 * Load environment variables from .env files
 * This is a server-side only function
 */
async function loadEnvVars(options = {}) {
    // Import modules only when the function is called
    const fs = await Promise.resolve().then(() => __importStar(require('fs')));
    const path = await Promise.resolve().then(() => __importStar(require('path')));
    const dotenv = await Promise.resolve().then(() => __importStar(require('dotenv')));
    const { envDir = process.cwd(), envFiles = ['.env.local', '.env.development.local', '.env.development', '.env'] } = options;
    // Merge the environment variables in reverse priority order
    let merged = { ...process.env };
    // Try loading each file in order of priority
    for (const fileName of envFiles) {
        try {
            const filePath = path.resolve(envDir, fileName);
            // Check if file exists
            if (fs.existsSync(filePath)) {
                // Parse the file content
                const parsed = dotenv.parse(fs.readFileSync(filePath, 'utf8'));
                // Merge variables (existing take precedence)
                merged = { ...parsed, ...merged };
                console.log(`Loaded environment variables from ${fileName}`);
            }
        }
        catch (error) {
            console.warn(`Error loading ${fileName}:`, error);
        }
    }
    return merged;
}
async function writeEnvVars(variables, options = {}) {
    try {
        // Import modules only when the function is called
        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
        const path = await Promise.resolve().then(() => __importStar(require('path')));
        const dotenv = await Promise.resolve().then(() => __importStar(require('dotenv')));
        const { envDir = process.cwd(), targetEnvFile = '.env.local' } = options;
        const targetFile = path.resolve(envDir, targetEnvFile);
        // Create .env.local content
        let envContent = '';
        // Read existing file if it exists
        if (fs.existsSync(targetFile)) {
            const existingContent = fs.readFileSync(targetFile, 'utf8');
            const existing = dotenv.parse(existingContent);
            // Merge with new variables, new ones take precedence
            const merged = { ...existing, ...variables };
            // Format as KEY=VALUE pairs
            envContent = Object.entries(merged)
                .map(([key, value]) => `${key}=${value}`)
                .join('\n');
        }
        else {
            // Just format the provided variables
            envContent = Object.entries(variables)
                .map(([key, value]) => `${key}=${value}`)
                .join('\n');
        }
        // Write to file
        fs.writeFileSync(targetFile, envContent);
        return {
            success: true,
            path: targetFile
        };
    }
    catch (error) {
        console.error('Error writing environment variables:', error);
        return {
            success: false,
            path: '',
            error: error instanceof Error ? error.message : String(error)
        };
    }
}
// Default export for convenient importing
exports.default = {
    loadEnvVars,
    writeEnvVars,
    createEnvApiHandler: createEnvApiHandler_1.createEnvApiHandler
};
//# sourceMappingURL=server.js.map