blendsdk 5.33.0

package/dist/dbcore/crud-statement.js

@@ -0,0 +1,75 @@
+import { Statement } from './statement.js';
+/**
+ * Abstract base class for CRUD (Create, Read, Update, Delete) statement builders.
+ * Extends the Statement class to provide common functionality for INSERT, UPDATE,
+ * and DELETE operations, including support for RETURNING clauses and value management.
+ *
+ * This class serves as the foundation for all data modification statements,
+ * providing shared functionality for handling values and return fields.
+ *
+ * @export
+ * @abstract
+ * @class CrudStatement
+ * @extends {Statement<TableType>}
+ * @template TableType - The type representing the table structure this statement operates on
+ */
+export class CrudStatement extends Statement {
+    tableName;
+    /**
+     * Array of field names to return after the operation completes.
+     * Used to construct the RETURNING clause in SQL statements.
+     * Can contain specific field names or '*' to return all fields.
+     *
+     * @protected
+     * @type {string[]}
+     * @memberof CrudStatement
+     */
+    _returning;
+    /**
+     * Object containing the values to be inserted or updated.
+     * Keys represent column names and values represent the data to be stored.
+     *
+     * @protected
+     * @type {Partial<TableType>}
+     * @memberof CrudStatement
+     */
+    _values;
+    /**
+     * Creates an instance of CrudStatement.
+     * Initializes the statement with a table name and database connection,
+     * and sets up empty arrays/objects for returning fields and values.
+     *
+     * @param {string} tableName - The name of the table this statement operates on
+     * @param {Database} db - The database instance to execute queries against
+     * @memberof CrudStatement
+     */
+    constructor(tableName, db) {
+        super(db);
+        this.tableName = tableName;
+        this._returning = [];
+        this._values = {};
+    }
+    /**
+     * Specifies which fields should be returned after the operation completes.
+     * Adds a RETURNING clause to the SQL statement, which is useful for getting
+     * auto-generated values (like IDs) or confirming the final state of modified records.
+     *
+     * @param {(keyof TableType)[] | '*'} fields - Array of field names to return, or '*' for all fields
+     * @return {this} The statement instance for method chaining
+     * @memberof CrudStatement
+     *
+     * @example
+     * // Return specific fields
+     * statement.returning(['id', 'created_at'])
+     *
+     * @example
+     * // Return all fields
+     * statement.returning('*')
+     */
+    returning(fields) {
+        const fld = fields === '*' ? ['*'] : fields;
+        this._returning = fld;
+        return this;
+    }
+}
+//# sourceMappingURL=crud-statement.js.map

package/dist/dbcore/crud-statement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud-statement.js","sourceRoot":"","sources":["../src/crud-statement.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAgB,aAAyB,SAAQ,SAAoB;IAgC7D;IA/BZ;;;;;;;;OAQG;IACO,UAAU,CAAW;IAE/B;;;;;;;OAOG;IACO,OAAO,CAAqB;IAEtC;;;;;;;;OAQG;IACH,YACY,SAAiB,EAC3B,EAAY;QAEZ,KAAK,CAAC,EAAE,CAAC,CAAC;QAHA,cAAS,GAAT,SAAS,CAAQ;QAI3B,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,MAAiC;QACzC,MAAM,GAAG,GAAG,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAE,MAAmB,CAAC;QAC1D,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/dbcore/database.d.ts

