pg-query-sdk 1.0.0

package/dist/cjs/query/QueryBuilder.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ParamContext_1 = __importDefault(require("../core/ParamContext"));
+const ConditionBuilder_1 = __importDefault(require("./ConditionBuilder"));
+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_1.default(this.dialect);
+        this.condition = new ConditionBuilder_1.default(this.ctx);
+        this.havingCondition = new ConditionBuilder_1.default(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;
+    }
+}
+exports.default = QueryBuilder;

package/dist/esm/builders/ConditionBuilder.d.ts

@@ -0,0 +1,11 @@
+import ParamContext from "../core/ParamContext";
+export default class ConditionBuilder {
+    private ctx;
+    private conditions;
+    constructor(ctx: ParamContext);
+    where(obj: Record<string, any>): this;
+    raw(expression: string): this;
+    andGroup(callback: (qb: ConditionBuilder) => void): this;
+    orGroup(callback: (qb: ConditionBuilder) => void): this;
+    build(prefix?: string): string;
+}

package/dist/esm/builders/ConditionBuilder.js

@@ -0,0 +1,40 @@
+export default class ConditionBuilder {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.conditions = [];
+    }
+    where(obj) {
+        Object.entries(obj).forEach(([key, value]) => {
+            const placeholder = this.ctx.add(value);
+            this.conditions.push(`${key} = ${placeholder}`);
+        });
+        return this;
+    }
+    raw(expression) {
+        this.conditions.push(expression);
+        return this;
+    }
+    andGroup(callback) {
+        const nested = new ConditionBuilder(this.ctx);
+        callback(nested);
+        const built = nested.build();
+        if (built) {
+            this.conditions.push(`(${built.replace(/^WHERE /, '')})`);
+        }
+        return this;
+    }
+    orGroup(callback) {
+        const nested = new ConditionBuilder(this.ctx);
+        callback(nested);
+        const built = nested.build();
+        if (built) {
+            this.conditions.push(`OR (${built.replace(/^WHERE /, '')})`);
+        }
+        return this;
+    }
+    build(prefix = 'WHERE') {
+        if (!this.conditions.length)
+            return '';
+        return `${prefix} ${this.conditions.join(' AND ')}`;
+    }
+}

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

@@ -0,0 +1,31 @@
+import QueryExecutor from '../core/QueryExecutor';
+import { Dialect } from "../dialects/Dialect";
+export default class QueryBuilder<T = any> {
+    private executor;
+    private fields;
+    private joins;
+    private groupByFields;
+    private orderByFields;
+    private limitCount?;
+    private offsetCount?;
+    private ctes;
+    private fromClause;
+    private condition;
+    private havingCondition;
+    private ctx;
+    constructor(table: string, executor: QueryExecutor, dialect: Dialect);
+    select(fields: 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;
+    fromSubquery(sub: QueryBuilder, alias: string): this;
+    where(obj: Record<string, any>): this;
+    whereSub(column: string, operator: 'IN' | 'NOT IN', sub: QueryBuilder): this;
+    limit(limit: number): this;
+    build(): {
+        query: string;
+        params: any[];
+    };
+    execute(): Promise<any[]>;
+}

package/dist/esm/builders/QueryBuilder.js

@@ -0,0 +1,82 @@
+import ParamContext from '../core/ParamContext';
+import ConditionBuilder from './ConditionBuilder';
+export default class QueryBuilder {
+    constructor(table, executor, dialect) {
+        this.executor = executor;
+        this.fields = [];
+        this.joins = [];
+        this.groupByFields = [];
+        this.orderByFields = [];
+        this.ctes = [];
+        this.fromClause = table;
+        this.ctx = new ParamContext(dialect);
+        this.condition = new ConditionBuilder(this.ctx);
+        this.havingCondition = new ConditionBuilder(this.ctx);
+    }
+    select(fields) {
+        this.fields = fields;
+        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);
+    }
+    fromSubquery(sub, alias) {
+        const { query, params } = sub.build();
+        params.forEach(p => this.ctx.add(p));
+        this.fromClause = `(${query}) AS ${alias}`;
+        return this;
+    }
+    where(obj) {
+        this.condition.where(obj);
+        return this;
+    }
+    whereSub(column, operator, sub) {
+        const { query, params } = sub.build();
+        params.forEach(p => this.ctx.add(p));
+        this.condition.raw(`${column} ${operator} (${query})`);
+        return this;
+    }
+    limit(limit) {
+        this.limitCount = limit;
+        return this;
+    }
+    build() {
+        const select = this.fields.length
+            ? this.fields.join(', ')
+            : '*';
+        let query = `SELECT ${select}
+                     FROM ${this.fromClause}`;
+        if (this.joins.length) {
+            query += ' ' + this.joins.join(' ');
+        }
+        const whereClause = this.condition.build();
+        if (whereClause)
+            query += ' ' + whereClause;
+        if (this.limitCount) {
+            query += ` LIMIT ${this.limitCount}`;
+        }
+        return {
+            query,
+            params: this.ctx.getParams()
+        };
+    }
+    async execute() {
+        if (!this.executor) {
+            throw new Error('No QueryExecutor provided');
+        }
+        const { query, params } = this.build();
+        // @ts-ignore
+        const result = await this.executor.execute(query, params);
+        return result.rows;
+    }
+}

