pg-query-sdk 1.0.0

package/dist/esm/query/ConditionBuilder.js

@@ -0,0 +1,64 @@
+export default class ConditionBuilder {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.parts = [];
+    }
+    where(obj) {
+        Object.entries(obj).forEach(([key, value]) => {
+            if (value === null) {
+                this.parts.push(`${key} IS NULL`);
+                return;
+            }
+            if (typeof value === 'object' && value !== null && 'op' in value) {
+                const { op, value: v } = value;
+                const placeholder = this.ctx.add(v);
+                this.parts.push(`${key} ${op} ${placeholder}`);
+                return;
+            }
+            const placeholder = this.ctx.add(value);
+            this.parts.push(`${key} = ${placeholder}`);
+        });
+        return this;
+    }
+    raw(expression) {
+        this.parts.push(expression);
+        return this;
+    }
+    andGroup(cb) {
+        const nested = new ConditionBuilder(this.ctx);
+        cb(nested);
+        const built = nested.build();
+        if (built) {
+            this.parts.push(`(${built.replace(/^WHERE\s/, '')})`);
+        }
+        return this;
+    }
+    orGroup(cb) {
+        const nested = new ConditionBuilder(this.ctx);
+        cb(nested);
+        const built = nested.build();
+        if (built) {
+            const clean = built.replace(/^WHERE\s/, '');
+            this.parts.push(`OR (${clean})`);
+        }
+        return this;
+    }
+    build(prefix = 'WHERE') {
+        if (!this.parts.length)
+            return '';
+        const normalized = [];
+        this.parts.forEach((part, index) => {
+            if (index === 0) {
+                normalized.push(part);
+                return;
+            }
+            if (part.startsWith('OR ')) {
+                normalized.push(part);
+            }
+            else {
+                normalized.push(`AND ${part}`);
+            }
+        });
+        return `${prefix} ${normalized.join(' ')}`;
+    }
+}

package/dist/esm/query/QueryBuilder.d.ts

@@ -0,0 +1,43 @@
+import ConditionBuilder from './ConditionBuilder';
+import QueryExecutor from '../core/QueryExecutor';
+import { Dialect } from '../dialects/Dialect';
+export default class QueryBuilder<T = any> {
+    private executor;
+    private dialect;
+    private cacheTTL?;
+    private fields;
+    private joins;
+    private groupByFields;
+    private orderByFields;
+    private limitCount?;
+    private offsetCount?;
+    private ctes;
+    private fromClause;
+    private ctx;
+    private condition;
+    private havingCondition;
+    constructor(table: string, executor: QueryExecutor, dialect: Dialect, cacheTTL?: number | 0 | undefined);
+    select(fields: (keyof T | string)[]): this;
+    private addJoin;
+    join(table: string, localKey: string, foreignKey: string): this;
+    leftJoin(table: string, localKey: string, foreignKey: string): this;
+    rightJoin(table: string, localKey: string, foreignKey: string): this;
+    where(obj: Partial<T>): this;
+    whereRaw(expression: string): this;
+    andGroup(cb: (qb: ConditionBuilder) => void): this;
+    orGroup(cb: (qb: ConditionBuilder) => void): this;
+    groupBy(fields: string | string[]): this;
+    having(obj: Record<string, any>): this;
+    havingRaw(expr: string): this;
+    orderBy(column: string, direction?: 'ASC' | 'DESC'): this;
+    limit(value: number): this;
+    offset(value: number): this;
+    with(name: string, subQuery: QueryBuilder<any>, recursive?: boolean): this;
+    fromSubquery(sub: QueryBuilder<any>, alias: string): this;
+    clone(): QueryBuilder<T>;
+    build(): {
+        query: string;
+        params: any[];
+    };
+    execute(): Promise<T[]>;
+}

package/dist/esm/query/QueryBuilder.js