@@ -0,0 +1,272 @@
+import { DeleteStatement } from './delete-statement.js';
+import { FromStatement } from './from-statement.js';
+import { InsertStatement } from './insert-statement.js';
+import { UpdateStatement } from './update-statement.js';
+/**
+ * Handler function type for transforming query parameters before query execution.
+ * Allows modification of parameter objects before the query is sent to the database.
+ *
+ * @export
+ * @callback QueryParamHandler
+ * @param {Record<string, any>} params - The parameter object to transform
+ * @return {Record<string, any>} The transformed parameter object
+ */
+export type QueryParamHandler = (params: Record<string, any>) => Record<string, any>;
+/**
+ * Handler function type for transforming query result rows after execution.
+ * Allows modification of result data before it is returned to the caller.
+ *
+ * @export
+ * @callback QueryResultHandler
+ * @param {any[]} rows - The result rows array to transform
+ * @return {any[]} The transformed rows array
+ */
+export type QueryResultHandler = (rows: any[]) => any[];
+/**
+ * Configuration options for executing database queries.
+ * Provides hooks for parameter transformation at different stages of query execution.
+ *
+ * @export
+ * @interface ExecuteQueryOptions
+ */
+export interface ExecuteQueryOptions {
+    /**
+     * Handler function called before query execution to transform parameters.
+     * Useful for parameter validation, sanitization, or transformation.
+     *
+     * @type {QueryParamHandler}
+     * @memberof ExecuteQueryOptions
+     */
+    beforeQuery?: QueryParamHandler;
+    /**
+     * Handler function called after query execution to transform result rows.
+     * Receives the raw result rows array and returns a transformed version.
+     * Useful for data transformation, field mapping, or post-processing of returned records.
+     *
+     * @type {QueryResultHandler}
+     * @memberof ExecuteQueryOptions
+     */
+    afterQuery?: QueryResultHandler;
+}
+/**
+ * Configuration settings for establishing a database connection.
+ * Contains all necessary connection parameters for database initialization.
+ *
+ * @export
+ * @interface DatabaseConfig
+ */
+export interface DatabaseConfig {
+    /**
+     * The hostname or IP address of the database server.
+     *
+     * @type {string}
+     * @memberof DatabaseConfig
+     */
+    host?: string;
+    /**
+     * The name of the database to connect to.
+     *
+     * @type {string}
+     * @memberof DatabaseConfig
+     */
+    database?: string;
+    /**
+     * The port number on which the database server is listening.
+     * Can be provided as a string or number.
+     *
+     * @type {(string | number)}
+     * @memberof DatabaseConfig
+     */
+    port?: string | number;
+    /**
+     * The username for database authentication.
+     *
+     * @type {string}
+     * @memberof DatabaseConfig
+     */
+    user?: string;
+    /**
+     * The password for database authentication.
+     *
+     * @type {string}
+     * @memberof DatabaseConfig
+     */
+    pass?: string;
+}
+/**
+ * Represents the result of a database query execution.
+ * Contains both the returned records and metadata about the query execution.
+ *
+ * @export
+ * @interface QueryResult
+ * @template T - The type of records returned by the query
+ */
+export interface QueryResult<T> {
+    /**
+     * Array of records returned by the query.
+     * Each record is of type T as specified by the generic parameter.
+     *
+     * @type {T[]}
+     * @memberof QueryResult
+     */
+    records: T[];
+    /**
+     * The number of rows affected or returned by the query.
+     * For SELECT queries, this is the number of rows returned.
+     * For INSERT/UPDATE/DELETE queries, this is the number of rows affected.
+     *
+     * @type {number}
+     * @memberof QueryResult
+     */
+    rowCount: number;
+}
+/**
+ * Abstract base class for database implementations.
+ * Provides a unified interface for database operations including connection management,
+ * query execution, and CRUD statement builders. Concrete implementations must provide
+ * database-specific logic for connection handling and query execution.
+ *
+ * This class serves as the foundation for all database adapters in the system,
+ * ensuring consistent API across different database backends (PostgreSQL, MySQL, etc.).
+ *
+ * @export
+ * @abstract
+ * @class Database
+ */
+export declare abstract class Database {
+    protected config: DatabaseConfig;
+    /**
+     * Creates an instance of Database with the provided configuration.
+     * Stores the configuration for later use during connection establishment.
+     *
+     * @param {DatabaseConfig} config - The database connection configuration
+     * @memberof Database
+     */
+    constructor(config: DatabaseConfig);
+    /**
+     * Establishes a connection to the database using the provided configuration.
+     * Must be implemented by concrete database classes to handle database-specific
+     * connection logic.
+     *
+     * @abstract
+     * @return {Promise<any>} Promise resolving to the database connection object
+     * @memberof Database
+     */
+    abstract connect(): Promise<any>;
+    /**
+     * Closes the database connection and releases associated resources.
+     * Must be implemented by concrete database classes to handle proper cleanup
+     * and connection termination.
+     *
+     * @abstract
+     * @param {number} [timeoutMs] - Optional maximum time in milliseconds to wait for graceful shutdown
+     * @return {Promise<void>} Promise resolving when disconnection is complete
+     * @memberof Database
+     */
+    abstract disconnect(timeoutMs?: number): Promise<void>;
+    /**
+     * Executes a SQL query without parameters.
+     *
+     * @abstract
+     * @template R - The type of records expected in the query result
+     * @param {string} query - The SQL query string to execute
+     * @return {Promise<QueryResult<R> | null>} Promise resolving to query results or null
+     * @memberof Database
+     */
+    abstract executeQuery<R>(query: string): Promise<QueryResult<R> | null>;
+    /**
+     * Executes a SQL query with parameterized values.
+     *
+     * @abstract
+     * @template R - The type of records expected in the query result
+     * @param {string} query - The SQL query string to execute
+     * @param {Record<string, any>} [params] - Optional parameters for the query
+     * @return {Promise<QueryResult<R> | null>} Promise resolving to query results or null
+     * @memberof Database
+     */
+    abstract executeQuery<R>(query: string, params?: Record<string, any>): Promise<QueryResult<R> | null>;
+    /**
+     * Executes a SQL query with parameterized values and execution options.
+     * Provides hooks for parameter transformation before and after query execution.
+     *
+     * @abstract
+     * @template R - The type of records expected in the query result
+     * @param {string} query - The SQL query string to execute
+     * @param {Record<string, any>} params - Parameters for the query
+     * @param {ExecuteQueryOptions} [options] - Optional execution configuration
+     * @return {Promise<QueryResult<R> | null>} Promise resolving to query results or null
+     * @memberof Database
+     */
+    abstract executeQuery<R>(query: string, params: Record<string, any>, options?: ExecuteQueryOptions): Promise<QueryResult<R> | null>;
+    /**
+     * Executes a function within a database transaction.
+     * Ensures that all operations within the function are executed atomically.
+     * If the function throws an error, the transaction is rolled back.
+     * If the function completes successfully, the transaction is committed.
+     *
+     * @abstract
+     * @template T - The return type of the transaction function
+     * @param {(db: this) => Promise<T>} fn - The function to execute within the transaction
+     * @return {Promise<T>} Promise resolving to the function's return value
+     * @memberof Database
+     */
+    abstract withTransaction<T>(fn: (db: this) => Promise<T>): Promise<T>;
+    /**
+     * Creates an INSERT statement builder for the specified table.
+     * Must be implemented by concrete database classes to provide database-specific
+     * INSERT statement construction.
+     *
+     * @abstract
+     * @template T - The type representing the table structure
+     * @param {string} tableName - The name of the table to insert into
+     * @return {InsertStatement<T>} An INSERT statement builder instance
+     * @memberof Database
+     */
+    abstract insert<T>(tableName: string): InsertStatement<T>;
+    /**
+     * Creates an UPDATE statement builder for the specified table.
+     * Must be implemented by concrete database classes to provide database-specific
+     * UPDATE statement construction.
+     *
+     * @abstract
+     * @template T - The type representing the table structure
+     * @template F - The type representing the filter criteria structure
+     * @param {string} tableName - The name of the table to update
+     * @return {UpdateStatement<T, F>} An UPDATE statement builder instance
+     * @memberof Database
+     */
+    abstract update<T, F>(tableName: string): UpdateStatement<T, F>;
+    /**
+     * Creates a DELETE statement builder for the specified table.
+     * Must be implemented by concrete database classes to provide database-specific
+     * DELETE statement construction.
+     *
+     * @abstract
+     * @template F - The type representing the filter criteria structure
+     * @param {string} tableName - The name of the table to delete from
+     * @return {DeleteStatement<F>} A DELETE statement builder instance
+     * @memberof Database
+     */
+    abstract delete<F>(tableName: string): DeleteStatement<F>;
+    /**
+     * Selects all records from the specified table.
+     * Returns a FromStatement configured to select all columns.
+     *
+     * @template T - The type representing the table structure
+     * @param {string} tableName - The name of the table to select from
+     * @return {FromStatement<T>} A FROM statement builder configured to select all columns
+     * @memberof Database
+     */
+    selectAll<T>(tableName: string): FromStatement<T>;
+    /**
+     * Creates a SELECT statement builder for the specified table.
+     * Provides a fluent interface for constructing SELECT queries with various clauses.
+     *
+     * @template T - The type representing the table structure
+     * @param {string} tableName - The name of the table to select from
+     * @return {FromStatement<T>} A FROM statement builder instance
+     * @memberof Database
+     */
+    from<T>(tableName: string): FromStatement<T>;
+}
+//# sourceMappingURL=database.d.ts.map

