@dbos-inc/dbos-sdk 3.0.43-preview → 3.0.45-preview.g34e483ff45

package/dist/src/dbos-runtime/config.js

@@ -3,8 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.overwrite_config = exports.translatePublicDBOSconfig = exports.processConfigFile = exports.parseConfigFile = exports.parseSSLConfig = exports.constructPoolConfig = exports.writeConfigFile = exports.loadConfigFile = exports.readConfigFile = exports.substituteEnvVars = exports.dbosConfigFilePath = void 0;
-const error_1 = require("../error");
+exports.overwriteConfigForDBOSCloud = exports.translateRuntimeConfig = exports.getRuntimeConfig = exports.translateDbosConfig = exports.getDbosConfig = exports.getDatabaseUrl = exports.getSystemDatabaseUrl = exports.writeConfigFile = exports.readConfigFile = exports.substituteEnvVars = exports.dbosConfigFilePath = void 0;
 const utils_1 = require("../utils");
 const yaml_1 = __importDefault(require("yaml"));
 const runtime_1 = require("./runtime");
@@ -12,9 +11,9 @@ const user_database_1 = require("../user_database");
 const fs_1 = require("fs");
 const ajv_1 = __importDefault(require("ajv"));
 const path_1 = __importDefault(require("path"));
-const validator_1 = __importDefault(require("validator"));
-const logs_1 = require("../telemetry/logs");
 const dbos_config_schema_json_1 = __importDefault(require("../../dbos-config.schema.json"));
