@decohere/data-typeorm 0.0.1-dev.116

package/commonjs/src/server-manager.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PostgresServerManager", {
+    enumerable: true,
+    get: function() {
+        return PostgresServerManager;
+    }
+});
+const _data = require("@decohere/data");
+const _pg = require("pg");
+const _user = require("./scripts/user.js");
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+/**
+ * Official Postgres images always have this DB. `pg` defaults an omitted
+ * `database` to the username — bootstrap roles like `decohere_bootstrap` are
+ * not databases, so connect here before CREATE DATABASE.
+ */ const MAINTENANCE_DATABASE = "postgres";
+class PostgresServerManager {
+    applicationName;
+    config;
+    pool;
+    client;
+    constructor(applicationName, config){
+        this.applicationName = applicationName;
+        this.config = config;
+    }
+    /** `auth: trust`: the server lets every connection in, so roles have no password. */ get trusted() {
+        return this.config.auth === "trust";
+    }
+    async connect() {
+        const { adminUser, adminPassword, host, port } = this.config;
+        if (!adminUser || !adminPassword && !this.trusted) {
+            throw new _data.DataConfigurationError(`Data source "${this.config.name}": adminUser and adminPassword are required to bootstrap the database (adminPassword may be left out only with auth: trust)`);
+        }
+        this.pool = new _pg.Pool({
+            user: adminUser,
+            host,
+            password: adminPassword,
+            port,
+            database: MAINTENANCE_DATABASE,
+            application_name: this.applicationName
+        });
+        try {
+            this.client = await this.pool.connect();
+        } catch (err) {
+            const cause = err instanceof Error ? err.message : String(err);
+            throw new _data.DataConfigurationError(`Cannot connect to PostgreSQL at ${host}:${port}. Is the server running? Cause: ${cause}`);
+        }
+    }
+    async initializeDatabase(database) {
+        (0, _user.quoteIdent)(database, "database");
+        const result = await this.pool.query(`SELECT datname FROM pg_catalog.pg_database WHERE lower(datname) = lower($1)`, [
+            database
+        ]);
+        if (result.rowCount === 1) {
+            return;
+        }
+        const dbIdent = (0, _user.quoteIdent)(database, "database");
+        await this.pool.query(`CREATE DATABASE ${dbIdent}`);
+    }
+    /**
+	 * Create the runtime app role (+ optional migrate role) and its schema, with least-privilege
+	 * grants. Running it again changes nothing: each grant is made only where the role lacks it,
+	 * since Postgres checks the grantor's rights even for a grant that would change nothing.
+	 *
+	 * The admin acts with the database owner's rights while it runs (it is made a member of the
+	 * owner, and of the migrate role, only for as long as it needs to be). That is how it creates a
+	 * schema and grants on it once the migrate role owns the database.
+	 */ async provisionRoles(options) {
+        const { database, appUsername, appPassword, migrateUsername, migratePassword, allowAppDdl, schema = "public" } = options;
+        (0, _user.quoteIdent)(schema, "schema");
+        if (appUsername === this.config.adminUser) {
+            throw new _data.DataConfigurationError(`Runtime username "${appUsername}" must not equal adminUser — use a dedicated app role`);
+        }
+        if (migrateUsername && migrateUsername === appUsername) {
+            throw new _data.DataConfigurationError("migrateUsername must differ from the runtime app username");
+        }
+        if (migrateUsername && migrateUsername === this.config.adminUser) {
+            throw new _data.DataConfigurationError("migrateUsername must not equal adminUser");
+        }
+        const adminUser = this.config.adminUser;
+        if (!adminUser) {
+            throw new _data.DataConfigurationError("adminUser is required to provision database roles");
+        }
+        const pool = new _pg.Pool({
+            host: this.config.host,
+            port: this.config.port,
+            user: adminUser,
+            database,
+            password: this.config.adminPassword,
+            application_name: this.applicationName
+        });
+        try {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                const roles = _ts_add_disposable_resource(env, new BorrowedRoles(pool, adminUser), true);
+                if (migrateUsername) {
+                    await this.ensureRole(pool, migrateUsername, migratePassword);
+                    // Membership is required for OWNER TO and DEFAULT PRIVILEGES FOR ROLE (not superuser).
+                    await roles.borrow(migrateUsername);
+                    // The owner holds every privilege on the database, so no separate GRANT is needed.
+                    if (await databaseOwner(pool, database) !== migrateUsername) {
+                        await pool.query((0, _user.alterDatabaseOwnerQuery)(database, migrateUsername).text);
+                    }
+                }
+                const owner = await databaseOwner(pool, database);
+                if (owner !== adminUser) await roles.borrow(owner);
+                // Owned by the database owner (the migrate role, when there is one), like `public`.
+                await pool.query((0, _user.createSchemaQuery)(schema, owner).text);
+                if (migrateUsername && !await hasAll(pool, (privilege)=>(0, _user.hasSchemaPrivilegeQuery)(migrateUsername, schema, privilege))) {
+                    await pool.query((0, _user.grantSchemaPrivilegesQuery)(migrateUsername, schema).text);
+                }
+                await this.ensureRole(pool, appUsername, appPassword);
+                if (!await granted(pool, (0, _user.hasDatabasePrivilegeQuery)(appUsername, database, "CONNECT"))) {
+                    await pool.query((0, _user.grantConnectQuery)(appUsername, database).text);
+                }
+                if (!await granted(pool, (0, _user.hasSchemaPrivilegeQuery)(appUsername, schema, "USAGE"))) {
+                    await pool.query((0, _user.grantSchemaUsageQuery)(appUsername, schema).text);
+                }
+                // Dev synchronize: the app connection must be able to CREATE tables.
+                if (allowAppDdl && !await granted(pool, (0, _user.hasSchemaPrivilegeQuery)(appUsername, schema, "CREATE"))) {
+                    await pool.query((0, _user.grantSchemaCreateQuery)(appUsername, schema).text);
+                }
+                if (migrateUsername) {
+                    // Setting a default privilege that is already set changes nothing.
+                    for (const q of (0, _user.defaultPrivilegesForAppQueries)(migrateUsername, appUsername, schema)){
+                        await pool.query(q.text);
+                    }
+                }
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
+            }
+        } finally{
+            await pool.end();
+        }
+    }
+    /** @deprecated Use provisionRoles. */ async createApiUser(username, password, database, _role) {
+        await this.provisionRoles({
+            database,
+            appUsername: username,
+            appPassword: password,
+            migrateUsername: this.config.migrateUsername,
+            migratePassword: this.config.migratePassword,
+            allowAppDdl: this.config.synchronize === true,
+            schema: this.config.schema
+        });
+    }
+    async ensureRole(pool, username, password) {
+        if (!password && !this.trusted) {
+            throw new _data.DataConfigurationError(`A password is required for database role "${username}" unless the data source sets auth: trust`);
+        }
+        const exists = (0, _user.roleExistsQuery)(username);
+        const found = await pool.query(exists.text, exists.values);
+        if (found.rowCount === 1) {
+            return;
+        }
+        const create = (0, _user.createUserQuery)(username, password);
+        await pool.query(create.text, create.values);
+    }
+    [Symbol.asyncDispose]() {
+        return this.closeConnection();
+    }
+    async closeConnection() {
+        this.client?.release();
+        await this.pool?.end();
+    }
+}
+async function granted(pool, query) {
+    const result = await pool.query(query.text, query.values);
+    return result.rows[0]?.granted === true;
+}
+/** Every schema privilege that `GRANT ALL ON SCHEMA` gives. Checked one at a time: Postgres
+ * answers true for a list when any one of them is held. */ async function hasAll(pool, query) {
+    for (const privilege of [
+        "USAGE",
+        "CREATE"
+    ]){
+        if (!await granted(pool, query(privilege))) return false;
+    }
+    return true;
+}
+async function databaseOwner(pool, database) {
+    const query = (0, _user.databaseOwnerQuery)(database);
+    const result = await pool.query(query.text, query.values);
+    const owner = result.rows[0]?.owner;
+    if (owner == null) {
+        throw new _data.DataConfigurationError(`Database "${database}" does not exist`);
+    }
+    return owner;
+}
+/**
+ * Roles the admin is made a member of for one provisioning run, so it acts with their rights.
+ * Disposing gives back exactly what was borrowed, even when the run fails: memberships the admin
+ * already had (or rights it has as a superuser) are left alone.
+ */ class BorrowedRoles {
+    pool;
+    adminUser;
+    borrowed = [];
+    constructor(pool, adminUser){
+        this.pool = pool;
+        this.adminUser = adminUser;
+    }
+    async borrow(role) {
+        if (this.borrowed.includes(role)) return;
+        if (await granted(this.pool, (0, _user.hasRolePrivilegesQuery)(this.adminUser, role))) return;
+        try {
+            await this.pool.query((0, _user.grantRoleMembershipQuery)(this.adminUser, role).text);
+        } catch (err) {
+            throw new _data.DataConfigurationError(`Bootstrap role "${this.adminUser}" cannot act as "${role}". Make it a member of "${role}" (or create "${role}" with it), then run again.`, {
+                cause: err
+            });
+        }
+        this.borrowed.push(role);
+    }
+    async [Symbol.asyncDispose]() {
+        for (const role of this.borrowed.reverse()){
+            await this.pool.query((0, _user.revokeRoleMembershipQuery)(this.adminUser, role).text);
+        }
+    }
+}