package/dist/dbcore/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"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"}

package/dist/dbcore/database.js

@@ -0,0 +1,53 @@
+import { FromStatement } from './from-statement.js';
+/**
+ * Abstract base class for database implementations.
+ * Provides a unified interface for database operations including connection management,
+ * query execution, and CRUD statement builders. Concrete implementations must provide
+ * database-specific logic for connection handling and query execution.
+ *
+ * This class serves as the foundation for all database adapters in the system,
+ * ensuring consistent API across different database backends (PostgreSQL, MySQL, etc.).
+ *
+ * @export
+ * @abstract
+ * @class Database
+ */
+export class Database {
+    config;
+    /**
+     * Creates an instance of Database with the provided configuration.
+     * Stores the configuration for later use during connection establishment.
+     *
+     * @param {DatabaseConfig} config - The database connection configuration
+     * @memberof Database
+     */
+    constructor(config) {
+        this.config = config;
+        // Config is automatically assigned via TypeScript parameter property
+    }
+    /**
+     * Selects all records from the specified table.
+     * Returns a FromStatement configured to select all columns.
+     *
+     * @template T - The type representing the table structure
+     * @param {string} tableName - The name of the table to select from
+     * @return {FromStatement<T>} A FROM statement builder configured to select all columns
+     * @memberof Database
+     */
+    selectAll(tableName) {
+        return this.from(tableName).select();
+    }
+    /**
+     * Creates a SELECT statement builder for the specified table.
+     * Provides a fluent interface for constructing SELECT queries with various clauses.
+     *
+     * @template T - The type representing the table structure
+     * @param {string} tableName - The name of the table to select from
+     * @return {FromStatement<T>} A FROM statement builder instance
+     * @memberof Database
+     */
+    from(tableName) {
+        return new FromStatement(tableName, this);
+    }
+}
+//# sourceMappingURL=database.js.map