+const assert_1 = __importDefault(require("assert"));
+const validator_1 = __importDefault(require("validator"));
 exports.dbosConfigFilePath = 'dbos-config.yaml';
 const ajv = new ajv_1.default({ allErrors: true, verbose: true, allowUnionTypes: true });
 /*
@@ -58,61 +57,14 @@ function readConfigFile(dirPath) {
     }
 }
 exports.readConfigFile = readConfigFile;
-/**
- * Loads config file as a ConfigFile.
- * @param {string} configFilePath - The path to the config file to be loaded.
- * @returns
- */
-function loadConfigFile(configFilePath) {
-    try {
-        const configFileContent = (0, utils_1.readFileSync)(configFilePath);
-        const interpolatedConfig = substituteEnvVars(configFileContent);
-        const configFile = yaml_1.default.parse(interpolatedConfig);
-        if (!configFile) {
-            throw new Error(`${configFilePath} is empty `);
-        }
-        const schemaValidator = ajv.compile(dbos_config_schema_json_1.default);
-        if (!schemaValidator(configFile)) {
-            const errorMessages = prettyPrintAjvErrors(schemaValidator);
-            throw new Error(`${configFilePath} failed schema validation. ${errorMessages}`);
-        }
-        if (!configFile.database) {
-            configFile.database = {}; // Create an empty database object if it doesn't exist
-        }
-        // Handle strings in the config file and convert them to arrays
-        if (configFile.telemetry?.OTLPExporter?.logsEndpoint &&
-            typeof configFile.telemetry.OTLPExporter.logsEndpoint === 'string') {
-            configFile.telemetry.OTLPExporter.logsEndpoint = [configFile.telemetry.OTLPExporter.logsEndpoint];
-        }
-        if (configFile.telemetry?.OTLPExporter?.tracesEndpoint &&
-            typeof configFile.telemetry.OTLPExporter.tracesEndpoint === 'string') {
-            configFile.telemetry.OTLPExporter.tracesEndpoint = [configFile.telemetry.OTLPExporter.tracesEndpoint];
-        }
-        return configFile;
-    }
-    catch (e) {
-        if (e instanceof Error) {
-            throw new error_1.DBOSInitializationError(`Failed to load config from ${configFilePath}: ${e.message}`);
-        }
-        else {
-            throw e;
-        }
-    }
-}
-exports.loadConfigFile = loadConfigFile;
-/**
- * Writes a YAML.Document object to configFilePath.
- * @param {YAML.Document} configFile - The config file to be written.
- * @param {string} configFilePath - The path to the config file to be written to.
- */
 function writeConfigFile(configFile, configFilePath) {
     try {
-        const configFileContent = configFile.toString();
+        const configFileContent = yaml_1.default.stringify(configFile);
         (0, fs_1.writeFileSync)(configFilePath, configFileContent);
     }
     catch (e) {
         if (e instanceof Error) {
-            throw new error_1.DBOSInitializationError(`Failed to write config to ${configFilePath}: ${e.message}`);
+            throw new Error(`Failed to write config to ${configFilePath}: ${e.message}`);
         }
         else {
             throw e;
@@ -120,457 +72,206 @@ function writeConfigFile(configFile, configFilePath) {
     }
 }
 exports.writeConfigFile = writeConfigFile;
-function retrieveApplicationName(configFile) {
-    let appName = configFile.name;
-    if (appName !== undefined) {
-        return appName;
-    }
-    const packageJson = JSON.parse((0, utils_1.readFileSync)(path_1.default.join(process.cwd(), 'package.json')).toString());
-    appName = packageJson.name;
-    if (appName === undefined) {
-        throw new error_1.DBOSInitializationError('Error: cannot find a valid package.json file. Please run this command in an application root directory.');
-    }
-    return appName;
-}
-/**
- * Build a PoolConfig object.
- *
- * If configFile.database_url is provided, set it directly in poolConfig.connectionString and backfill the other poolConfig options.
- * Backfilling allows the rest of the code to access database parameters easily.
- * We configure the ORMs with the connection string
- * We still need to extract pool size and connectionTimeoutMillis from the config file and give them manually to the ORMs.
- *
- * If configFile.database_url is not provided, we build the connection string from the configFile.database object.
- *
- * In debug mode, apply overrides from DBOS_DBHOST, DBOS_DBPORT, DBOS_DBUSER, and DBOS_DBPASSWORD.
- *
- * Default configuration:
- * - Hostname: localhost
- * - Port: 5432
- * - Username: postgres
- * - Password: $PGPASSWORD
- * - Database name: transformed application name. The name is either the one provided in the config file or the one found in package.json.
- *
- * @param configFile - The configuration to be used.
- * @param cliOptions - Optional CLI options.
- * @returns PoolConfig - The constructed PoolConfig object.
- */
-function constructPoolConfig(configFile, cliOptions) {
-    // FIXME: this is not a good place to set the app name
-    const appName = retrieveApplicationName(configFile);
-    const isDebugMode = process.env.DBOS_DEBUG_WORKFLOW_ID !== undefined;
-    if (!cliOptions?.silent) {
-        const logger = new logs_1.GlobalLogger();
-        if (isDebugMode) {
-            logger.info('Loading database connection parameters from debug environment variables');
-        }
-        else if (configFile.database_url) {
-            logger.info('Loading database connection parameters from database_url');
-        }
-        else if (configFile.database?.hostname) {
-            logger.info('Loading database connection parameters from dbos-config.yaml');
-        }
-        else {
-            logger.info('Using default database connection parameters');
-        }
+function getSystemDatabaseUrl(configFileOrString) {
+    if (typeof configFileOrString === 'string') {
+        return convertUserDbUrl(configFileOrString);
     }
-    let connectionString = undefined;
-    let databaseName = undefined;
-    let connectionTimeoutMillis = 10000;
-    let ssl = false;
-    // If a database_url is found, parse it to backfill the poolConfig
-    if (configFile.database_url) {
-        const url = new URL(configFile.database_url);
-        // If in debug mode, apply the debug overrides
-        if (isDebugMode) {
-            if (process.env.DBOS_DBHOST) {
-                url.hostname = process.env.DBOS_DBHOST;
-            }
-            if (process.env.DBOS_DBPORT) {
-                url.port = process.env.DBOS_DBPORT;
-            }
-            if (process.env.DBOS_DBUSER) {
-                url.username = process.env.DBOS_DBUSER;
-            }
-            if (process.env.DBOS_DBPASSWORD) {
-                url.password = process.env.DBOS_DBPASSWORD;
-            }
-            configFile.database_url = url.toString();
-        }
-        connectionString = configFile.database_url;
-        databaseName = url.pathname.substring(1);
-        const queryParams = url.searchParams;
-        if (queryParams.has('connect_timeout')) {
-            connectionTimeoutMillis = parseInt(queryParams.get('connect_timeout'), 10) * 1000;
-        }
-        const sslMode = queryParams.get('sslmode');
-        const sslRootCert = queryParams.get('sslrootcert');
-        ssl = getSSLFromParams(sslMode, sslRootCert);
-        // Validate required fields
-        const missingFields = [];
-        if (!url.username)
-            missingFields.push('username');
-        if (!url.hostname)
-            missingFields.push('hostname');
-        if (!databaseName)
-            missingFields.push('database name');
-        if (missingFields.length > 0) {
-            throw new Error(`Invalid database URL: missing required field(s): ${missingFields.join(', ')}`);
-        }
-        // Backfill the poolConfig
-        configFile.database = {
-            ...configFile.database,
-            hostname: url.hostname,
-            port: url.port ? parseInt(url.port, 10) : 5432,
-            username: url.username,
-            password: url.password,
-            app_db_name: databaseName,
-        };
-        if (!cliOptions?.silent) {
-            const logger = new logs_1.GlobalLogger();
-            let logConnectionString = `postgresql://${configFile.database.username}:***@${configFile.database.hostname}:${configFile.database.port}/${databaseName}`;
-            const logQueryParamsArray = Object.entries(url.searchParams.entries()).map(([key, value]) => `${key}=${value}`);
-            if (logQueryParamsArray.length > 0) {
-                logConnectionString += `?${logQueryParamsArray.join('&')}`;
-            }
-            logger.info(`Using database connection string: ${logConnectionString}`);
-        }
+    if (configFileOrString.system_database_url) {
+        return configFileOrString.system_database_url;
     }
-    else {
-        // Else, build the config from configFile.database and apply overrides
-        configFile.database ??= {};
-        configFile.database.hostname = process.env.DBOS_DBHOST || configFile.database.hostname || 'localhost';
-        const dbos_dbport = process.env.DBOS_DBPORT ? parseInt(process.env.DBOS_DBPORT) : undefined;
-        configFile.database.port = dbos_dbport || configFile.database.port || 5432;
-        configFile.database.username = process.env.DBOS_DBUSER || configFile.database.username || 'postgres';
-        configFile.database.password =
-            process.env.DBOS_DBPASSWORD || configFile.database.password || process.env.PGPASSWORD || 'dbos';
-        connectionTimeoutMillis = configFile.database.connectionTimeoutMillis || 10000;
-        databaseName = configFile.database.app_db_name;
-        // Construct the database name from the application name, if needed
-        if (databaseName === undefined || databaseName === '') {
-            databaseName = appName.toLowerCase().replaceAll('-', '_').replaceAll(' ', '_');
-            if (databaseName.match(/^\d/)) {
-                databaseName = '_' + databaseName; // Append an underscore if the name starts with a digit
-            }
-        }
-        connectionString = `postgresql://${configFile.database.username}:${configFile.database.password}@${configFile.database.hostname}:${configFile.database.port}/${databaseName}`;
-        // Build connection string query parameters
-        const queryParams = [];
-        queryParams.push(`connect_timeout=${connectionTimeoutMillis / 1000}`);
-        // SSL configuration
-        ssl = parseSSLConfig(configFile.database);
-        if (ssl === false) {
-            queryParams.push(`sslmode=disable`);
-        }
-        else if (ssl && 'ca' in ssl) {
-            queryParams.push(`sslmode=verify-full`);
-            queryParams.push(`sslrootcert=${configFile.database.ssl_ca}`);
-        }
-        else {
-            queryParams.push(`sslmode=no-verify`);
-        }
-        if (queryParams.length > 0) {
-            connectionString += `?${queryParams.join('&')}`;
-        }
-        if (!cliOptions?.silent) {
-            const logger = new logs_1.GlobalLogger();
-            let logConnectionString = `postgresql://${configFile.database.username}:***@${configFile.database.hostname}:${configFile.database.port}/${databaseName}`;
-            if (queryParams.length > 0) {
-                logConnectionString += `?${queryParams.join('&')}`;
-            }
-            logger.info(`Using database connection string: ${logConnectionString}`);
-        }
+    if (process.env.DBOS_SYSTEM_DATABASE_URL) {
+        return process.env.DBOS_SYSTEM_DATABASE_URL;
     }
-    // Build the final poolConfig
-    const poolConfig = {
-        connectionString,
-        connectionTimeoutMillis,
-        ssl,
-        host: configFile.database.hostname,
-        port: configFile.database.port,
-        user: configFile.database.username,
-        password: configFile.database.password,
-        database: databaseName,
-        max: cliOptions?.userDbPoolSize || 20,
-    };
-    if (!poolConfig.database) {
-        throw new error_1.DBOSInitializationError(`DBOS configuration (${exports.dbosConfigFilePath}) does not contain application database name`);
+    const databaseUrl = getDatabaseUrl(configFileOrString);
+    return convertUserDbUrl(databaseUrl);
+    function convertUserDbUrl(databaseUrl) {
+        const url = new URL(databaseUrl);
+        const database = url.pathname.slice(1);
+        url.pathname = `/${database}_dbos_sys`;
+        return url.toString();
     }
-    return poolConfig;
 }
-exports.constructPoolConfig = constructPoolConfig;
-/**
- * A helper to backfill TLS configuration from a connection string sslmode/sslrootcert query parameters
- *
- * @param sslmode
- * @param sslrootcert
- * @returns
- */
-function getSSLFromParams(sslmode, sslrootcert) {
-    if (!sslmode || sslmode === 'disable') {
+exports.getSystemDatabaseUrl = getSystemDatabaseUrl;
+function isValidDBname(dbName) {
+    if (dbName.length < 1 || dbName.length > 63) {
         return false;
     }
-    const ssl = {};
-    if (sslmode === 'require' || sslmode === 'no-verify') {
-        ssl.rejectUnauthorized = false;
-    }
-    else if (sslmode === 'verify-ca' || sslmode === 'verify-full') {
-        ssl.rejectUnauthorized = sslmode === 'verify-full';
-        if (sslrootcert) {
-            try {
-                ssl.ca = (0, utils_1.readFileSync)(path_1.default.resolve(sslrootcert)).toString();
-            }
-            catch (err) {
-                throw new Error(`Failed to read sslrootcert from "${sslrootcert}": ${err.message}`);
-            }
-        }
-        else {
-            throw new Error(`sslmode=${sslmode} requires sslrootcert`);
-        }
-    }
-    return ssl;
-}
-function parseSSLConfig(dbConfig) {
-    // Details on Postgres SSL/TLS modes: https://www.postgresql.org/docs/current/libpq-ssl.html#LIBPQ-SSL-PROTECTION
-    if (dbConfig.ssl === false) {
-        // If SSL is set to false, do not use TLS
+    if (dbName.match(/^\d/)) {
+        // Cannot start with a digit
         return false;
     }
-    if (dbConfig.ssl_ca) {
-        // If an SSL certificate is provided, connect to Postgres using TLS and verify the server certificate. (equivalent to verify-full)
-        return { ca: [(0, utils_1.readFileSync)(dbConfig.ssl_ca)], rejectUnauthorized: true };
+    return validator_1.default.matches(dbName, '^[a-z0-9_]+$');
+}
+function getDatabaseUrl(configFile) {
+    const databaseUrl = configFile.database_url || process.env.DBOS_DATABASE_URL || defaultDatabaseUrl(configFile.name);
+    const url = new URL(databaseUrl);
+    const dbName = url.pathname.slice(1);
+    const missingFields = [];
+    if (!url.username)
+        missingFields.push('username');
+    if (!url.hostname)
+        missingFields.push('hostname');
+    if (!dbName)
+        missingFields.push('database name');
+    if (missingFields.length > 0) {
+        throw new Error(`Invalid database URL: missing required field(s): ${missingFields.join(', ')}`);
+    }
+    (0, assert_1.default)(isValidDBname(dbName), `Database name "${dbName}" in database_url is invalid.`);
+    if (process.env.DBOS_DEBUG_WORKFLOW_ID !== undefined) {
+        // If in debug mode, apply the debug overrides
+        url.hostname = process.env.DBOS_DBHOST || url.hostname;
+        url.port = process.env.DBOS_DBPORT || url.port;
+        url.username = process.env.DBOS_DBUSER || url.username;
+        url.password = process.env.DBOS_DBPASSWORD || url.password;
+        return url.toString();
     }
-    if (dbConfig.ssl === undefined && (dbConfig.hostname === 'localhost' || dbConfig.hostname === '127.0.0.1')) {
-        // For local development only, do not use TLS unless it is specifically asked for (to support Dockerized Postgres, which does not support SSL connections)
-        return false;
+    else {
+        return databaseUrl;
+    }
+    function defaultDatabaseUrl(appName) {
+        (0, assert_1.default)(appName, 'Application name must be defined to construct a valid database URL.');
+        const host = process.env.PGHOST || 'localhost';
+        const port = process.env.PGPORT || '5432';
+        const username = process.env.PGUSER || 'postgres';
+        const password = process.env.PGPASSWORD || 'dbos';
+        const database = toDbName(appName);
+        const timeout = process.env.PGCONNECT_TIMEOUT || '10';
+        const sslmode = process.env.PGSSLMODE || (host === 'localhost' ? 'disable' : 'allow');
+        return `postgresql://${username}:${password}@${host}:${port}/${database}?connect_timeout=${timeout}&sslmode=${sslmode}`;
+    }
+    function toDbName(appName) {
+        const dbName = appName.toLowerCase().replaceAll('-', '_').replaceAll(' ', '_');
+        return dbName.match(/^\d/) ? '_' + dbName : dbName;
     }
-    // Otherwise, connect to Postgres using TLS but do not verify the server certificate. (equivalent to require)
-    return { rejectUnauthorized: false };
 }
-exports.parseSSLConfig = parseSSLConfig;
-function prettyPrintAjvErrors(validate) {
-    return validate
-        .errors.map((error) => {
-        let message = `Error: ${error.message}`;
-        if (error.schemaPath)
-            message += ` (schema path: ${error.schemaPath})`;
-        if (error.params && error.keyword === 'additionalProperties') {
-            message += `; the additional property '${error.params.additionalProperty}' is not allowed`;
-        }
-        if (error.data && error.keyword === 'not') {
-            message += `; the value ${utils_1.DBOSJSON.stringify(error.data)} is not allowed for field ${error.instancePath}`;
-        }
-        return message;
-    })
-        .join(', ');
+exports.getDatabaseUrl = getDatabaseUrl;
+function getDbosConfig(config, options = {}) {
+    (0, assert_1.default)(config.language === undefined || config.language === 'node', `Config file specifies invalid language ${config.language}`);
+    const userDbClient = config.database?.app_db_client ?? user_database_1.UserDatabaseName.KNEX;
+    (0, assert_1.default)(isValidUserDbClient(userDbClient), `Invalid app_db_client ${userDbClient} in config file`);
+    return translateDbosConfig({
+        name: config.name,
+        databaseUrl: config.database_url,
+        systemDatabaseUrl: config.system_database_url,
+        userDatabaseClient: userDbClient,
+        logLevel: options.logLevel ?? config.telemetry?.logs?.logLevel,
+        addContextMetadata: config.telemetry?.logs?.addContextMetadata,
+        otlpTracesEndpoints: toArray(config.telemetry?.OTLPExporter?.tracesEndpoint),
+        otlpLogsEndpoints: toArray(config.telemetry?.OTLPExporter?.logsEndpoint),
+        runAdminServer: config.runtimeConfig?.runAdminServer,
+    }, options.forceConsole);
 }
-/*
- * Parse `dbosConfigFilePath` and return DBOSConfig and DBOSRuntimeConfig
- * Considers DBOSCLIStartOptions if provided, which takes precedence over config file
- * */
-function parseConfigFile(cliOptions) {
-    if (cliOptions?.appDir) {
-        process.chdir(cliOptions.appDir);
-    }
-    const configFilePath = cliOptions?.configfile ?? exports.dbosConfigFilePath;
-    const configFile = loadConfigFile(configFilePath);
-    if (!configFile) {
-        throw new error_1.DBOSInitializationError(`DBOS configuration file ${configFilePath} is empty`);
-    }
-    return processConfigFile(configFile, cliOptions);
+exports.getDbosConfig = getDbosConfig;
+function toArray(endpoint) {
+    return endpoint ? (Array.isArray(endpoint) ? endpoint : [endpoint]) : [];
 }
-exports.parseConfigFile = parseConfigFile;
-function processConfigFile(configFile, cliOptions) {
-    if (configFile.language && configFile.language !== 'node') {
-        throw new error_1.DBOSInitializationError(`Config file specifies invalid language ${configFile.language}`);
-    }
-    /*******************************/
-    /* Handle user database config */
-    /*******************************/
-    const poolConfig = constructPoolConfig(configFile, cliOptions);
-    if (!isValidDBname(poolConfig.database)) {
-        throw new error_1.DBOSInitializationError(`Config file specifies invalid app_db_name ${poolConfig.database}. Must be between 3 and 31 characters long and contain only lowercase letters, underscores, and digits (cannot begin with a digit).`);
-    }
-    /***************************/
-    /* Handle telemetry config */
-    /***************************/
-    // Consider CLI --loglevel and forceConsole flags
-    const logs = {
-        ...configFile.telemetry?.logs,
-        logLevel: cliOptions?.loglevel ?? configFile.telemetry?.logs?.logLevel ?? 'info',
-        forceConsole: cliOptions?.forceConsole ?? configFile.telemetry?.logs?.forceConsole,
-    };
-    const traceEndpointSet = (0, utils_1.toStringSet)(configFile.telemetry?.OTLPExporter?.tracesEndpoint);
-    const logEndpointSet = (0, utils_1.toStringSet)(configFile.telemetry?.OTLPExporter?.logsEndpoint);
-    /************************************/
-    /* Build final DBOS configuration */
-    /************************************/
-    utils_1.globalParams.appVersion = getAppVersion(cliOptions?.appVersion);
-    const dbosConfig = {
-        poolConfig: poolConfig,
-        userDbclient: configFile.database?.app_db_client || user_database_1.UserDatabaseName.KNEX,
-        databaseUrl: configFile.database_url,
+function isValidUserDbClient(name) {
+    return Object.values(user_database_1.UserDatabaseName).includes(name);
+}
+function translateDbosConfig(options, forceConsole = false) {
+    const databaseUrl = getDatabaseUrl({ database_url: options.databaseUrl, name: options.name });
+    const systemDatabaseUrl = getSystemDatabaseUrl({
+        database_url: options.databaseUrl,
+        system_database_url: options.systemDatabaseUrl,
+        name: options.name,
+    });
+    return {
+        databaseUrl,
+        userDbPoolSize: options.userDatabasePoolSize,
+        systemDatabaseUrl,
+        sysDbPoolSize: options.systemDatabasePoolSize,
+        userDbClient: options.userDatabaseClient,
         telemetry: {
-            logs,
+            logs: {
+                logLevel: options.logLevel || 'info',
+                addContextMetadata: options.addContextMetadata,
+                forceConsole,
+            },
             OTLPExporter: {
-                tracesEndpoint: Array.from(traceEndpointSet),
-                logsEndpoint: Array.from(logEndpointSet),
+                tracesEndpoint: options.otlpTracesEndpoints,
+                logsEndpoint: options.otlpLogsEndpoints,
             },
         },
-        system_database: configFile.database?.sys_db_name ?? `${poolConfig.database}_dbos_sys`,
-        http: configFile.http,
     };
-    /*************************************/
-    /* Build final runtime Configuration */
-    /*************************************/
+}
+exports.translateDbosConfig = translateDbosConfig;
+function getRuntimeConfig(config, options = {}) {
+    return translateRuntimeConfig(config.runtimeConfig, options.port);
+}
+exports.getRuntimeConfig = getRuntimeConfig;
+function translateRuntimeConfig(config = {}, port) {
     const entrypoints = new Set();
-    if (configFile.runtimeConfig?.entrypoints) {
-        configFile.runtimeConfig.entrypoints.forEach((entry) => entrypoints.add(entry));
-    }
-    else {
+    config.entrypoints?.forEach((entry) => entrypoints.add(entry));
+    if (entrypoints.size === 0) {
         entrypoints.add(runtime_1.defaultEntryPoint);
     }
-    const appPort = Number(cliOptions?.port) || Number(configFile.runtimeConfig?.port) || 3000;
-    const runtimeConfig = {
+    port ??= config.port ?? 3000;
+    return {
         entrypoints: [...entrypoints],
-        port: appPort,
-        runAdminServer: true,
-        admin_port: Number(configFile.runtimeConfig?.admin_port) || appPort + 1,
-        start: configFile.runtimeConfig?.start || [],
-        setup: configFile.runtimeConfig?.setup || [],
+        port: port,
+        runAdminServer: config.runAdminServer ?? true,
+        admin_port: config.admin_port ?? port + 1,
+        start: config.start ?? [],
+        setup: config.setup ?? [],
     };
-    return [dbosConfig, runtimeConfig];
 }
-exports.processConfigFile = processConfigFile;
-function getAppVersion(appVersion) {
-    if (typeof appVersion === 'string') {
-        return appVersion;
+exports.translateRuntimeConfig = translateRuntimeConfig;
+function overwriteConfigForDBOSCloud(providedDBOSConfig, providedRuntimeConfig, configFile) {
+    // Load the DBOS configuration file and force the use of:
+    // 1. Use the application name from the file. This is a defensive measure to ensure the application name is whatever it was registered with in the cloud
+    // 2. use the database URL from environment var
+    // 3. OTLP traces endpoints (add the config data to the provided config)
+    // 4. Force admin_port and runAdminServer
+    const appName = configFile.name ?? providedDBOSConfig.name;
+    let databaseUrl = process.env.DBOS_DATABASE_URL;
+    if (!databaseUrl) {
+        databaseUrl = configFile.database_url;
     }
-    if (appVersion === false) {
-        return '';
+    if (!databaseUrl) {
+        databaseUrl = providedDBOSConfig.databaseUrl;
     }
-    return process.env.DBOS__APPVERSION || '';
-}
-function isValidDBname(dbName) {
-    if (dbName.length < 1 || dbName.length > 63) {
-        return false;
+    let systemDatabaseUrl = process.env.DBOS_SYSTEM_DATABASE_URL;
+    if (!systemDatabaseUrl && process.env.DBOS_DATABASE_URL) {
+        systemDatabaseUrl = getSystemDatabaseUrl(process.env.DBOS_DATABASE_URL);
     }
-    if (dbName.match(/^\d/)) {
-        // Cannot start with a digit
-        return false;
+    if (!systemDatabaseUrl) {
+        systemDatabaseUrl = configFile.system_database_url;
     }
-    return validator_1.default.matches(dbName, '^[a-z0-9_]+$');
-}
-/*
- This function takes a DBOSConfig and ensure that 'public' fields take precedence over 'internal' fields.
- It assumes that the DBOSConfig was passed programmatically and thus does not need to consider CLI options.
-
- - Application Name: check there is no inconsistency between the provided name and the one in dbos-config.yaml, if any
- - Database configuration: Ignore provided poolConfig and reconstructs it from the databaseUrl field and constructPoolConfig()
-*/
-function translatePublicDBOSconfig(config, isDebugging) {
-    let appName = config.name;
-    // Opportunistically grab the name from the config file if none was provided
-    try {
-        const configFile = loadConfigFile(exports.dbosConfigFilePath);
-        if (configFile?.name && !appName) {
-            appName = configFile.name;
-        }
+    if (!systemDatabaseUrl) {
+        systemDatabaseUrl = providedDBOSConfig.systemDatabaseUrl;
     }
-    catch (e) {
-        // Ignore file not found errors
-        if (!e.message.includes('ENOENT: no such file or directory')) {
-            throw e;
+    const logsSet = new Set(providedDBOSConfig.telemetry.OTLPExporter?.logsEndpoint);
+    const logsEndpoint = configFile.telemetry?.OTLPExporter?.logsEndpoint;
+    if (logsEndpoint) {
+        if (Array.isArray(logsEndpoint)) {
+            logsEndpoint.forEach((endpoint) => logsSet.add(endpoint));
+        }
+        else {
+            logsSet.add(logsEndpoint);
         }
     }
-    // Resolve database configuration
-    const poolConfig = constructPoolConfig({
-        name: appName,
-        database: {},
-        database_url: config.databaseUrl,
-        application: {},
-        env: {},
-    }, { silent: true, userDbPoolSize: config.userDbPoolSize });
-    const translatedConfig = {
-        name: appName,
-        poolConfig: poolConfig,
-        userDbclient: config.userDbclient || user_database_1.UserDatabaseName.KNEX,
-        databaseUrl: config.databaseUrl,
-        telemetry: {
-            logs: {
-                logLevel: config.logLevel || 'info',
-                addContextMetadata: config.addContextMetadata,
-                forceConsole: isDebugging === undefined ? false : isDebugging,
-            },
-            OTLPExporter: {
-                tracesEndpoint: config.otlpTracesEndpoints || [],
-                logsEndpoint: config.otlpLogsEndpoints || [],
-            },
-        },
-        system_database: config.sysDbName || `${poolConfig.database}_dbos_sys`,
-        sysDbPoolSize: config.sysDbPoolSize || 20,
-    };
-    const runtimeConfig = {
-        port: 3000,
-        admin_port: config.adminPort || 3001,
-        runAdminServer: config.runAdminServer === undefined ? true : config.runAdminServer,
-        entrypoints: [],
-        start: [],
-        setup: [],
-    };
-    return [translatedConfig, runtimeConfig];
-}
-exports.translatePublicDBOSconfig = translatePublicDBOSconfig;
-function overwrite_config(providedDBOSConfig, providedRuntimeConfig, configFile) {
-    if (configFile === undefined) {
-        try {
-            configFile = loadConfigFile(exports.dbosConfigFilePath);
+    const tracesSet = new Set(providedDBOSConfig.telemetry.OTLPExporter?.tracesEndpoint);
+    const tracesEndpoint = configFile.telemetry?.OTLPExporter?.tracesEndpoint;
+    if (tracesEndpoint) {
+        if (Array.isArray(tracesEndpoint)) {
+            tracesEndpoint.forEach((endpoint) => tracesSet.add(endpoint));
         }
-        catch (e) {
-            if (e.message.includes('ENOENT: no such file or directory')) {
-                return [providedDBOSConfig, providedRuntimeConfig];
-            }
-            else {
-                throw e;
-            }
+        else {
+            tracesSet.add(tracesEndpoint);
         }
     }
-    // Load the DBOS configuration file and force the use of:
-    // 1. Use the application name from the file. This is a defensive measure to ensure the application name is whatever it was registered with in the cloud
-    // 2. The database connection parameters (sub the file data to the provided config)
-    // 3. OTLP traces endpoints (add the config data to the provided config)
-    // 4. Force admin_port and runAdminServer
-    const appName = configFile.name || providedDBOSConfig.name;
-    if (configFile.database?.ssl_ca) {
-        configFile.database_url = `postgresql://${configFile.database.username}:${configFile.database.password}@${configFile.database.hostname}:${configFile.database.port}/${configFile.database.app_db_name}?connect_timeout=10&sslmode=verify-full&sslrootcert=${configFile.database.ssl_ca}`;
-    }
-    else {
-        configFile.database_url = `postgresql://${configFile.database?.username}:${configFile.database?.password}@${configFile.database?.hostname}:${configFile.database?.port}/${configFile.database?.app_db_name}?connect_timeout=10&sslmode=no-verify`;
-    }
-    const poolConfig = constructPoolConfig(configFile);
-    const providedTraceEndpointSet = (0, utils_1.toStringSet)(providedDBOSConfig.telemetry.OTLPExporter?.tracesEndpoint);
-    const configTraceEndpointSet = (0, utils_1.toStringSet)(configFile.telemetry?.OTLPExporter?.tracesEndpoint);
-    for (const endpoint of configTraceEndpointSet) {
-        providedTraceEndpointSet.add(endpoint);
-    }
-    const providedLogEndpointSet = (0, utils_1.toStringSet)(providedDBOSConfig.telemetry?.OTLPExporter?.logsEndpoint);
-    const configLogEndpointSet = (0, utils_1.toStringSet)(configFile.telemetry?.OTLPExporter?.logsEndpoint);
-    for (const endpoint of configLogEndpointSet) {
-        providedLogEndpointSet.add(endpoint);
-    }
     const overwritenDBOSConfig = {
         ...providedDBOSConfig,
         name: appName,
-        poolConfig: poolConfig,
+        databaseUrl,
+        systemDatabaseUrl,
         telemetry: {
             logs: providedDBOSConfig.telemetry.logs,
             OTLPExporter: {
-                tracesEndpoint: Array.from(providedTraceEndpointSet),
-                logsEndpoint: Array.from(providedLogEndpointSet),
+                tracesEndpoint: Array.from(tracesSet),
+                logsEndpoint: Array.from(logsSet),
             },
         },
-        system_database: configFile.database?.sys_db_name || poolConfig.database + '_dbos_sys', // Unexpected, but possible
     };
     const overwriteDBOSRuntimeConfig = {
         admin_port: 3001,
@@ -582,5 +283,5 @@ function overwrite_config(providedDBOSConfig, providedRuntimeConfig, configFile)
     };
     return [overwritenDBOSConfig, overwriteDBOSRuntimeConfig];
 }
-exports.overwrite_config = overwrite_config;
+exports.overwriteConfigForDBOSCloud = overwriteConfigForDBOSCloud;
 //# sourceMappingURL=config.js.map