package/dist/esm/core/Database.d.ts

@@ -0,0 +1,20 @@
+import { Dialect } from '../dialects/Dialect';
+import QueryExecutor from './QueryExecutor';
+import QueryBuilder from '../query/QueryBuilder';
+interface DatabaseOptions {
+    connectionString: string;
+    dialect?: Dialect;
+    defaultCacheTTL?: number;
+}
+export default class Database {
+    private executor;
+    private dialect;
+    private transactionManager;
+    private defaultCacheTTL?;
+    constructor(options: DatabaseOptions);
+    table<T = any>(name: string): QueryBuilder<T>;
+    transaction<T>(callback: (trxDb: Database) => Promise<T>): Promise<T>;
+    setExecutor(executor: QueryExecutor): void;
+    repository<R>(RepoClass: new (executor: QueryExecutor, dialect: Dialect) => R): R;
+}
+export {};

package/dist/esm/core/Database.js

@@ -0,0 +1,33 @@
+import PostgresDialect from '../dialects/PostgresDialect';
+import QueryExecutor from './QueryExecutor';
+import QueryBuilder from '../query/QueryBuilder';
+import TransactionManager from './TransactionManager';
+export default class Database {
+    constructor(options) {
+        this.dialect = options.dialect ?? new PostgresDialect();
+        this.executor = new QueryExecutor(options);
+        this.transactionManager = new TransactionManager(this.executor.getPool());
+        this.defaultCacheTTL = options.defaultCacheTTL;
+    }
+    table(name) {
+        return new QueryBuilder(name, this.executor, this.dialect, this.defaultCacheTTL);
+    }
+    async transaction(callback) {
+        return this.transactionManager.transaction(async (trxClient) => {
+            const trxExecutor = new QueryExecutor(undefined, trxClient);
+            const trxDb = new Database({
+                connectionString: '',
+                dialect: this.dialect,
+                defaultCacheTTL: this.defaultCacheTTL
+            });
+            trxDb.setExecutor(trxExecutor);
+            return callback(trxDb);
+        });
+    }
+    setExecutor(executor) {
+        this.executor = executor;
+    }
+    repository(RepoClass) {
+        return new RepoClass(this.executor, this.dialect);
+    }
+}

package/dist/esm/core/ParamContext.d.ts

@@ -0,0 +1,8 @@
+import { Dialect } from "../dialects/Dialect";
+export default class ParamContext {
+    private dialect;
+    private params;
+    constructor(dialect: Dialect);
+    add(value: any): string;
+    getParams(): any[];
+}