package/dist/dbcore/database.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.js","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAqIpD;;;;;;;;;;;;GAYG;AACH,MAAM,OAAgB,QAAQ;IAQN;IAPtB;;;;;;OAMG;IACH,YAAsB,MAAsB;QAAtB,WAAM,GAAN,MAAM,CAAgB;QAC1C,qEAAqE;IACvE,CAAC;IA2HD;;;;;;;;OAQG;IACH,SAAS,CAAI,SAAiB;QAC5B,OAAO,IAAI,CAAC,IAAI,CAAI,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC;IAC1C,CAAC;IAED;;;;;;;;OAQG;IACH,IAAI,CAAI,SAAiB;QACvB,OAAO,IAAI,aAAa,CAAI,SAAS,EAAE,IAAI,CAAC,CAAC;IAC/C,CAAC;CACF"}

package/dist/dbcore/dataservice-base.d.ts

@@ -0,0 +1,18 @@
+import { Database } from './database.js';
+/**
+ * Abstract base class for data services.
+ * Provides access to the database instance for subclasses to perform queries.
+ *
+ * @abstract
+ * @class DataServiceBase
+ */
+export declare abstract class DataServiceBase {
+    /**
+     * The database instance used by this data service.
+     * Protected to enforce encapsulation — subclasses should access it directly,
+     * but external consumers should interact through the data service's public API.
+     */
+    protected db: Database;
+    constructor(db: Database);
+}
+//# sourceMappingURL=dataservice-base.d.ts.map

package/dist/dbcore/dataservice-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataservice-base.d.ts","sourceRoot":"","sources":["../src/dataservice-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;;;;GAMG;AACH,8BAAsB,eAAe;IACnC;;;;OAIG;IACH,SAAS,CAAC,EAAE,EAAE,QAAQ,CAAC;gBAEX,EAAE,EAAE,QAAQ;CAGzB"}

package/dist/dbcore/dataservice-base.js

@@ -0,0 +1,19 @@
+/**
+ * Abstract base class for data services.
+ * Provides access to the database instance for subclasses to perform queries.
+ *
+ * @abstract
+ * @class DataServiceBase
+ */
+export class DataServiceBase {
+    /**
+     * The database instance used by this data service.
+     * Protected to enforce encapsulation — subclasses should access it directly,
+     * but external consumers should interact through the data service's public API.
+     */
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+}
+//# sourceMappingURL=dataservice-base.js.map

package/dist/dbcore/dataservice-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataservice-base.js","sourceRoot":"","sources":["../src/dataservice-base.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,OAAgB,eAAe;IACnC;;;;OAIG;IACO,EAAE,CAAW;IAEvB,YAAY,EAAY;QACtB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,CAAC;CACF"}

package/dist/dbcore/delete-statement.d.ts