package/commonjs/src/sql-pretty.transport.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SqlPretty", {
+    enumerable: true,
+    get: function() {
+        return SqlPretty;
+    }
+});
+const _pinopretty = /*#__PURE__*/ _interop_require_default(require("pino-pretty"));
+const _PlatformTools = require("typeorm/platform/PlatformTools.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const SqlPretty = (opts)=>(0, _pinopretty.default)({
+        colorizeObjects: true,
+        customLevels: Object.entries(opts?.levels ?? []).map(([key, value])=>`${key}:${value}`).join(",") ?? [],
+        customPrettifiers: {
+            sql: tryParseSql
+        },
+        ...opts
+    });
+function tryParseSql(value) {
+    const isString = typeof value === "string";
+    const statement = isString ? value : value.statement;
+    try {
+        const formatted = _PlatformTools.PlatformTools.highlightSql(_PlatformTools.PlatformTools.formatSql(statement));
+        return formatted;
+    } catch  {
+        return statement;
+    }
+}

package/commonjs/src/type-orm.module.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TypeOrmModule", {
+    enumerable: true,
+    get: function() {
+        return TypeOrmModule;
+    }
+});
+const _data = require("@decohere/data");
+const _http = require("@decohere/http");
+const _caching = require("@decohere/core/caching");
+const _bootstrap = require("./bootstrap.js");
+const _datasourcefactory = require("./data-source.factory.js");
+const _injectdatasource = require("./inject-data-source.js");
+const _typeormscribelogger = require("./typeorm-scribe.logger.js");
+const _unitofwork = require("./unit-of-work.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class TypeOrmModule {
+    /** Registers and opens a DataSource per module. Returns the names it registered them under. */ async configure(options) {
+        const { moduleConfigurations, databaseConfig, containerBuilder, applicationName } = options;
+        if (databaseConfig.dataSources.length === 0) {
+            throw new _data.DataConfigurationError("No datasources detected in config");
+        }
+        const modules = this.resolveDataSources(databaseConfig, moduleConfigurations);
+        // Once, before any DataSource opens: modules sharing a database must not race to create it.
+        await (0, _bootstrap.bootstrapDataSources)(modules.map((m)=>m.connectionInfo), {
+            applicationName
+        });
+        return await Promise.all(modules.map(async ({ name, connectionInfo, moduleConfig })=>{
+            await this.init(applicationName, name, connectionInfo, moduleConfig, containerBuilder);
+            return name;
+        }));
+    }
+    resolveDataSources(databaseConfig, moduleConfigurations) {
+        if (databaseConfig.dataSources.length === 1 && moduleConfigurations.length === 1) {
+            const moduleConfig = moduleConfigurations.at(0);
+            return [
+                {
+                    name: moduleConfig.name ?? _data.DEFAULT_DATA_SOURCE,
+                    connectionInfo: databaseConfig.dataSources.at(0),
+                    moduleConfig
+                }
+            ];
+        }
+        return moduleConfigurations.map((moduleConfig)=>{
+            const { name } = moduleConfig;
+            if (name == null) {
+                throw new _data.DataConfigurationError(`Name is required if there is more than one datasource`);
+            }
+            const connectionInfo = databaseConfig.dataSources.find((ds)=>ds.name === name);
+            if (connectionInfo == null) {
+                throw new _data.DataConfigurationError(`Cannot find connection info for ${name.toString()}`);
+            }
+            return {
+                name,
+                connectionInfo,
+                moduleConfig
+            };
+        });
+    }
+    async init(applicationName, name, connectionInfo, moduleConfig, builder) {
+        const logger = this.getLoggerFor(name, connectionInfo.dialect);
+        const dataSource = await this.configureTypeOrmDataSource(applicationName, name, moduleConfig, connectionInfo, builder, logger);
+        if (connectionInfo.seed) {
+            await moduleConfig.seed?.(dataSource);
+        }
+    }
+    async configureTypeOrmDataSource(applicationName, name, moduleConfig, connectionInfo, builder, logger) {
+        const { entities, repositories } = moduleConfig;
+        const dataSource = _datasourcefactory.DataSourceFactory.create({
+            entities,
+            applicationName,
+            ...connectionInfo
+        }, logger);
+        await dataSource.initialize();
+        const unitOfWork = ()=>new _unitofwork.TypeOrmUnitOfWork(dataSource);
+        builder.registerRequestScoped(name, unitOfWork);
+        builder.registerSingleton((0, _injectdatasource.typeOrmDataSourceToken)(name), dataSource);
+        builder.registerSingleton(_http.ReadinessCheckToken, createTypeOrmReadinessCheck(name, dataSource));
+        for (const repo of repositories ?? []){
+            builder.registerRequestScoped(repo);
+        }
+        return dataSource;
+    }
+    getLoggerFor(name, dialectOrProvider) {
+        return new _typeormscribelogger.TypeOrmScribeLogger(name.toString(), dialectOrProvider);
+    }
+}
+_ts_decorate([
+    (0, _caching.memoize)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object,
+        Object
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], TypeOrmModule.prototype, "getLoggerFor", null);
+function createTypeOrmReadinessCheck(name, dataSource) {
+    return {
+        name: `typeorm:${String(name)}`,
+        async check () {
+            await dataSource.query("SELECT 1");
+        }
+    };
+}

