@forestadmin/datasource-sql 1.6.6 → 1.6.8

package/dist/connection/connection-options.d.ts

@@ -0,0 +1,47 @@
+import { Logger } from '@forestadmin/datasource-toolkit';
+import { Dialect, Options as SequelizeOptions } from 'sequelize';
+import { PlainConnectionOptions, PlainConnectionOptionsOrUri, ProxyOptions } from '../types';
+/**
+ * Connection options.
+ * This wrapper is constructed from a plain object or a URI string.
+ *
+ * It is capable of parsing them, and providing an interface to the rest of the code to:
+ * - Build parameters to create sequelize instances
+ * - Build connections options with both dialect and sslmode resolved (for quick startup in cloud)
+ * - Provide safe urls for error messages (without credentials)
+ * - Play with the host and port without breaking SSL servername / error messages (for the proxy)
+ */
+export default class ConnectionOptions {
+    proxyOptions?: ProxyOptions;
+    private initialHost;
+    private initialPort;
+    private logger?;
+    private sequelizeOptions;
+    private sslMode;
+    private uri?;
+    /**
+     * Database URI without credentials, which can be used in error messages.
+     * Ensure that this is never substituted by the proxy, nor that it includes credentials.
+     */
+    get debugDatabaseUri(): string;
+    /** Proxy URI without credentials, which can be used in error messages INTERNALLY */
+    get debugProxyUri(): string;
+    get dialect(): Dialect;
+    get host(): string;
+    get port(): number;
+    get database(): string;
+    constructor(options: PlainConnectionOptionsOrUri, logger?: Logger);
+    changeHostAndPort(host: string, port: number): void;
+    buildPreprocessedOptions(): Promise<PlainConnectionOptions>;
+    /** Options that can be passed to the sequelize constructor */
+    buildSequelizeCtorOptions(): Promise<[SequelizeOptions] | [string, SequelizeOptions]>;
+    private parseDatabaseUri;
+    /** Helper to fill the sequelize's options.schema  */
+    private makeSequelizeSchema;
+    /** Helper to fill the sequelize's options.logging */
+    private makeSequelizeLogging;
+    /** Helper to fill the sequelize's options.dialectOptions */
+    private makeSequelizeDialectOptions;
+    private computeSslMode;
+}
+//# sourceMappingURL=connection-options.d.ts.map

package/dist/connection/connection-options.js

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("./errors");
+const index_1 = __importDefault(require("./index"));
+/**
+ * Connection options.
+ * This wrapper is constructed from a plain object or a URI string.
+ *
+ * It is capable of parsing them, and providing an interface to the rest of the code to:
+ * - Build parameters to create sequelize instances
+ * - Build connections options with both dialect and sslmode resolved (for quick startup in cloud)
+ * - Provide safe urls for error messages (without credentials)
+ * - Play with the host and port without breaking SSL servername / error messages (for the proxy)
+ */
+class ConnectionOptions {
+    /**
+     * Database URI without credentials, which can be used in error messages.
+     * Ensure that this is never substituted by the proxy, nor that it includes credentials.
+     */
+    get debugDatabaseUri() {
+        const dialect = this.dialect ?? '?';
+        const port = this.initialPort ?? '?';
+        const database = this.database ?? '?';
+        return dialect === 'sqlite'
+            ? this.uri?.href ?? `sqlite:${this.sequelizeOptions.storage}`
+            : `${dialect}://${this.initialHost}:${port}/${database}`;
+    }
+    /** Proxy URI without credentials, which can be used in error messages INTERNALLY */
+    get debugProxyUri() {
+        return this.proxyOptions ? `tcp://${this.proxyOptions.host}:${this.proxyOptions.port}` : 'none';
+    }
+    get dialect() {
+        let dialect = this.uri?.protocol?.slice(0, -1) || this.sequelizeOptions.dialect;
+        if (dialect === 'mysql2')
+            dialect = 'mysql';
+        else if (dialect === 'tedious')
+            dialect = 'mssql';
+        else if (dialect === 'pg' || dialect === 'postgresql')
+            dialect = 'postgres';
+        return dialect;
+    }
+    get host() {
+        return this.uri?.hostname ?? this.sequelizeOptions.host ?? 'localhost';
+    }
+    get port() {
+        let port = Number(this.uri?.port) || this.sequelizeOptions.port;
+        if (!port) {
+            // Use default port for known dialects otherwise
+            if (this.dialect === 'postgres')
+                port = 5432;
+            else if (this.dialect === 'mssql')
+                port = 1433;
+            else if (this.dialect === 'mysql' || this.dialect === 'mariadb')
+                port = 3306;
+        }
+        return port;
+    }
+    get database() {
+        return this.uri?.pathname?.slice(1) || this.sequelizeOptions.database;
+    }
+    constructor(options, logger) {
+        this.logger = logger;
+        if (typeof options === 'string') {
+            this.uri = this.parseDatabaseUri(options);
+            this.sequelizeOptions = {};
+        }
+        else {
+            const { uri, sslMode, proxySocks, ...sequelizeOptions } = options;
+            this.proxyOptions = proxySocks;
+            this.sequelizeOptions = sequelizeOptions;
+            this.sslMode = sslMode ?? 'manual';
+            this.uri = uri ? this.parseDatabaseUri(uri) : null;
+        }
+        // Save initial host & port (for SSL and error messages)
+        this.initialHost = this.host;
+        this.initialPort = this.port;
+        // Check required options
+        if (!this.dialect)
+            throw new errors_1.DatabaseConnectError(`Dialect is required`, this.debugDatabaseUri);
+        if (this.dialect !== 'sqlite' && !this.port)
+            throw new errors_1.DatabaseConnectError(`Port is required`, this.debugDatabaseUri);
+    }
+    changeHostAndPort(host, port) {
+        // Host
+        if (this.uri)
+            this.uri.hostname = host;
+        else
+            this.sequelizeOptions.host = host;
+        // Port
+        if (this.uri)
+            this.uri.port = String(port);
+        else
+            this.sequelizeOptions.port = port;
+    }
+    async buildPreprocessedOptions() {
+        const options = { ...this.sequelizeOptions };
+        if (this.uri)
+            options.uri = this.uri.toString();
+        if (this.proxyOptions)
+            options.proxySocks = this.proxyOptions;
+        options.dialect = this.dialect;
+        options.sslMode = await this.computeSslMode();
+        return options;
+    }
+    /** Options that can be passed to the sequelize constructor */
+    async buildSequelizeCtorOptions() {
+        const options = { ...this.sequelizeOptions };
+        options.dialect = this.dialect;
+        options.logging = this.makeSequelizeLogging();
+        options.schema = this.makeSequelizeSchema();
+        options.dialectOptions = {
+            ...(options.dialectOptions ?? {}),
+            ...(await this.makeSequelizeDialectOptions()),
+        };
+        return this.uri ? [this.uri.toString(), options] : [options];
+    }
+    parseDatabaseUri(str) {
+        const message = `Connection Uri "${str}" provided to SQL data source is not valid. ` +
+            `Should be <dialect>://<connection>.`;
+        if (!str.startsWith('sqlite') && !/.*:\/\//g.test(str))
+            throw new errors_1.DatabaseConnectError(message, str);
+        try {
+            return new URL(str);
+        }
+        catch {
+            throw new errors_1.DatabaseConnectError(message, str);
+        }
+    }
+    /** Helper to fill the sequelize's options.schema  */
+    makeSequelizeSchema() {
+        return this.uri?.searchParams.get('schema') || this.sequelizeOptions.schema || null;
+    }
+    /** Helper to fill the sequelize's options.logging */
+    makeSequelizeLogging() {
+        return this.logger
+            ? (sql) => this.logger?.('Debug', sql.substring(sql.indexOf(':') + 2))
+            : false;
+    }
+    /** Helper to fill the sequelize's options.dialectOptions */
+    async makeSequelizeDialectOptions() {
+        const sslMode = await this.computeSslMode();
+        switch (this.dialect) {
+            case 'mariadb':
+                if (sslMode === 'disabled')
+                    return { ssl: false };
+                if (sslMode === 'required')
+                    return { ssl: { rejectUnauthorized: false } };
+                if (sslMode === 'verify')
+                    return { ssl: true };
+                break;
+            case 'mssql':
+                if (sslMode === 'disabled')
+                    return { options: { encrypt: false } };
+                if (sslMode === 'required')
+                    return { options: { encrypt: true, trustServerCertificate: true } };
+                if (sslMode === 'verify')
+                    return { options: { encrypt: true, trustServerCertificate: false } };
+                break;
+            case 'mysql':
+                if (sslMode === 'disabled')
+                    return { ssl: false };
+                if (sslMode === 'required')
+                    return { ssl: { rejectUnauthorized: false } };
+                if (sslMode === 'verify')
+                    return { ssl: { rejectUnauthorized: true } };
+                break;
+            case 'postgres':
+                if (sslMode === 'disabled')
+                    return { ssl: false };
+                // Pass servername to the net.tlsSocket constructor.
+                // This is done so that
+                // - Certificate verification still work when using a proxy server to reach the db (we are
+                //   forced to use a tcp reverse proxy because some drivers do not support them)
+                // - Providers which use SNI to route requests to the correct database still work (most
+                //   notably neon.tech).
+                // Note that we should either do that for the other vendors (if possible), or
+                // replace the reverse proxy by a forward proxy (when supported).
+                if (sslMode === 'required')
+                    return {
+                        ssl: { require: true, rejectUnauthorized: false, servername: this.initialHost },
+                    };
+                if (sslMode === 'verify')
+                    return { ssl: { require: true, rejectUnauthorized: true, servername: this.initialHost } };
+                break;
+            case 'db2':
+            case 'oracle':
+            case 'snowflake':
+            case 'sqlite':
+            default:
+                if (sslMode && sslMode !== 'manual') {
+                    this.logger?.('Warn', `ignoring sslMode=${sslMode} (not supported for ${this.dialect})`);
+                }
+                return {};
+        }
+    }
+    async computeSslMode() {
+        if (this.sslMode !== 'preferred') {
+            return this.sslMode ?? 'manual';
+        }
+        // When NODE_TLS_REJECT_UNAUTHORIZED is set to 0, we skip the 'verify' mode, as we know it will
+        // always work locally, but not when deploying to another environment.
+        const modes = ['verify', 'required', 'disabled'];
+        if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0')
+            modes.shift();
+        let error;
+        for (const sslMode of modes) {
+            let sequelize;
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                sequelize = await (0, index_1.default)(new ConnectionOptions({
+                    uri: this.uri?.toString(),
+                    sslMode,
+                    ...this.sequelizeOptions,
+                }));
+                return sslMode;
+            }
+            catch (e) {
+                error = e;
+            }
+            finally {
+                await sequelize?.close(); // eslint-disable-line no-await-in-loop
+            }
+        }
+        throw error;
+    }
+}
+exports.default = ConnectionOptions;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection-options.js","sourceRoot":"","sources":["../../src/connection/connection-options.ts"],"names":[],"mappings":"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"}