@@ -0,0 +1,29 @@
+import { FilterableStatement } from './filterable-statement.js';
+import { Database } from './database.js';
+/**
+ * Abstract statement builder for DELETE operations.
+ * Extends FilterableStatement to provide functionality for deleting records from database tables.
+ * Concrete database implementations must extend this class to provide database-specific
+ * DELETE query construction and parameter handling.
+ *
+ * This class provides a fluent interface for building DELETE statements with support
+ * for filtering which records to delete and RETURNING clauses to retrieve deleted data.
+ *
+ * @export
+ * @abstract
+ * @class DeleteStatement
+ * @extends {FilterableStatement<FilterType, FilterType>}
+ * @template FilterType - The type representing the filter criteria structure
+ */
+export declare abstract class DeleteStatement<FilterType> extends FilterableStatement<FilterType, FilterType> {
+    /**
+     * Creates an instance of DeleteStatement.
+     * Initializes the statement with a table name and database connection.
+     *
+     * @param {string} tableName - The name of the table to delete from
+     * @param {Database} db - The database instance to execute queries against
+     * @memberof DeleteStatement
+     */
+    constructor(tableName: string, db: Database);
+}
+//# sourceMappingURL=delete-statement.d.ts.map

package/dist/dbcore/delete-statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-statement.d.ts","sourceRoot":"","sources":["../src/delete-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,eAAe,CAAC,UAAU,CAAE,SAAQ,mBAAmB,CAC3E,UAAU,EACV,UAAU,CACX;IACC;;;;;;;OAOG;gBACS,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ;CAG5C"}

package/dist/dbcore/delete-statement.js

@@ -0,0 +1,30 @@
+import { FilterableStatement } from './filterable-statement.js';
+/**
+ * Abstract statement builder for DELETE operations.
+ * Extends FilterableStatement to provide functionality for deleting records from database tables.
+ * Concrete database implementations must extend this class to provide database-specific
+ * DELETE query construction and parameter handling.
+ *
+ * This class provides a fluent interface for building DELETE statements with support
+ * for filtering which records to delete and RETURNING clauses to retrieve deleted data.
+ *
+ * @export
+ * @abstract
+ * @class DeleteStatement
+ * @extends {FilterableStatement<FilterType, FilterType>}
+ * @template FilterType - The type representing the filter criteria structure
+ */
+export class DeleteStatement extends FilterableStatement {
+    /**
+     * Creates an instance of DeleteStatement.
+     * Initializes the statement with a table name and database connection.
+     *
+     * @param {string} tableName - The name of the table to delete from
+     * @param {Database} db - The database instance to execute queries against
+     * @memberof DeleteStatement
+     */
+    constructor(tableName, db) {
+        super(tableName, db);
+    }
+}
+//# sourceMappingURL=delete-statement.js.map

package/dist/dbcore/delete-statement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-statement.js","sourceRoot":"","sources":["../src/delete-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAGhE;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAgB,eAA4B,SAAQ,mBAGzD;IACC;;;;;;;OAOG;IACH,YAAY,SAAiB,EAAE,EAAY;QACzC,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IACvB,CAAC;CACF"}

package/dist/dbcore/filterable-statement.d.ts