package/commonjs/src/type-orm.provider.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TypeOrmQueryProvider", {
+    enumerable: true,
+    get: function() {
+        return TypeOrmQueryProvider;
+    }
+});
+class TypeOrmQueryProvider {
+    unitOfWork;
+    constructor(unitOfWork){
+        this.unitOfWork = unitOfWork;
+    }
+    firstOrDefault(entity, options) {
+        return this.unitOfWork.entityManager.findOne(entity, options);
+    }
+    all(entity, options) {
+        return this.unitOfWork.getRepository(entity).find(options);
+    }
+    findById(entity, key) {
+        return this.unitOfWork.entityManager.findOneBy(entity, {
+            id: key
+        });
+    }
+    save(entity) {
+        return this.unitOfWork.entityManager.save(entity);
+    }
+    query(entity, filter) {
+        return this.unitOfWork.entityManager.find(entity, filter);
+    }
+    delete(entity) {
+        return this.unitOfWork.entityManager.remove(entity);
+    }
+}

package/commonjs/src/type-orm.repository.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TypeOrmRepository", {
+    enumerable: true,
+    get: function() {
+        return TypeOrmRepository;
+    }
+});
+const _data = require("@decohere/data");
+const _typeormprovider = require("./type-orm.provider.js");
+class TypeOrmRepository extends _data.Repository {
+    provider;
+    type;
+    constructor(unitOfWork, type){
+        super();
+        this.type = type;
+        this.provider = new _typeormprovider.TypeOrmQueryProvider(unitOfWork);
+    }
+    firstOrDefault(optionsOrType, options) {
+        if (typeof optionsOrType === "function") {
+            if (!options) {
+                throw new Error("options parameter is required when type is provided");
+            }
+            return this.provider.firstOrDefault(optionsOrType, options);
+        }
+        return this.provider.firstOrDefault(this.type, optionsOrType);
+    }
+}

