@sprucelabs/postgres-data-store 0.0.1

package/build/QueryBuilder.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class QueryBuilder {
+    constructor() { }
+    static Builder() {
+        return new this();
+    }
+    find(tableName, query, options) {
+        const { includeFields, limit, skip, sort } = options !== null && options !== void 0 ? options : {};
+        const fields = this.buildColumnListFromIncludeFields(includeFields);
+        let sql = `SELECT ${fields} FROM ${tableName}`;
+        const { values, sql: where } = this.optionallyBuildWhere(query);
+        sql += where;
+        sql += this.optionallyBuildSkip(skip);
+        sql += this.optionallyBuildSort(sort);
+        sql += this.optionallyBuildLimit(limit);
+        return { sql, values };
+    }
+    optionallyBuildWhere(query, startingPlaceholderCount = 0) {
+        let sql = '';
+        const values = [];
+        const queryKeys = Object.keys(query);
+        if ((queryKeys !== null && queryKeys !== void 0 ? queryKeys : []).length > 0) {
+            const { set: columnSpecs, values: whereValues } = this.buildSetClause({
+                query,
+                startingCount: startingPlaceholderCount,
+                isBuildingWhere: true,
+            });
+            sql += ` WHERE ${columnSpecs.join(' AND ')}`;
+            values.push(...whereValues);
+        }
+        return { values, sql };
+    }
+    buildSetClause(options) {
+        const { query, startingCount = 0, placeholderTemplate = '${{count}}', isBuildingWhere = false, } = options;
+        let placeholderCount = startingCount;
+        const queryKeys = Object.keys(query);
+        const values = [];
+        const set = [];
+        queryKeys.forEach((k) => {
+            let value = query[k];
+            if (value === null || value === void 0 ? void 0 : value.$in) {
+                values.push(...value.$in.map((v) => this.normalizeValue(v)));
+                set.push(`${k} IN (${value.$in
+                    .map(() => `$${++placeholderCount}`)
+                    .join(', ')})`);
+            }
+            else if (value === null || value === void 0 ? void 0 : value.$regex) {
+                values.push(this.normalizeValue(value.$regex));
+                set.push(`${k} ~* $${++placeholderCount}`);
+            }
+            else if (value === null || value === void 0 ? void 0 : value.$lte) {
+                values.push(this.normalizeValue(value.$lte));
+                set.push(`${k} <= $${++placeholderCount}`);
+            }
+            else if (value === null || value === void 0 ? void 0 : value.$lt) {
+                values.push(this.normalizeValue(value.$lt));
+                set.push(`${k} < $${++placeholderCount}`);
+            }
+            else if (value === null || value === void 0 ? void 0 : value.$gte) {
+                values.push(this.normalizeValue(value.$gte));
+                set.push(`${k} >= $${++placeholderCount}`);
+            }
+            else if (value === null || value === void 0 ? void 0 : value.$gt) {
+                values.push(this.normalizeValue(value.$gt));
+                set.push(`${k} > $${++placeholderCount}`);
+            }
+            else if (value === null || value === void 0 ? void 0 : value.$ne) {
+                values.push(this.normalizeValue(value.$ne));
+                set.push(`${k} != $${++placeholderCount}`);
+            }
+            else if (k === '$or') {
+                const { set: orWheres, values: orValues } = this.buildSetClausFor$Or(value, placeholderCount);
+                set.push(`(${orWheres.join(' OR ')})`);
+                values.push(...orValues);
+            }
+            else if (k === '$push') {
+                const sub = this.buildSetClause({
+                    query: value,
+                    startingCount: placeholderCount++,
+                    placeholderTemplate: `JSONB_SET(COALESCE(names || \${{count}}::JSONB, '[]'::JSONB), '{-1}', \${{count}}::JSONB)`,
+                });
+                values.push(...sub.values.map((v) => JSON.stringify(v)));
+                set.push(...sub.set);
+            }
+            else if (value === null || value === undefined) {
+                set.push(`${k} IS NULL`);
+            }
+            else {
+                placeholderCount++;
+                let placeholder = placeholderTemplate
+                    .replace(/{{count}}/gm, `${placeholderCount}`)
+                    .replace(/{{fieldName}}/gm, k);
+                const isDotSearch = k.includes('.');
+                if (isDotSearch) {
+                    const [field, prop] = k.split('.');
+                    if (isBuildingWhere) {
+                        k = `${field} ->> '${prop}'`;
+                        value = `${value}`;
+                    }
+                    else {
+                        k = field;
+                        placeholder = `${k} || jsonb_build_object('${prop}', ${placeholder}::text)`;
+                    }
+                }
+                values.push(this.normalizeValue(value));
+                set.push(`${k} = ${placeholder}`);
+            }
+        });
+        return { set, values };
+    }
+    buildSetClausFor$Or(value, placeholderCount) {
+        const ors = [];
+        const orValues = [];
+        value.forEach((q) => {
+            const { set: where, values } = this.buildSetClause({
+                query: q,
+                startingCount: placeholderCount++,
+            });
+            ors.push(...where);
+            orValues.push(...values);
+        });
+        return { set: ors, values: orValues };
+    }
+    create(tableName, records) {
+        let { sql, values } = this.createWithoutReturning(tableName, records);
+        sql += ` RETURNING *`;
+        return {
+            sql,
+            values,
+        };
+    }
+    createWithoutReturning(tableName, records) {
+        const { fields, placeholders, values } = this.splitRecordsIntoFieldsPlaceholdersAndValues(records);
+        const sql = `INSERT INTO ${tableName} (${fields.join(', ')}) VALUES ${placeholders.join(', ')}`;
+        return { sql, values };
+    }
+    splitRecordsIntoFieldsPlaceholdersAndValues(records) {
+        const fields = this.buildColumnListFromAllRecords(records);
+        let placeholderCount = 0;
+        const values = [];
+        const placeholders = records.map((record) => {
+            const placeholders = [];
+            fields.forEach((f) => {
+                values.push(this.fieldValueToSqlValue(record, f));
+                let placeholder = `$${++placeholderCount}`;
+                if (this.isValueObject(record[f])) {
+                    placeholder += `::json`;
+                }
+                placeholders.push(placeholder);
+            });
+            return `(${placeholders.join(', ')})`;
+        });
+        return { fields, placeholders, values };
+    }
+    fieldValueToSqlValue(record, f) {
+        let value = record[f];
+        return this.normalizeValue(value);
+    }
+    normalizeValue(value) {
+        if (value instanceof RegExp) {
+            value = value.toString().replace(/\//g, '');
+        }
+        if (this.isValueObject(value)) {
+            value = JSON.stringify(value);
+        }
+        return value !== null && value !== void 0 ? value : null;
+    }
+    isValueObject(value) {
+        return value !== null && (Array.isArray(value) || typeof value === 'object');
+    }
+    buildColumnListFromAllRecords(records) {
+        const fields = records.map((r) => Object.keys(r)).flat();
+        const uniqueFields = new Set(fields);
+        return Array.from(uniqueFields);
+    }
+    optionallyBuildSort(sort) {
+        if (sort) {
+            const sortSpecs = sort.map((s) => `${s.field} ${s.direction.toUpperCase()}`);
+            return ` ORDER BY ${sortSpecs.join(', ')}`;
+        }
+        return '';
+    }
+    optionallyBuildSkip(limit) {
+        if (typeof limit === 'number') {
+            return ` OFFSET ${limit}`;
+        }
+        return '';
+    }
+    optionallyBuildLimit(limit) {
+        if (typeof limit === 'number') {
+            return ` LIMIT ${limit}`;
+        }
+        return '';
+    }
+    buildColumnListFromIncludeFields(includeFields) {
+        return !includeFields ? '*' : includeFields.join(', ');
+    }
+    update(tableName, query, updates, shouldReturnUpdatedRecords = true) {
+        const { set: set, values } = this.buildSetClause({
+            query: updates,
+            startingCount: 0,
+        });
+        let sql = `UPDATE ${tableName} SET ${set.join(', ')}`;
+        const { sql: where, values: whereValues } = this.optionallyBuildWhere(query, values.length);
+        sql += where;
+        if (shouldReturnUpdatedRecords) {
+            sql += ' RETURNING *';
+        }
+        return {
+            sql,
+            values: [...values, ...whereValues],
+        };
+    }
+    delete(tableName, query) {
+        let sql = `DELETE FROM ${tableName}`;
+        const { values, sql: where } = this.optionallyBuildWhere(query !== null && query !== void 0 ? query : {});
+        sql += where;
+        return {
+            sql,
+            values,
+        };
+    }
+    upsert(tableName, query, updates) {
+        let { sql, values } = this.createWithoutReturning(tableName, [
+            Object.assign(Object.assign({}, query), updates),
+        ]);
+        const { sql: whereSql, values: whereValues } = this.optionallyBuildWhere(query, values.length);
+        const queryFields = this.buildColumnListFromAllRecords([query]);
+        const updateFields = this.buildColumnListFromAllRecords([updates]);
+        sql += ` ON CONFLICT (${queryFields.join(', ')})`;
+        sql += whereSql;
+        sql += ` DO UPDATE SET ${updateFields
+            .map((f) => `${f} = EXCLUDED.${f}`)
+            .join(', ')}`;
+        sql += ' RETURNING *';
+        return {
+            sql,
+            values: [...values, ...whereValues],
+        };
+    }
+}
+exports.default = QueryBuilder;

package/build/esm/PostgresDatabase.d.ts

@@ -0,0 +1,45 @@
+import { Database, Index, QueryOptions, UniqueIndex } from '@sprucelabs/data-stores';
+export default class PostgresDatabase implements Database {
+    private connectionString;
+    private client;
+    private idCount;
+    private query;
+    constructor(connectionString: string);
+    dropCollection(_name: string): Promise<void>;
+    generateId(): string;
+    update(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<number>;
+    count(collection: string, query?: Record<string, any> | undefined): Promise<number>;
+    updateOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;
+    private executeUpdateAndThrowIfNoResults;
+    find(collection: string, query?: Record<string, any> | undefined, options?: QueryOptions | undefined): Promise<Record<string, any>[]>;
+    createIndex(collection: string, fields: Index): Promise<void>;
+    getIndexes(collectionName: string): Promise<Index[] | UniqueIndex[]>;
+    findOne(collection: string, query?: Record<string, any> | undefined, options?: QueryOptions | undefined): Promise<Record<string, any> | null>;
+    delete(collection: string, query: Record<string, any>): Promise<number>;
+    dropDatabase(): Promise<void>;
+    private dropAllNonPrimaryKeyIndexes;
+    private getIndexNames;
+    private getTables;
+    upsertOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;
+    deleteOne(collection: string, query: Record<string, any>): Promise<number>;
+    private truncateTables;
+    createOne(collection: string, values: Record<string, any>): Promise<Record<string, any>>;
+    create(collection: string, records: Record<string, any>[]): Promise<Record<string, any>[]>;
+    private executeQuery;
+    connect(): Promise<void>;
+    getUniqueIndexes(collectionName: string): Promise<UniqueIndex[]>;
+    private executeGetIndexes;
+    dropIndex(collectionName: string, fields: UniqueIndex): Promise<void>;
+    syncIndexes(collectionName: string, indexes: Index[]): Promise<void>;
+    syncUniqueIndexes(collectionName: string, indexes: UniqueIndex[]): Promise<void>;
+    private executeSyncIndexes;
+    private areIndexesEqual;
+    createUniqueIndex(collection: string, fields: UniqueIndex): Promise<void>;
+    private executeCreateIndex;
+    private generateKeyExpressions;
+    private generateKeyExpression;
+    private generateIndexName;
+    close(): Promise<void>;
+    isConnected(): boolean;
+    private parseIndexViolatedForFieldsAndValues;
+}

package/build/esm/PostgresDatabase.js

@@ -0,0 +1,404 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DataStoresError, } from '@sprucelabs/data-stores';
+import { assertOptions } from '@sprucelabs/schema';
+import { Client } from 'pg';
+import QueryBuilder from './QueryBuilder.js';
+export default class PostgresDatabase {
+    constructor(connectionString) {
+        this.idCount = 1;
+        assertOptions({ connectionString }, ['connectionString']);
+        this.connectionString = connectionString;
+        this.query = QueryBuilder.Builder();
+    }
+    dropCollection(_name) {
+        throw new Error('Method not implemented.');
+    }
+    generateId() {
+        return `${this.idCount++}`;
+    }
+    update(collection, query, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sql, values } = this.query.update(collection, query, updates, false);
+            const results = yield this.client.query({
+                text: sql,
+                values,
+            });
+            return results.rowCount;
+        });
+    }
+    count(collection, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sql, values } = this.query.find(collection, query !== null && query !== void 0 ? query : {}, {
+                includeFields: ['count(*) as count'],
+            });
+            const results = yield this.client.query({
+                text: sql,
+                values,
+            });
+            return parseInt(results.rows[0].count);
+        });
+    }
+    updateOne(collection, query, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const action = 'updateOne';
+            const record = yield this.executeUpdateAndThrowIfNoResults(collection, query, updates, action);
+            return record;
+        });
+    }
+    executeUpdateAndThrowIfNoResults(collection, query, updates, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sql, values } = this.query.update(collection, query, updates);
+            const results = yield this.executeQuery(action, sql, values);
+            if (results.rowCount === 0) {
+                throw new DataStoresError({
+                    code: 'RECORD_NOT_FOUND',
+                    storeName: collection,
+                    query,
+                });
+            }
+            const record = results.rows[0];
+            return record;
+        });
+    }
+    find(collection, query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sql, values } = this.query.find(collection, query !== null && query !== void 0 ? query : {}, options);
+            const results = yield this.client.query({
+                text: sql,
+                values,
+            });
+            return results.rows;
+        });
+    }
+    createIndex(collection, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.executeCreateIndex(collection, fields, false);
+        });
+    }
+    getIndexes(collectionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.executeGetIndexes(collectionName, false);
+        });
+    }
+    findOne(collection, query, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield this.find(collection, query, Object.assign(Object.assign({}, options), { limit: 1 }));
+            return (_a = results[0]) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    delete(collection, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sql, values } = this.query.delete(collection, query);
+            const results = yield this.client.query({
+                text: sql,
+                values,
+            });
+            return results.rowCount;
+        });
+    }
+    dropDatabase() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.truncateTables();
+            const names = yield this.getTables();
+            for (const name of names) {
+                yield this.dropAllNonPrimaryKeyIndexes(name);
+            }
+        });
+    }
+    dropAllNonPrimaryKeyIndexes(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const indexNames = yield this.getIndexNames(name);
+            for (const indexName of indexNames) {
+                yield this.client.query(`DROP INDEX ${indexName}`);
+            }
+        });
+    }
+    getIndexNames(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sql = `SELECT indexname FROM pg_indexes WHERE tablename = '${name}' AND indexname != '${name}_pk';`;
+            const results = yield this.client.query(sql);
+            const indexNames = results.rows.map((row) => row.indexname);
+            return indexNames;
+        });
+    }
+    getTables() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sql = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE';`;
+            const results = yield this.client.query(sql);
+            const names = results.rows.map((row) => row.table_name);
+            return names;
+        });
+    }
+    upsertOne(collection, query, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [match] = yield this.find(collection, query, { limit: 1 });
+            if (match) {
+                return this.executeUpdateAndThrowIfNoResults(collection, { id: match.id }, updates, 'upsertOne');
+            }
+            else {
+                return this.createOne(collection, updates);
+            }
+        });
+    }
+    deleteOne(collection, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!query.id) {
+                const match = yield this.findOne(collection, query, {
+                    includeFields: ['id'],
+                });
+                query = { id: match === null || match === void 0 ? void 0 : match.id };
+            }
+            let { sql, values } = this.query.delete(collection, query);
+            const results = yield this.client.query({
+                text: sql,
+                values,
+            });
+            return results.rowCount;
+        });
+    }
+    truncateTables() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.query(`
+			SELECT table_name 
+			FROM information_schema.tables 
+			WHERE table_schema = 'public' 
+			AND table_type = 'BASE TABLE';
+		  `);
+            const tableNames = res.rows.map((row) => row.table_name);
+            yield Promise.all(tableNames.map((tableName) => this.client.query(`TRUNCATE TABLE ${tableName} RESTART IDENTITY CASCADE`)));
+        });
+    }
+    createOne(collection, values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.create(collection, [values]);
+            return rows[0];
+        });
+    }
+    create(collection, records) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (records.length === 0) {
+                return [];
+            }
+            const { sql, values } = this.query.create(collection, records);
+            const { rows } = yield this.executeQuery('create', sql, values);
+            return rows;
+        });
+    }
+    executeQuery(action, sql, values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const results = yield this.client.query({
+                    text: sql,
+                    values,
+                });
+                return results;
+            }
+            catch (err) {
+                const parsed = this.parseIndexViolatedForFieldsAndValues(err === null || err === void 0 ? void 0 : err.detail);
+                if (parsed) {
+                    const { fields, values } = parsed;
+                    throw new DataStoresError({
+                        code: 'DUPLICATE_RECORD',
+                        duplicateFields: fields,
+                        duplicateValues: values,
+                        collectionName: 'test_collection',
+                        action,
+                    });
+                }
+                throw err;
+            }
+        });
+    }
+    connect() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = new Client({
+                connectionString: this.connectionString,
+            });
+            try {
+                yield client.connect();
+            }
+            catch (err) {
+                const message = err.message;
+                if (message === null || message === void 0 ? void 0 : message.includes('ECONNREFUSED')) {
+                    throw new DataStoresError({
+                        code: 'UNABLE_TO_CONNECT_TO_DB',
+                        originalError: err,
+                    });
+                }
+                if (message === null || message === void 0 ? void 0 : message.includes('does not exist')) {
+                    const match = (_a = message.match(/"([^"]*)"/)) !== null && _a !== void 0 ? _a : ['', ''];
+                    throw new DataStoresError({
+                        code: 'INVALID_DATABASE_NAME',
+                        suppliedName: match[1],
+                        originalError: err,
+                    });
+                }
+                throw new DataStoresError({
+                    code: 'INVALID_DB_CONNECTION_STRING',
+                    originalError: err,
+                });
+            }
+            this.client = client;
+        });
+    }
+    getUniqueIndexes(collectionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isUnique = true;
+            const uniqueIndexes = yield this.executeGetIndexes(collectionName, isUnique);
+            return uniqueIndexes;
+        });
+    }
+    executeGetIndexes(collectionName, isUnique) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `SELECT indexname FROM pg_indexes WHERE tablename = '${collectionName}' AND indexdef ${isUnique ? '' : 'NOT'} LIKE '%UNIQUE%';`;
+            const res = yield this.client.query(query);
+            const uniqueIndexes = [];
+            res.rows.forEach((row) => {
+                const indexName = row.indexname.replace(`${collectionName}_`, '');
+                const fields = indexName.split('_').slice(0, -1);
+                if (fields.length > 0) {
+                    uniqueIndexes.push(fields);
+                }
+            });
+            return uniqueIndexes;
+        });
+    }
+    dropIndex(collectionName, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const indexName = this.generateIndexName(collectionName, fields);
+            const query = `DROP INDEX ${indexName}`;
+            try {
+                yield this.client.query({
+                    text: query,
+                });
+            }
+            catch (err) {
+                throw new DataStoresError({
+                    code: 'INDEX_NOT_FOUND',
+                    missingIndex: fields,
+                    collectionName: 'test_collection',
+                });
+            }
+        });
+    }
+    syncIndexes(collectionName, indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.executeSyncIndexes(collectionName, indexes, false);
+        });
+    }
+    syncUniqueIndexes(collectionName, indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.executeSyncIndexes(collectionName, indexes, true);
+        });
+    }
+    executeSyncIndexes(collectionName, indexes, isUnique) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingIndexes = yield this.executeGetIndexes(collectionName, isUnique);
+            const indexesToAdd = indexes.filter((index) => !existingIndexes.find((existing) => this.areIndexesEqual(existing, index)));
+            const indexesToRemove = existingIndexes.filter((existing) => !indexes.find((index) => this.areIndexesEqual(existing, index)));
+            yield Promise.all([
+                ...indexesToAdd.map((index) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    try {
+                        yield this.executeCreateIndex(collectionName, index, isUnique);
+                    }
+                    catch (err) {
+                        if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
+                            throw new DataStoresError({
+                                code: 'DUPLICATE_KEY',
+                                originalError: err,
+                            });
+                        }
+                    }
+                    return null;
+                })),
+                ...indexesToRemove.map((index) => this.dropIndex(collectionName, index)),
+            ]);
+        });
+    }
+    areIndexesEqual(existing, index) {
+        return (this.generateIndexName('any', existing) ===
+            this.generateIndexName('any', index));
+    }
+    createUniqueIndex(collection, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isUnique = true;
+            yield this.executeCreateIndex(collection, fields, isUnique);
+        });
+    }
+    executeCreateIndex(collection, fields, isUnique) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const indexName = this.generateIndexName(collection, fields);
+            const keys = this.generateKeyExpressions(fields);
+            const query = `CREATE ${isUnique ? `UNIQUE` : ''} INDEX ${indexName} ON ${collection} (${keys})`;
+            try {
+                yield this.client.query({
+                    text: query,
+                });
+            }
+            catch (err) {
+                if ((_b = (_a = err.message) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, 'already exists')) {
+                    throw new DataStoresError({
+                        code: 'INDEX_EXISTS',
+                        collectionName: 'test_collection',
+                        index: ['uniqueField'],
+                    });
+                }
+                throw err;
+            }
+        });
+    }
+    generateKeyExpressions(fields) {
+        return fields.map((f) => this.generateKeyExpression(f)).join(', ');
+    }
+    generateKeyExpression(field) {
+        if (field.includes('.')) {
+            const parts = field.split('.');
+            return `(${parts[0]}->>'${parts[1]}')`;
+        }
+        return field;
+    }
+    generateIndexName(collection, fields) {
+        return `${collection}_${fields
+            .map((f) => f.toLowerCase())
+            .join('_')}${'_index'}`.replace(/\./g, '_');
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.end();
+        });
+    }
+    isConnected() {
+        //@ts-ignore
+        return this.client._connected && !this.client._ending;
+    }
+    parseIndexViolatedForFieldsAndValues(input) {
+        const regex = /Key \((.*)\)=\((.*)\) already exists\./;
+        const matches = input === null || input === void 0 ? void 0 : input.match(regex);
+        if (!matches) {
+            return null;
+        }
+        const fieldsStr = matches[1];
+        const valuesStr = matches[2];
+        const fields = fieldsStr.split(', ');
+        const values = valuesStr.split(', ');
+        const fixedFields = fields.map((field) => field
+            .replace(/ ->> /g, '.')
+            .split('::')[0]
+            .replace('(', '')
+            .replace(/'/g, ''));
+        const result = { fields: fixedFields, values };
+        return result;
+    }
+}