blendsdk 5.33.0

package/dist/dbcore/filterable-statement.js

@@ -0,0 +1,178 @@
+import { CrudStatement } from './crud-statement.js';
+import { query } 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 class FilterableStatement extends CrudStatement {
+    /**
+     * 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
+     */
+    _expressionBuilder;
+    /**
+     * 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
+     */
+    _compiledExpression;
+    /**
+     * 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, db) {
+        super(tableName, db);
+    }
+    /**
+     * 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
+     */
+    getCompiledExpression() {
+        if (!this._expressionBuilder)
+            return null;
+        if (!this._compiledExpression) {
+            const expr = query();
+            const result = this._expressionBuilder(expr);
+            this._compiledExpression = result.compile();
+        }
+        return this._compiledExpression;
+    }
+    /**
+     * 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) {
+        // Convert filter object to expression builder
+        const newBuilder = (q) => {
+            let builder = q;
+            const keys = Object.keys(values);
+            if (keys.length === 0)
+                return builder;
+            // First condition uses where()
+            const firstKey = keys[0];
+            builder = builder.where(firstKey).equals(values[firstKey]);
+            // Subsequent conditions use and()
+            for (let i = 1; i < keys.length; i++) {
+                const key = keys[i];
+                builder = builder.and(key).equals(values[key]);
+            }
+            return builder;
+        };
+        // Merge with existing expression builder using AND
+        if (this._expressionBuilder) {
+            const existingBuilder = this._expressionBuilder;
+            this._expressionBuilder = (q) => {
+                const existing = existingBuilder(q);
+                return newBuilder(existing);
+            };
+        }
+        else {
+            this._expressionBuilder = newBuilder;
+        }
+        return 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) {
+        // Merge with existing expression builder using AND
+        if (this._expressionBuilder) {
+            const existingBuilder = this._expressionBuilder;
+            this._expressionBuilder = (q) => {
+                const existing = existingBuilder(q);
+                return builder(existing);
+            };
+        }
+        else {
+            this._expressionBuilder = builder;
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=filterable-statement.js.map

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

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

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

@@ -0,0 +1,120 @@
+import { CompileResult } from '../expression/index.js';
+import { Database } from './database.js';
+import { Statement } from './statement.js';
+/**
+ * Statement builder for SELECT queries with FROM clauses.
+ * Provides a fluent interface for constructing SELECT statements with column selection,
+ * WHERE clauses, and parameter binding. Supports both simple column lists and
+ * aliased column expressions.
+ *
+ * This class enables type-safe query construction for retrieving data from database tables,
+ * with support for filtering via expression compilation results.
+ *
+ * @export
+ * @class FromStatement
+ * @extends {Statement<TableType>}
+ * @template TableType - The type representing the table structure being queried
+ */
+export declare class FromStatement<TableType> extends Statement<TableType> {
+    protected tableName: string;
+    /**
+     * Array of column names or expressions to select.
+     * Can include simple column names, aliased expressions, or '*' for all columns.
+     *
+     * @protected
+     * @type {string[]}
+     * @memberof FromStatement
+     */
+    protected _selectColumns: string[];
+    /**
+     * Object containing named parameters for the query.
+     * These parameters are used in the WHERE clause for safe parameterized queries.
+     *
+     * @protected
+     * @type {Record<string, any>}
+     * @memberof FromStatement
+     */
+    protected _parameters: Record<string, any>;
+    /**
+     * The WHERE clause string for filtering results.
+     * Generated from expression compilation or left empty for unfiltered queries.
+     *
+     * @protected
+     * @type {string}
+     * @memberof FromStatement
+     */
+    protected _whereClause: string;
+    /**
+     * Builds the parameters object for the query.
+     * Returns the stored parameters that will be used in the WHERE clause.
+     *
+     * @protected
+     * @return {Record<string, any>} The parameters object for query execution
+     * @memberof FromStatement
+     */
+    protected buildParameters(): Record<string, any>;
+    /**
+     * Creates an instance of FromStatement.
+     * Initializes the statement with a table name and database connection,
+     * and sets up an empty array for select columns.
+     *
+     * @param {string} tableName - The name of the table to select from
+     * @param {Database} db - The database instance to execute queries against
+     * @memberof FromStatement
+     */
+    constructor(tableName: string, db: Database);
+    /**
+     * Specifies which columns to select in the query.
+     * Accepts an array of column names, an object mapping aliases to expressions,
+     * or defaults to '*' for all columns if not specified.
+     *
+     * When an object is provided, keys become column aliases and values are the expressions.
+     * For example, { total: 'price * quantity' } becomes "price * quantity AS total".
+     *
+     * @param {string[] | Record<string, any>} [columns] - Columns to select, or undefined for all columns
+     * @return {this} The statement instance for method chaining
+     * @memberof FromStatement
+     *
+     * @example
+     * // Select specific columns
+     * statement.select(['id', 'name', 'email'])
+     *
+     * @example
+     * // Select all columns
+     * statement.select()
+     *
+     * @example
+     * // Select with aliases
+     * statement.select({ fullName: 'first_name || \' \' || last_name', total: 'price * quantity' })
+     */
+    select(columns?: string[] | Record<string, any>): this;
+    /**
+     * Applies a WHERE clause filter using a compiled expression result.
+     * The expression result contains both the WHERE clause string and the associated
+     * parameters, which are stored for use during query execution.
+     *
+     * This method is typically used with the expression builder from @blendsdk/expression
+     * to create type-safe, parameterized WHERE clauses.
+     *
+     * @param {CompileResult} filter - The compiled expression containing WHERE clause and parameters
+     * @return {this} The statement instance for method chaining
+     * @memberof FromStatement
+     *
+     * @example
+     * // Using with expression builder
+     * const filter = expr.compile(t => t.age.gt(18).and(t.status.eq('active')));
+     * statement.byExpression(filter);
+     */
+    byExpression(filter: CompileResult): this;
+    /**
+     * Builds the complete SELECT query string.
+     * Combines the SELECT clause, FROM clause, and optional WHERE clause
+     * into a complete SQL query string.
+     *
+     * @protected
+     * @return {string} The complete SQL query string
+     * @memberof FromStatement
+     */
+    protected buildQuery(): string;
+}
+//# sourceMappingURL=from-statement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"from-statement.d.ts","sourceRoot":"","sources":["../src/from-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAa,CAAC,SAAS,CAAE,SAAQ,SAAS,CAAC,SAAS,CAAC;IAqD9D,SAAS,CAAC,SAAS,EAAE,MAAM;IApD7B;;;;;;;OAOG;IACH,SAAS,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC;IAEnC;;;;;;;OAOG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM;IAEhD;;;;;;;OAOG;IACH,SAAS,CAAC,YAAY,EAAE,MAAM,CAAM;IAEpC;;;;;;;OAOG;IACH,SAAS,CAAC,eAAe;IAIzB;;;;;;;;OAQG;gBAES,SAAS,EAAE,MAAM,EAC3B,EAAE,EAAE,QAAQ;IAMd;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAmBtD;;;;;;;;;;;;;;;;OAgBG;IACH,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAOzC;;;;;;;;OAQG;IACH,SAAS,CAAC,UAAU,IAAI,MAAM;CAI/B"}

package/dist/dbcore/from-statement.js

@@ -0,0 +1,150 @@
+import { Statement } from './statement.js';
+/**
+ * Statement builder for SELECT queries with FROM clauses.
+ * Provides a fluent interface for constructing SELECT statements with column selection,
+ * WHERE clauses, and parameter binding. Supports both simple column lists and
+ * aliased column expressions.
+ *
+ * This class enables type-safe query construction for retrieving data from database tables,
+ * with support for filtering via expression compilation results.
+ *
+ * @export
+ * @class FromStatement
+ * @extends {Statement<TableType>}
+ * @template TableType - The type representing the table structure being queried
+ */
+export class FromStatement extends Statement {
+    tableName;
+    /**
+     * Array of column names or expressions to select.
+     * Can include simple column names, aliased expressions, or '*' for all columns.
+     *
+     * @protected
+     * @type {string[]}
+     * @memberof FromStatement
+     */
+    _selectColumns;
+    /**
+     * Object containing named parameters for the query.
+     * These parameters are used in the WHERE clause for safe parameterized queries.
+     *
+     * @protected
+     * @type {Record<string, any>}
+     * @memberof FromStatement
+     */
+    _parameters = {};
+    /**
+     * The WHERE clause string for filtering results.
+     * Generated from expression compilation or left empty for unfiltered queries.
+     *
+     * @protected
+     * @type {string}
+     * @memberof FromStatement
+     */
+    _whereClause = '';
+    /**
+     * Builds the parameters object for the query.
+     * Returns the stored parameters that will be used in the WHERE clause.
+     *
+     * @protected
+     * @return {Record<string, any>} The parameters object for query execution
+     * @memberof FromStatement
+     */
+    buildParameters() {
+        return this._parameters;
+    }
+    /**
+     * Creates an instance of FromStatement.
+     * Initializes the statement with a table name and database connection,
+     * and sets up an empty array for select columns.
+     *
+     * @param {string} tableName - The name of the table to select from
+     * @param {Database} db - The database instance to execute queries against
+     * @memberof FromStatement
+     */
+    constructor(tableName, db) {
+        super(db);
+        this.tableName = tableName;
+        this._selectColumns = [];
+    }
+    /**
+     * Specifies which columns to select in the query.
+     * Accepts an array of column names, an object mapping aliases to expressions,
+     * or defaults to '*' for all columns if not specified.
+     *
+     * When an object is provided, keys become column aliases and values are the expressions.
+     * For example, { total: 'price * quantity' } becomes "price * quantity AS total".
+     *
+     * @param {string[] | Record<string, any>} [columns] - Columns to select, or undefined for all columns
+     * @return {this} The statement instance for method chaining
+     * @memberof FromStatement
+     *
+     * @example
+     * // Select specific columns
+     * statement.select(['id', 'name', 'email'])
+     *
+     * @example
+     * // Select all columns
+     * statement.select()
+     *
+     * @example
+     * // Select with aliases
+     * statement.select({ fullName: 'first_name || \' \' || last_name', total: 'price * quantity' })
+     */
+    select(columns) {
+        // normalize columns
+        columns = columns || ['*'];
+        if (Array.isArray(columns)) {
+            this._selectColumns = columns;
+        }
+        else if (typeof columns === 'object') {
+            // convert object to array of "key AS val"
+            this._selectColumns = Object.entries(columns)
+                .map(([key, val]) => {
+                return `${val} AS ${key}`;
+            })
+                .filter(Boolean);
+        }
+        else {
+            this._selectColumns = ['*'];
+        }
+        return this;
+    }
+    /**
+     * Applies a WHERE clause filter using a compiled expression result.
+     * The expression result contains both the WHERE clause string and the associated
+     * parameters, which are stored for use during query execution.
+     *
+     * This method is typically used with the expression builder from @blendsdk/expression
+     * to create type-safe, parameterized WHERE clauses.
+     *
+     * @param {CompileResult} filter - The compiled expression containing WHERE clause and parameters
+     * @return {this} The statement instance for method chaining
+     * @memberof FromStatement
+     *
+     * @example
+     * // Using with expression builder
+     * const filter = expr.compile(t => t.age.gt(18).and(t.status.eq('active')));
+     * statement.byExpression(filter);
+     */
+    byExpression(filter) {
+        const { sql, params } = filter;
+        this._whereClause = `WHERE ${sql}`;
+        this._parameters = params;
+        return this;
+    }
+    /**
+     * Builds the complete SELECT query string.
+     * Combines the SELECT clause, FROM clause, and optional WHERE clause
+     * into a complete SQL query string.
+     *
+     * @protected
+     * @return {string} The complete SQL query string
+     * @memberof FromStatement
+     */
+    buildQuery() {
+        const whereClause = this._whereClause ? ` ${this._whereClause}` : '';
+        return `SELECT ${this._selectColumns.join(', ')} FROM ${this.tableName}${whereClause}`.trim();
+    }
+}
+//# sourceMappingURL=from-statement.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"from-statement.js","sourceRoot":"","sources":["../src/from-statement.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,aAAyB,SAAQ,SAAoB;IAqDpD;IApDZ;;;;;;;OAOG;IACO,cAAc,CAAW;IAEnC;;;;;;;OAOG;IACO,WAAW,GAAwB,EAAE,CAAC;IAEhD;;;;;;;OAOG;IACO,YAAY,GAAW,EAAE,CAAC;IAEpC;;;;;;;OAOG;IACO,eAAe;QACvB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;;;;;;;OAQG;IACH,YACY,SAAiB,EAC3B,EAAY;QAEZ,KAAK,CAAC,EAAE,CAAC,CAAC;QAHA,cAAS,GAAT,SAAS,CAAQ;QAI3B,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,OAAwC;QAC7C,oBAAoB;QACpB,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;QAE3B,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3B,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC;QAChC,CAAC;aAAM,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YACvC,0CAA0C;YAC1C,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;iBAC1C,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;gBAClB,OAAO,GAAG,GAAG,OAAO,GAAG,EAAE,CAAC;YAC5B,CAAC,CAAC;iBACD,MAAM,CAAC,OAAO,CAAa,CAAC;QACjC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,YAAY,CAAC,MAAqB;QAChC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;QAC/B,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,EAAE,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IACO,UAAU;QAClB,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACrE,OAAO,UAAU,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,GAAG,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC;IAChG,CAAC;CACF"}

package/dist/dbcore/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Main entry point for the dbcore package.
+ * Exports all database-related classes, interfaces, and utilities for building
+ * type-safe database queries and managing database connections.
+ *
+ * Core database abstractions including statement builders for CRUD operations.
+ *
+ * **Note:** Expression types (query, CompileResult, etc.) should be imported
+ * directly from `@blendsdk/expression`, not from this package.
+ */
+export * from './crud-statement.js';
+export * from './database.js';
+export * from './dataservice-base.js';
+export * from './delete-statement.js';
+export * from './filterable-statement.js';
+export * from './from-statement.js';
+export * from './insert-statement.js';
+export * from './query-dataservice.js';
+export * from './statement.js';
+export * from './update-statement.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC"}

package/dist/dbcore/index.js

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Main entry point for the dbcore package.
+ * Exports all database-related classes, interfaces, and utilities for building
+ * type-safe database queries and managing database connections.
+ *
+ * Core database abstractions including statement builders for CRUD operations.
+ *
+ * **Note:** Expression types (query, CompileResult, etc.) should be imported
+ * directly from `@blendsdk/expression`, not from this package.
+ */
+export * from './crud-statement.js';
+export * from './database.js';
+export * from './dataservice-base.js';
+export * from './delete-statement.js';
+export * from './filterable-statement.js';
+export * from './from-statement.js';
+export * from './insert-statement.js';
+export * from './query-dataservice.js';
+export * from './statement.js';
+export * from './update-statement.js';
+//# sourceMappingURL=index.js.map

package/dist/dbcore/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC"}

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

@@ -0,0 +1,48 @@
+import { CrudStatement } from './crud-statement.js';
+import { Database } from './database.js';
+/**
+ * Abstract statement builder for INSERT operations.
+ * Extends CrudStatement to provide functionality for inserting new records into database tables.
+ * Concrete database implementations must extend this class to provide database-specific
+ * INSERT query construction and parameter handling.
+ *
+ * This class provides a fluent interface for building INSERT statements with support
+ * for RETURNING clauses to retrieve inserted data.
+ *
+ * @export
+ * @abstract
+ * @class InsertStatement
+ * @extends {CrudStatement<TableType>}
+ * @template TableType - The type representing the table structure for insertion
+ */
+export declare abstract class InsertStatement<TableType> extends CrudStatement<TableType> {
+    /**
+     * Creates an instance of InsertStatement.
+     * Initializes the statement with a table name and database connection.
+     *
+     * @param {string} tableName - The name of the table to insert into
+     * @param {Database} db - The database instance to execute queries against
+     * @memberof InsertStatement
+     */
+    constructor(tableName: string, db: Database);
+    /**
+     * Sets the values to be inserted into the table.
+     * Accepts a partial object where keys represent column names and values
+     * represent the data to be inserted. Only the specified columns will be
+     * included in the INSERT statement.
+     *
+     * @param {Partial<TableType>} values - Object containing column names and values to insert
+     * @return {this} The statement instance for method chaining
+     * @memberof InsertStatement
+     *
+     * @example
+     * // Insert a new user record
+     * statement.values({
+     *   name: 'John Doe',
+     *   email: 'john@example.com',
+     *   age: 30
+     * })
+     */
+    values(values: Partial<TableType>): this;
+}
+//# sourceMappingURL=insert-statement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insert-statement.d.ts","sourceRoot":"","sources":["../src/insert-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,eAAe,CAAC,SAAS,CAAE,SAAQ,aAAa,CAAC,SAAS,CAAC;IAC/E;;;;;;;OAOG;gBACS,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ;IAI3C;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;CAIzC"}

package/dist/dbcore/insert-statement.js

@@ -0,0 +1,52 @@
+import { CrudStatement } from './crud-statement.js';
+/**
+ * Abstract statement builder for INSERT operations.
+ * Extends CrudStatement to provide functionality for inserting new records into database tables.
+ * Concrete database implementations must extend this class to provide database-specific
+ * INSERT query construction and parameter handling.
+ *
+ * This class provides a fluent interface for building INSERT statements with support
+ * for RETURNING clauses to retrieve inserted data.
+ *
+ * @export
+ * @abstract
+ * @class InsertStatement
+ * @extends {CrudStatement<TableType>}
+ * @template TableType - The type representing the table structure for insertion
+ */
+export class InsertStatement extends CrudStatement {
+    /**
+     * Creates an instance of InsertStatement.
+     * Initializes the statement with a table name and database connection.
+     *
+     * @param {string} tableName - The name of the table to insert into
+     * @param {Database} db - The database instance to execute queries against
+     * @memberof InsertStatement
+     */
+    constructor(tableName, db) {
+        super(tableName, db);
+    }
+    /**
+     * Sets the values to be inserted into the table.
+     * Accepts a partial object where keys represent column names and values
+     * represent the data to be inserted. Only the specified columns will be
+     * included in the INSERT statement.
+     *
+     * @param {Partial<TableType>} values - Object containing column names and values to insert
+     * @return {this} The statement instance for method chaining
+     * @memberof InsertStatement
+     *
+     * @example
+     * // Insert a new user record
+     * statement.values({
+     *   name: 'John Doe',
+     *   email: 'john@example.com',
+     *   age: 30
+     * })
+     */
+    values(values) {
+        this._values = values;
+        return this;
+    }
+}
+//# sourceMappingURL=insert-statement.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insert-statement.js","sourceRoot":"","sources":["../src/insert-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAgB,eAA2B,SAAQ,aAAwB;IAC/E;;;;;;;OAOG;IACH,YAAY,SAAiB,EAAE,EAAY;QACzC,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,MAA0B;QAC/B,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}