@iamkirbki/database-handler-core 2.0.0 → 3.0.0

package/dist/helpers/QueryStatementBuilder.d.ts

@@ -0,0 +1,333 @@
+import { DefaultQueryOptions, QueryOptions, QueryParameters, Join } from "../types/index";
+import Table from "Table";
+/**
+ * QueryStatementBuilder - Utility class for building SQL query strings
+ *
+ * Provides static methods to construct SQL statements in a consistent, safe manner.
+ * All methods use named parameters (@fieldName syntax) for better-sqlite3 compatibility.
+ *
+ * Features:
+ * - Consistent query building pattern using array concatenation
+ * - Support for SELECT, INSERT, UPDATE, DELETE, and COUNT operations
+ * - JOIN support with nested join capabilities
+ * - WHERE clause building with AND conditions
+ * - Query options (ORDER BY, LIMIT, OFFSET)
+ *
+ * @example
+ * ```typescript
+ * // Build a SELECT query
+ * const query = QueryStatementBuilder.BuildSelect(usersTable, {
+ *   select: 'id, name, email',
+ *   where: { status: 'active' },
+ *   orderBy: 'created_at DESC',
+ *   limit: 10
+ * });
+ * // Result: "SELECT id, name, email FROM users WHERE status = @status ORDER BY created_at DESC LIMIT 10"
+ *
+ * // Build an INSERT query
+ * const insertQuery = QueryStatementBuilder.BuildInsert(usersTable, {
+ *   name: 'John',
+ *   email: 'john@example.com'
+ * });
+ * // Result: "INSERT INTO users (name, email) VALUES (@name, @email)"
+ * ```
+ */
+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(table: Table, options?: DefaultQueryOptions & QueryOptions): 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(table: Table, record: QueryParameters): 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(table: Table, record: QueryParameters, where: QueryParameters): 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(table: Table, where: QueryParameters): 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(table: Table, where?: QueryParameters): 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?: QueryParameters): string;
+    /**
+     * 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(fromTable: Table, joins: Join | Join[], options?: DefaultQueryOptions & QueryOptions): 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(fromTable: Table, 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 - QueryParameters 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(table: Table, joinTable: Table, on: QueryParameters | QueryParameters[]): 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: QueryOptions): string;
+}
+//# sourceMappingURL=QueryStatementBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStatementBuilder.d.ts","sourceRoot":"","sources":["../../src/helpers/QueryStatementBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,OAAO,OAAO,qBAAqB;IACtC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACW,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,GAAG,MAAM;IAY7F;;;;;;;;;;;;;;;;;;OAkBG;WACW,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,GAAG,MAAM;IAYxE;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACW,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,MAAM;IAWhG;;;;;;;;;;;;;;;;;;;OAmBG;WACW,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,GAAG,MAAM;IASvE;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,eAAe,GAAG,MAAM;IAQvE;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;WACW,UAAU,CAAC,KAAK,CAAC,EAAE,eAAe,GAAG,MAAM;IAYzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;WACW,SAAS,CACnB,SAAS,EAAE,KAAK,EAChB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,EACpB,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY;IAYhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;WACW,aAAa,CACvB,SAAS,EAAE,KAAK,EAChB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,GACrB,MAAM;IAeT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;WACW,eAAe,CACzB,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,KAAK,EAChB,EAAE,EAAE,eAAe,GAAG,eAAe,EAAE,GACxC,MAAM;IAWT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;CAiBjE"}

package/dist/helpers/Validator.d.ts

@@ -0,0 +1,210 @@
+import { QueryParameters, TableColumnInfo } from "../types/index";
+/**
+ * Validator class for validating table names, column names, column types, SQL queries, and query parameters
+ *
+ * Provides static methods to ensure data integrity and prevent SQL injection attacks by:
+ * - Validating table and column naming conventions
+ * - Checking column type compatibility with SQLite standards
+ * - Detecting SQL injection patterns in queries
+ * - Verifying parameter types match column types
+ * - Enforcing NOT NULL constraints
+ *
+ * @example
+ * ```typescript
+ * // Validate a table name
+ * Validator.ValidateTableName('users'); // OK
+ * Validator.ValidateTableName('invalid-name'); // throws Error
+ *
+ * // Validate a column type
+ * Validator.ValidateColumnType('TEXT NOT NULL'); // OK
+ * Validator.ValidateColumnType('INVALID_TYPE'); // throws Error
+ *
+ * // Validate a query for SQL injection
+ * Validator.ValidateQuery('SELECT * FROM users WHERE id = @id', columnInfo); // OK
+ * Validator.ValidateQuery('SELECT * FROM users; DROP TABLE users', columnInfo); // throws Error
+ * ```
+ */
+export default class Validator {
+    /**
+     * List of valid SQLite column types
+     * Includes numeric, text, binary, date/time types and compatibility types for other SQL dialects
+     */
+    private static readonly validTypes;
+    /**
+     * List of SQL keywords that are valid in column type definitions
+     * These keywords are stripped when validating the base column type
+     */
+    private static readonly sqlKeywords;
+    /**
+     * Validates a table name according to SQLite naming conventions
+     *
+     * Rules:
+     * - Must be a non-empty string
+     * - Cannot contain commas
+     * - Must only contain letters, numbers, and underscores
+     *
+     * @param name - The table name to validate
+     * @throws Error if the table name is invalid
+     *
+     * @example
+     * ```typescript
+     * Validator.ValidateTableName('users'); // OK
+     * Validator.ValidateTableName('user_accounts'); // OK
+     * Validator.ValidateTableName('users123'); // OK
+     * Validator.ValidateTableName('invalid-name'); // throws Error
+     * Validator.ValidateTableName(''); // throws Error
+     * ```
+     */
+    static ValidateTableName(name: string): void;
+    /**
+     * Validates a column name according to SQLite naming conventions
+     *
+     * Rules:
+     * - Must be a non-empty string
+     * - Cannot contain commas
+     * - Must only contain letters, numbers, and underscores
+     *
+     * @param name - The column name to validate
+     * @throws Error if the column name is invalid
+     *
+     * @example
+     * ```typescript
+     * Validator.ValidateColumnName('email'); // OK
+     * Validator.ValidateColumnName('user_id'); // OK
+     * Validator.ValidateColumnName('created_at'); // OK
+     * Validator.ValidateColumnName('invalid-name'); // throws Error
+     * Validator.ValidateColumnName(''); // throws Error
+     * ```
+     */
+    static ValidateColumnName(name: string): void;
+    /**
+     * Generic name validation for tables and columns
+     *
+     * Rules:
+     * - Must be a non-empty string
+     * - Cannot contain commas
+     * - Must only contain letters, numbers, and underscores
+     *
+     * @param name - The table/column name to validate
+     * @param type - The type, either table or column
+     * @throws Error if the name is invalid
+    */
+    private static ValidateName;
+    /**
+     * Validates a column type definition against SQLite type standards
+     *
+     * Strips SQL keywords (NOT NULL, PRIMARY KEY, etc.) and length specifications
+     * before checking if the base type is valid. Supports all SQLite types and
+     * common types from other SQL dialects for compatibility.
+     *
+     * @param type - The column type definition to validate (e.g., "TEXT NOT NULL", "VARCHAR(255)")
+     * @throws Error if the column type is invalid
+     *
+     * @example
+     * ```typescript
+     * Validator.ValidateColumnType('TEXT'); // OK
+     * Validator.ValidateColumnType('INTEGER NOT NULL'); // OK
+     * Validator.ValidateColumnType('VARCHAR(255)'); // OK
+     * Validator.ValidateColumnType('TEXT PRIMARY KEY'); // OK
+     * Validator.ValidateColumnType('INVALID_TYPE'); // throws Error
+     * ```
+     */
+    static ValidateColumnType(type: string): void;
+    /**
+     * Validates an SQL query for security and correctness
+     *
+     * Security checks:
+     * - Detects SQL injection attempts (semicolon followed by DROP, DELETE, UPDATE, INSERT, ALTER)
+     * - Ensures all field references (@fieldName) exist in the table schema
+     *
+     * Correctness checks:
+     * - Verifies all required (NOT NULL) fields are provided in INSERT queries
+     * - Validates query is a non-empty string
+     *
+     * @param query - The SQL query string to validate
+     * @param TableColumnInformation - Array of column metadata from the table schema
+     * @throws Error if the query contains forbidden operations, references unknown fields, or missing required fields
+     *
+     * @example
+     * ```typescript
+     * const columnInfo = [
+     *   { name: 'id', type: 'INTEGER', notnull: 1 },
+     *   { name: 'name', type: 'TEXT', notnull: 1 },
+     *   { name: 'email', type: 'TEXT', notnull: 0 }
+     * ];
+     *
+     * // Valid queries
+     * Validator.ValidateQuery('SELECT * FROM users WHERE id = @id', columnInfo); // OK
+     * Validator.ValidateQuery('INSERT INTO users (name, email) VALUES (@name, @email)', columnInfo); // OK
+     *
+     * // Invalid queries
+     * Validator.ValidateQuery('SELECT * FROM users; DROP TABLE users', columnInfo); // throws Error - SQL injection
+     * Validator.ValidateQuery('SELECT * FROM users WHERE @nonexistent = 1', columnInfo); // throws Error - unknown field
+     * Validator.ValidateQuery('INSERT INTO users (email) VALUES (@email)', columnInfo); // throws Error - missing required field 'name'
+     * ```
+     */
+    static ValidateQuery(query: string, TableColumnInformation: TableColumnInfo[]): void;
+    /**
+     * Validates query parameters against table schema
+     *
+     * Checks performed:
+     * - Each parameter key must match a column in the table
+     * - NOT NULL columns cannot receive null or undefined values
+     * - Parameter types must match their corresponding column types
+     * - All field references in the query must have corresponding parameters
+     *
+     * @param query - The SQL query string containing field references
+     * @param parameters - Object mapping parameter names to values
+     * @param TableColumnInformation - Array of column metadata from the table schema
+     * @throws Error if parameters don't match schema, have wrong types, or violate NOT NULL constraints
+     *
+     * @example
+     * ```typescript
+     * const columnInfo = [
+     *   { name: 'id', type: 'INTEGER', notnull: 1 },
+     *   { name: 'name', type: 'TEXT', notnull: 1 },
+     *   { name: 'age', type: 'INTEGER', notnull: 0 }
+     * ];
+     *
+     * const query = 'INSERT INTO users (name, age) VALUES (@name, @age)';
+     *
+     * // Valid parameters
+     * Validator.ValidateQueryParameters(query, { name: 'John', age: 30 }, columnInfo); // OK
+     * Validator.ValidateQueryParameters(query, { name: 'Jane', age: null }, columnInfo); // OK - age is nullable
+     *
+     * // Invalid parameters
+     * Validator.ValidateQueryParameters(query, { name: null, age: 30 }, columnInfo); // throws Error - name is NOT NULL
+     * Validator.ValidateQueryParameters(query, { name: 'John', age: 'thirty' }, columnInfo); // throws Error - wrong type
+     * Validator.ValidateQueryParameters(query, { name: 'John' }, columnInfo); // throws Error - missing @age parameter
+     * Validator.ValidateQueryParameters(query, { name: 'John', age: 30, extra: 'value' }, columnInfo); // throws Error - extra is not a column
+     * ```
+     */
+    static ValidateQueryParameters(query: string, parameters: QueryParameters, TableColumnInformation: TableColumnInfo[]): void;
+    /**
+     * Compares a column type with a JavaScript parameter type for compatibility
+     *
+     * Type mappings:
+     * - TEXT/CHAR types → string
+     * - INTEGER/INT types → number
+     * - REAL/FLOAT/DOUBLE types → number
+     * - BOOLEAN types → boolean
+     * - BLOB types → object (Buffer/Uint8Array)
+     * - UUID → string (with format validation)
+     *
+     * @param columnType - The SQLite column type from the schema
+     * @param parameterType - The JavaScript typeof value for the parameter
+     * @returns true if the types are compatible, false otherwise
+     *
+     * @example
+     * ```typescript
+     * Validator.CompareTypes('TEXT', 'string'); // true
+     * Validator.CompareTypes('INTEGER', 'number'); // true
+     * Validator.CompareTypes('VARCHAR(255)', 'string'); // true
+     * Validator.CompareTypes('REAL', 'number'); // true
+     * Validator.CompareTypes('TEXT', 'number'); // false
+     * Validator.CompareTypes('INTEGER', 'string'); // false
+     * ```
+     */
+    static CompareTypes(columnType?: string, parameterType?: string): boolean;
+}
+//# sourceMappingURL=Validator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Validator.d.ts","sourceRoot":"","sources":["../../src/helpers/Validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC1B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAkBhC;IAEF;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAWjC;IAEF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI5C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI7C;;;;;;;;;;;MAWE;IACF,OAAO,CAAC,MAAM,CAAC,YAAY;IAY3B;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAgB7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,sBAAsB,EAAE,eAAe,EAAE,GAAG,IAAI;IA0CpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,MAAM,CAAC,uBAAuB,CAC1B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,eAAe,EAC3B,sBAAsB,EAAE,eAAe,EAAE,GAC1C,IAAI;IAkCP;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO;CAoC5E"}

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * kirbkis-bettersqlite3-handler
+ * A TypeScript wrapper for better-sqlite3 with type-safe operations and parameter validation
+ *
+ * Features:
+ * - Type-safe database operations with TypeScript generics
+ * - Automatic parameter validation against table schema
+ * - SQL injection prevention through query validation
+ * - Named parameters using @fieldName syntax
+ * - Record-based API for easy updates and deletes
+ * - Transaction support for atomic operations
+ * - Comprehensive error messages for debugging
+ *
+ * @example
+ * ```typescript
+ * import { Database } from 'kirbkis-bettersqlite3-handler';
+ *
+ * // Create/open database
+ * const db = new Database('./myapp.db');
+ *
+ * // Create table
+ * const users = db.CreateTable('users', {
+ *   id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
+ *   name: 'TEXT NOT NULL',
+ *   email: 'TEXT UNIQUE',
+ *   age: 'INTEGER'
+ * });
+ *
+ * // Insert data
+ * users.Insert({ name: 'John', email: 'john@example.com', age: 30 });
+ *
+ * // Query data
+ * const activeUsers = users.Records({ where: { age: 30 } });
+ *
+ * // Update record
+ * const user = users.Record({ where: { id: 1 } });
+ * user?.Update({ age: 31 });
+ *
+ * // Custom query
+ * const query = db.Query(users, 'SELECT * FROM users WHERE age > @minAge');
+ * query.Parameters = { minAge: 25 };
+ * const results = query.All();
+ * ```
+ *
+ * @packageDocumentation
+ */
+import Database from "./Database";
+import Model from "./abstract/Model";
+import IDatabaseAdapter from "./interfaces/IDatabaseAdapter";
+import IStatementAdapter from "./interfaces/IStatementAdapter";
+import Table from "./Table";
+import Query from "./Query";
+import Record from "./Record";
+export { Database, Model, IDatabaseAdapter, IStatementAdapter, Table, Query, Record };
+export * from "./types/index";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,QAAQ,MAAM,YAAY,CAAC;AAClC,OAAO,KAAK,MAAM,kBAAkB,CAAC;AACrC,OAAO,gBAAgB,MAAM,+BAA+B,CAAC;AAC7D,OAAO,iBAAiB,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,MAAM,MAAM,UAAU,CAAC;AAE9B,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AACtF,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -46,4 +46,8 @@
  */
 import Database from "./Database";
 import Model from "./abstract/Model";
