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

package/LICENSE

@@ -1,15 +0,0 @@
-ISC License
-
-Copyright (c) 2025-2026 Typesmiths
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/commonjs/src/bootstrap-policy.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get assertBootstrapCredentials () {
-        return assertBootstrapCredentials;
-    },
-    get assertDataSourceAuth () {
-        return assertDataSourceAuth;
-    },
-    get isDevelopmentEnv () {
-        return isDevelopmentEnv;
-    },
-    get shouldBootstrapDatabase () {
-        return shouldBootstrapDatabase;
-    }
-});
-const _data = require("@decohere/data");
-function isDevelopmentEnv(nodeEnv = process.env.NODE_ENV) {
-    const env = nodeEnv?.toLowerCase() ?? "";
-    return env === "development" || env === "dev";
-}
-function isTrusted(info) {
-    return info.auth === "trust";
-}
-function has(value) {
-    return typeof value === "string" && value.length > 0;
-}
-function assertDataSourceAuth(info, nodeEnv = process.env.NODE_ENV) {
-    const auth = info.auth ?? "password";
-    if (auth !== "password" && auth !== "trust") {
-        throw new _data.DataConfigurationError(`Data source "${info.name}": auth must be "password" or "trust" (got ${JSON.stringify(auth)})`);
-    }
-    if (auth === "trust") {
-        if (!isDevelopmentEnv(nodeEnv)) {
-            throw new _data.DataConfigurationError(`Data source "${info.name}" sets auth: trust, which is allowed only in development (NODE_ENV is ${JSON.stringify(nodeEnv ?? "")}). A server that trusts every connection belongs on a developer's machine.`);
-        }
-        return;
-    }
-    if (!has(info.password)) {
-        throw new _data.DataConfigurationError(`Data source "${info.name}" has no password. Set password, or auth: trust for a local server that trusts every connection.`);
-    }
-}
-function shouldBootstrapDatabase(info, nodeEnv = process.env.NODE_ENV) {
-    if (info.bootstrap === false) {
-        return false;
-    }
-    const hasAdmin = has(info.adminUser) && (isTrusted(info) || has(info.adminPassword));
-    if (info.bootstrap === true) {
-        if (!hasAdmin) {
-            throw new _data.DataConfigurationError(`Data source "${info.name}": bootstrap requires adminUser and adminPassword (adminPassword may be left out only with auth: trust)`);
-        }
-        return true;
-    }
-    return isDevelopmentEnv(nodeEnv) && hasAdmin;
-}
-function assertBootstrapCredentials(info) {
-    if (isTrusted(info)) return;
-    if (has(info.migrateUsername) && !has(info.migratePassword)) {
-        throw new _data.DataConfigurationError(`Data source "${info.name}" has migrateUsername but no migratePassword. Set migratePassword, or auth: trust for a local server that trusts every connection.`);
-    }
-}

package/commonjs/src/bootstrap.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "bootstrapDataSources", {
-    enumerable: true,
-    get: function() {
-        return bootstrapDataSources;
-    }
-});
-const _data = require("@decohere/data");
-const _bootstrappolicy = require("./bootstrap-policy.js");
-const _servermanager = require("./server-manager.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);
-}
-/** What every data source on one server and database must agree on. */ const SHARED_FIELDS = [
-    "auth",
-    "adminUser",
-    "migrateUsername"
-];
-async function bootstrapDataSources(dataSources, options) {
-    const nodeEnv = options.nodeEnv ?? process.env.NODE_ENV;
-    for (const info of dataSources)(0, _bootstrappolicy.assertDataSourceAuth)(info, nodeEnv);
-    const toBootstrap = dataSources.filter((info)=>(0, _bootstrappolicy.shouldBootstrapDatabase)(info, nodeEnv));
-    for (const info of toBootstrap)(0, _bootstrappolicy.assertBootstrapCredentials)(info);
-    for (const group of byServerAndDatabase(toBootstrap)){
-        const env = {
-            stack: [],
-            error: void 0,
-            hasError: false
-        };
-        try {
-            const [first] = group;
-            const server = _ts_add_disposable_resource(env, new _servermanager.PostgresServerManager(options.applicationName, first), true);
-            await server.connect();
-            await server.initializeDatabase(first.database);
-            for (const info of group){
-                await server.provisionRoles({
-                    database: info.database,
-                    appUsername: info.username,
-                    appPassword: info.password,
-                    migrateUsername: info.migrateUsername,
-                    migratePassword: info.migratePassword,
-                    allowAppDdl: info.synchronize === true,
-                    schema: info.schema
-                });
-            }
-        } catch (e) {
-            env.error = e;
-            env.hasError = true;
-        } finally{
-            const result = _ts_dispose_resources(env);
-            if (result) await result;
-        }
-    }
-}
-function byServerAndDatabase(dataSources) {
-    const groups = new Map();
-    for (const info of dataSources){
-        const key = `${info.host}:${info.port}/${info.database}`;
-        const group = groups.get(key);
-        if (group == null) {
-            groups.set(key, [
-                info
-            ]);
-            continue;
-        }
-        const [first] = group;
-        for (const field of SHARED_FIELDS){
-            if (info[field] !== first[field]) {
-                throw new _data.DataConfigurationError(`Data sources "${first.name}" and "${info.name}" share database ${key} but set different ${field} (${JSON.stringify(first[field])} and ${JSON.stringify(info[field])})`);
-            }
-        }
-        group.push(info);
-    }
-    return [
-        ...groups.values()
-    ];
-}

