@sprucelabs/postgres-data-store 0.0.1

package/README.md

@@ -0,0 +1,20 @@
+<img src="https://raw.githubusercontent.com/sprucelabsai/mercury-types/master/docs/images/hero.jpg">
+
+<h1 align="center">
+Spruce XP Documentation
+</h1>
+<h3 align="center">Spruce XP is an Experience Platform built to create unforgettable experiences and long-lasting relationships.
+</h3>
+<p align="center">
+<img align="center" width="80%" src="https://raw.githubusercontent.com/sprucelabsai/mercury-types/master/docs/images/bullets.jpg">
+</p>
+<img src="https://raw.githubusercontent.com/sprucelabsai/mercury-types/master/docs/images/spacer.png">
+<br />
+<p align="center">
+<img align="center" width="80%" src="https://raw.githubusercontent.com/sprucelabsai/mercury-types/master/docs/images/sprucebot-message.png">
+</p>
+
+<br />
+<p align="center">
+<a href="https://developer.spruce.ai/"><img width="250" src="https://raw.githubusercontent.com/sprucelabsai/mercury-types/master/docs/images/read-full-docs.png" /></a>
+</p>

package/build/.spruce/settings.json

@@ -0,0 +1,11 @@
+{
+  "scriptUpdater": {
+    "skipped": []
+  },
+  "skipped": [
+    "skill"
+  ],
+  "installed": [
+    "test"
+  ]
+}

package/build/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/PostgresDatabase.js