-export { Database, Model };
+import Table from "./Table";
+import Query from "./Query";
+import Record from "./Record";
+export { Database, Model, Table, Query, Record };
+export * from "./types/index";

package/dist/interfaces/IDatabaseAdapter.d.ts

@@ -0,0 +1,11 @@
+import { TableColumnInfo } from '@core/types/table';
+import IStatementAdapter from './IStatementAdapter';
+export default interface IDatabaseAdapter {
+    connect(params: unknown): Promise<void>;
+    prepare(query: string): Promise<IStatementAdapter>;
+    exec(query: string): Promise<void>;
+    transaction(fn: (items: any[]) => void): Promise<Function>;
+    tableColumnInformation(tableName: string): Promise<TableColumnInfo[]>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=IDatabaseAdapter.d.ts.map

package/dist/interfaces/IDatabaseAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IDatabaseAdapter.d.ts","sourceRoot":"","sources":["../../src/interfaces/IDatabaseAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AAEpD,MAAM,CAAC,OAAO,WAAW,gBAAgB;IACrC,OAAO,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACnD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,WAAW,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC3D,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IACtE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}

package/dist/interfaces/IStatementAdapter.d.ts

@@ -0,0 +1,7 @@
+export default interface IStatementAdapter {
+    run(parameters?: object): Promise<unknown>;
+    all(parameters?: object): Promise<unknown[]>;
+    get(parameters?: object): Promise<unknown | undefined>;
+    runSync?(parameters?: object): unknown;
+}
+//# sourceMappingURL=IStatementAdapter.d.ts.map

package/dist/interfaces/IStatementAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IStatementAdapter.d.ts","sourceRoot":"","sources":["../../src/interfaces/IStatementAdapter.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,WAAW,iBAAiB;IACtC,GAAG,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3C,GAAG,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAC7C,GAAG,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;IAEvD,OAAO,CAAC,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1C"}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+export * from './query';
+export * from './table';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,iBAAiB,CAAC,CAAC,EAAE,IAAI,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IAC3D,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,GAC7B;KACG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;CAC3E,CAAC,IAAI,CAAC,CAAA;AAEX,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}