pg-query-sdk 1.0.0

package/dist/cjs/builders/QueryBuilder.js

@@ -0,0 +1,88 @@
+"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) {
+        this.executor = executor;
+        this.fields = [];
+        this.joins = [];
+        this.groupByFields = [];
+        this.orderByFields = [];
+        this.ctes = [];
+        this.fromClause = table;
+        this.ctx = new ParamContext_1.default(dialect);
+        this.condition = new ConditionBuilder_1.default(this.ctx);
+        this.havingCondition = new ConditionBuilder_1.default(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;
+    }
+}
+exports.default = QueryBuilder;

package/dist/cjs/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/cjs/core/Database.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PostgresDialect_1 = __importDefault(require("../dialects/PostgresDialect"));
+const QueryExecutor_1 = __importDefault(require("./QueryExecutor"));
+const QueryBuilder_1 = __importDefault(require("../query/QueryBuilder"));
+const TransactionManager_1 = __importDefault(require("./TransactionManager"));
+class Database {
+    constructor(options) {
+        this.dialect = options.dialect ?? new PostgresDialect_1.default();
+        this.executor = new QueryExecutor_1.default(options);
+        this.transactionManager = new TransactionManager_1.default(this.executor.getPool());
+        this.defaultCacheTTL = options.defaultCacheTTL;
+    }
+    table(name) {
+        return new QueryBuilder_1.default(name, this.executor, this.dialect, this.defaultCacheTTL);
+    }
+    async transaction(callback) {
+        return this.transactionManager.transaction(async (trxClient) => {
+            const trxExecutor = new QueryExecutor_1.default(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);
+    }
+}
+exports.default = Database;

package/dist/cjs/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/cjs/core/ParamContext.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+    }
+}
+exports.default = ParamContext;

package/dist/cjs/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/cjs/core/QueryExecutor.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pg_1 = require("pg");
+class QueryExecutor {
+    constructor(options, client) {
+        if (client) {
+            this.client = client;
+            return;
+        }
+        if (options?.connectionString) {
+            this.pool = new pg_1.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();
+        }
+    }
+}
+exports.default = QueryExecutor;

package/dist/cjs/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/cjs/core/TransactionManager.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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();
+        }
+    }
+}
+exports.default = TransactionManager;

package/dist/cjs/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/cjs/core/UnitOfWork.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+    }
+}
+exports.default = UnitOfWork;

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

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

package/dist/cjs/dialects/Dialect.js

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

package/dist/cjs/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/cjs/dialects/MysqlDialect.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MysqlDialect {
+    placeholder() {
+        return '?';
+    }
+    wrapIdentifier(id) {
+        return `\`${id}\``;
+    }
+}
+exports.default = MysqlDialect;

package/dist/cjs/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/cjs/dialects/PostgresDialect.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PostgresDialect {
+    placeholder(index) {
+        return `$${index}`;
+    }
+    wrapIdentifier(id) {
+        return `"${id}"`;
+    }
+}
+exports.default = PostgresDialect;

package/dist/cjs/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/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = exports.PostgresDialect = exports.TransactionManager = exports.Database = exports.ConditionBuilder = exports.QueryBuilder = exports.QueryExecutor = void 0;
+var QueryExecutor_1 = require("./core/QueryExecutor");
+Object.defineProperty(exports, "QueryExecutor", { enumerable: true, get: function () { return __importDefault(QueryExecutor_1).default; } });
+var QueryBuilder_1 = require("./builders/QueryBuilder");
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return __importDefault(QueryBuilder_1).default; } });
+var ConditionBuilder_1 = require("./builders/ConditionBuilder");
+Object.defineProperty(exports, "ConditionBuilder", { enumerable: true, get: function () { return __importDefault(ConditionBuilder_1).default; } });
+var Database_1 = require("./core/Database");
+Object.defineProperty(exports, "Database", { enumerable: true, get: function () { return __importDefault(Database_1).default; } });
+var TransactionManager_1 = require("./core/TransactionManager");
+Object.defineProperty(exports, "TransactionManager", { enumerable: true, get: function () { return __importDefault(TransactionManager_1).default; } });
+var PostgresDialect_1 = require("./dialects/PostgresDialect");
+Object.defineProperty(exports, "PostgresDialect", { enumerable: true, get: function () { return __importDefault(PostgresDialect_1).default; } });
+var Repository_1 = require("./orm/Repository");
+Object.defineProperty(exports, "Repository", { enumerable: true, get: function () { return __importDefault(Repository_1).default; } });

package/dist/cjs/orm/EntityManager.js

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

package/dist/cjs/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/cjs/orm/Repository.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+class Repository {
+    constructor(table, executor, dialect) {
+        this.table = table;
+        this.executor = executor;
+        this.dialect = dialect;
+    }
+    qb() {
+        return new index_1.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
+    }
+}
+exports.default = Repository;

package/dist/cjs/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;
+}

package/dist/cjs/query/ConditionBuilder.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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(' ')}`;
+    }
+}
+exports.default = ConditionBuilder;

package/dist/cjs/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[]>;
+}