@relq/orm 0.1.0

package/dist/cjs/core/helpers/select-pagination.cjs

@@ -0,0 +1,233 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCursorEach = executeCursorEach;
+exports.executePagination = executePagination;
+const pg_cursor_1 = __importDefault(require("../../addon/cursor.cjs"));
+const relq_errors_1 = require("../../../shared/errors/relq-errors.cjs");
+const pagination_types_1 = require("../../types/pagination-types.cjs");
+const methods_1 = require("./methods.cjs");
+async function executeCursorEach(ctx, callback, options = {}) {
+    const batchSize = options.batchSize ?? 100;
+    const sql = ctx.builder.toString();
+    const relqAny = ctx.relq;
+    if (relqAny.usePooling === false || (!relqAny.pool && relqAny.client)) {
+        throw new relq_errors_1.RelqConfigError('each() requires pooled connections', { field: 'pooling', value: 'false (must be true)' });
+    }
+    const { client, release } = await ctx.relq[methods_1.INTERNAL].getClientForCursor();
+    let cursor = null;
+    try {
+        await client.query('BEGIN');
+        cursor = client.query(new pg_cursor_1.default(sql));
+        let rows;
+        let index = 0;
+        outer: do {
+            rows = await new Promise((resolve, reject) => {
+                cursor.read(batchSize, (err, result) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(result);
+                });
+            });
+            const internal = ctx.relq[methods_1.INTERNAL];
+            const transformedRows = ctx.tableName && internal.hasColumnMapping()
+                ? internal.transformResultsFromDb(ctx.tableName, rows)
+                : rows;
+            for (const row of transformedRows) {
+                const result = await callback(row, index++);
+                if (result === false) {
+                    break outer;
+                }
+            }
+        } while (rows.length > 0);
+        await closeCursor(cursor);
+        cursor = null;
+        await client.query('COMMIT');
+    }
+    catch (error) {
+        if (cursor) {
+            try {
+                await closeCursor(cursor);
+            }
+            catch {
+            }
+        }
+        try {
+            await client.query('ROLLBACK');
+        }
+        catch {
+        }
+        throw error;
+    }
+    finally {
+        release();
+    }
+}
+async function executePagination(ctx, options, recurse) {
+    if (!options.mode || !['paging', 'offset'].includes(options.mode)) {
+        throw new relq_errors_1.RelqQueryError('pagination() requires "mode" to be one of: \'paging\', \'offset\'', { hint: 'Set mode: "paging" or mode: "offset"' });
+    }
+    const orderByArr = options.orderBy
+        ? (Array.isArray(options.orderBy[0]) ? options.orderBy : [options.orderBy])
+        : [];
+    for (const [column, direction] of orderByArr) {
+        const dbColumn = ctx.relq[methods_1.INTERNAL].hasColumnMapping()
+            ? Object.keys(ctx.relq[methods_1.INTERNAL].transformToDbColumns(ctx.tableName, { [column]: true }))[0]
+            : column;
+        ctx.builder.orderBy(dbColumn, direction);
+    }
+    const isPaging = options.mode === 'paging';
+    const shouldCount = options.count ?? isPaging;
+    let total = 0;
+    if (shouldCount) {
+        const countSql = ctx.builder.toCountSQL();
+        const countResult = await ctx.relq[methods_1.INTERNAL].executeCount(countSql);
+        total = countResult.count;
+    }
+    if (isPaging) {
+        return executePagingMode(ctx, options, total, recurse);
+    }
+    if (options.mode === 'offset') {
+        return executeOffsetMode(ctx, options, total, shouldCount, recurse);
+    }
+    throw new relq_errors_1.RelqQueryError('Invalid pagination mode');
+}
+async function executePagingMode(ctx, options, total, recurse) {
+    const { page, perPage } = options;
+    if (typeof page !== 'number' || isNaN(page) || page < 1) {
+        throw new relq_errors_1.RelqQueryError('pagination() paging mode requires "page" as a positive number (1-indexed)', { hint: 'page must be >= 1' });
+    }
+    if (typeof perPage !== 'number' || isNaN(perPage) || perPage < 1) {
+        throw new relq_errors_1.RelqQueryError('pagination() paging mode requires "perPage" as a positive number', { hint: 'perPage must be >= 1' });
+    }
+    const offset = (page - 1) * perPage;
+    ctx.builder.limit(perPage);
+    ctx.builder.offset(offset);
+    const sql = ctx.builder.toString();
+    const result = await ctx.relq[methods_1.INTERNAL].executeSelect(sql, ctx.tableName);
+    const totalPages = Math.ceil(total / perPage);
+    const hasNext = page < totalPages;
+    const hasPrev = page > 1;
+    const pagination = {
+        page,
+        perPage,
+        total,
+        totalPages,
+    };
+    if (hasNext) {
+        pagination.hasNext = true;
+        pagination.nextPage = page + 1;
+        Object.defineProperty(pagination, 'loadNext', {
+            value: () => recurse({ ...options, page: page + 1 }),
+            enumerable: false,
+            configurable: false
+        });
+    }
+    else {
+        pagination.hasNext = false;
+    }
+    if (hasPrev) {
+        pagination.hasPrev = true;
+        pagination.prevPage = page - 1;
+        Object.defineProperty(pagination, 'loadPrev', {
+            value: () => recurse({ ...options, page: page - 1 }),
+            enumerable: false,
+            configurable: false
+        });
+    }
+    else {
+        pagination.hasPrev = false;
+    }
+    addInspectProperties(pagination, () => {
+        const visible = { page, perPage, total, totalPages, hasNext };
+        if (hasNext)
+            visible.nextPage = page + 1;
+        visible.hasPrev = hasPrev;
+        if (hasPrev)
+            visible.prevPage = page - 1;
+        return visible;
+    });
+    return { data: result.data, pagination };
+}
+async function executeOffsetMode(ctx, options, total, shouldCount, recurse) {
+    const { position, limit: limitOpt } = options;
+    if (typeof position !== 'number' || isNaN(position)) {
+        throw new relq_errors_1.RelqQueryError('pagination() offset mode requires "position" as a number', { hint: 'position must be >= 0' });
+    }
+    if (limitOpt === undefined || (typeof limitOpt !== 'number' && !Array.isArray(limitOpt))) {
+        throw new relq_errors_1.RelqQueryError('pagination() offset mode requires "limit" as a number or [min, max] array', { hint: 'Use limit: number or limit: [min, max]' });
+    }
+    const limit = Array.isArray(limitOpt) ? (0, pagination_types_1.randomLimit)(limitOpt) : limitOpt;
+    ctx.builder.limit(limit + 1);
+    ctx.builder.offset(position);
+    const sql = ctx.builder.toString();
+    const result = await ctx.relq[methods_1.INTERNAL].executeSelect(sql, ctx.tableName);
+    const hasMore = result.data.length > limit;
+    const hasPrev = position > 0;
+    const data = hasMore ? result.data.slice(0, limit) : result.data;
+    const pagination = {
+        position,
+        limit,
+        ...(shouldCount && { total }),
+    };
+    if (hasMore) {
+        pagination.hasMore = true;
+        pagination.nextPos = position + limit;
+        Object.defineProperty(pagination, 'loadNext', {
+            value: () => recurse({ ...options, position: position + limit }),
+            enumerable: false,
+            configurable: false
+        });
+    }
+    else {
+        pagination.hasMore = false;
+    }
+    if (hasPrev) {
+        pagination.hasPrev = true;
+        pagination.prevPos = Math.max(0, position - limit);
+        Object.defineProperty(pagination, 'loadPrev', {
+            value: () => recurse({ ...options, position: Math.max(0, position - limit) }),
+            enumerable: false,
+            configurable: false
+        });
+    }
+    else {
+        pagination.hasPrev = false;
+    }
+    addInspectProperties(pagination, () => {
+        const visible = { position, limit };
+        if (shouldCount)
+            visible.total = total;
+        visible.hasMore = hasMore;
+        if (hasMore)
+            visible.nextPos = position + limit;
+        visible.hasPrev = hasPrev;
+        if (hasPrev)
+            visible.prevPos = Math.max(0, position - limit);
+        return visible;
+    });
+    return { data, pagination };
+}
+function closeCursor(cursor) {
+    return new Promise((resolve, reject) => {
+        cursor.close((err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+function addInspectProperties(obj, getVisibleProps) {
+    Object.defineProperty(obj, Symbol.for('nodejs.util.inspect.custom'), {
+        value: () => getVisibleProps(),
+        enumerable: false
+    });
+    Object.defineProperty(obj, 'toJSON', {
+        value: () => getVisibleProps(),
+        enumerable: false
+    });
+}

package/dist/cjs/core/helpers/select-types.cjs

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

package/dist/cjs/core/pg-family/cockroachdb-client/capabilities.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COCKROACHDB_CAPABILITIES = void 0;
+exports.COCKROACHDB_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: false,
+    pooling: true,
+    cursors: true,
+    jsonb: true,
+    arrays: true,
+    ranges: false,
+    fullTextSearch: false,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: true,
+    vacuum: true,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/cjs/core/pg-family/cockroachdb-client/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COCKROACHDB_CAPABILITIES = exports.RelqCockroachDB = void 0;
+var relq_cockroach_1 = require("./relq-cockroach.cjs");
+Object.defineProperty(exports, "RelqCockroachDB", { enumerable: true, get: function () { return relq_cockroach_1.RelqCockroachDB; } });
+var capabilities_1 = require("./capabilities.cjs");
+Object.defineProperty(exports, "COCKROACHDB_CAPABILITIES", { enumerable: true, get: function () { return capabilities_1.COCKROACHDB_CAPABILITIES; } });

package/dist/cjs/core/pg-family/cockroachdb-client/relq-cockroach.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelqCockroachDB = void 0;
+const pg_base_1 = require("../shared/pg-base.cjs");
+const capabilities_1 = require("./capabilities.cjs");
+const env_resolver_1 = require("../../../utils/env-resolver.cjs");
+class RelqCockroachDB extends pg_base_1.PgBase {
+    dialect = 'cockroachdb';
+    capabilities = capabilities_1.COCKROACHDB_CAPABILITIES;
+    constructor(schema, config = {}) {
+        (0, env_resolver_1.validateEnvConfig)('cockroachdb', config);
+        const resolvedConfig = (0, env_resolver_1.mergeWithPgEnv)({ ...config, dialect: 'cockroachdb' });
+        super(schema, resolvedConfig);
+    }
+}
+exports.RelqCockroachDB = RelqCockroachDB;

package/dist/cjs/core/pg-family/dsql-client/capabilities.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DSQL_CAPABILITIES = void 0;
+exports.DSQL_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: false,
+    pooling: true,
+    cursors: true,
+    jsonb: false,
+    arrays: false,
+    ranges: false,
+    fullTextSearch: false,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: false,
+    triggers: false,
+    sequences: false,
+    copy: true,
+    vacuum: false,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/cjs/core/pg-family/dsql-client/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DSQL_CAPABILITIES = exports.RelqDsql = void 0;
+var relq_dsql_1 = require("./relq-dsql.cjs");
+Object.defineProperty(exports, "RelqDsql", { enumerable: true, get: function () { return relq_dsql_1.RelqDsql; } });
+var capabilities_1 = require("./capabilities.cjs");
+Object.defineProperty(exports, "DSQL_CAPABILITIES", { enumerable: true, get: function () { return capabilities_1.DSQL_CAPABILITIES; } });

package/dist/cjs/core/pg-family/dsql-client/relq-dsql.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelqDsql = void 0;
+const pg_base_1 = require("../shared/pg-base.cjs");
+const capabilities_1 = require("./capabilities.cjs");
+const env_resolver_1 = require("../../../utils/env-resolver.cjs");
+class RelqDsql extends pg_base_1.PgBase {
+    dialect = 'awsdsql';
+    capabilities = capabilities_1.DSQL_CAPABILITIES;
+    constructor(schema, config = {}) {
+        (0, env_resolver_1.validateEnvConfig)('awsdsql', config);
+        const resolvedConfig = (0, env_resolver_1.mergeWithAwsEnv)({ ...config, dialect: 'awsdsql' });
+        super(schema, resolvedConfig);
+    }
+}
+exports.RelqDsql = RelqDsql;

package/dist/cjs/core/pg-family/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pgDialect = exports.PgBase = exports.COCKROACHDB_CAPABILITIES = exports.RelqCockroachDB = exports.DSQL_CAPABILITIES = exports.RelqDsql = exports.NILE_CAPABILITIES = exports.RelqNile = exports.PG_CAPABILITIES = exports.RelqPostgres = void 0;
+var pg_client_1 = require("./pg-client/index.cjs");
+Object.defineProperty(exports, "RelqPostgres", { enumerable: true, get: function () { return pg_client_1.RelqPostgres; } });
+Object.defineProperty(exports, "PG_CAPABILITIES", { enumerable: true, get: function () { return pg_client_1.PG_CAPABILITIES; } });
+var nile_client_1 = require("./nile-client/index.cjs");
+Object.defineProperty(exports, "RelqNile", { enumerable: true, get: function () { return nile_client_1.RelqNile; } });
+Object.defineProperty(exports, "NILE_CAPABILITIES", { enumerable: true, get: function () { return nile_client_1.NILE_CAPABILITIES; } });
+var dsql_client_1 = require("./dsql-client/index.cjs");
+Object.defineProperty(exports, "RelqDsql", { enumerable: true, get: function () { return dsql_client_1.RelqDsql; } });
+Object.defineProperty(exports, "DSQL_CAPABILITIES", { enumerable: true, get: function () { return dsql_client_1.DSQL_CAPABILITIES; } });
+var cockroachdb_client_1 = require("./cockroachdb-client/index.cjs");
+Object.defineProperty(exports, "RelqCockroachDB", { enumerable: true, get: function () { return cockroachdb_client_1.RelqCockroachDB; } });
+Object.defineProperty(exports, "COCKROACHDB_CAPABILITIES", { enumerable: true, get: function () { return cockroachdb_client_1.COCKROACHDB_CAPABILITIES; } });
+var pg_base_1 = require("./shared/pg-base.cjs");
+Object.defineProperty(exports, "PgBase", { enumerable: true, get: function () { return pg_base_1.PgBase; } });
+var pg_dialect_1 = require("./shared/pg-dialect.cjs");
+Object.defineProperty(exports, "pgDialect", { enumerable: true, get: function () { return pg_dialect_1.pgDialect; } });

package/dist/cjs/core/pg-family/nile-client/capabilities.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NILE_CAPABILITIES = void 0;
+exports.NILE_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: false,
+    pooling: true,
+    cursors: true,
+    jsonb: true,
+    arrays: true,
+    ranges: true,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: true,
+    vacuum: true,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/cjs/core/pg-family/nile-client/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NILE_CAPABILITIES = exports.RelqNile = void 0;
+var relq_nile_1 = require("./relq-nile.cjs");
+Object.defineProperty(exports, "RelqNile", { enumerable: true, get: function () { return relq_nile_1.RelqNile; } });
+var capabilities_1 = require("./capabilities.cjs");
+Object.defineProperty(exports, "NILE_CAPABILITIES", { enumerable: true, get: function () { return capabilities_1.NILE_CAPABILITIES; } });

package/dist/cjs/core/pg-family/nile-client/relq-nile.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelqNile = void 0;
+const pg_base_1 = require("../shared/pg-base.cjs");
+const capabilities_1 = require("./capabilities.cjs");
+const tenant_context_1 = require("./tenant-context.cjs");
+const env_resolver_1 = require("../../../utils/env-resolver.cjs");
+class RelqNile extends pg_base_1.PgBase {
+    dialect = 'nile';
+    capabilities = capabilities_1.NILE_CAPABILITIES;
+    tenantCtx = new tenant_context_1.TenantContext();
+    constructor(schema, config = {}) {
+        (0, env_resolver_1.validateEnvConfig)('nile', config);
+        const resolvedConfig = (0, env_resolver_1.mergeWithPgEnv)({ ...config, dialect: 'nile' });
+        super(schema, resolvedConfig);
+    }
+    get queryFn() {
+        return async (sql) => { await this._executeQuery(sql); };
+    }
+    async setTenant(tenantId) {
+        await this.ensureInitialized();
+        await this.tenantCtx.setTenant(tenantId, this.queryFn);
+    }
+    async clearTenant() {
+        await this.ensureInitialized();
+        await this.tenantCtx.clearTenant(this.queryFn);
+    }
+    getTenantContext() {
+        return this.tenantCtx.getTenantId();
+    }
+    async withTenant(tenantId, callback) {
+        await this.ensureInitialized();
+        return this.tenantCtx.withTenant(tenantId, this.queryFn, callback);
+    }
+}
+exports.RelqNile = RelqNile;

package/dist/cjs/core/pg-family/nile-client/tenant-context.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantContext = void 0;
+const relq_errors_1 = require("../../../../shared/errors/relq-errors.cjs");
+function escapeTenantId(value) {
+    if (value.includes('\0')) {
+        throw new relq_errors_1.RelqConfigError('Tenant ID cannot contain null bytes', {
+            field: 'tenantId',
+            value: '<contains null byte>'
+        });
+    }
+    return value.replace(/'/g, "''");
+}
+class TenantContext {
+    currentTenantId = null;
+    async setTenant(tenantId, queryFn) {
+        const escapedId = escapeTenantId(tenantId);
+        await queryFn(`SET nile.tenant_id = '${escapedId}'`);
+        this.currentTenantId = tenantId;
+    }
+    async clearTenant(queryFn) {
+        await queryFn('RESET nile.tenant_id');
+        this.currentTenantId = null;
+    }
+    getTenantId() {
+        return this.currentTenantId;
+    }
+    async withTenant(tenantId, queryFn, callback) {
+        const previousTenantId = this.currentTenantId;
+        try {
+            await this.setTenant(tenantId, queryFn);
+            return await callback();
+        }
+        finally {
+            if (previousTenantId) {
+                await this.setTenant(previousTenantId, queryFn);
+            }
+            else {
+                await this.clearTenant(queryFn);
+            }
+        }
+    }
+}
+exports.TenantContext = TenantContext;

package/dist/cjs/core/pg-family/pg-client/capabilities.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PG_CAPABILITIES = void 0;
+exports.PG_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: true,
+    pooling: true,
+    cursors: true,
+    jsonb: true,
+    arrays: true,
+    ranges: true,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: true,
+    vacuum: true,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/cjs/core/pg-family/pg-client/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PG_CAPABILITIES = exports.RelqPostgres = void 0;
+var relq_postgres_1 = require("./relq-postgres.cjs");
+Object.defineProperty(exports, "RelqPostgres", { enumerable: true, get: function () { return relq_postgres_1.RelqPostgres; } });
+var capabilities_1 = require("./capabilities.cjs");
+Object.defineProperty(exports, "PG_CAPABILITIES", { enumerable: true, get: function () { return capabilities_1.PG_CAPABILITIES; } });

package/dist/cjs/core/pg-family/pg-client/relq-postgres.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelqPostgres = void 0;
+const listener_connection_1 = require("../../../pubsub/listener-connection.cjs");
+const env_resolver_1 = require("../../../utils/env-resolver.cjs");
+const pg_base_1 = require("../shared/pg-base.cjs");
+const capabilities_1 = require("./capabilities.cjs");
+class RelqPostgres extends pg_base_1.PgBase {
+    dialect = 'postgres';
+    capabilities = capabilities_1.PG_CAPABILITIES;
+    listener = null;
+    constructor(schema, config = {}) {
+        (0, env_resolver_1.validateEnvConfig)('postgres', config);
+        const resolvedConfig = (0, env_resolver_1.mergeWithPgEnv)({ ...config, dialect: 'postgres' });
+        super(schema, resolvedConfig);
+    }
+    async subscribe(channel, callback) {
+        if (!this.listener) {
+            this.listener = new listener_connection_1.ListenerConnection({
+                host: this.config.host,
+                port: this.config.port,
+                user: this.config.user,
+                password: this.config.password,
+                database: this.config.database,
+                connectionString: this.config.connectionString,
+                ssl: this.config.ssl
+            });
+            this.listener.on('error', (err) => this.emitter.emit('listenerError', err));
+            this.listener.on('connect', () => this.emitter.emit('listenerConnect'));
+        }
+        const sub = await this.listener.subscribe(channel);
+        sub.on('notification', callback);
+        return () => sub.close();
+    }
+    async _close() {
+        if (this.listener) {
+            await this.listener.close();
+            this.listener = null;
+        }
+        await super._close();
+    }
+}
+exports.RelqPostgres = RelqPostgres;