package/commonjs/src/typeorm-scribe.logger.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TypeOrmScribeLogger", {
+    enumerable: true,
+    get: function() {
+        return TypeOrmScribeLogger;
+    }
+});
+const _caching = require("@decohere/core/caching");
+const _scribe = require("@decohere/scribe");
+const _typeorm = require("typeorm");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+const MessageTypeMap = {
+    log: "info",
+    info: "info",
+    query: "info",
+    warn: "warn",
+    error: "error",
+    "query-error": "error",
+    "query-slow": "warn",
+    "schema-build": "info",
+    migration: "info"
+};
+class TypeOrmScribeLogger extends _typeorm.AbstractLogger {
+    logger;
+    dialect;
+    constructor(name, dialect, enable = true){
+        super(enable);
+        this.dialect = dialect;
+        this.logger = _scribe.scribe.logger(`${name ?? "TypeOrm"}`);
+    }
+    writeLog(level, logMessage, _queryRunner) {
+        const messages = Array.isArray(logMessage) ? logMessage : [
+            logMessage
+        ];
+        for (const message of messages){
+            const logLevel = this.getLogLevel(message.type);
+            const prefix = message.type ?? level;
+            const statement = {
+                sql: {
+                    statement: message.message,
+                    language: this.dialect
+                }
+            };
+            this.logger[logLevel](prefix, statement);
+        }
+    }
+    getLogLevel(type) {
+        const level = Object.entries(MessageTypeMap).find(([key])=>type === key)?.at(1);
+        return this.logger.isLevelEnabled(level) ? level : this.logger.currentLevel;
+    }
+}
+_ts_decorate([
+    (0, _caching.cache)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], TypeOrmScribeLogger.prototype, "getLogLevel", null);