@@ -0,0 +1,146 @@
+import ParamContext from '../core/ParamContext';
+import ConditionBuilder from './ConditionBuilder';
+export default class QueryBuilder {
+    constructor(table, executor, dialect, cacheTTL) {
+        this.executor = executor;
+        this.dialect = dialect;
+        this.cacheTTL = cacheTTL;
+        this.fields = [];
+        this.joins = [];
+        this.groupByFields = [];
+        this.orderByFields = [];
+        this.ctes = [];
+        this.fromClause = table;
+        this.ctx = new ParamContext(this.dialect);
+        this.condition = new ConditionBuilder(this.ctx);
+        this.havingCondition = new ConditionBuilder(this.ctx);
+    }
+    select(fields) {
+        this.fields = fields.map(String);
+        return this;
+    }
+    addJoin(type, table, localKey, foreignKey) {
+        this.joins.push(`${type} JOIN ${table} ON ${localKey} = ${foreignKey}`);
+        return this;
+    }
+    join(table, localKey, foreignKey) {
+        return this.addJoin('INNER', table, localKey, foreignKey);
+    }
+    leftJoin(table, localKey, foreignKey) {
+        return this.addJoin('LEFT', table, localKey, foreignKey);
+    }
+    rightJoin(table, localKey, foreignKey) {
+        return this.addJoin('RIGHT', table, localKey, foreignKey);
+    }
+    where(obj) {
+        this.condition.where(obj);
+        return this;
+    }
+    whereRaw(expression) {
+        this.condition.raw(expression);
+        return this;
+    }
+    andGroup(cb) {
+        this.condition.andGroup(cb);
+        return this;
+    }
+    orGroup(cb) {
+        this.condition.orGroup(cb);
+        return this;
+    }
+    groupBy(fields) {
+        if (Array.isArray(fields)) {
+            this.groupByFields.push(...fields);
+        }
+        else {
+            this.groupByFields.push(fields);
+        }
+        return this;
+    }
+    having(obj) {
+        this.havingCondition.where(obj);
+        return this;
+    }
+    havingRaw(expr) {
+        this.havingCondition.raw(expr);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByFields.push(`${column} ${direction}`);
+        return this;
+    }
+    limit(value) {
+        this.limitCount = value;
+        return this;
+    }
+    offset(value) {
+        this.offsetCount = value;
+        return this;
+    }
+    with(name, subQuery, recursive = false) {
+        this.ctes.push({ name, query: subQuery, recursive });
+        return this;
+    }
+    fromSubquery(sub, alias) {
+        const { query, params } = sub.build();
+        params.forEach(p => this.ctx.add(p));
+        this.fromClause = `(${query}) AS ${alias}`;
+        return this;
+    }
+    clone() {
+        const qb = new QueryBuilder(this.fromClause, this.executor, this.dialect, this.cacheTTL);
+        qb.fields = [...this.fields];
+        qb.joins = [...this.joins];
+        qb.groupByFields = [...this.groupByFields];
+        qb.orderByFields = [...this.orderByFields];
+        qb.limitCount = this.limitCount;
+        qb.offsetCount = this.offsetCount;
+        qb.ctes = [...this.ctes];
+        return qb;
+    }
+    build() {
+        let query = '';
+        if (this.ctes.length) {
+            const recursive = this.ctes.some(c => c.recursive);
+            query += `WITH ${recursive ? 'RECURSIVE ' : ''}`;
+            const parts = this.ctes.map(cte => {
+                const { query: q, params } = cte.query.build();
+                params.forEach(p => this.ctx.add(p));
+                return `${cte.name} AS (${q})`;
+            });
+            query += parts.join(', ') + ' ';
+        }
+        const select = this.fields.length ? this.fields.join(', ') : '*';
+        query += `SELECT ${select} FROM ${this.fromClause}`;
+        if (this.joins.length) {
+            query += ' ' + this.joins.join(' ');
+        }
+        const where = this.condition.build();
+        if (where)
+            query += ' ' + where;
+        if (this.groupByFields.length) {
+            query += ` GROUP BY ${this.groupByFields.join(', ')}`;
+        }
+        const having = this.havingCondition.build('HAVING');
+        if (having)
+            query += ' ' + having;
+        if (this.orderByFields.length) {
+            query += ` ORDER BY ${this.orderByFields.join(', ')}`;
+        }
+        if (this.limitCount) {
+            query += ` LIMIT ${this.limitCount}`;
+        }
+        if (this.offsetCount) {
+            query += ` OFFSET ${this.offsetCount}`;
+        }
+        return {
+            query,
+            params: this.ctx.getParams()
+        };
+    }
+    async execute() {
+        const { query, params } = this.build();
+        const result = await this.executor.execute(query, params, this.cacheTTL);
+        return result.rows;
+    }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "pg-query-sdk",
+  "version": "1.0.0",
+  "description": "PostgreSQL SDK with Query Builder and Executor",
+  "main": "dist/cjs/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "types": "./dist/esm/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "npm run build:cjs && npm run build:esm",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": {
+    "name": "Guilherme",
+    "email": "sguii5147@gmail.com",
+    "url": "https://github.com/guio11221"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/guio11221/pg-query-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/guio11221/pg-query-sdk/issues"
+  },
+  "homepage": "https://github.com/guio11221/pg-query-sdk#readme",
+  "license": "MIT",
+  "dependencies": {
+    "pg": "^8.18.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/node": "^20.10.5",
+    "@types/pg": "^8.16.0"
+  }
+}