@iamkirbki/database-handler-core 4.3.1 → 4.4.0

package/dist/helpers/QueryStatementBuilder.d.ts

@@ -1,305 +0,0 @@
-import { Query } from "../index.js";
-import { DefaultQueryParameters, ExtraQueryParameters, QueryWhereCondition, Join, QueryIsEqualParameter } from "../types/index.js";
-/** Utility class for building SQL query strings */
-export default class QueryStatementBuilder {
-    /**
-     * Build a SELECT SQL statement with optional filtering, ordering, and pagination
-     *
-     * @param table - The table to select from
-     * @param options - Query options including select columns, where conditions, orderBy, limit, offset
-     * @returns Complete SELECT SQL statement string
-     *
-     * @example
-     * ```typescript
-     * // Select all columns
-     * const query = QueryStatementBuilder.BuildSelect(usersTable);
-     * // "SELECT * FROM users"
-     *
-     * // Select specific columns with filtering
-     * const query = QueryStatementBuilder.BuildSelect(usersTable, {
-     *   select: 'id, name, email',
-     *   where: { status: 'active', age: 25 },
-     *   orderBy: 'created_at DESC',
-     *   limit: 10,
-     *   offset: 20
-     * });
-     * // "SELECT id, name, email FROM users WHERE status = @status AND age = @age ORDER BY created_at DESC LIMIT 10 OFFSET 20"
-     * ```
-     */
-    static BuildSelect(tableName: string, options?: DefaultQueryParameters & ExtraQueryParameters): string;
-    /**
-     * Build an INSERT SQL statement with named parameter placeholders
-     *
-     * @param table - The table to insert into
-     * @param record - Object containing column names and their placeholder values
-     * @returns Complete INSERT SQL statement string with @fieldName placeholders
-     *
-     * @example
-     * ```typescript
-     * const query = QueryStatementBuilder.BuildInsert(usersTable, {
-     *   name: 'John',
-     *   email: 'john@example.com',
-     *   age: 30
-     * });
-     * // "INSERT INTO users (name, email, age) VALUES (@name, @email, @age)"
-     *
-     * // Note: The actual values will be bound separately using the Parameters object
-     * ```
-     */
-    static BuildInsert(tableName: string, record: QueryIsEqualParameter): string;
-    /**
-     * Build an UPDATE SQL statement with SET clause and WHERE conditions
-     *
-     * @param table - The table to update
-     * @param record - Object containing columns to update with their placeholder values
-     * @param where - Object containing WHERE conditions for targeting specific rows
-     * @returns Complete UPDATE SQL statement string with @fieldName placeholders
-     *
-     * @example
-     * ```typescript
-     * const query = QueryStatementBuilder.BuildUpdate(
-     *   usersTable,
-     *   { name: 'John Doe', age: 31 },
-     *   { id: 1 }
-     * );
-     * // "UPDATE users SET name = @name, age = @age WHERE id = @id"
-     *
-     * // Multiple WHERE conditions
-     * const query = QueryStatementBuilder.BuildUpdate(
-     *   usersTable,
-     *   { status: 'inactive' },
-     *   { status: 'active', last_login: '2023-01-01' }
-     * );
-     * // "UPDATE users SET status = @status WHERE status = @status AND last_login = @last_login"
-     * ```
-     */
-    static BuildUpdate(tableName: string, record: QueryWhereCondition, where: QueryWhereCondition): string;
-    /**
-     * Build a DELETE SQL statement with WHERE conditions
-     *
-     * @param table - The table to delete from
-     * @param where - Object containing WHERE conditions for targeting specific rows to delete
-     * @returns Complete DELETE SQL statement string with @fieldName placeholders
-     *
-     * @example
-     * ```typescript
-     * const query = QueryStatementBuilder.BuildDelete(usersTable, { id: 1 });
-     * // "DELETE FROM users WHERE id = @id"
-     *
-     * // Multiple WHERE conditions
-     * const query = QueryStatementBuilder.BuildDelete(usersTable, {
-     *   status: 'deleted',
-     *   last_login: '2020-01-01'
-     * });
-     * // "DELETE FROM users WHERE status = @status AND last_login = @last_login"
-     * ```
-     */
-    static BuildDelete(tableName: string, where: QueryWhereCondition): string;
-    /**
-     * Build a COUNT SQL statement to count rows, optionally with WHERE conditions
-     *
-     * @param table - The table to count rows from
-     * @param where - Optional object containing WHERE conditions to filter counted rows
-     * @returns Complete COUNT SQL statement string with @fieldName placeholders
-     *
-     * @example
-     * ```typescript
-     * // Count all rows
-     * const query = QueryStatementBuilder.BuildCount(usersTable);
-     * // "SELECT COUNT(*) as count FROM users"
-     *
-     * // Count with conditions
-     * const query = QueryStatementBuilder.BuildCount(usersTable, {
-     *   status: 'active',
-     *   age: 25
-     * });
-     * // "SELECT COUNT(*) as count FROM users WHERE status = @status AND age = @age"
-     * ```
-     */
-    static BuildCount(tableName: string, where?: QueryWhereCondition): string;
-    /**
-     * Build a WHERE clause from parameter conditions (helper method)
-     *
-     * Joins multiple conditions with AND operator.
-     * Returns empty string if no conditions are provided.
-     *
-     * @param where - Optional object containing WHERE conditions
-     * @returns WHERE clause string with @fieldName placeholders, or empty string if no conditions
-     *
-     * @example
-     * ```typescript
-     * // Single condition
-     * const whereClause = QueryStatementBuilder.BuildWhere({ id: 1 });
-     * // "WHERE id = @id"
-     *
-     * // Multiple conditions (joined with AND)
-     * const whereClause = QueryStatementBuilder.BuildWhere({
-     *   status: 'active',
-     *   age: 25,
-     *   role: 'admin'
-     * });
-     * // "WHERE status = @status AND age = @age AND role = @role"
-     *
-     * // No conditions
-     * const whereClause = QueryStatementBuilder.BuildWhere();
-     * // ""
-     * ```
-     */
-    static BuildWhere(where?: QueryWhereCondition): string;
-    private static buildWhereWithOperators;
-    private static buildWhereSimple;
-    /**
-     * Build a SELECT statement with JOIN operations (INNER, LEFT, RIGHT, FULL)
-     *
-     * Supports single or multiple joins, including nested joins.
-     * Combines the base SELECT with JOIN clauses and query options.
-     * The join type (INNER, LEFT, RIGHT, FULL) is specified in each Join object.
-     *
-     * @param fromTable - The primary table to select from
-     * @param joins - Single Join object or array of Join objects defining the join operations
-     * @param options - Query options including select columns, orderBy, limit, offset
-     * @returns Complete SELECT statement with JOIN clauses
-     *
-     * @example
-     * ```typescript
-     * // Single INNER JOIN
-     * const query = QueryStatementBuilder.BuildJoin(
-     *   usersTable,
-     *   { fromTable: ordersTable, joinType: 'INNER', on: { user_id: 'id' } },
-     *   { select: 'users.*, orders.total' }
-     * );
-     * // "SELECT users.*, orders.total FROM users INNER JOIN orders ON users.id = orders.user_id"
-     *
-     * // Multiple joins with different types
-     * const query = QueryStatementBuilder.BuildJoin(
-     *   usersTable,
-     *   [
-     *     { fromTable: ordersTable, joinType: 'INNER', on: { user_id: 'id' } },
-     *     { fromTable: addressesTable, joinType: 'LEFT', on: { address_id: 'id' } }
-     *   ],
-     *   { orderBy: 'users.created_at DESC', limit: 10 }
-     * );
-     *
-     * // Nested JOIN
-     * const query = QueryStatementBuilder.BuildJoin(
-     *   usersTable,
-     *   {
-     *     fromTable: ordersTable,
-     *     joinType: 'INNER',
-     *     on: { user_id: 'id' },
-     *     join: { fromTable: productsTable, joinType: 'INNER', on: { product_id: 'id' } }
-     *   }
-     * );
-     * ```
-     */
-    static BuildJoin(fromTableName: string, joins: Join | Join[], query: Query, options?: DefaultQueryParameters & ExtraQueryParameters): Promise<string>;
-    static BuildJoinSelect(fromTableName: string, joins: Join | Join[], query: Query): Promise<string>;
-    /**
-     * Build JOIN clause(s) recursively (helper method)
-     *
-     * Processes single or multiple join definitions and handles nested joins.
-     * Each join includes the JOIN clause (INNER, LEFT, RIGHT, FULL) and ON conditions.
-     *
-     * @param fromTable - The table being joined from (for ON clause context)
-     * @param joins - Single Join object or array of Join objects
-     * @returns JOIN clause(s) as a string
-     *
-     * @example
-     * ```typescript
-     * // Single INNER JOIN
-     * const joinClause = QueryStatementBuilder.BuildJoinPart(
-     *   usersTable,
-     *   { fromTable: ordersTable, joinType: 'INNER', on: { user_id: 'id' } }
-     * );
-     * // "INNER JOIN orders ON users.id = orders.user_id"
-     *
-     * // LEFT JOIN
-     * const joinClause = QueryStatementBuilder.BuildJoinPart(
-     *   usersTable,
-     *   { fromTable: profilesTable, joinType: 'LEFT', on: { profile_id: 'id' } }
-     * );
-     * // "LEFT JOIN profiles ON users.id = profiles.profile_id"
-     *
-     * // Nested join
-     * const joinClause = QueryStatementBuilder.BuildJoinPart(
-     *   usersTable,
-     *   {
-     *     fromTable: ordersTable,
-     *     joinType: 'INNER',
-     *     on: { user_id: 'id' },
-     *     join: { fromTable: productsTable, joinType: 'INNER', on: { product_id: 'id' } }
-     *   }
-     * );
-     * // "INNER JOIN orders ON users.id = orders.user_id INNER JOIN products ON orders.id = products.product_id"
-     * ```
-     */
-    static BuildJoinPart(fromTableName: string, joins: Join | Join[]): string;
-    /**
-     * Build ON clause for JOIN operations (helper method)
-     *
-     * Creates ON conditions for join operations.
-     * Compares the foreign key column in the joined table with the primary key in the source table.
-     * Multiple conditions are joined with AND operator.
-     *
-     * @param table - The source table (left side of the join)
-     * @param joinTable - The table being joined (right side of the join)
-     * @param on - QueryCondition object where key is the foreign key in joinTable and value is the primary key in table
-     * @returns ON clause string for JOIN operations
-     *
-     * @example
-     * ```typescript
-     * // Single ON condition
-     * // Key: column in joinTable (orders), Value: column in table (users)
-     * const onClause = QueryStatementBuilder.BuildJoinOnPart(
-     *   usersTable,
-     *   ordersTable,
-     *   { user_id: 'id' }
-     * );
-     * // "ON users.id = orders.user_id"
-     *
-     * // Multiple ON conditions
-     * const onClause = QueryStatementBuilder.BuildJoinOnPart(
-     *   usersTable,
-     *   ordersTable,
-     *   [{ user_id: 'id' }, { company_id: 'company_id' }]
-     * );
-     * // "ON users.id = orders.user_id AND users.company_id = orders.company_id"
-     * ```
-     */
-    static BuildJoinOnPart(tableName: string, joinTableName: string, on: QueryIsEqualParameter | QueryIsEqualParameter[]): string;
-    /**
-     * Build query options clause (ORDER BY, LIMIT, OFFSET) (helper method)
-     *
-     * Processes query options and builds the corresponding SQL clauses.
-     * Returns empty string if no options are provided.
-     *
-     * @param options - Object containing orderBy, limit, and/or offset options
-     * @returns Query options clause as a string
-     *
-     * @example
-     * ```typescript
-     * // All options
-     * const optionsClause = QueryStatementBuilder.BuildQueryOptions({
-     *   orderBy: 'created_at DESC',
-     *   limit: 10,
-     *   offset: 20
-     * });
-     * // "ORDER BY created_at DESC LIMIT 10 OFFSET 20"
-     *
-     * // Just ordering
-     * const optionsClause = QueryStatementBuilder.BuildQueryOptions({
-     *   orderBy: 'name ASC'
-     * });
-     * // "ORDER BY name ASC"
-     *
-     * // Pagination only
-     * const optionsClause = QueryStatementBuilder.BuildQueryOptions({
-     *   limit: 25,
-     *   offset: 50
-     * });
-     * // "LIMIT 25 OFFSET 50"
-     * ```
-     */
-    static BuildQueryOptions(options: ExtraQueryParameters): string;
-}
-//# sourceMappingURL=QueryStatementBuilder.d.ts.map

