@decohere/data-typeorm 0.0.1-dev.125 → 0.0.1-dev.5

package/es6/src/server-manager.js

@@ -1,284 +0,0 @@
-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);
-}
-import { DataConfigurationError } from "@decohere/data";
-import { Pool } from "pg";
-import { alterDatabaseOwnerQuery, createSchemaQuery, createUserQuery, databaseOwnerQuery, defaultPrivilegesForAppQueries, grantConnectQuery, grantRoleMembershipQuery, grantSchemaCreateQuery, grantSchemaPrivilegesQuery, grantSchemaUsageQuery, hasDatabasePrivilegeQuery, hasRolePrivilegesQuery, hasSchemaPrivilegeQuery, quoteIdent, revokeRoleMembershipQuery, roleExistsQuery } from "./scripts/user.js";
-/**
- * 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";
-export 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 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 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 DataConfigurationError(`Cannot connect to PostgreSQL at ${host}:${port}. Is the server running? Cause: ${cause}`);
-        }
-    }
-    async initializeDatabase(database) {
-        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 = 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;
-        quoteIdent(schema, "schema");
-        if (appUsername === this.config.adminUser) {
-            throw new DataConfigurationError(`Runtime username "${appUsername}" must not equal adminUser — use a dedicated app role`);
-        }
-        if (migrateUsername && migrateUsername === appUsername) {
-            throw new DataConfigurationError("migrateUsername must differ from the runtime app username");
-        }
-        if (migrateUsername && migrateUsername === this.config.adminUser) {
-            throw new DataConfigurationError("migrateUsername must not equal adminUser");
-        }
-        const adminUser = this.config.adminUser;
-        if (!adminUser) {
-            throw new DataConfigurationError("adminUser is required to provision database roles");
-        }
-        const pool = new 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(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(createSchemaQuery(schema, owner).text);
-                if (migrateUsername && !await hasAll(pool, (privilege)=>hasSchemaPrivilegeQuery(migrateUsername, schema, privilege))) {
-                    await pool.query(grantSchemaPrivilegesQuery(migrateUsername, schema).text);
-                }
-                await this.ensureRole(pool, appUsername, appPassword);
-                if (!await granted(pool, hasDatabasePrivilegeQuery(appUsername, database, "CONNECT"))) {
-                    await pool.query(grantConnectQuery(appUsername, database).text);
-                }
-                if (!await granted(pool, hasSchemaPrivilegeQuery(appUsername, schema, "USAGE"))) {
-                    await pool.query(grantSchemaUsageQuery(appUsername, schema).text);
-                }
-                // Dev synchronize: the app connection must be able to CREATE tables.
-                if (allowAppDdl && !await granted(pool, hasSchemaPrivilegeQuery(appUsername, schema, "CREATE"))) {
-                    await pool.query(grantSchemaCreateQuery(appUsername, schema).text);
-                }
-                if (migrateUsername) {
-                    // Setting a default privilege that is already set changes nothing.
-                    for (const q of 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 DataConfigurationError(`A password is required for database role "${username}" unless the data source sets auth: trust`);
-        }
-        const exists = roleExistsQuery(username);
-        const found = await pool.query(exists.text, exists.values);
-        if (found.rowCount === 1) {
-            return;
-        }
-        const create = 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 = databaseOwnerQuery(database);
-    const result = await pool.query(query.text, query.values);
-    const owner = result.rows[0]?.owner;
-    if (owner == null) {
-        throw new 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, hasRolePrivilegesQuery(this.adminUser, role))) return;
-        try {
-            await this.pool.query(grantRoleMembershipQuery(this.adminUser, role).text);
-        } catch (err) {
-            throw new 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(revokeRoleMembershipQuery(this.adminUser, role).text);
-        }
-    }
-}

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

@@ -1,20 +0,0 @@
-import pinoPretty from "pino-pretty";
-import { PlatformTools } from "typeorm/platform/PlatformTools.js";
-export const SqlPretty = (opts)=>pinoPretty({
-        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.highlightSql(PlatformTools.formatSql(statement));
-        return formatted;
-    } catch  {
-        return statement;
-    }
-}

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

@@ -1,105 +0,0 @@
-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);
-}
-import { DataConfigurationError, DEFAULT_DATA_SOURCE } from "@decohere/data";
-import { ReadinessCheckToken } from "@decohere/http";
-import { memoize } from "@decohere/core/caching";
-import { bootstrapDataSources } from "./bootstrap.js";
-import { DataSourceFactory } from "./data-source.factory.js";
-import { typeOrmDataSourceToken } from "./inject-data-source.js";
-import { TypeOrmScribeLogger } from "./typeorm-scribe.logger.js";
-import { TypeOrmUnitOfWork } from "./unit-of-work.js";
-export 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 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 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 ?? DEFAULT_DATA_SOURCE,
-                    connectionInfo: databaseConfig.dataSources.at(0),
-                    moduleConfig
-                }
-            ];
-        }
-        return moduleConfigurations.map((moduleConfig)=>{
-            const { name } = moduleConfig;
-            if (name == null) {
-                throw new 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 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.create({
-            entities,
-            applicationName,
-            ...connectionInfo
-        }, logger);
-        await dataSource.initialize();
-        const unitOfWork = ()=>new TypeOrmUnitOfWork(dataSource);
-        builder.registerRequestScoped(name, unitOfWork);
-        builder.registerSingleton(typeOrmDataSourceToken(name), dataSource);
-        builder.registerSingleton(ReadinessCheckToken, createTypeOrmReadinessCheck(name, dataSource));
-        for (const repo of repositories ?? []){
-            builder.registerRequestScoped(repo);
-        }
-        return dataSource;
-    }
-    getLoggerFor(name, dialectOrProvider) {
-        return new TypeOrmScribeLogger(name.toString(), dialectOrProvider);
-    }
-}
-_ts_decorate([
-    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/es6/src/type-orm.provider.js

@@ -1,26 +0,0 @@
-export 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/es6/src/type-orm.repository.js

@@ -1,20 +0,0 @@
-import { Repository } from "@decohere/data";
-import { TypeOrmQueryProvider } from "./type-orm.provider.js";
-export class TypeOrmRepository extends Repository {
-    provider;
-    type;
-    constructor(unitOfWork, type){
-        super();
-        this.type = type;
-        this.provider = new 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/es6/src/typeorm-scribe.logger.js

@@ -1,60 +0,0 @@
-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);
-}
-import { cache } from "@decohere/core/caching";
-import { scribe } from "@decohere/scribe";
-import { AbstractLogger } from "typeorm";
-const MessageTypeMap = {
-    log: "info",
-    info: "info",
-    query: "info",
-    warn: "warn",
-    error: "error",
-    "query-error": "error",
-    "query-slow": "warn",
-    "schema-build": "info",
-    migration: "info"
-};
-export class TypeOrmScribeLogger extends AbstractLogger {
-    logger;
-    dialect;
-    constructor(name, dialect, enable = true){
-        super(enable);
-        this.dialect = dialect;
-        this.logger = 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([
-    cache(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], TypeOrmScribeLogger.prototype, "getLogLevel", null);

package/es6/src/typeorm.extensions.js

@@ -1,50 +0,0 @@
-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);
-}
-import { DatabaseConfig } from "@decohere/data";
-import { Builder } from "@decohere/http";
-import { extension } from "@decohere/core/extensibility";
-import { typeOrmDataSourceToken } from "./inject-data-source.js";
-import { TypeOrmModule } from "./type-orm.module.js";
-export class BuilderExtensions {
-    static withTypeOrm(builder, config) {
-        const names = [];
-        builder.registerPreBuildStep(async (configService, containerBuilder)=>{
-            const databaseConfig = await configService.get(DatabaseConfig);
-            const module = new 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(typeOrmDataSourceToken(name));
-        });
-        return builder;
-    }
-}
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        Object
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withTypeOrm", null);

package/es6/src/unit-of-work.js

@@ -1,39 +0,0 @@
-export class TypeOrmUnitOfWork {
-    dataSource;
-    queryRunner;
-    constructor(dataSource){
-        this.dataSource = dataSource;
-        this.queryRunner = this.dataSource.createQueryRunner();
-    }
-    get entityManager() {
-        return this.queryRunner.manager;
-    }
-    getRepository(entity) {
-        return this.entityManager.getRepository(entity);
-    }
-    async beginTransaction() {
-        return this.queryRunner.startTransaction();
-    }
-    async commit() {
-        return this.queryRunner.commitTransaction();
-    }
-    /**
-	 * Hand the connection back to the pool, rolling back first if a transaction is still open
-	 * (e.g. the request failed before commit). Otherwise the next user of that pooled
-	 * connection would inherit the half-finished transaction (#502).
-	 */ async [Symbol.asyncDispose]() {
-        if (this.queryRunner.isReleased) {
-            return;
-        }
-        try {
-            if (this.queryRunner.isTransactionActive) {
-                await this.queryRunner.rollbackTransaction();
-            }
-        } finally{
-            await this.queryRunner.release();
-        }
-    }
-    /** Prefer `await using` / async disposal; this starts the same cleanup without waiting. */ [Symbol.dispose]() {
-        void this[Symbol.asyncDispose]();
-    }
-}

