{"version":3,"sources":["jsdelivr-header.js","/npm/knex-snowflake-dialect@0.3.3/lib/index.js"],"names":[],"mappings":"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","file":"/npm/knex-snowflake-dialect@0.3.3/lib/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/knex-snowflake-dialect@0.3.3/lib/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst Bluebird = require(\"bluebird\");\nconst Knex = require(\"knex\");\nconst lodash_1 = require(\"lodash\");\nconst QueryCompiler_1 = require(\"./query/QueryCompiler\");\nconst schema_1 = require(\"./schema\");\nconst ColumnBuilder = require(\"knex/lib/schema/columnbuilder\");\nconst ColumnCompiler_MySQL = require(\"knex/lib/dialects/mysql/schema/columncompiler\");\nconst Transaction = require(\"knex/lib/transaction\");\nconst util_1 = require(\"util\");\nclass SnowflakeDialect extends Knex.Client {\n    constructor(config = {\n        dialect: \"snowflake\",\n        driverName: \"snowflake-sdk\",\n    }) {\n        if (config.connection) {\n            if (config.connection.user && !config.connection.username) {\n                config.connection.username = config.connection.user;\n            }\n            if (config.connection.host) {\n                const [account, region] = config.connection.host.split(\".\");\n                if (!config.connection.account) {\n                    config.connection.account = account;\n                }\n                if (!config.connection.region) {\n                    config.connection.region = region;\n                }\n            }\n        }\n        super(config);\n    }\n    get dialect() {\n        return \"snowflake\";\n    }\n    get driverName() {\n        return \"snowflake-sdk\";\n    }\n    transaction(container, config, outerTx) {\n        const transax = new Transaction(this, container, config, outerTx);\n        transax.savepoint = (conn) => {\n            // @ts-ignore\n            transax.trxClient.logger(\"Snowflake does not support savepoints.\");\n        };\n        transax.release = (conn, value) => {\n            // @ts-ignore\n            transax.trxClient.logger(\"Snowflake does not support savepoints.\");\n        };\n        transax.rollbackTo = (conn, error) => {\n            // @ts-ignore\n            this.trxClient.logger(\"Snowflake does not support savepoints.\");\n        };\n        return transax;\n    }\n    queryCompiler(builder) {\n        return new QueryCompiler_1.QueryCompiler(this, builder);\n    }\n    columnBuilder(tableBuilder, type, args) {\n        // ColumnBuilder methods are created at runtime, so that it does not play well with TypeScript.\n        // So instead of extending ColumnBuilder, we override methods at runtime here\n        const columnBuilder = new ColumnBuilder(this, tableBuilder, type, args);\n        columnBuilder.primary = (constraintName) => {\n            // @ts-ignore\n            columnBuilder.notNullable();\n            return columnBuilder;\n        };\n        columnBuilder.index = (indexName) => {\n            // @ts-ignore\n            columnBuilder.client.logger.warn(\"Snowflake does not support the creation of indexes.\");\n            return columnBuilder;\n        };\n        return columnBuilder;\n    }\n    columnCompiler(tableCompiler, columnBuilder) {\n        // ColumnCompiler methods are created at runtime, so that it does not play well with TypeScript.\n        // So instead of extending ColumnCompiler, we override methods at runtime here\n        const columnCompiler = new ColumnCompiler_MySQL(this, tableCompiler.tableBuilder, columnBuilder);\n        columnCompiler.increments = \"int not null autoincrement primary key\";\n        columnCompiler.bigincrements = \"bigint not null autoincrement primary key\";\n        columnCompiler.mediumint = (colName) => \"integer\";\n        columnCompiler.decimal = (colName, precision, scale) => {\n            if (precision) {\n                return ColumnCompiler_MySQL.prototype.decimal(colName, precision, scale);\n            }\n            return \"decimal\";\n        };\n        columnCompiler.double = (colName, precision, scale) => {\n            if (precision) {\n                return ColumnCompiler_MySQL.prototype.decimal(colName, precision, scale);\n            }\n            return \"double\";\n        };\n        columnCompiler.enu = (colName, values) => \"varchar\";\n        columnCompiler.json = columnCompiler.jsonb = (colName) => \"variant\";\n        return columnCompiler;\n    }\n    tableCompiler(tableBuilder) {\n        return new schema_1.TableCompiler(this, tableBuilder);\n    }\n    schemaCompiler(builder) {\n        return new schema_1.SchemaCompiler(this, builder);\n    }\n    _driver() {\n        const Snowflake = require(\"snowflake-sdk\");\n        return Snowflake;\n    }\n    // Get a raw connection, called by the `pool` whenever a new\n    // connection needs to be added to the pool.\n    acquireRawConnection() {\n        return new Bluebird((resolver, rejecter) => {\n            // @ts-ignore\n            const connection = this.driver.createConnection(this.connectionSettings);\n            connection.on(\"error\", (err) => {\n                connection.__knex__disposed = err;\n            });\n            connection.connect((err) => {\n                if (err) {\n                    // if connection is rejected, remove listener that was registered above...\n                    connection.removeAllListeners();\n                    return rejecter(err);\n                }\n                resolver(connection);\n            });\n        });\n    }\n    // Used to explicitly close a connection, called internally by the pool\n    // when a connection times out or the pool is shutdown.\n    async destroyRawConnection(connection) {\n        try {\n            const end = util_1.promisify((cb) => connection.end(cb));\n            await end();\n        }\n        catch (err) {\n            connection.__knex__disposed = err;\n        }\n        finally {\n            // see discussion https://github.com/knex/knex/pull/3483\n            lodash_1.defer(() => connection.removeAllListeners());\n        }\n    }\n    async validateConnection(connection) {\n        if (connection) {\n            return true;\n        }\n        return false;\n    }\n    // Runs the query on the specified connection, providing the bindings\n    // and any other necessary prep work.\n    _query(connection, obj) {\n        if (!obj || typeof obj === \"string\")\n            obj = { sql: obj };\n        return new Bluebird((resolver, rejecter) => {\n            if (!obj.sql) {\n                resolver();\n                return;\n            }\n            const queryOptions = Object.assign({ sqlText: obj.sql, binds: obj.bindings, complete(err, statement, rows) {\n                    if (err)\n                        return rejecter(err);\n                    obj.response = { rows, statement };\n                    resolver(obj);\n                } }, obj.options);\n            connection.execute(queryOptions);\n        });\n    }\n    // Ensures the response is returned in the same format as other clients.\n    processResponse(obj, runner) {\n        const resp = obj.response;\n        if (obj.output)\n            return obj.output.call(runner, resp);\n        if (obj.method === \"raw\")\n            return resp;\n        if (obj.method === \"select\") {\n            // if (obj.method === 'first') return resp.rows[0];\n            // if (obj.method === 'pluck') return map(resp.rows, obj.pluck);\n            return resp.rows;\n        }\n        if (obj.method === \"insert\" ||\n            obj.method === \"update\" ||\n            obj.method === \"delete\") {\n            if (resp.rows) {\n                const method = obj.method === \"insert\" ? \"inserte\" : obj.method;\n                return resp.rows.reduce((count, row) => count + row[`number of rows ${method}d`], 0);\n            }\n            return resp;\n        }\n        if (resp.statement && resp.rows) {\n            return resp.rows;\n        }\n        return resp;\n    }\n    postProcessResponse(result, queryContext) {\n        if (this.config.postProcessResponse) {\n            return this.config.postProcessResponse(result, queryContext);\n        }\n        // Snowflake returns column names in uppercase, convert to lowercase\n        // (to conform with knex, e.g. schema migrations)\n        const lowercaseAttrs = (row) => {\n            return lodash_1.fromPairs(lodash_1.toPairs(row).map(([key, value]) => [key.toLowerCase(), value]));\n        };\n        if (result.rows) {\n            return Object.assign(Object.assign({}, result), { rows: result.rows.map(lowercaseAttrs) });\n        }\n        else if (lodash_1.isArray(result)) {\n            return result.map(lowercaseAttrs);\n        }\n        return result;\n    }\n    customWrapIdentifier(value, origImpl, queryContext) {\n        if (this.config.wrapIdentifier) {\n            return this.config.wrapIdentifier(value, origImpl, queryContext);\n        }\n        else if (!value.startsWith('\"')) {\n            return origImpl(value.toUpperCase());\n        }\n        return origImpl;\n    }\n}\nexports.SnowflakeDialect = SnowflakeDialect;\n"]}