package/dist/helpers/QueryStatementBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryStatementBuilder.d.ts","sourceRoot":"","sources":["../../src/helpers/QueryStatementBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,IAAI,EAA6B,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAEjK,mDAAmD;AACnD,MAAM,CAAC,OAAO,OAAO,qBAAqB;IACtC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,oBAAoB,GAAG,MAAM;IAW7G;;;;;;;;;;;;;;;;;;OAkBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,qBAAqB,GAAG,MAAM;IAYnF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM;IAW7G;;;;;;;;;;;;;;;;;;;OAmBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM;IAShF;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,mBAAmB,GAAG,MAAM;IAQhF;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;WACW,UAAU,CAAC,KAAK,CAAC,EAAE,mBAAmB,GAAG,MAAM;IAgB7D,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAStC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAK/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;WACiB,SAAS,CACzB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,EACpB,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,sBAAsB,GAAG,oBAAoB,GACxD,OAAO,CAAC,MAAM,CAAC;WAaE,eAAe,CAC/B,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,EACpB,KAAK,EAAE,KAAK,GACb,OAAO,CAAC,MAAM,CAAC;IAmBlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;WACW,aAAa,CACvB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,GACrB,MAAM;IAaT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;WACW,eAAe,CACzB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,qBAAqB,GAAG,qBAAqB,EAAE,GACpD,MAAM;IAWT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM;CAiBzE"}