package/commonjs/src/typeorm.extensions.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BuilderExtensions", {
+    enumerable: true,
+    get: function() {
+        return BuilderExtensions;
+    }
+});
+const _data = require("@decohere/data");
+const _http = require("@decohere/http");
+const _extensibility = require("@decohere/core/extensibility");
+const _injectdatasource = require("./inject-data-source.js");
+const _typeormmodule = require("./type-orm.module.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class BuilderExtensions {
+    static withTypeOrm(builder, config) {
+        const names = [];
+        builder.registerPreBuildStep(async (configService, containerBuilder)=>{
+            const databaseConfig = await configService.get(_data.DatabaseConfig);
+            const module = new _typeormmodule.TypeOrmModule();
+            const moduleConfigurations = Array.isArray(config) ? config : [
+                config
+            ];
+            const applicationName = builder.applicationName;
+            names.push(...await module.configure({
+                applicationName,
+                databaseConfig,
+                moduleConfigurations,
+                containerBuilder
+            }));
+        });
+        // The container disposes only what it has handed out, and nothing may ever ask for a
+        // DataSource by its token. Resolving each here makes the root container own it, as one of
+        // its first instances, so it is closed last: after hosted services and other services
+        // that use it (#541).
+        builder.registerPostBuildStep((container)=>{
+            for (const name of names)container.resolve((0, _injectdatasource.typeOrmDataSourceToken)(name));
+        });
+        return builder;
+    }
+}
+_ts_decorate([
+    (0, _extensibility.extension)(_http.Builder),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _http.Builder === "undefined" ? Object : _http.Builder,
+        Object
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], BuilderExtensions, "withTypeOrm", null);