@sprucelabs/postgres-data-store 0.0.1

package/build/esm/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[];
+}

package/build/esm/QueryBuilder.js

@@ -0,0 +1,240 @@
+export default 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],
+        };
+    }
+}

package/build/esm/index.js

@@ -0,0 +1,2 @@
+"use strict";
+//exports go here

package/build/esm/postgres.types.d.ts

@@ -0,0 +1,2 @@
+import { QueryBuilder } from '@sprucelabs/data-stores';
+export type Query = QueryBuilder<Record<string, any>>;

package/build/esm/postgres.types.js

@@ -0,0 +1 @@
+export {};

package/build/index.js

@@ -0,0 +1,2 @@
+"use strict";
+//exports go here

package/build/postgres.types.d.ts

@@ -0,0 +1,2 @@
+import { QueryBuilder } from '@sprucelabs/data-stores';
+export type Query = QueryBuilder<Record<string, any>>;

package/build/postgres.types.js

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

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@sprucelabs/postgres-data-store",
+  "description": "Postgres production and test adapters for @sprucelabs/data-stores",
+  "skill": {
+    "namespace": "postgres-data-store",
+    "upgradeIgnoreList": [
+      "globby",
+      "@types/node",
+      "@sprucelabs/spruce-core-schemas",
+      "@sprucelabs/spruce-test-fixtures"
+    ]
+  },
+  "files": [
+    "build"
+  ],
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "module": "./build/esm/index.js",
+  "sideEffects": false,
+  "keywords": [
+    "node",
+    "components",
+    "sprucebot",
+    "sprucelabs"
+  ],
+  "version": "0.0.1",
+  "scripts": {
+    "build.ci": "yarn build.tsc && yarn build.resolve-paths && yarn lint",
+    "build.dev": "yarn build.tsc --sourceMap ; yarn resolve-paths.lint",
+    "build.copy-files": "mkdir -p build && rsync -avzq --exclude='*.ts' ./src/ ./build/",
+    "build.dist": "tsc --project tsconfig.dist.json && yarn build.resolve-paths && mv build esm && yarn build.esm-postbuild && yarn build.tsc && yarn build.resolve-paths && mv esm build/ && yarn clean.dist",
+    "build.esm-postbuild": "esm-postbuild --target esm --patterns '**/*.js'",
+    "build.resolve-paths": "resolve-path-aliases --target build --patterns '**/*.js,**/*.d.ts'",
+    "build.tsc": "yarn build.copy-files && tsc",
+    "clean": "yarn clean.build",
+    "clean.all": "yarn clean.dependencies && yarn clean.build",
+    "clean.build": "rm -rf build/",
+    "clean.dependencies": "rm -rf node_modules/ package-lock.json yarn.lock",
+    "clean.dist": "rm -rf build/__tests__ build/esm/__tests__",
+    "fix.lint": "eslint --fix --cache '**/*.ts'",
+    "lint": "eslint --cache '**/*.ts'",
+    "lint.tsc": "tsc -p . --noEmit",
+    "post.watch.build": "yarn build.copy-files && yarn build.resolve-paths",
+    "rebuild": "yarn clean.all && yarn && yarn build.dev",
+    "release": "semantic-release",
+    "resolve-paths.lint": "yarn build.resolve-paths ; yarn lint",
+    "test": "jest",
+    "update.dependencies": "yarn clean.dependencies && yarn",
+    "watch.build.dev": "tsc-watch --sourceMap --onCompilationComplete 'yarn post.watch.build'",
+    "watch.lint": "concurrently 'yarn lint' \"chokidar 'src/**/*' -c 'yarn lint.tsc'\"",
+    "watch.rebuild": "yarn clean.all && yarn && yarn watch.build.dev",
+    "watch.tsc": "tsc -w"
+  },
+  "dependencies": {
+    "@sprucelabs/data-stores": "^20.0.8",
+    "@sprucelabs/schema": "^28.5.128",
+    "pg": "^8.9.0"
+  },
+  "devDependencies": {
+    "@sprucelabs/esm-postbuild": "^2.0.97",
+    "@sprucelabs/jest-json-reporter": "^6.0.562",
+    "@sprucelabs/resolve-path-aliases": "^1.1.176",
+    "@sprucelabs/semantic-release": "^4.0.8",
+    "@sprucelabs/spruce-test-fixtures": "^52.8.0",
+    "@sprucelabs/test": "^7.7.420",
+    "@sprucelabs/test-utils": "^3.3.10",
+    "@types/node": "^18.14.0",
+    "@types/pg": "^8.6.6",
+    "chokidar-cli": "^3.0.0",
+    "concurrently": "^7.6.0",
+    "eslint": "^8.34.0",
+    "eslint-config-spruce": "^10.12.0",
+    "jest": "^29.4.3",
+    "jest-circus": "^29.4.3",
+    "prettier": "^2.8.4",
+    "ts-node": "^10.9.1",
+    "tsc-watch": "^6.0.0",
+    "typescript": "^4.9.5"
+  },
+  "jest": {
+    "testRunner": "jest-circus/runner",
+    "maxWorkers": 4,
+    "testTimeout": 120000,
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": [
+      "<rootDir>/tmp/",
+      "<rootDir>/src/",
+      "<rootDir>/node_modules/",
+      "<rootDir>/build/__tests__/testDirsAndFiles/"
+    ],
+    "testMatch": [
+      "**/__tests__/**/*.test.js?(x)"
+    ],
+    "moduleNameMapper": {
+      "^#spruce/(.*)$": "<rootDir>/build/.spruce/$1"
+    }
+  }
+}