@@ -0,0 +1,343 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_stores_1 = require("@sprucelabs/data-stores");
+const schema_1 = require("@sprucelabs/schema");
+const pg_1 = require("pg");
+const QueryBuilder_1 = __importDefault(require("./QueryBuilder"));
+class PostgresDatabase {
+    constructor(connectionString) {
+        this.idCount = 1;
+        (0, schema_1.assertOptions)({ connectionString }, ['connectionString']);
+        this.connectionString = connectionString;
+        this.query = QueryBuilder_1.default.Builder();
+    }
+    dropCollection(_name) {
+        throw new Error('Method not implemented.');
+    }
+    generateId() {
+        return `${this.idCount++}`;
+    }
+    async update(collection, query, updates) {
+        const { sql, values } = this.query.update(collection, query, updates, false);
+        const results = await this.client.query({
+            text: sql,
+            values,
+        });
+        return results.rowCount;
+    }
+    async count(collection, query) {
+        const { sql, values } = this.query.find(collection, query !== null && query !== void 0 ? query : {}, {
+            includeFields: ['count(*) as count'],
+        });
+        const results = await this.client.query({
+            text: sql,
+            values,
+        });
+        return parseInt(results.rows[0].count);
+    }
+    async updateOne(collection, query, updates) {
+        const action = 'updateOne';
+        const record = await this.executeUpdateAndThrowIfNoResults(collection, query, updates, action);
+        return record;
+    }
+    async executeUpdateAndThrowIfNoResults(collection, query, updates, action) {
+        const { sql, values } = this.query.update(collection, query, updates);
+        const results = await this.executeQuery(action, sql, values);
+        if (results.rowCount === 0) {
+            throw new data_stores_1.DataStoresError({
+                code: 'RECORD_NOT_FOUND',
+                storeName: collection,
+                query,
+            });
+        }
+        const record = results.rows[0];
+        return record;
+    }
+    async find(collection, query, options) {
+        const { sql, values } = this.query.find(collection, query !== null && query !== void 0 ? query : {}, options);
+        const results = await this.client.query({
+            text: sql,
+            values,
+        });
+        return results.rows;
+    }
+    async createIndex(collection, fields) {
+        return this.executeCreateIndex(collection, fields, false);
+    }
+    async getIndexes(collectionName) {
+        return this.executeGetIndexes(collectionName, false);
+    }
+    async findOne(collection, query, options) {
+        var _a;
+        const results = await this.find(collection, query, Object.assign(Object.assign({}, options), { limit: 1 }));
+        return (_a = results[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    async delete(collection, query) {
+        const { sql, values } = this.query.delete(collection, query);
+        const results = await this.client.query({
+            text: sql,
+            values,
+        });
+        return results.rowCount;
+    }
+    async dropDatabase() {
+        await this.truncateTables();
+        const names = await this.getTables();
+        for (const name of names) {
+            await this.dropAllNonPrimaryKeyIndexes(name);
+        }
+    }
+    async dropAllNonPrimaryKeyIndexes(name) {
+        const indexNames = await this.getIndexNames(name);
+        for (const indexName of indexNames) {
+            await this.client.query(`DROP INDEX ${indexName}`);
+        }
+    }
+    async getIndexNames(name) {
+        const sql = `SELECT indexname FROM pg_indexes WHERE tablename = '${name}' AND indexname != '${name}_pk';`;
+        const results = await this.client.query(sql);
+        const indexNames = results.rows.map((row) => row.indexname);
+        return indexNames;
+    }
+    async getTables() {
+        const sql = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE';`;
+        const results = await this.client.query(sql);
+        const names = results.rows.map((row) => row.table_name);
+        return names;
+    }
+    async upsertOne(collection, query, updates) {
+        const [match] = await this.find(collection, query, { limit: 1 });
+        if (match) {
+            return this.executeUpdateAndThrowIfNoResults(collection, { id: match.id }, updates, 'upsertOne');
+        }
+        else {
+            return this.createOne(collection, updates);
+        }
+    }
+    async deleteOne(collection, query) {
+        if (!query.id) {
+            const match = await 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 = await this.client.query({
+            text: sql,
+            values,
+        });
+        return results.rowCount;
+    }
+    async truncateTables() {
+        const res = await 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);
+        await Promise.all(tableNames.map((tableName) => this.client.query(`TRUNCATE TABLE ${tableName} RESTART IDENTITY CASCADE`)));
+    }
+    async createOne(collection, values) {
+        const rows = await this.create(collection, [values]);
+        return rows[0];
+    }
+    async create(collection, records) {
+        if (records.length === 0) {
+            return [];
+        }
+        const { sql, values } = this.query.create(collection, records);
+        const { rows } = await this.executeQuery('create', sql, values);
+        return rows;
+    }
+    async executeQuery(action, sql, values) {
+        try {
+            const results = await 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 data_stores_1.DataStoresError({
+                    code: 'DUPLICATE_RECORD',
+                    duplicateFields: fields,
+                    duplicateValues: values,
+                    collectionName: 'test_collection',
+                    action,
+                });
+            }
+            throw err;
+        }
+    }
+    async connect() {
+        var _a;
+        const client = new pg_1.Client({
+            connectionString: this.connectionString,
+        });
+        try {
+            await client.connect();
+        }
+        catch (err) {
+            const message = err.message;
+            if (message === null || message === void 0 ? void 0 : message.includes('ECONNREFUSED')) {
+                throw new data_stores_1.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 data_stores_1.DataStoresError({
+                    code: 'INVALID_DATABASE_NAME',
+                    suppliedName: match[1],
+                    originalError: err,
+                });
+            }
+            throw new data_stores_1.DataStoresError({
+                code: 'INVALID_DB_CONNECTION_STRING',
+                originalError: err,
+            });
+        }
+        this.client = client;
+    }
+    async getUniqueIndexes(collectionName) {
+        const isUnique = true;
+        const uniqueIndexes = await this.executeGetIndexes(collectionName, isUnique);
+        return uniqueIndexes;
+    }
+    async executeGetIndexes(collectionName, isUnique) {
+        const query = `SELECT indexname FROM pg_indexes WHERE tablename = '${collectionName}' AND indexdef ${isUnique ? '' : 'NOT'} LIKE '%UNIQUE%';`;
+        const res = await 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;
+    }
+    async dropIndex(collectionName, fields) {
+        const indexName = this.generateIndexName(collectionName, fields);
+        const query = `DROP INDEX ${indexName}`;
+        try {
+            await this.client.query({
+                text: query,
+            });
+        }
+        catch (err) {
+            throw new data_stores_1.DataStoresError({
+                code: 'INDEX_NOT_FOUND',
+                missingIndex: fields,
+                collectionName: 'test_collection',
+            });
+        }
+    }
+    async syncIndexes(collectionName, indexes) {
+        await this.executeSyncIndexes(collectionName, indexes, false);
+    }
+    async syncUniqueIndexes(collectionName, indexes) {
+        await this.executeSyncIndexes(collectionName, indexes, true);
+    }
+    async executeSyncIndexes(collectionName, indexes, isUnique) {
+        const existingIndexes = await 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)));
+        await Promise.all([
+            ...indexesToAdd.map(async (index) => {
+                var _a;
+                try {
+                    await this.executeCreateIndex(collectionName, index, isUnique);
+                }
+                catch (err) {
+                    if (((_a = err.options) === null || _a === void 0 ? void 0 : _a.code) !== 'INDEX_EXISTS') {
+                        throw new data_stores_1.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));
+    }
+    async createUniqueIndex(collection, fields) {
+        const isUnique = true;
+        await this.executeCreateIndex(collection, fields, isUnique);
+    }
+    async executeCreateIndex(collection, fields, isUnique) {
+        var _a, _b;
+        const indexName = this.generateIndexName(collection, fields);
+        const keys = this.generateKeyExpressions(fields);
+        const query = `CREATE ${isUnique ? `UNIQUE` : ''} INDEX ${indexName} ON ${collection} (${keys})`;
+        try {
+            await 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 data_stores_1.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, '_');
+    }
+    async close() {
+        await 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;
+    }
+}
+exports.default = PostgresDatabase;

package/build/QueryBuilder.d.ts

@@ -0,0 +1,37 @@
+import { QueryOptions } from '@sprucelabs/data-stores';
+import { Query } from './postgres.types';
+export default class QueryBuilder {
+    private constructor();
+    static Builder(): QueryBuilder;
+    find(tableName: string, query: Query, options?: QueryOptions): BuiltQuery;
+    private optionallyBuildWhere;
+    private buildSetClause;
+    private buildSetClausFor$Or;
+    create(tableName: string, records: Record<string, any>[]): BuiltQuery;
+    createWithoutReturning(tableName: string, records: Record<string, any>[]): BuiltQuery;
+    private splitRecordsIntoFieldsPlaceholdersAndValues;
+    private fieldValueToSqlValue;
+    private normalizeValue;
+    private isValueObject;
+    private buildColumnListFromAllRecords;
+    private optionallyBuildSort;
+    private optionallyBuildSkip;
+    private optionallyBuildLimit;
+    private buildColumnListFromIncludeFields;
+    update(tableName: string, query: Query, updates: Record<string, any>, shouldReturnUpdatedRecords?: boolean): {
+        sql: string;
+        values: unknown[];
+    };
+    delete(tableName: string, query?: Query): {
+        sql: string;
+        values: unknown[];
+    };
+    upsert(tableName: string, query: Query, updates: Record<string, any>): {
+        sql: string;
+        values: unknown[];
+    };
+}
+export interface BuiltQuery {
+    sql: string;
+    values: unknown[];
+}