package/commonjs/src/data-source.factory.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get DataSourceFactory () {
-        return DataSourceFactory;
-    },
-    get ManagedDataSource () {
-        return ManagedDataSource;
-    }
-});
-const _typeorm = require("typeorm");
-const _dialectmap = require("./dialect-map.js");
-/** Fields used only for bootstrap / privilege provisioning — not TypeORM connection options. */ function omitProvisionFields(options) {
-    const { adminUser: _adminUser, adminPassword: _adminPassword, migrateUsername: _migrateUsername, migratePassword: _migratePassword, bootstrap: _bootstrap, auth: _auth, seed: _seed, dialect: _dialect, name: _name, ...rest } = options;
-    return rest;
-}
-class ManagedDataSource extends _typeorm.DataSource {
-    async [Symbol.asyncDispose]() {
-        if (this.isInitialized) await this.destroy();
-    }
-}
-class DataSourceFactory {
-    static create(options, logger) {
-        const { applicationName } = options;
-        const { provider } = options;
-        const type = _dialectmap.ProviderMap[provider];
-        return new ManagedDataSource({
-            type,
-            logger,
-            applicationName,
-            ...omitProvisionFields(options)
-        });
-    }
-}

package/commonjs/src/database-options.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/commonjs/src/dialect-map.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get DialectMap () {
-        return DialectMap;
-    },
-    get ProviderMap () {
-        return ProviderMap;
-    }
-});
-const ProviderMap = {
-    postgres: "postgres",
-    mssql: "mssql"
-};
-const DialectMap = {
-    postgresql: "postgres",
-    tsql: "mssql"
-};

package/commonjs/src/index.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./bootstrap.js"), exports);
-_export_star(require("./inject-data-source.js"), exports);
-_export_star(require("./sql-pretty.transport.js"), exports);
-_export_star(require("./type-orm.provider.js"), exports);
-_export_star(require("./type-orm.repository.js"), exports);
-_export_star(require("./typeorm.extensions.js"), exports);
-_export_star(require("./unit-of-work.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/commonjs/src/inject-data-source.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get TypeOrmDataSourceToken () {
-        return TypeOrmDataSourceToken;
-    },
-    get injectDataSource () {
-        return injectDataSource;
-    },
-    get typeOrmDataSourceToken () {
-        return typeOrmDataSourceToken;
-    }
-});
-const _data = require("@decohere/data");
-const _decorators = require("@decohere/crucible/decorators");
-const TypeOrmDataSourceToken = Symbol("TypeOrmDataSource");
-function typeOrmDataSourceToken(name) {
-    if (name == null || name === _data.DEFAULT_DATA_SOURCE) {
-        return TypeOrmDataSourceToken;
-    }
-    return Symbol.for(`decohere:typeorm:datasource:${String(name)}`);
-}
-function injectDataSource(name) {
-    return (0, _decorators.inject)(typeOrmDataSourceToken(name));
-}

package/commonjs/src/scripts/user.js

