import * as tslib_1 from "tslib";
|
import { PlatformTools } from "../platform/PlatformTools";
|
import { ConnectionOptionsEnvReader } from "./options-reader/ConnectionOptionsEnvReader";
|
import { ConnectionOptionsYmlReader } from "./options-reader/ConnectionOptionsYmlReader";
|
import { ConnectionOptionsXmlReader } from "./options-reader/ConnectionOptionsXmlReader";
|
/**
|
* Reads connection options from the ormconfig.
|
* Can read from multiple file extensions including env, json, js, xml and yml.
|
*/
|
var ConnectionOptionsReader = /** @class */ (function () {
|
// -------------------------------------------------------------------------
|
// Constructor
|
// -------------------------------------------------------------------------
|
function ConnectionOptionsReader(options) {
|
this.options = options;
|
}
|
// -------------------------------------------------------------------------
|
// Public Methods
|
// -------------------------------------------------------------------------
|
/**
|
* Returns all connection options read from the ormconfig.
|
*/
|
ConnectionOptionsReader.prototype.all = function () {
|
return tslib_1.__awaiter(this, void 0, void 0, function () {
|
var options;
|
return tslib_1.__generator(this, function (_a) {
|
switch (_a.label) {
|
case 0: return [4 /*yield*/, this.load()];
|
case 1:
|
options = _a.sent();
|
if (!options)
|
throw new Error("No connection options were found in any of configurations file.");
|
return [2 /*return*/, options];
|
}
|
});
|
});
|
};
|
/**
|
* Gets a connection with a given name read from ormconfig.
|
* If connection with such name would not be found then it throw error.
|
*/
|
ConnectionOptionsReader.prototype.get = function (name) {
|
return tslib_1.__awaiter(this, void 0, void 0, function () {
|
var allOptions, targetOptions;
|
return tslib_1.__generator(this, function (_a) {
|
switch (_a.label) {
|
case 0: return [4 /*yield*/, this.all()];
|
case 1:
|
allOptions = _a.sent();
|
targetOptions = allOptions.find(function (options) { return options.name === name || (name === "default" && !options.name); });
|
if (!targetOptions)
|
throw new Error("Cannot find connection " + name + " because its not defined in any orm configuration files.");
|
return [2 /*return*/, targetOptions];
|
}
|
});
|
});
|
};
|
/**
|
* Checks if there is a TypeORM configuration file.
|
*/
|
ConnectionOptionsReader.prototype.has = function (name) {
|
return tslib_1.__awaiter(this, void 0, void 0, function () {
|
var allOptions, targetOptions;
|
return tslib_1.__generator(this, function (_a) {
|
switch (_a.label) {
|
case 0: return [4 /*yield*/, this.load()];
|
case 1:
|
allOptions = _a.sent();
|
if (!allOptions)
|
return [2 /*return*/, false];
|
targetOptions = allOptions.find(function (options) { return options.name === name || (name === "default" && !options.name); });
|
return [2 /*return*/, !!targetOptions];
|
}
|
});
|
});
|
};
|
// -------------------------------------------------------------------------
|
// Protected Methods
|
// -------------------------------------------------------------------------
|
/**
|
* Loads all connection options from a configuration file.
|
*
|
* todo: get in count NODE_ENV somehow
|
*/
|
ConnectionOptionsReader.prototype.load = function () {
|
return tslib_1.__awaiter(this, void 0, void 0, function () {
|
var connectionOptions, fileFormats, possibleExtension, fileExtension, foundFileFormat, dotenv, dotenv, configFile;
|
var _this = this;
|
return tslib_1.__generator(this, function (_a) {
|
switch (_a.label) {
|
case 0:
|
connectionOptions = undefined;
|
fileFormats = ["env", "js", "ts", "json", "yml", "yaml", "xml"];
|
possibleExtension = this.baseFilePath.substr(this.baseFilePath.lastIndexOf("."));
|
fileExtension = fileFormats.find(function (extension) { return "." + extension === possibleExtension; });
|
foundFileFormat = fileExtension || fileFormats.find(function (format) {
|
return PlatformTools.fileExist(_this.baseFilePath + "." + format);
|
});
|
// if .env file found then load all its variables into process.env using dotenv package
|
if (foundFileFormat === "env") {
|
dotenv = PlatformTools.load("dotenv");
|
dotenv.config({ path: this.baseFilePath });
|
}
|
else if (PlatformTools.fileExist(".env")) {
|
dotenv = PlatformTools.load("dotenv");
|
dotenv.config({ path: ".env" });
|
}
|
configFile = fileExtension ? this.baseFilePath : this.baseFilePath + "." + foundFileFormat;
|
if (!(PlatformTools.getEnvVariable("TYPEORM_CONNECTION") || PlatformTools.getEnvVariable("TYPEORM_URL"))) return [3 /*break*/, 1];
|
connectionOptions = new ConnectionOptionsEnvReader().read();
|
return [3 /*break*/, 8];
|
case 1:
|
if (!(foundFileFormat === "js")) return [3 /*break*/, 2];
|
connectionOptions = PlatformTools.load(configFile);
|
return [3 /*break*/, 8];
|
case 2:
|
if (!(foundFileFormat === "ts")) return [3 /*break*/, 3];
|
connectionOptions = PlatformTools.load(configFile);
|
return [3 /*break*/, 8];
|
case 3:
|
if (!(foundFileFormat === "json")) return [3 /*break*/, 4];
|
connectionOptions = PlatformTools.load(configFile);
|
return [3 /*break*/, 8];
|
case 4:
|
if (!(foundFileFormat === "yml")) return [3 /*break*/, 5];
|
connectionOptions = new ConnectionOptionsYmlReader().read(configFile);
|
return [3 /*break*/, 8];
|
case 5:
|
if (!(foundFileFormat === "yaml")) return [3 /*break*/, 6];
|
connectionOptions = new ConnectionOptionsYmlReader().read(configFile);
|
return [3 /*break*/, 8];
|
case 6:
|
if (!(foundFileFormat === "xml")) return [3 /*break*/, 8];
|
return [4 /*yield*/, new ConnectionOptionsXmlReader().read(configFile)];
|
case 7:
|
connectionOptions = _a.sent();
|
_a.label = 8;
|
case 8:
|
// normalize and return connection options
|
if (connectionOptions) {
|
return [2 /*return*/, this.normalizeConnectionOptions(connectionOptions)];
|
}
|
return [2 /*return*/, undefined];
|
}
|
});
|
});
|
};
|
/**
|
* Normalize connection options.
|
*/
|
ConnectionOptionsReader.prototype.normalizeConnectionOptions = function (connectionOptions) {
|
var _this = this;
|
if (!(connectionOptions instanceof Array))
|
connectionOptions = [connectionOptions];
|
connectionOptions.forEach(function (options) {
|
if (options.entities) {
|
var entities = options.entities.map(function (entity) {
|
if (typeof entity === "string" && entity.substr(0, 1) !== "/")
|
return _this.baseDirectory + "/" + entity;
|
return entity;
|
});
|
Object.assign(connectionOptions, { entities: entities });
|
}
|
if (options.subscribers) {
|
var subscribers = options.subscribers.map(function (subscriber) {
|
if (typeof subscriber === "string" && subscriber.substr(0, 1) !== "/")
|
return _this.baseDirectory + "/" + subscriber;
|
return subscriber;
|
});
|
Object.assign(connectionOptions, { subscribers: subscribers });
|
}
|
if (options.migrations) {
|
var migrations = options.migrations.map(function (migration) {
|
if (typeof migration === "string" && migration.substr(0, 1) !== "/")
|
return _this.baseDirectory + "/" + migration;
|
return migration;
|
});
|
Object.assign(connectionOptions, { migrations: migrations });
|
}
|
// make database path file in sqlite relative to package.json
|
if (options.type === "sqlite") {
|
if (typeof options.database === "string" &&
|
options.database.substr(0, 1) !== "/" && // unix absolute
|
options.database.substr(1, 2) !== ":\\" && // windows absolute
|
options.database !== ":memory:") {
|
Object.assign(options, {
|
database: _this.baseDirectory + "/" + options.database
|
});
|
}
|
}
|
});
|
return connectionOptions;
|
};
|
Object.defineProperty(ConnectionOptionsReader.prototype, "baseFilePath", {
|
/**
|
* Gets directory where configuration file should be located and configuration file name.
|
*/
|
get: function () {
|
return this.baseDirectory + "/" + this.baseConfigName;
|
},
|
enumerable: true,
|
configurable: true
|
});
|
Object.defineProperty(ConnectionOptionsReader.prototype, "baseDirectory", {
|
/**
|
* Gets directory where configuration file should be located.
|
*/
|
get: function () {
|
if (this.options && this.options.root)
|
return this.options.root;
|
return PlatformTools.load("app-root-path").path;
|
},
|
enumerable: true,
|
configurable: true
|
});
|
Object.defineProperty(ConnectionOptionsReader.prototype, "baseConfigName", {
|
/**
|
* Gets configuration file name.
|
*/
|
get: function () {
|
if (this.options && this.options.configName)
|
return this.options.configName;
|
return "ormconfig";
|
},
|
enumerable: true,
|
configurable: true
|
});
|
return ConnectionOptionsReader;
|
}());
|
export { ConnectionOptionsReader };
|
|
//# sourceMappingURL=ConnectionOptionsReader.js.map
|