package/dist/esm/core/ParamContext.js

@@ -0,0 +1,13 @@
+export default class ParamContext {
+    constructor(dialect) {
+        this.dialect = dialect;
+        this.params = [];
+    }
+    add(value) {
+        this.params.push(value);
+        return this.dialect.placeholder(this.params.length);
+    }
+    getParams() {
+        return this.params;
+    }
+}

package/dist/esm/core/QueryExecutor.d.ts

@@ -0,0 +1,14 @@
+import { Pool, PoolClient, QueryResult } from 'pg';
+interface ExecutorOptions {
+    connectionString: string;
+}
+export default class QueryExecutor {
+    private pool?;
+    private client?;
+    constructor(options?: ExecutorOptions, client?: PoolClient);
+    execute(query: string, params: any[] | undefined, cacheTTL: number | undefined): Promise<QueryResult>;
+    getPool(): Pool | undefined;
+    getClient(): PoolClient | undefined;
+    close(): Promise<void>;
+}
+export {};

package/dist/esm/core/QueryExecutor.js

@@ -0,0 +1,36 @@
+import { Pool } from 'pg';
+export default class QueryExecutor {
+    constructor(options, client) {
+        if (client) {
+            this.client = client;
+            return;
+        }
+        if (options?.connectionString) {
+            this.pool = new Pool({
+                connectionString: options.connectionString
+            });
+            return;
+        }
+        throw new Error('Invalid QueryExecutor initialization');
+    }
+    async execute(query, params = [], cacheTTL) {
+        if (this.client) {
+            return this.client.query(query, params);
+        }
+        if (this.pool) {
+            return this.pool.query(query, params);
+        }
+        throw new Error('Executor not initialized');
+    }
+    getPool() {
+        return this.pool;
+    }
+    getClient() {
+        return this.client;
+    }
+    async close() {
+        if (this.pool) {
+            await this.pool.end();
+        }
+    }
+}

package/dist/esm/core/TransactionManager.d.ts

@@ -0,0 +1,6 @@
+import { Pool, PoolClient } from 'pg';
+export default class TransactionManager {
+    private pool;
+    constructor(pool: Pool);
+    transaction<T>(callback: (trxClient: PoolClient) => Promise<T>): Promise<T>;
+}

package/dist/esm/core/TransactionManager.js

@@ -0,0 +1,21 @@
+export default class TransactionManager {
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async transaction(callback) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            const result = await callback(client);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+}

package/dist/esm/core/UnitOfWork.d.ts

@@ -0,0 +1,10 @@
+import Repository from "../orm/Repository";
+export default class UnitOfWork {
+    private newEntities;
+    private dirtyEntities;
+    private removedEntities;
+    registerNew(entity: any): void;
+    registerDirty(entity: any): void;
+    registerRemoved(entity: any): void;
+    commit(repository: Repository<any>): Promise<void>;
+}

package/dist/esm/core/UnitOfWork.js

@@ -0,0 +1,24 @@
+export default class UnitOfWork {
+    constructor() {
+        this.newEntities = [];
+        this.dirtyEntities = [];
+        this.removedEntities = [];
+    }
+    registerNew(entity) {
+        this.newEntities.push(entity);
+    }
+    registerDirty(entity) {
+        this.dirtyEntities.push(entity);
+    }
+    registerRemoved(entity) {
+        this.removedEntities.push(entity);
+    }
+    async commit(repository) {
+        for (const e of this.newEntities)
+            await repository.insert(e);
+        for (const e of this.dirtyEntities)
+            await repository.update(e);
+        for (const e of this.removedEntities)
+            await repository.delete(e);
+    }
+}

package/dist/esm/dialects/Dialect.d.ts

@@ -0,0 +1,4 @@
+export interface Dialect {
+    placeholder(index: number): string;
+    wrapIdentifier(identifier: string): string;
+}

package/dist/esm/dialects/Dialect.js

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