@@ -1,259 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get alterDatabaseOwnerQuery () {
-        return alterDatabaseOwnerQuery;
-    },
-    get assertSafeSqlIdent () {
-        return assertSafeSqlIdent;
-    },
-    get createSchemaQuery () {
-        return createSchemaQuery;
-    },
-    get createUserQuery () {
-        return createUserQuery;
-    },
-    get databaseOwnerQuery () {
-        return databaseOwnerQuery;
-    },
-    get defaultPrivilegesForAppQueries () {
-        return defaultPrivilegesForAppQueries;
-    },
-    get grantConnectQuery () {
-        return grantConnectQuery;
-    },
-    get grantRoleMembershipQuery () {
-        return grantRoleMembershipQuery;
-    },
-    get grantSchemaCreateQuery () {
-        return grantSchemaCreateQuery;
-    },
-    get grantSchemaPrivilegesQuery () {
-        return grantSchemaPrivilegesQuery;
-    },
-    get grantSchemaUsageQuery () {
-        return grantSchemaUsageQuery;
-    },
-    get hasDatabasePrivilegeQuery () {
-        return hasDatabasePrivilegeQuery;
-    },
-    get hasRolePrivilegesQuery () {
-        return hasRolePrivilegesQuery;
-    },
-    get hasSchemaPrivilegeQuery () {
-        return hasSchemaPrivilegeQuery;
-    },
-    get quoteIdent () {
-        return quoteIdent;
-    },
-    get quoteLiteral () {
-        return quoteLiteral;
-    },
-    get revokeRoleMembershipQuery () {
-        return revokeRoleMembershipQuery;
-    },
-    get roleExistsQuery () {
-        return roleExistsQuery;
-    },
-    get userScripts () {
-        return userScripts;
-    }
-});
-/** Postgres identifier: letters, digits, underscore; must start with letter or underscore. */ const SAFE_IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function assertSafeSqlIdent(value, label) {
-    if (typeof value !== "string" || value.length === 0 || !SAFE_IDENT.test(value)) {
-        throw new Error(`Invalid ${label}: must match ${SAFE_IDENT} (got ${JSON.stringify(value)})`);
-    }
-    return value;
-}
-function quoteIdent(value, label = "identifier") {
-    const safe = assertSafeSqlIdent(value, label);
-    return `"${safe.replaceAll('"', '""')}"`;
-}
-function quoteLiteral(value) {
-    return `'${value.replaceAll("'", "''")}'`;
-}
-function roleExistsQuery(username) {
-    assertSafeSqlIdent(username, "username");
-    return {
-        text: `SELECT 1 FROM pg_catalog.pg_roles WHERE rolname = $1`,
-        values: [
-            username
-        ]
-    };
-}
-function createUserQuery(username, password) {
-    const userIdent = quoteIdent(username, "username");
-    const attributes = "NOSUPERUSER NOBYPASSRLS NOCREATEDB NOCREATEROLE";
-    if (password === undefined) {
-        return {
-            text: `CREATE USER ${userIdent} WITH LOGIN ${attributes}`,
-            values: []
-        };
-    }
-    if (typeof password !== "string" || password.length === 0) {
-        throw new Error("Invalid password: must be a non-empty string");
-    }
-    const passwordLiteral = quoteLiteral(password);
-    return {
-        text: `CREATE USER ${userIdent} WITH LOGIN PASSWORD ${passwordLiteral} ${attributes}`,
-        values: []
-    };
-}
-function grantConnectQuery(username, database) {
-    const userIdent = quoteIdent(username, "username");
-    const dbIdent = quoteIdent(database, "database");
-    return {
-        text: `GRANT CONNECT ON DATABASE ${dbIdent} TO ${userIdent}`,
-        values: []
-    };
-}
-function grantSchemaUsageQuery(username, schema = "public") {
-    const userIdent = quoteIdent(username, "username");
-    const schemaIdent = quoteIdent(schema, "schema");
-    return {
-        text: `GRANT USAGE ON SCHEMA ${schemaIdent} TO ${userIdent}`,
-        values: []
-    };
-}
-function grantSchemaCreateQuery(username, schema = "public") {
-    const userIdent = quoteIdent(username, "username");
-    const schemaIdent = quoteIdent(schema, "schema");
-    return {
-        text: `GRANT CREATE ON SCHEMA ${schemaIdent} TO ${userIdent}`,
-        values: []
-    };
-}
-function createSchemaQuery(schema, owner) {
-    const schemaIdent = quoteIdent(schema, "schema");
-    const ownerIdent = quoteIdent(owner, "owner");
-    return {
-        text: `CREATE SCHEMA IF NOT EXISTS ${schemaIdent} AUTHORIZATION ${ownerIdent}`,
-        values: []
-    };
-}
-function hasDatabasePrivilegeQuery(username, database, privilege) {
-    assertSafeSqlIdent(username, "username");
-    assertSafeSqlIdent(database, "database");
-    return {
-        text: `SELECT has_database_privilege($1, $2, $3) AS granted`,
-        values: [
-            username,
-            database,
-            privilege
-        ]
-    };
-}
-function hasSchemaPrivilegeQuery(username, schema, privilege) {
-    assertSafeSqlIdent(username, "username");
-    assertSafeSqlIdent(schema, "schema");
-    return {
-        text: `SELECT has_schema_privilege($1, $2, $3) AS granted`,
-        values: [
-            username,
-            schema,
-            privilege
-        ]
-    };
-}
-function hasRolePrivilegesQuery(member, role) {
-    assertSafeSqlIdent(member, "member");
-    assertSafeSqlIdent(role, "role");
-    return {
-        text: `SELECT pg_has_role($1, $2, 'USAGE') AS granted`,
-        values: [
-            member,
-            role
-        ]
-    };
-}
-function databaseOwnerQuery(database) {
-    assertSafeSqlIdent(database, "database");
-    return {
-        text: `SELECT pg_get_userbyid(datdba) AS owner FROM pg_catalog.pg_database WHERE datname = $1`,
-        values: [
-            database
-        ]
-    };
-}
-function grantSchemaPrivilegesQuery(username, schema = "public") {
-    const userIdent = quoteIdent(username, "username");
-    const schemaIdent = quoteIdent(schema, "schema");
-    return {
-        text: `GRANT ALL ON SCHEMA ${schemaIdent} TO ${userIdent}`,
-        values: []
-    };
-}
-function alterDatabaseOwnerQuery(database, username) {
-    const dbIdent = quoteIdent(database, "database");
-    const userIdent = quoteIdent(username, "username");
-    return {
-        text: `ALTER DATABASE ${dbIdent} OWNER TO ${userIdent}`,
-        values: []
-    };
-}
-function grantRoleMembershipQuery(member, role) {
-    const memberIdent = quoteIdent(member, "member");
-    const roleIdent = quoteIdent(role, "role");
-    return {
-        text: `GRANT ${roleIdent} TO ${memberIdent}`,
-        values: []
-    };
-}
-function revokeRoleMembershipQuery(member, role) {
-    const memberIdent = quoteIdent(member, "member");
-    const roleIdent = quoteIdent(role, "role");
-    return {
-        text: `REVOKE ${roleIdent} FROM ${memberIdent}`,
-        values: []
-    };
-}
-function defaultPrivilegesForAppQueries(migrateUsername, appUsername, schema = "public") {
-    const migrateIdent = quoteIdent(migrateUsername, "migrateUsername");
-    const appIdent = quoteIdent(appUsername, "username");
-    const schemaIdent = quoteIdent(schema, "schema");
-    return [
-        {
-            text: `ALTER DEFAULT PRIVILEGES FOR ROLE ${migrateIdent} IN SCHEMA ${schemaIdent} GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO ${appIdent}`,
-            values: []
-        },
-        {
-            text: `ALTER DEFAULT PRIVILEGES FOR ROLE ${migrateIdent} IN SCHEMA ${schemaIdent} GRANT USAGE, SELECT ON SEQUENCES TO ${appIdent}`,
-            values: []
-        }
-    ];
-}
-/**
- * @deprecated Prefer discrete query helpers + PostgresServerManager.provisionRoles.
- * Kept for call-site / pen-test migration: emits create + CONNECT + USAGE (not ALL PRIVILEGES).
- */ const createOwnerUser = (username, password, database)=>{
-    quoteIdent(username, "username");
-    quoteIdent(database, "database");
-    if (typeof password !== "string" || password.length === 0) {
-        throw new Error("Invalid password: must be a non-empty string");
-    }
-    const create = createUserQuery(username, password);
-    const connect = grantConnectQuery(username, database);
-    const usage = grantSchemaUsageQuery(username);
-    return {
-        text: [
-            create.text,
-            connect.text,
-            usage.text
-        ].join(";\n"),
-        values: []
-    };
-};
-const userExists = (username)=>roleExistsQuery(username);
-const userScripts = {
-    createOwnerUser,
-    userExists
-};