package/types/src/bootstrap-policy.d.ts

@@ -1,19 +0,0 @@
-import { type ConnectionInfo } from "@decohere/data";
-/** True when NODE_ENV says development. Only then may a data source declare `auth: trust`. */
-export declare function isDevelopmentEnv(nodeEnv?: string | undefined): boolean;
-/**
- * Check how a data source signs in, in every environment. A server that needs no password is
- * declared with `auth: trust`, never inferred from a missing password: a password left out by
- * mistake would otherwise look like a trusted server and fail later, less clearly.
- */
-export declare function assertDataSourceAuth(info: ConnectionInfo, nodeEnv?: string | undefined): void;
-/**
- * Decide whether to bootstrap a data source (create its database, roles and schema).
- *
- * - `bootstrap: false` → never
- * - `bootstrap: true` → yes (requires adminUser, and adminPassword unless `auth: trust`)
- * - omitted → only in development, when those admin credentials are present
- */
-export declare function shouldBootstrapDatabase(info: ConnectionInfo, nodeEnv?: string | undefined): boolean;
-/** A data source that will be bootstrapped must have every password the bootstrap needs. */
-export declare function assertBootstrapCredentials(info: ConnectionInfo): void;

package/types/src/bootstrap.d.ts

@@ -1,16 +0,0 @@
-import { type ConnectionInfo } from "@decohere/data";
-export type BootstrapDataSourcesOptions = {
-    /** Shown as `application_name` on the bootstrap connections. */
-    applicationName: string;
-    /** Defaults to `process.env.NODE_ENV`. Decides whether `auth: trust` is allowed. */
-    nodeEnv?: string;
-};
-/**
- * Check every data source's auth, then create the databases, roles and schemas of those that
- * bootstrap. Data sources on the same server and database are bootstrapped once, one after the
- * other: in parallel they would race to create the same database and roles. Running it again
- * changes nothing.
- *
- * For runners and scripts that open their own `DataSource`; `withTypeOrm` calls it for you.
- */
-export declare function bootstrapDataSources(dataSources: readonly ConnectionInfo[], options: BootstrapDataSourcesOptions): Promise<void>;

package/types/src/data-source.factory.d.ts

@@ -1,17 +0,0 @@
-import type { ConnectionInfo } from "@decohere/data";
-import type { Constructable } from "@decohere/core/reflection";
-import { DataSource, type Logger } from "typeorm";
-export type ConnectionOptions = ConnectionInfo & {
-    entities: Constructable[];
-    applicationName?: string;
-};
-/**
- * A DataSource the container can close: TypeORM's has `destroy()` but no `Symbol.asyncDispose`,
- * so disposing the app's container used to leave its connections open (#541).
- */
-export declare class ManagedDataSource extends DataSource {
-    [Symbol.asyncDispose](): Promise<void>;
-}
-export declare class DataSourceFactory {
-    static create(options: ConnectionOptions, logger: Logger): DataSource;
-}

package/types/src/database-options.d.ts

@@ -1,9 +0,0 @@
-import type { Constructable } from "@decohere/core/reflection";
-import type { DataSource } from "typeorm";
-export type ModuleConfig = {
-    /** The unique identifier for the data source. Required when multiple data sources are configured. */
-    name?: string | symbol;
-    repositories?: Constructable[];
-    entities: Constructable[];
-    seed?: (dataSource: DataSource) => Promise<void>;
-};