package/dist/esm/dialects/MysqlDialect.d.ts

@@ -0,0 +1,5 @@
+import { Dialect } from "./Dialect";
+export default class MysqlDialect implements Dialect {
+    placeholder(): string;
+    wrapIdentifier(id: string): string;
+}

package/dist/esm/dialects/MysqlDialect.js

@@ -0,0 +1,8 @@
+export default class MysqlDialect {
+    placeholder() {
+        return '?';
+    }
+    wrapIdentifier(id) {
+        return `\`${id}\``;
+    }
+}

package/dist/esm/dialects/PostgresDialect.d.ts

@@ -0,0 +1,5 @@
+import { Dialect } from "./Dialect";
+export default class PostgresDialect implements Dialect {
+    placeholder(index: number): string;
+    wrapIdentifier(id: string): string;
+}

package/dist/esm/dialects/PostgresDialect.js

@@ -0,0 +1,8 @@
+export default class PostgresDialect {
+    placeholder(index) {
+        return `$${index}`;
+    }
+    wrapIdentifier(id) {
+        return `"${id}"`;
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export { default as QueryExecutor } from './core/QueryExecutor';
+export { default as QueryBuilder } from './builders/QueryBuilder';
+export { default as ConditionBuilder } from './builders/ConditionBuilder';
+export { default as Database } from './core/Database';
+export { default as TransactionManager } from './core/TransactionManager';
+export { default as PostgresDialect } from './dialects/PostgresDialect';
+export { default as Repository } from './orm/Repository';

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+export { default as QueryExecutor } from './core/QueryExecutor';
+export { default as QueryBuilder } from './builders/QueryBuilder';
+export { default as ConditionBuilder } from './builders/ConditionBuilder';
+export { default as Database } from './core/Database';
+export { default as TransactionManager } from './core/TransactionManager';
+export { default as PostgresDialect } from './dialects/PostgresDialect';
+export { default as Repository } from './orm/Repository';

package/dist/esm/orm/EntityManager.js

@@ -0,0 +1 @@
+"use strict";

package/dist/esm/orm/Repository.d.ts

@@ -0,0 +1,13 @@
+import { QueryBuilder, QueryExecutor } from "../index";
+import { Dialect } from "../dialects/Dialect";
+export default abstract class Repository<T> {
+    protected table: string;
+    protected executor: QueryExecutor;
+    protected dialect: Dialect;
+    constructor(table: string, executor: QueryExecutor, dialect: Dialect);
+    qb(): QueryBuilder<T>;
+    findById(id: number): Promise<T | null>;
+    insert(data: Partial<T>): Promise<void>;
+    update(data: Partial<T>): Promise<void>;
+    delete(data: Partial<T>): Promise<void>;
+}

package/dist/esm/orm/Repository.js

@@ -0,0 +1,27 @@
+import { QueryBuilder } from "../index";
+export default class Repository {
+    constructor(table, executor, dialect) {
+        this.table = table;
+        this.executor = executor;
+        this.dialect = dialect;
+    }
+    qb() {
+        return new QueryBuilder(this.table, this.executor, this.dialect);
+    }
+    async findById(id) {
+        const rows = await this.qb()
+            .where({ id })
+            .limit(1)
+            .execute();
+        return rows[0] ?? null;
+    }
+    async insert(data) {
+        // implementação insert segura
+    }
+    async update(data) {
+        // implementação update segura
+    }
+    async delete(data) {
+        // soft delete opcional
+    }
+}

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

@@ -0,0 +1,11 @@
+import ParamContext from '../core/ParamContext';
+export default class ConditionBuilder {
+    private ctx;
+    private parts;
+    constructor(ctx: ParamContext);
+    where(obj: Record<string, any>): this;
+    raw(expression: string): this;
+    andGroup(cb: (qb: ConditionBuilder) => void): this;
+    orGroup(cb: (qb: ConditionBuilder) => void): this;
+    build(prefix?: string): string;
+}