package/dist/connection/errors.d.ts

@@ -1,17 +1,17 @@
-import { ConnectionOptionsObj } from '../types';
-export type SourceError = 'Proxy' | 'Database';
-declare class BaseError extends Error {
-    source: SourceError;
-    uri: string;
+export type ErrorSource = 'Proxy' | 'Database';
+declare abstract class BaseError extends Error {
+    abstract readonly source: ErrorSource;
+    readonly uri: string;
     readonly details: string;
-    constructor(message: string, details?: string);
+    constructor(message: string, uri: string, details?: string);
 }
 export declare class DatabaseConnectError extends BaseError {
-    constructor(message: string, databaseUri?: string, source?: SourceError);
+    readonly source: ErrorSource;
+    constructor(message: string, debugDatabaseUri: string, source?: ErrorSource);
 }
 export declare class ProxyConnectError extends BaseError {
-    constructor(message: string, proxyConfig?: ConnectionOptionsObj['proxySocks']);
-    private static buildSanitizedUriFromConfig;
+    readonly source = "Proxy";
+    constructor(message: string, debugProxyUri: string);
 }
 export {};
 //# sourceMappingURL=errors.d.ts.map

package/dist/connection/errors.js

@@ -1,59 +1,29 @@
 "use strict";
+/* eslint-disable max-classes-per-file */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyConnectError = exports.DatabaseConnectError = void 0;
-function sanitizeUri(uri) {
-    const uriObject = new URL(uri);
-    if (uriObject.password) {
-        uriObject.password = '**sanitizedPassword**';
-    }
-    return uriObject.toString();
-}
 class BaseError extends Error {
-    constructor(message, details) {
-        const messageWithDetails = details ? `${message}\n${details}` : message;
-        super(messageWithDetails);
+    constructor(message, uri, details) {
+        super(details ? `${message}\n${details}` : message);
+        this.name = this.constructor.name;
         this.details = details;
+        this.uri = uri;
     }
 }
 class DatabaseConnectError extends BaseError {
-    constructor(message, databaseUri, source = 'Database') {
-        if (databaseUri) {
-            const sanitizedUri = sanitizeUri(databaseUri);
-            super(`Unable to connect to the given uri: ${sanitizedUri}.`, message);
-            this.uri = sanitizedUri;
-        }
-        else {
-            super(`Unable to connect to the given uri.`, message);
-        }
-        this.name = this.constructor.name;
+    constructor(message, debugDatabaseUri, source = 'Database') {
+        super(`Unable to connect to the given uri: ${debugDatabaseUri}.`, debugDatabaseUri, message);
         this.source = source;
     }
 }
 exports.DatabaseConnectError = DatabaseConnectError;
 class ProxyConnectError extends BaseError {
-    constructor(message, proxyConfig) {
-        const defaultMessage = 'Your proxy has encountered an error.';
-        if (proxyConfig) {
-            const sanitizedUri = ProxyConnectError.buildSanitizedUriFromConfig(proxyConfig);
-            super(`${defaultMessage} Unable to connect to the given uri: ${sanitizedUri}.`, message);
-            this.uri = sanitizedUri;
-        }
-        else {
-            super(defaultMessage, message);
-        }
-        this.name = this.constructor.name;
+    constructor(message, debugProxyUri) {
+        // remove tcp protocol because its not added by the user
+        const sanitizedUri = debugProxyUri.replace('tcp://', '');
+        super(`Your proxy has encountered an error. Unable to connect to the given uri: ${sanitizedUri}.`, sanitizedUri, message);
         this.source = 'Proxy';
     }
-    static buildSanitizedUriFromConfig(proxyConfig) {
-        const proxyUri = new URL(`socks://${proxyConfig.host}:${proxyConfig.port}`);
-        if (proxyConfig.userId) {
-            proxyUri.username = proxyConfig.userId;
-        }
-        if (proxyConfig.password) {
-            proxyUri.password = proxyConfig.password;
-        }
-        return sanitizeUri(proxyUri.toString()).replace('socks://', '');
-    }
 }
 exports.ProxyConnectError = ProxyConnectError;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Nvbm5lY3Rpb24vZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSx5Q0FBeUM7OztBQUl6QyxNQUFlLFNBQVUsU0FBUSxLQUFLO0lBS3BDLFlBQVksT0FBZSxFQUFFLEdBQVcsRUFBRSxPQUFnQjtRQUN4RCxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxHQUFHLE9BQU8sS0FBSyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFcEQsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQztRQUNsQyxJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN2QixJQUFJLENBQUMsR0FBRyxHQUFHLEdBQUcsQ0FBQztJQUNqQixDQUFDO0NBQ0Y7QUFFRCxNQUFhLG9CQUFxQixTQUFRLFNBQVM7SUFHakQsWUFBWSxPQUFlLEVBQUUsZ0JBQXdCLEVBQUUsU0FBc0IsVUFBVTtRQUNyRixLQUFLLENBQUMsdUNBQXVDLGdCQUFnQixHQUFHLEVBQUUsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFFN0YsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7SUFDdkIsQ0FBQztDQUNGO0FBUkQsb0RBUUM7QUFFRCxNQUFhLGlCQUFrQixTQUFRLFNBQVM7SUFHOUMsWUFBWSxPQUFlLEVBQUUsYUFBcUI7UUFDaEQsd0RBQXdEO1FBQ3hELE1BQU0sWUFBWSxHQUFHLGFBQWEsQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRXpELEtBQUssQ0FDSCw0RUFBNEUsWUFBWSxHQUFHLEVBQzNGLFlBQVksRUFDWixPQUFPLENBQ1IsQ0FBQztRQVZLLFdBQU0sR0FBRyxPQUFPLENBQUM7SUFXMUIsQ0FBQztDQUNGO0FBYkQsOENBYUMifQ==

package/dist/connection/handle-errors.d.ts

@@ -1,4 +1,3 @@
-import ReverseProxy from './reverse-proxy';
-import { ConnectionOptionsObj } from '../types';
-export default function handleErrors(error: Error, options?: ConnectionOptionsObj, proxy?: ReverseProxy): void;
+import ConnectionOptions from './connection-options';
+export default function handleErrors(error: Error, options: ConnectionOptions): void;
 //# sourceMappingURL=handle-errors.d.ts.map

package/dist/connection/handle-errors.js

@@ -2,25 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sequelize_1 = require("sequelize");
 const errors_1 = require("./errors");
-function handleProxyErrors(error, databaseUri, proxyConfig) {
-    // eslint-disable-next-line max-len
-    // @link: list of errors thrown by the proxy https://github.com/JoshGlazebrook/socks/blob/76d013e4c9a2d956f07868477d8f12ec0b96edfc/src/common/constants.ts#LL10C10-L10C10
-    if (error?.stack?.includes('SocksClient')) {
-        if (error.message.includes('Socket closed') ||
-            error.message.includes('Socks5 proxy rejected connection')) {
-            throw new errors_1.DatabaseConnectError(null, databaseUri, 'Proxy');
-        }
-        throw new errors_1.ProxyConnectError(error.message, proxyConfig);
+function handleProxyErrors(error, options) {
+    /** @see https://github.com/JoshGlazebrook/socks/blob/76d013/src/common/constants.ts#L10 */
+    if (error.message.includes('Socket closed') ||
+        error.message.includes('Socks5 proxy rejected connection')) {
+        throw new errors_1.DatabaseConnectError(null, options.debugDatabaseUri, 'Proxy');
     }
+    throw new errors_1.ProxyConnectError(error.message, options.debugProxyUri);
+}
+function handleSequelizeError(error, options) {
+    const nameWithoutSequelize = error.name.replace('Sequelize', '');
+    const nameWithSpaces = nameWithoutSequelize.replace(/([a-z])([A-Z])/g, (_, m1, m2) => `${m1} ${m2.toLowerCase()}`);
+    throw new errors_1.DatabaseConnectError(`${nameWithSpaces}: ${error.message}`, options.debugDatabaseUri);
 }
-function handleErrors(error, options, proxy) {
-    handleProxyErrors(error, proxy?.destination.uri, proxy?.destination.proxySocks);
+function handleErrors(error, options) {
+    if (error?.stack?.includes('SocksClient')) {
+        handleProxyErrors(error, options);
+    }
     if (error instanceof sequelize_1.BaseError) {
-        const nameWithoutSequelize = error.name.replace('Sequelize', '');
-        const nameWithSpaces = nameWithoutSequelize.replace(/([a-z])([A-Z])/g, (_, m1, m2) => `${m1} ${m2.toLowerCase()}`);
-        throw new errors_1.DatabaseConnectError(`${nameWithSpaces}: ${error.message}`, options?.uri);
+        handleSequelizeError(error, options);
     }
     throw error;
 }
 exports.default = handleErrors;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlLWVycm9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25uZWN0aW9uL2hhbmRsZS1lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx5Q0FBc0M7QUFFdEMscUNBQW1FO0FBSW5FLFNBQVMsaUJBQWlCLENBQ3hCLEtBQVksRUFDWixXQUFvQixFQUNwQixXQUFnRDtJQUVoRCxtQ0FBbUM7SUFDbkMseUtBQXlLO0lBQ3pLLElBQUksS0FBSyxFQUFFLEtBQUssRUFBRSxRQUFRLENBQUMsYUFBYSxDQUFDLEVBQUU7UUFDekMsSUFDRSxLQUFLLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUM7WUFDdkMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsa0NBQWtDLENBQUMsRUFDMUQ7WUFDQSxNQUFNLElBQUksNkJBQW9CLENBQUMsSUFBSSxFQUFFLFdBQVcsRUFBRSxPQUFPLENBQUMsQ0FBQztTQUM1RDtRQUVELE1BQU0sSUFBSSwwQkFBaUIsQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLFdBQVcsQ0FBQyxDQUFDO0tBQ3pEO0FBQ0gsQ0FBQztBQUVELFNBQXdCLFlBQVksQ0FDbEMsS0FBWSxFQUNaLE9BQThCLEVBQzlCLEtBQW9CO0lBRXBCLGlCQUFpQixDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsV0FBVyxDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsV0FBVyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBRWhGLElBQUksS0FBSyxZQUFZLHFCQUFTLEVBQUU7UUFDOUIsTUFBTSxvQkFBb0IsR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDakUsTUFBTSxjQUFjLEdBQUcsb0JBQW9CLENBQUMsT0FBTyxDQUNqRCxpQkFBaUIsRUFDakIsQ0FBQyxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLENBQUMsR0FBRyxFQUFFLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQzNDLENBQUM7UUFFRixNQUFNLElBQUksNkJBQW9CLENBQUMsR0FBRyxjQUFjLEtBQUssS0FBSyxDQUFDLE9BQU8sRUFBRSxFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUMsQ0FBQztLQUNyRjtJQUVELE1BQU0sS0FBSyxDQUFDO0FBQ2QsQ0FBQztBQWxCRCwrQkFrQkMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlLWVycm9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25uZWN0aW9uL2hhbmRsZS1lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx5Q0FBd0Q7QUFHeEQscUNBQW1FO0FBRW5FLFNBQVMsaUJBQWlCLENBQUMsS0FBWSxFQUFFLE9BQTBCO0lBQ2pFLDJGQUEyRjtJQUMzRixJQUNFLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLGVBQWUsQ0FBQztRQUN2QyxLQUFLLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxrQ0FBa0MsQ0FBQyxFQUMxRDtRQUNBLE1BQU0sSUFBSSw2QkFBb0IsQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLGdCQUFnQixFQUFFLE9BQU8sQ0FBQyxDQUFDO0tBQ3pFO0lBRUQsTUFBTSxJQUFJLDBCQUFpQixDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0FBQ3BFLENBQUM7QUFFRCxTQUFTLG9CQUFvQixDQUFDLEtBQXFCLEVBQUUsT0FBMEI7SUFDN0UsTUFBTSxvQkFBb0IsR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDakUsTUFBTSxjQUFjLEdBQUcsb0JBQW9CLENBQUMsT0FBTyxDQUNqRCxpQkFBaUIsRUFDakIsQ0FBQyxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLENBQUMsR0FBRyxFQUFFLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQzNDLENBQUM7SUFFRixNQUFNLElBQUksNkJBQW9CLENBQUMsR0FBRyxjQUFjLEtBQUssS0FBSyxDQUFDLE9BQU8sRUFBRSxFQUFFLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0FBQ2xHLENBQUM7QUFFRCxTQUF3QixZQUFZLENBQUMsS0FBWSxFQUFFLE9BQTBCO0lBQzNFLElBQUksS0FBSyxFQUFFLEtBQUssRUFBRSxRQUFRLENBQUMsYUFBYSxDQUFDLEVBQUU7UUFDekMsaUJBQWlCLENBQUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0tBQ25DO0lBRUQsSUFBSSxLQUFLLFlBQVkscUJBQWMsRUFBRTtRQUNuQyxvQkFBb0IsQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUM7S0FDdEM7SUFFRCxNQUFNLEtBQUssQ0FBQztBQUNkLENBQUM7QUFWRCwrQkFVQyJ9

package/dist/connection/index.d.ts

@@ -1,6 +1,5 @@
-import type { ConnectionOptions } from '../types';
-import type { Logger } from '@forestadmin/datasource-toolkit';
 import { Sequelize } from 'sequelize';
+import ConnectionOptions from './connection-options';
 /** Attempt to connect to the database */
-export default function connect(uriOrOptions: ConnectionOptions, logger?: Logger): Promise<Sequelize>;
+export default function connect(options: ConnectionOptions): Promise<Sequelize>;
 //# sourceMappingURL=index.d.ts.map

package/dist/connection/index.js

@@ -3,57 +3,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const sequelize_1 = require("sequelize");
 const handle_errors_1 = __importDefault(require("./handle-errors"));
-const preprocess_1 = __importDefault(require("./preprocess"));
-const reverse_proxy_1 = __importDefault(require("./reverse-proxy"));
-const utils_1 = require("./utils");
+const reverse_proxy_1 = __importDefault(require("./services/reverse-proxy"));
+const sequelize_factory_1 = __importDefault(require("./services/sequelize-factory"));
+const tcp_server_1 = __importDefault(require("./services/tcp-server"));
 /** Attempt to connect to the database */
-async function connect(uriOrOptions, logger) {
+async function connect(options) {
     let proxy;
+    let tcpServer;
     let sequelize;
-    let options;
-    let servername;
     try {
-        options = await (0, preprocess_1.default)(uriOrOptions);
-        try {
-            servername = options?.host ?? new URL(options.uri).hostname;
+        if (options.proxyOptions) {
+            tcpServer = new tcp_server_1.default();
+            await tcpServer.start();
+            proxy = new reverse_proxy_1.default(options.proxyOptions, options.host, options.port);
+            tcpServer.onConnect(proxy.connectListener.bind(proxy));
+            tcpServer.onClose(proxy.closeListener.bind(proxy));
+            // swap database host and port with the ones from the proxy.
+            options.changeHostAndPort(tcpServer.host, tcpServer.port);
         }
-        catch {
-            // don't crash if using unix socket, sqlite, etc...
-        }
-        if (options.proxySocks) {
-            proxy = new reverse_proxy_1.default(options);
-            await proxy.start();
-            options = proxy.connectionOptions;
-        }
-        const { uri, sslMode, ...opts } = options;
-        const schema = opts.schema ?? (0, utils_1.getSchema)(uri);
-        const logging = logger ? (0, utils_1.getLogger)(logger) : false;
-        opts.dialectOptions = {
-            ...(opts.dialectOptions ?? {}),
-            ...(0, utils_1.getSslConfiguration)(opts.dialect, sslMode, servername, logger),
-        };
-        sequelize = uri
-            ? new sequelize_1.Sequelize(uri, { ...opts, schema, logging })
-            : new sequelize_1.Sequelize({ ...opts, schema, logging });
-        // we want to stop the proxy when the sequelize connection is closed
-        sequelize.close = async function close() {
-            try {
-                await sequelize_1.Sequelize.prototype.close.call(this);
-            }
-            finally {
-                await proxy?.stop();
-            }
-        };
+        const sequelizeFactory = new sequelize_factory_1.default();
+        if (tcpServer)
+            sequelizeFactory.onClose(tcpServer.closeListener.bind(tcpServer));
+        sequelize = sequelizeFactory.build(await options.buildSequelizeCtorOptions());
         await sequelize.authenticate(); // Test connection
         return sequelize;
     }
     catch (e) {
         await sequelize?.close();
         // if proxy encountered an error, we want to throw it instead of the sequelize error
-        (0, handle_errors_1.default)(proxy?.error || e, options, proxy);
+        (0, handle_errors_1.default)(proxy?.error ?? e, options);
     }
 }
 exports.default = connect;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29ubmVjdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUdBLG9FQUEyQztBQUMzQyw2RUFBb0Q7QUFDcEQscUZBQTREO0FBQzVELHVFQUE4QztBQUU5Qyx5Q0FBeUM7QUFDMUIsS0FBSyxVQUFVLE9BQU8sQ0FBQyxPQUEwQjtJQUM5RCxJQUFJLEtBQW1CLENBQUM7SUFDeEIsSUFBSSxTQUFvQixDQUFDO0lBQ3pCLElBQUksU0FBb0IsQ0FBQztJQUV6QixJQUFJO1FBQ0YsSUFBSSxPQUFPLENBQUMsWUFBWSxFQUFFO1lBQ3hCLFNBQVMsR0FBRyxJQUFJLG9CQUFTLEVBQUUsQ0FBQztZQUM1QixNQUFNLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUN4QixLQUFLLEdBQUcsSUFBSSx1QkFBWSxDQUFDLE9BQU8sQ0FBQyxZQUFZLEVBQUUsT0FBTyxDQUFDLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDM0UsU0FBUyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1lBQ3ZELFNBQVMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztZQUNuRCw0REFBNEQ7WUFDNUQsT0FBTyxDQUFDLGlCQUFpQixDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDO1NBQzNEO1FBRUQsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLDJCQUFnQixFQUFFLENBQUM7UUFDaEQsSUFBSSxTQUFTO1lBQUUsZ0JBQWdCLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7UUFFakYsU0FBUyxHQUFHLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxNQUFNLE9BQU8sQ0FBQyx5QkFBeUIsRUFBRSxDQUFDLENBQUM7UUFDOUUsTUFBTSxTQUFTLENBQUMsWUFBWSxFQUFFLENBQUMsQ0FBQyxrQkFBa0I7UUFFbEQsT0FBTyxTQUFTLENBQUM7S0FDbEI7SUFBQyxPQUFPLENBQUMsRUFBRTtRQUNWLE1BQU0sU0FBUyxFQUFFLEtBQUssRUFBRSxDQUFDO1FBQ3pCLG9GQUFvRjtRQUNwRixJQUFBLHVCQUFZLEVBQUMsS0FBSyxFQUFFLEtBQUssSUFBSSxDQUFDLEVBQUUsT0FBTyxDQUFDLENBQUM7S0FDMUM7QUFDSCxDQUFDO0FBNUJELDBCQTRCQyJ9

package/dist/connection/services/reverse-proxy.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import net from 'net';
+import Service from './service';
+import { ProxyOptions } from '../../types';
+export default class ReverseProxy extends Service {
+    private readonly errors;
+    private readonly connectedClients;
+    private readonly options;
+    private readonly targetHost;
+    private readonly targetPort;
+    get error(): Error | null;
+    constructor(proxyOptions: ProxyOptions, targetHost: string, targetPort: number);
+    closeListener(): Promise<void>;
+    connectListener(socket: net.Socket): Promise<void>;
+}
+//# sourceMappingURL=reverse-proxy.d.ts.map

package/dist/connection/services/reverse-proxy.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const socks_1 = require("socks");
+const service_1 = __importDefault(require("./service"));
+class ReverseProxy extends service_1.default {
+    get error() {
+        return this.errors.length > 0 ? this.errors[0] : null;
+    }
+    constructor(proxyOptions, targetHost, targetPort) {
+        super();
+        this.errors = [];
+        this.connectedClients = new Set();
+        this.options = proxyOptions;
+        this.targetHost = targetHost;
+        this.targetPort = targetPort;
+        if (!this.targetHost)
+            throw new Error('Host is required');
+        if (!this.targetPort)
+            throw new Error('Port is required');
+    }
+    async closeListener() {
+        await super.closeListener();
+        this.connectedClients.forEach(client => client.destroy());
+    }
+    async connectListener(socket) {
+        let socks5Proxy;
+        this.connectedClients.add(socket);
+        socket.on('error', error => {
+            this.errors.push(error);
+            if (!socket.closed)
+                socket.destroy(error);
+        });
+        socket.on('close', () => {
+            this.connectedClients.delete(socket);
+            if (!socks5Proxy?.socket.closed)
+                socks5Proxy?.socket.destroy();
+        });
+        try {
+            socks5Proxy = await socks_1.SocksClient.createConnection({
+                proxy: { ...this.options, type: 5 },
+                command: 'connect',
+                destination: { host: this.targetHost, port: this.targetPort },
+                timeout: 4000,
+            });
+            socks5Proxy.socket.on('close', () => {
+                this.connectedClients.delete(socks5Proxy.socket);
+                if (!socket.closed)
+                    socket.destroy();
+            });
+            socks5Proxy.socket.on('error', socket.destroy);
+            socks5Proxy.socket.pipe(socket).pipe(socks5Proxy.socket);
+            await super.connectListener(socks5Proxy.socket);
+        }
+        catch (err) {
+            socket.destroy(err);
+        }
+    }
+}
+exports.default = ReverseProxy;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/connection/services/sequelize-factory.d.ts

@@ -0,0 +1,8 @@
+import { Sequelize } from 'sequelize';
+import { Options as SequelizeOptions } from 'sequelize/types/sequelize';
+import Service from './service';
+export default class SequelizeFactory extends Service {
+    build(sequelizeCtorOptions: [SequelizeOptions] | [string, SequelizeOptions]): Sequelize;
+    private overrideCloseMethod;
+}
+//# sourceMappingURL=sequelize-factory.d.ts.map

package/dist/connection/services/sequelize-factory.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const service_1 = __importDefault(require("./service"));
+class SequelizeFactory extends service_1.default {
+    build(sequelizeCtorOptions) {
+        const sequelize = sequelizeCtorOptions.length === 1
+            ? new sequelize_1.Sequelize(sequelizeCtorOptions[0])
+            : new sequelize_1.Sequelize(sequelizeCtorOptions[0], sequelizeCtorOptions[1]);
+        this.overrideCloseMethod(sequelize);
+        return sequelize;
+    }
+    overrideCloseMethod(sequelize) {
+        const closeListener = this.closeListener.bind(this);
+        // override close method to ensure to execute the closeListener
+        sequelize.close = async function close() {
+            try {
+                await sequelize_1.Sequelize.prototype.close.call(this);
+            }
+            finally {
+                await closeListener();
+            }
+        };
+    }
+}
+exports.default = SequelizeFactory;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VxdWVsaXplLWZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29ubmVjdGlvbi9zZXJ2aWNlcy9zZXF1ZWxpemUtZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLHlDQUFzQztBQUd0Qyx3REFBZ0M7QUFFaEMsTUFBcUIsZ0JBQWlCLFNBQVEsaUJBQU87SUFDbkQsS0FBSyxDQUFDLG9CQUFxRTtRQUN6RSxNQUFNLFNBQVMsR0FDYixvQkFBb0IsQ0FBQyxNQUFNLEtBQUssQ0FBQztZQUMvQixDQUFDLENBQUMsSUFBSSxxQkFBUyxDQUFDLG9CQUFvQixDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3hDLENBQUMsQ0FBQyxJQUFJLHFCQUFTLENBQUMsb0JBQW9CLENBQUMsQ0FBQyxDQUFDLEVBQUUsb0JBQW9CLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUV0RSxJQUFJLENBQUMsbUJBQW1CLENBQUMsU0FBUyxDQUFDLENBQUM7UUFFcEMsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUVPLG1CQUFtQixDQUFDLFNBQW9CO1FBQzlDLE1BQU0sYUFBYSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBRXBELCtEQUErRDtRQUMvRCxTQUFTLENBQUMsS0FBSyxHQUFHLEtBQUssVUFBVSxLQUFLO1lBQ3BDLElBQUk7Z0JBQ0YsTUFBTSxxQkFBUyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO2FBQzVDO29CQUFTO2dCQUNSLE1BQU0sYUFBYSxFQUFFLENBQUM7YUFDdkI7UUFDSCxDQUFDLENBQUM7SUFDSixDQUFDO0NBQ0Y7QUF4QkQsbUNBd0JDIn0=

package/dist/connection/services/service.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import net from 'net';
+export type ConnectionCallback = (socket: net.Socket) => Promise<void>;
+export type CloseCallback = () => Promise<void>;
+export default abstract class Service {
+    private connectionCallback;
+    private closeCallback;
+    /** attach a callback when there is a new connection on the service. */
+    onConnect(callback: ConnectionCallback): void;
+    /** callback to execute when there is a new connection. */
+    connectListener(socket: net.Socket): Promise<void>;
+    /** attach a callback when a service is closing. */
+    onClose(callback: CloseCallback): void;
+    /** callback to execute when the service is closing. */
+    closeListener(): Promise<void>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/connection/services/service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Service {
+    /** attach a callback when there is a new connection on the service. */
+    onConnect(callback) {
+        this.connectionCallback = callback;
+    }
+    /** callback to execute when there is a new connection. */
+    async connectListener(socket) {
+        await this.connectionCallback?.(socket);
+    }
+    /** attach a callback when a service is closing. */
+    onClose(callback) {
+        this.closeCallback = callback;
+    }
+    /** callback to execute when the service is closing. */
+    async closeListener() {
+        await this.closeCallback?.();
+    }
+}
+exports.default = Service;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25uZWN0aW9uL3NlcnZpY2VzL3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFLQSxNQUE4QixPQUFPO0lBSW5DLHVFQUF1RTtJQUN2RSxTQUFTLENBQUMsUUFBNEI7UUFDcEMsSUFBSSxDQUFDLGtCQUFrQixHQUFHLFFBQVEsQ0FBQztJQUNyQyxDQUFDO0lBRUQsMERBQTBEO0lBQzFELEtBQUssQ0FBQyxlQUFlLENBQUMsTUFBa0I7UUFDdEMsTUFBTSxJQUFJLENBQUMsa0JBQWtCLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUMxQyxDQUFDO0lBRUQsbURBQW1EO0lBQ25ELE9BQU8sQ0FBQyxRQUF1QjtRQUM3QixJQUFJLENBQUMsYUFBYSxHQUFHLFFBQVEsQ0FBQztJQUNoQyxDQUFDO0lBRUQsdURBQXVEO0lBQ3ZELEtBQUssQ0FBQyxhQUFhO1FBQ2pCLE1BQU0sSUFBSSxDQUFDLGFBQWEsRUFBRSxFQUFFLENBQUM7SUFDL0IsQ0FBQztDQUNGO0FBdkJELDBCQXVCQyJ9

package/dist/connection/services/tcp-server.d.ts

@@ -0,0 +1,12 @@
+import Service from './service';
+/** TcpServer is used as proxy to redirect all the database requests */
+export default class TcpServer extends Service {
+    private readonly server;
+    get host(): string;
+    get port(): number;
+    constructor();
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    closeListener(): Promise<void>;
+}
+//# sourceMappingURL=tcp-server.d.ts.map

package/dist/connection/services/tcp-server.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const net_1 = __importDefault(require("net"));
+const service_1 = __importDefault(require("./service"));
+/** TcpServer is used as proxy to redirect all the database requests */
+class TcpServer extends service_1.default {
+    get host() {
+        return this.server.address().address;
+    }
+    get port() {
+        return this.server.address().port;
+    }
+    constructor() {
+        super();
+        this.server = net_1.default.createServer(this.connectListener.bind(this));
+    }
+    start() {
+        return new Promise((resolve, reject) => {
+            this.server.on('error', reject);
+            // By using port 0, the operating system
+            // will assign an available port for the server to listen on.
+            this.server.listen(0, '127.0.0.1', resolve);
+        });
+    }
+    async stop() {
+        try {
+            await super.closeListener();
+        }
+        finally {
+            await new Promise((resolve, reject) => {
+                this.server.close(e => {
+                    if (e)
+                        reject(e);
+                    else
+                        resolve();
+                });
+            });
+        }
+    }
+    async closeListener() {
+        await this.stop();
+    }
+}
+exports.default = TcpServer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGNwLXNlcnZlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25uZWN0aW9uL3NlcnZpY2VzL3RjcC1zZXJ2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSw4Q0FBc0I7QUFFdEIsd0RBQWdDO0FBRWhDLHVFQUF1RTtBQUN2RSxNQUFxQixTQUFVLFNBQVEsaUJBQU87SUFHNUMsSUFBSSxJQUFJO1FBQ04sT0FBUSxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBc0IsQ0FBQyxPQUFPLENBQUM7SUFDNUQsQ0FBQztJQUVELElBQUksSUFBSTtRQUNOLE9BQVEsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQXNCLENBQUMsSUFBSSxDQUFDO0lBQ3pELENBQUM7SUFFRDtRQUNFLEtBQUssRUFBRSxDQUFDO1FBQ1IsSUFBSSxDQUFDLE1BQU0sR0FBRyxhQUFHLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDbEUsQ0FBQztJQUVELEtBQUs7UUFDSCxPQUFPLElBQUksT0FBTyxDQUFPLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFO1lBQzNDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQztZQUNoQyx3Q0FBd0M7WUFDeEMsNkRBQTZEO1lBQzdELElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxXQUFXLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDOUMsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQsS0FBSyxDQUFDLElBQUk7UUFDUixJQUFJO1lBQ0YsTUFBTSxLQUFLLENBQUMsYUFBYSxFQUFFLENBQUM7U0FDN0I7Z0JBQVM7WUFDUixNQUFNLElBQUksT0FBTyxDQUFPLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFO2dCQUMxQyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRTtvQkFDcEIsSUFBSSxDQUFDO3dCQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQzs7d0JBQ1osT0FBTyxFQUFFLENBQUM7Z0JBQ2pCLENBQUMsQ0FBQyxDQUFDO1lBQ0wsQ0FBQyxDQUFDLENBQUM7U0FDSjtJQUNILENBQUM7SUFFUSxLQUFLLENBQUMsYUFBYTtRQUMxQixNQUFNLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNwQixDQUFDO0NBQ0Y7QUF6Q0QsNEJBeUNDIn0=

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 import type { Table } from './introspection/types';
-import type { ConnectionOptions, SslMode } from './types';
+import type { PlainConnectionOptions, PlainConnectionOptionsOrUri, SslMode } from './types';
 import type { DataSourceFactory, Logger } from '@forestadmin/datasource-toolkit';
 import { Sequelize } from 'sequelize';
-export declare function introspect(uriOrOptions: ConnectionOptions, logger?: Logger): Promise<Table[]>;
-export declare function buildSequelizeInstance(uriOrOptions: ConnectionOptions, logger: Logger, introspection?: Table[]): Promise<Sequelize>;
-export declare function createSqlDataSource(uriOrOptions: ConnectionOptions, options?: {
+export declare function introspect(uriOrOptions: PlainConnectionOptionsOrUri, logger?: Logger): Promise<Table[]>;
+export declare function buildSequelizeInstance(uriOrOptions: PlainConnectionOptionsOrUri, logger: Logger, introspection?: Table[]): Promise<Sequelize>;
+export declare function createSqlDataSource(uriOrOptions: PlainConnectionOptionsOrUri, options?: {
     introspection: Table[];
 }): DataSourceFactory;
-export type { ConnectionOptions, Table, SslMode };
-export { default as preprocessOptions } from './connection/preprocess';
+/** Preprocess the connection options so that they can be cached for faster connections */
+export declare function preprocessOptions(uriOrOptions: PlainConnectionOptionsOrUri): Promise<PlainConnectionOptions>;
 export * from './connection/errors';
+export type { PlainConnectionOptionsOrUri as ConnectionOptions, Table, SslMode };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -20,13 +20,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preprocessOptions = exports.createSqlDataSource = exports.buildSequelizeInstance = exports.introspect = void 0;
 const datasource_sequelize_1 = require("@forestadmin/datasource-sequelize");
 const connection_1 = __importDefault(require("./connection"));
+const connection_options_1 = __importDefault(require("./connection/connection-options"));
 const introspector_1 = __importDefault(require("./introspection/introspector"));
 const model_1 = __importDefault(require("./orm-builder/model"));
 const relations_1 = __importDefault(require("./orm-builder/relations"));
 async function introspect(uriOrOptions, logger) {
+    const options = new connection_options_1.default(uriOrOptions, logger);
     let sequelize;
     try {
-        sequelize = await (0, connection_1.default)(uriOrOptions, logger);
+        sequelize = await (0, connection_1.default)(options);
         return await introspector_1.default.introspect(sequelize, logger);
     }
     finally {
@@ -35,9 +37,10 @@ async function introspect(uriOrOptions, logger) {
 }
 exports.introspect = introspect;
 async function buildSequelizeInstance(uriOrOptions, logger, introspection) {
+    const options = new connection_options_1.default(uriOrOptions, logger);
     let sequelize;
     try {
-        sequelize = await (0, connection_1.default)(uriOrOptions, logger);
+        sequelize = await (0, connection_1.default)(options);
         const tables = introspection ?? (await introspector_1.default.introspect(sequelize, logger));
         model_1.default.defineModels(sequelize, logger, tables);
         relations_1.default.defineRelations(sequelize, logger, tables);
@@ -56,7 +59,10 @@ function createSqlDataSource(uriOrOptions, options) {
     };
 }
 exports.createSqlDataSource = createSqlDataSource;
-var preprocess_1 = require("./connection/preprocess");
-Object.defineProperty(exports, "preprocessOptions", { enumerable: true, get: function () { return __importDefault(preprocess_1).default; } });
+/** Preprocess the connection options so that they can be cached for faster connections */
+async function preprocessOptions(uriOrOptions) {
+    return new connection_options_1.default(uriOrOptions).buildPreprocessedOptions();
+}
+exports.preprocessOptions = preprocessOptions;
 __exportStar(require("./connection/errors"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFJQSw0RUFBd0U7QUFHeEUsOERBQW1DO0FBQ25DLGdGQUF3RDtBQUN4RCxnRUFBK0M7QUFDL0Msd0VBQXNEO0FBRS9DLEtBQUssVUFBVSxVQUFVLENBQzlCLFlBQStCLEVBQy9CLE1BQWU7SUFFZixJQUFJLFNBQW9CLENBQUM7SUFFekIsSUFBSTtRQUNGLFNBQVMsR0FBRyxNQUFNLElBQUEsb0JBQU8sRUFBQyxZQUFZLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFFaEQsT0FBTyxNQUFNLHNCQUFZLENBQUMsVUFBVSxDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUMsQ0FBQztLQUN6RDtZQUFTO1FBQ1IsTUFBTSxTQUFTLEVBQUUsS0FBSyxFQUFFLENBQUM7S0FDMUI7QUFDSCxDQUFDO0FBYkQsZ0NBYUM7QUFFTSxLQUFLLFVBQVUsc0JBQXNCLENBQzFDLFlBQStCLEVBQy9CLE1BQWMsRUFDZCxhQUF1QjtJQUV2QixJQUFJLFNBQW9CLENBQUM7SUFFekIsSUFBSTtRQUNGLFNBQVMsR0FBRyxNQUFNLElBQUEsb0JBQU8sRUFBQyxZQUFZLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDaEQsTUFBTSxNQUFNLEdBQUcsYUFBYSxJQUFJLENBQUMsTUFBTSxzQkFBWSxDQUFDLFVBQVUsQ0FBQyxTQUFTLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUNuRixlQUFZLENBQUMsWUFBWSxDQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDckQsbUJBQWUsQ0FBQyxlQUFlLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztLQUM1RDtJQUFDLE9BQU8sS0FBSyxFQUFFO1FBQ2QsTUFBTSxTQUFTLEVBQUUsS0FBSyxFQUFFLENBQUM7UUFDekIsTUFBTSxLQUFLLENBQUM7S0FDYjtJQUVELE9BQU8sU0FBUyxDQUFDO0FBQ25CLENBQUM7QUFsQkQsd0RBa0JDO0FBRUQsU0FBZ0IsbUJBQW1CLENBQ2pDLFlBQStCLEVBQy9CLE9BQW9DO0lBRXBDLE9BQU8sS0FBSyxFQUFFLE1BQWMsRUFBRSxFQUFFO1FBQzlCLE1BQU0sU0FBUyxHQUFHLE1BQU0sc0JBQXNCLENBQUMsWUFBWSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFFN0YsT0FBTyxJQUFJLDBDQUFtQixDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNwRCxDQUFDLENBQUM7QUFDSixDQUFDO0FBVEQsa0RBU0M7QUFHRCxzREFBdUU7QUFBOUQsZ0lBQUEsT0FBTyxPQUFxQjtBQUNyQyxzREFBb0MifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFJQSw0RUFBd0U7QUFHeEUsOERBQW1DO0FBQ25DLHlGQUFnRTtBQUNoRSxnRkFBd0Q7QUFDeEQsZ0VBQStDO0FBQy9DLHdFQUFzRDtBQUUvQyxLQUFLLFVBQVUsVUFBVSxDQUM5QixZQUF5QyxFQUN6QyxNQUFlO0lBRWYsTUFBTSxPQUFPLEdBQUcsSUFBSSw0QkFBaUIsQ0FBQyxZQUFZLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDNUQsSUFBSSxTQUFvQixDQUFDO0lBRXpCLElBQUk7UUFDRixTQUFTLEdBQUcsTUFBTSxJQUFBLG9CQUFPLEVBQUMsT0FBTyxDQUFDLENBQUM7UUFFbkMsT0FBTyxNQUFNLHNCQUFZLENBQUMsVUFBVSxDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUMsQ0FBQztLQUN6RDtZQUFTO1FBQ1IsTUFBTSxTQUFTLEVBQUUsS0FBSyxFQUFFLENBQUM7S0FDMUI7QUFDSCxDQUFDO0FBZEQsZ0NBY0M7QUFFTSxLQUFLLFVBQVUsc0JBQXNCLENBQzFDLFlBQXlDLEVBQ3pDLE1BQWMsRUFDZCxhQUF1QjtJQUV2QixNQUFNLE9BQU8sR0FBRyxJQUFJLDRCQUFpQixDQUFDLFlBQVksRUFBRSxNQUFNLENBQUMsQ0FBQztJQUM1RCxJQUFJLFNBQW9CLENBQUM7SUFFekIsSUFBSTtRQUNGLFNBQVMsR0FBRyxNQUFNLElBQUEsb0JBQU8sRUFBQyxPQUFPLENBQUMsQ0FBQztRQUNuQyxNQUFNLE1BQU0sR0FBRyxhQUFhLElBQUksQ0FBQyxNQUFNLHNCQUFZLENBQUMsVUFBVSxDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBQ25GLGVBQVksQ0FBQyxZQUFZLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztRQUNyRCxtQkFBZSxDQUFDLGVBQWUsQ0FBQyxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0tBQzVEO0lBQUMsT0FBTyxLQUFLLEVBQUU7UUFDZCxNQUFNLFNBQVMsRUFBRSxLQUFLLEVBQUUsQ0FBQztRQUN6QixNQUFNLEtBQUssQ0FBQztLQUNiO0lBRUQsT0FBTyxTQUFTLENBQUM7QUFDbkIsQ0FBQztBQW5CRCx3REFtQkM7QUFFRCxTQUFnQixtQkFBbUIsQ0FDakMsWUFBeUMsRUFDekMsT0FBb0M7SUFFcEMsT0FBTyxLQUFLLEVBQUUsTUFBYyxFQUFFLEVBQUU7UUFDOUIsTUFBTSxTQUFTLEdBQUcsTUFBTSxzQkFBc0IsQ0FBQyxZQUFZLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxhQUFhLENBQUMsQ0FBQztRQUU3RixPQUFPLElBQUksMENBQW1CLENBQUMsU0FBUyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ3BELENBQUMsQ0FBQztBQUNKLENBQUM7QUFURCxrREFTQztBQUVELDBGQUEwRjtBQUNuRixLQUFLLFVBQVUsaUJBQWlCLENBQ3JDLFlBQXlDO0lBRXpDLE9BQU8sSUFBSSw0QkFBaUIsQ0FBQyxZQUFZLENBQUMsQ0FBQyx3QkFBd0IsRUFBRSxDQUFDO0FBQ3hFLENBQUM7QUFKRCw4Q0FJQztBQUVELHNEQUFvQyJ9

package/dist/types.d.ts

@@ -1,16 +1,19 @@
 import { Options } from 'sequelize/types';
-export type ConnectionOptionsObj = {
+type SupportedSequelizeOptions = Pick<Options, 'database' | 'dialect' | 'dialectModule' | 'dialectModulePath' | 'dialectOptions' | 'host' | 'minifyAliases' | 'native' | 'password' | 'pool' | 'port' | 'protocol' | 'replication' | 'schema' | 'ssl' | 'storage' | 'username'>;
+export type ProxyOptions = {
+    userId?: string;
+    password?: string;
+    host: string;
+    port: number;
+    version?: 5;
+    command?: 'connect';
+};
+export type PlainConnectionOptions = SupportedSequelizeOptions & {
     uri?: string;
     sslMode?: SslMode;
-    proxySocks?: {
-        userId?: string;
-        password?: string;
-        host: string;
-        port: number;
-        version?: 5;
-        command?: 'connect';
-    };
-} & Pick<Options, 'database' | 'dialect' | 'dialectModule' | 'dialectModulePath' | 'dialectOptions' | 'host' | 'minifyAliases' | 'native' | 'password' | 'pool' | 'port' | 'protocol' | 'replication' | 'schema' | 'ssl' | 'storage' | 'username'>;
-export type ConnectionOptions = ConnectionOptionsObj | string;
+    proxySocks?: ProxyOptions;
+};
+export type PlainConnectionOptionsOrUri = PlainConnectionOptions | string;
 export type SslMode = 'preferred' | 'disabled' | 'required' | 'verify' | 'manual';
+export {};
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/datasource-sql",
-  "version": "1.6.6",
+  "version": "1.6.8",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "publishConfig": {

package/dist/connection/preprocess.d.ts

@@ -1,11 +0,0 @@
-import type { ConnectionOptions, ConnectionOptionsObj } from '../types';
-/**
- * Preprocess connection options.
- * Allows to speed up the connection process by avoiding attempts to connect to the database.
- *
- * It ensures that
- * - both sslMode and dialect are set
- * - the automatic 'preferred' sslMode is resolved to the most appropriate value
- */
-export default function preprocessOptions(uriOrOptions: ConnectionOptions): Promise<ConnectionOptionsObj>;
-//# sourceMappingURL=preprocess.d.ts.map

package/dist/connection/preprocess.js

@@ -1,50 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = __importDefault(require("./index"));
-const utils_1 = require("./utils");
-async function resolveSslMode(uriOrOptions) {
-    // Try to connect with the different sslModes in order of preference
-    if (uriOrOptions.sslMode === 'preferred') {
-        // When NODE_TLS_REJECT_UNAUTHORIZED is set to 0, we skip the 'verify' mode, as we know it will
-        // always work locally, but not when deploying to another environment.
-        const modes = ['verify', 'required', 'disabled'];
-        if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0')
-            modes.shift();
-        let error;
-        for (const sslMode of modes) {
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                const sequelize = await (0, index_1.default)({ ...uriOrOptions, sslMode });
-                await sequelize.close(); // eslint-disable-line no-await-in-loop
-                return sslMode;
-            }
-            catch (e) {
-                error = e;
-            }
-        }
-        throw error;
-    }
-    return uriOrOptions.sslMode ?? 'manual';
-}
-/**
- * Preprocess connection options.
- * Allows to speed up the connection process by avoiding attempts to connect to the database.
- *
- * It ensures that
- * - both sslMode and dialect are set
- * - the automatic 'preferred' sslMode is resolved to the most appropriate value
- */
-async function preprocessOptions(uriOrOptions) {
-    // Extract sanitized dialect and uri from the connection options
-    const dialect = (0, utils_1.getDialect)(uriOrOptions);
-    const uri = (0, utils_1.getUri)(uriOrOptions, dialect);
-    // Create a new object with the sanitized dialect and uri and resolve the sslMode
-    const obj = typeof uriOrOptions === 'string' ? { uri, dialect } : { ...uriOrOptions, uri, dialect };
-    const sslMode = await resolveSslMode(obj);
-    return { ...obj, sslMode };
-}
-exports.default = preprocessOptions;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlcHJvY2Vzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25uZWN0aW9uL3ByZXByb2Nlc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFFQSxvREFBOEI7QUFDOUIsbUNBQTZDO0FBRTdDLEtBQUssVUFBVSxjQUFjLENBQUMsWUFBa0M7SUFDOUQsb0VBQW9FO0lBQ3BFLElBQUksWUFBWSxDQUFDLE9BQU8sS0FBSyxXQUFXLEVBQUU7UUFDeEMsK0ZBQStGO1FBQy9GLHNFQUFzRTtRQUN0RSxNQUFNLEtBQUssR0FBRyxDQUFDLFFBQVEsRUFBRSxVQUFVLEVBQUUsVUFBVSxDQUFjLENBQUM7UUFDOUQsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLDRCQUE0QixLQUFLLEdBQUc7WUFBRSxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFcEUsSUFBSSxLQUFZLENBQUM7UUFFakIsS0FBSyxNQUFNLE9BQU8sSUFBSSxLQUFLLEVBQUU7WUFDM0IsSUFBSTtnQkFDRiw0Q0FBNEM7Z0JBQzVDLE1BQU0sU0FBUyxHQUFHLE1BQU0sSUFBQSxlQUFPLEVBQUMsRUFBRSxHQUFHLFlBQVksRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO2dCQUM5RCxNQUFNLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLHVDQUF1QztnQkFFaEUsT0FBTyxPQUFPLENBQUM7YUFDaEI7WUFBQyxPQUFPLENBQUMsRUFBRTtnQkFDVixLQUFLLEdBQUcsQ0FBQyxDQUFDO2FBQ1g7U0FDRjtRQUVELE1BQU0sS0FBSyxDQUFDO0tBQ2I7SUFFRCxPQUFPLFlBQVksQ0FBQyxPQUFPLElBQUksUUFBUSxDQUFDO0FBQzFDLENBQUM7QUFFRDs7Ozs7OztHQU9HO0FBQ1ksS0FBSyxVQUFVLGlCQUFpQixDQUM3QyxZQUErQjtJQUUvQixnRUFBZ0U7SUFDaEUsTUFBTSxPQUFPLEdBQUcsSUFBQSxrQkFBVSxFQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ3pDLE1BQU0sR0FBRyxHQUFHLElBQUEsY0FBTSxFQUFDLFlBQVksRUFBRSxPQUFPLENBQUMsQ0FBQztJQUUxQyxpRkFBaUY7SUFDakYsTUFBTSxHQUFHLEdBQ1AsT0FBTyxZQUFZLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxFQUFFLEdBQUcsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFHLFlBQVksRUFBRSxHQUFHLEVBQUUsT0FBTyxFQUFFLENBQUM7SUFDMUYsTUFBTSxPQUFPLEdBQUcsTUFBTSxjQUFjLENBQUMsR0FBRyxDQUFDLENBQUM7SUFFMUMsT0FBTyxFQUFFLEdBQUcsR0FBRyxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBQzdCLENBQUM7QUFiRCxvQ0FhQyJ9

package/dist/connection/reverse-proxy.d.ts

@@ -1,16 +0,0 @@
-import { ConnectionOptionsObj } from '../types';
-export default class ReverseProxy {
-    private readonly errors;
-    private readonly server;
-    private readonly connectedClients;
-    readonly destination: ConnectionOptionsObj;
-    constructor(destination: ConnectionOptionsObj);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    get connectionOptions(): ConnectionOptionsObj;
-    get error(): Error | null;
-    private get destinationHost();
-    private get destinationPort();
-    private onConnection;
-}
-//# sourceMappingURL=reverse-proxy.d.ts.map

package/dist/connection/reverse-proxy.js

@@ -1,109 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const net_1 = __importDefault(require("net"));
-const socks_1 = require("socks");
-class ReverseProxy {
-    constructor(destination) {
-        this.errors = [];
-        this.connectedClients = new Set();
-        this.destination = destination;
-        this.server = net_1.default.createServer(this.onConnection.bind(this));
-        if (!this.destinationPort)
-            throw new Error('Port is required');
-        if (!this.destinationHost)
-            throw new Error('Host is required');
-    }
-    start() {
-        return new Promise((resolve, reject) => {
-            this.server.on('error', reject);
-            this.server.listen(0, '127.0.0.1', resolve);
-        });
-    }
-    stop() {
-        return new Promise((resolve, reject) => {
-            this.server.close(e => {
-                if (e)
-                    reject(e);
-                else
-                    resolve();
-            });
-            this.connectedClients.forEach(client => client.destroy());
-        });
-    }
-    get connectionOptions() {
-        const { address, port } = this.server.address();
-        const connection = { ...this.destination };
-        if (this.destination.uri) {
-            const uri = new URL(this.destination.uri);
-            uri.host = address;
-            uri.port = port.toString();
-            connection.uri = uri.toString();
-        }
-        connection.host = address;
-        connection.port = port;
-        return connection;
-    }
-    get error() {
-        return this.errors.length > 0 ? this.errors[0] : null;
-    }
-    get destinationHost() {
-        return this.destination.uri ? new URL(this.destination.uri).hostname : this.destination.host;
-    }
-    get destinationPort() {
-        // Use port from object or uri if provided
-        if (this.destination.port)
-            return this.destination.port;
-        if (this.destination.uri && new URL(this.destination.uri).port)
-            return Number(new URL(this.destination.uri).port);
-        // Use default port for known dialects otherwise
-        if (this.destination.dialect === 'postgres')
-            return 5432;
-        if (this.destination.dialect === 'mysql' || this.destination.dialect === 'mariadb')
-            return 3306;
-        if (this.destination.dialect === 'mssql')
-            return 1433;
-        // Otherwise throw an error
-        throw new Error('Port is required');
-    }
-    async onConnection(socket) {
-        let socks5Proxy;
-        this.connectedClients.add(socket);
-        socket.on('error', error => {
-            this.errors.push(error);
-            if (!socket.closed) {
-                socket.destroy(error);
-            }
-        });
-        socket.on('close', () => {
-            this.connectedClients.delete(socket);
-            if (!socks5Proxy?.socket.closed) {
-                socks5Proxy?.socket.destroy();
-            }
-        });
-        try {
-            socks5Proxy = await socks_1.SocksClient.createConnection({
-                proxy: { ...this.destination.proxySocks, type: 5 },
-                command: 'connect',
-                destination: { host: this.destinationHost, port: this.destinationPort },
-                timeout: 4000,
-            });
-            socks5Proxy.socket.on('close', () => {
-                this.connectedClients.delete(socks5Proxy.socket);
-                if (!socket.closed) {
-                    socket.destroy();
-                }
-            });
-            socks5Proxy.socket.on('error', socket.destroy);
-            socks5Proxy.socket.pipe(socket);
-            socket.pipe(socks5Proxy.socket);
-        }
-        catch (err) {
-            socket.destroy(err);
-        }
-    }
-}
-exports.default = ReverseProxy;
-//# sourceMappingURL=data:application/json;base64,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

package/dist/connection/utils.d.ts

@@ -1,10 +0,0 @@
-import type { ConnectionOptions } from '../types';
-import type { Logger } from '@forestadmin/datasource-toolkit';
-import { Dialect } from 'sequelize';
-import { SslMode } from '../types';
-export declare function getUri(uriOrOptions: ConnectionOptions, dialect: Dialect): string | null;
-export declare function getDialect(uriOrOptions: ConnectionOptions): Dialect;
-export declare function getSchema(uri: string): string;
-export declare function getLogger(logger: Logger): (sql: string) => void;
-export declare function getSslConfiguration(dialect: Dialect, sslMode: SslMode, servername?: string, logger?: Logger): Record<string, unknown>;
-//# sourceMappingURL=utils.d.ts.map

package/dist/connection/utils.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSslConfiguration = exports.getLogger = exports.getSchema = exports.getDialect = exports.getUri = void 0;
-const errors_1 = require("./errors");
-function checkUri(uri) {
-    if (!/.*:\/\//g.test(uri) && uri !== 'sqlite::memory:') {
-        throw new errors_1.DatabaseConnectError(`Connection Uri "${uri}" provided to SQL data source is not valid.` +
-            ' Should be <dialect>://<connection>.');
-    }
-}
-function getUri(uriOrOptions, dialect) {
-    const uri = typeof uriOrOptions === 'string' ? uriOrOptions : uriOrOptions.uri;
-    if (uri) {
-        checkUri(uri);
-        const url = new URL(uri);
-        url.protocol = dialect;
-        return url.toString();
-    }
-    return null;
-}
-exports.getUri = getUri;
-function getDialect(uriOrOptions) {
-    let dialect;
-    if (typeof uriOrOptions !== 'string' && uriOrOptions.dialect) {
-        dialect = uriOrOptions.dialect;
-    }
-    else if (typeof uriOrOptions === 'string' || uriOrOptions.uri) {
-        const uri = typeof uriOrOptions === 'string' ? uriOrOptions : uriOrOptions.uri;
-        checkUri(uri);
-        dialect = new URL(uri).protocol.slice(0, -1);
-    }
-    else {
-        throw new errors_1.DatabaseConnectError('Expected dialect to be provided in options or uri.');
-    }
-    if (dialect === 'mysql2')
-        return 'mysql';
-    if (dialect === 'tedious')
-        return 'mssql';
-    if (dialect === 'pg' || dialect === 'postgresql')
-        return 'postgres';
-    return dialect;
-}
-exports.getDialect = getDialect;
-function getSchema(uri) {
-    return uri ? new URL(uri).searchParams.get('schema') : null;
-}
-exports.getSchema = getSchema;
-function getLogger(logger) {
-    return (sql) => logger?.('Debug', sql.substring(sql.indexOf(':') + 2));
-}
-exports.getLogger = getLogger;
-function getSslConfiguration(dialect, sslMode, servername, logger) {
-    switch (dialect) {
-        case 'mariadb':
-            if (sslMode === 'disabled')
-                return { ssl: false };
-            if (sslMode === 'required')
-                return { ssl: { rejectUnauthorized: false } };
-            if (sslMode === 'verify')
-                return { ssl: true };
-            break;
-        case 'mssql':
-            if (sslMode === 'disabled')
-                return { options: { encrypt: false } };
-            if (sslMode === 'required')
-                return { options: { encrypt: true, trustServerCertificate: true } };
-            if (sslMode === 'verify')
-                return { options: { encrypt: true, trustServerCertificate: false } };
-            break;
-        case 'mysql':
-            if (sslMode === 'disabled')
-                return { ssl: false };
-            if (sslMode === 'required')
-                return { ssl: { rejectUnauthorized: false } };
-            if (sslMode === 'verify')
-                return { ssl: { rejectUnauthorized: true } };
-            break;
-        case 'postgres':
-            if (sslMode === 'disabled')
-                return { ssl: false };
-            // Pass servername to the net.tlsSocket constructor.
-            // This is done so that
-            // - Certificate verification still work when using a proxy server to reach the db (we are
-            //   forced to use a tcp reverse proxy because some drivers do not support them)
-            // - Providers which use SNI to route requests to the correct database still work (most
-            //   notably neon.tech).
-            // Note that we should either do that for the other vendors (if possible), or
-            // replace the reverse proxy by a forward proxy (when supported).
-            if (sslMode === 'required')
-                return { ssl: { require: true, rejectUnauthorized: false, servername } };
-            if (sslMode === 'verify')
-                return { ssl: { require: true, rejectUnauthorized: true, servername } };
-            break;
-        case 'db2':
-        case 'oracle':
-        case 'snowflake':
-        case 'sqlite':
-        default:
-            if (sslMode && sslMode !== 'manual') {
-                logger?.('Warn', `ignoring sslMode=${sslMode} (not supported for ${dialect})`);
-            }
-            return {};
-    }
-}
-exports.getSslConfiguration = getSslConfiguration;
-//# sourceMappingURL=data:application/json;base64,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