@@ -0,0 +1,126 @@
+import { CrudStatement } from './crud-statement.js';
+import { Database } from './database.js';
+import type { CompileResult, QueryBuilder } from '../expression/index.js';
+/**
+ * Abstract statement builder that adds filtering capabilities to CRUD statements.
+ * Provides shared filter logic used by both UPDATE and DELETE operations,
+ * including simple key-value filters and complex expression-based filters.
+ *
+ * This class eliminates code duplication between UpdateStatement and DeleteStatement
+ * by centralizing the `_expressionBuilder`, `filter()`, and `filterByExpression()` methods.
+ *
+ * @export
+ * @abstract
+ * @class FilterableStatement
+ * @extends {CrudStatement<TableType>}
+ * @template TableType - The type representing the table structure this statement operates on
+ * @template FilterType - The type representing the filter criteria structure
+ */
+export declare abstract class FilterableStatement<TableType, FilterType> extends CrudStatement<TableType> {
+    /**
+     * Expression builder function for constructing complex WHERE clauses.
+     * This is the primary mechanism for filtering records in UPDATE/DELETE operations.
+     *
+     * @protected
+     * @type {((q: QueryBuilder<FilterType>) => QueryBuilder<FilterType>) | undefined}
+     * @memberof FilterableStatement
+     */
+    protected _expressionBuilder?: (q: QueryBuilder<FilterType>) => QueryBuilder<FilterType>;
+    /**
+     * Cached compiled expression result to avoid double compilation.
+     * The expression builder is invoked once and the result is reused
+     * by both buildQuery() and buildParameters() in concrete implementations.
+     *
+     * @protected
+     * @type {CompileResult | undefined}
+     * @memberof FilterableStatement
+     */
+    protected _compiledExpression?: CompileResult;
+    /**
+     * Creates an instance of FilterableStatement.
+     * Initializes the statement with a table name and database connection.
+     *
+     * @param {string} tableName - The name of the table this statement operates on
+     * @param {Database} db - The database instance to execute queries against
+     * @memberof FilterableStatement
+     */
+    constructor(tableName: string, db: Database);
+    /**
+     * Compiles the expression builder and caches the result.
+     * If no expression builder is set, returns null.
+     * Subsequent calls return the cached result without recompilation.
+     *
+     * This method is used by concrete statement implementations (e.g., PostgreSQL)
+     * to generate WHERE clause SQL and parameters from the expression builder.
+     *
+     * @protected
+     * @returns {CompileResult | null} The compiled expression result, or null if no filter is set
+     * @memberof FilterableStatement
+     */
+    protected getCompiledExpression(): CompileResult | null;
+    /**
+     * Sets the filter criteria for selecting which records to modify.
+     * Accepts a partial object where keys represent column names and values
+     * represent the criteria. Only records matching all specified criteria will be affected.
+     *
+     * This method internally converts the key-value pairs to an expression builder
+     * using equality comparisons. Multiple filters are combined with AND logic.
+     * Can be chained with filterByExpression() to add additional conditions.
+     *
+     * @param {Partial<FilterType>} values - Object containing filter column names and criteria values
+     * @return {this} The statement instance for method chaining
+     * @memberof FilterableStatement
+     *
+     * @example
+     * // Filter by a single criterion
+     * statement.filter({ id: 123 })
+     *
+     * @example
+     * // Filter by multiple criteria (combined with AND)
+     * statement.filter({ status: 'pending', active: true })
+     *
+     * @example
+     * // Chain with filterByExpression for complex conditions
+     * statement
+     *   .filter({ active: true })
+     *   .filterByExpression(q => q.where('age').greaterThan(18))
+     */
+    filter(values: Partial<FilterType>): this;
+    /**
+     * Sets a complex filter expression for selecting which records to modify.
+     * Provides full access to the expression builder API for constructing
+     * sophisticated WHERE clauses with logical operators, comparisons, and more.
+     *
+     * Can be chained with filter() to combine simple and complex conditions.
+     * Multiple calls to filterByExpression() are merged with AND logic.
+     *
+     * @param {(q: QueryBuilder<FilterType>) => QueryBuilder<FilterType>} builder - Expression builder function
+     * @return {this} The statement instance for method chaining
+     * @memberof FilterableStatement
+     *
+     * @example
+     * // Filter with complex conditions
+     * statement.filterByExpression(q =>
+     *   q.where('age').greaterThan(65)
+     *    .or('status').equals('inactive')
+     * )
+     *
+     * @example
+     * // Chain with simple filter
+     * statement
+     *   .filter({ active: true })
+     *   .filterByExpression(q => q.where('last_login').lessThan(cutoffDate))
+     *
+     * @example
+     * // Complex nested conditions
+     * statement.filterByExpression(q =>
+     *   q.where('category').equals('archived')
+     *    .and(sub =>
+     *      sub.where('created_at').lessThan(oldDate)
+     *         .or('updated_at').isNull()
+     *    )
+     * )
+     */
+    filterByExpression(builder: (q: QueryBuilder<FilterType>) => QueryBuilder<FilterType>): this;
+}
+//# sourceMappingURL=filterable-statement.d.ts.map

package/dist/dbcore/filterable-statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterable-statement.d.ts","sourceRoot":"","sources":["../src/filterable-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGxE;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,mBAAmB,CAAC,SAAS,EAAE,UAAU,CAAE,SAAQ,aAAa,CAAC,SAAS,CAAC;IAC/F;;;;;;;OAOG;IACH,SAAS,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC,EAAE,YAAY,CAAC,UAAU,CAAC,KAAK,YAAY,CAAC,UAAU,CAAC,CAAC;IAEzF;;;;;;;;OAQG;IACH,SAAS,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC;IAE9C;;;;;;;OAOG;gBACS,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ;IAI3C;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,qBAAqB,IAAI,aAAa,GAAG,IAAI;IAUvD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI;IAmCzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,kBAAkB,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,YAAY,CAAC,UAAU,CAAC,KAAK,YAAY,CAAC,UAAU,CAAC,GAAG,IAAI;CAc7F"}