@iamkirbki/database-handler-core 3.1.2 → 3.1.4

package/dist/Database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Database.d.ts","sourceRoot":"","sources":["../src/Database.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,KAAK,MAAM,YAAY,CAAC;AAE/B,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAEhE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IACpB,OAAO,EAAE,gBAAgB,CAAC;IAEjC;;;;;;;;;;;;;;;;OAgBG;gBACS,OAAO,EAAE,gBAAgB;IAIrC;;;;;;;;;;;;OAYG;IACU,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAMhD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACU,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAsBvE;;;;;;;;;;;;;;OAcG;IACI,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK;CAGjD"}
+{"version":3,"file":"Database.d.ts","sourceRoot":"","sources":["../src/Database.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAEhE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IACpB,OAAO,EAAE,gBAAgB,CAAC;IAEjC;;;;;;;;;;;;;;;;OAgBG;gBACS,OAAO,EAAE,gBAAgB;IAIrC;;;;;;;;;;;;OAYG;IACU,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAKhD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACU,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAmBvE;;;;;;;;;;;;;;OAcG;IACI,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK;CAGjD"}

package/dist/Database.js

@@ -62,7 +62,6 @@ export default class Database {
      */
     Table(name) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Validator.ValidateTableName(name);
             return yield Table.create(name, this.adapter);
         });
     }
@@ -94,14 +93,11 @@ export default class Database {
      */
     CreateTable(name, columns) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Validator.ValidateTableName(name);
             const names = Object.keys(columns || {}).map((colName) => {
-                // Validator.ValidateColumnName(colName);
                 return colName;
             });
             const colsDef = names.map(colName => {
                 const colType = columns[colName];
-                // Validator.ValidateColumnType(colType);
                 return `"${colName}" ${colType}`;
             }).join(", ");
             const stmt = yield this.adapter.prepare(`CREATE TABLE IF NOT EXISTS "${name}" (${colsDef});`);

package/dist/Query.d.ts

@@ -1,5 +1,5 @@
 import Table from "./Table.js";
-import { QueryParameters } from "./types/index.js";
+import { QueryCondition } from "./types/index.js";
 import Record from "./Record.js";
 import IDatabaseAdapter from "./interfaces/IDatabaseAdapter.js";
 /**
@@ -35,7 +35,9 @@ export default class Query {
     readonly Table: Table;
     private readonly adapter;
     private query;
-    Parameters: QueryParameters;
+    private _parameters;
+    get Parameters(): QueryCondition;
+    set Parameters(value: QueryCondition);
     /**
      * Creates a Query instance (usually called via db.Query() method)
      *
@@ -108,6 +110,8 @@ export default class Query {
      * ```
      */
     All<Type>(): Promise<Record<Type>[]>;
+    private convertParamsToObject;
+    private convertIdToString;
     /**
      * Execute a SELECT query and return the first matching row as a Record object
      * Returns undefined if no rows match the query
@@ -134,6 +138,6 @@ export default class Query {
      * ```
      */
     Get<Type>(): Promise<Record<Type> | undefined>;
-    Transaction(paramList: QueryParameters[]): Promise<void>;
+    Transaction(paramList: QueryCondition[]): Promise<void>;
 }
 //# sourceMappingURL=Query.d.ts.map

package/dist/Query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Query.d.ts","sourceRoot":"","sources":["../src/Query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB,SAAgB,KAAK,EAAE,KAAK,CAAC;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,KAAK,CAAc;IACpB,UAAU,EAAE,eAAe,CAAM;IAExC;;;;;;;;;;;;;;;;;;;;;OAqBG;gBACS,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB;IAMlE;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC;IAKvC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;IAajD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACU,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAM9C,WAAW,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAiBtE"}
+{"version":3,"file":"Query.d.ts","sourceRoot":"","sources":["../src/Query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAwB,MAAM,kBAAkB,CAAC;AACxE,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB,SAAgB,KAAK,EAAE,KAAK,CAAC;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,WAAW,CAAsB;IAEzC,IAAW,UAAU,IAAI,cAAc,CAEtC;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,cAAc,EAE1C;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;gBACS,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB;IAMlE;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC;IAKvC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;IAMjD,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,iBAAiB;IAQzB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACU,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAM9C,WAAW,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAiBrE"}

package/dist/Query.js

@@ -38,6 +38,12 @@ import Record from "./Record.js";
  * ```
  */
 export default class Query {
+    get Parameters() {
+        return this._parameters;
+    }
+    set Parameters(value) {
+        this._parameters = this.convertParamsToObject(value);
+    }
     /**
      * Creates a Query instance (usually called via db.Query() method)
      *
@@ -62,7 +68,7 @@ export default class Query {
      */
     constructor(Table, Query, adapter) {
         this.query = "";
-        this.Parameters = {};
+        this._parameters = {};
         this.Table = Table;
         this.query = Query;
         this.adapter = adapter;
@@ -123,15 +129,28 @@ export default class Query {
     All() {
         return __awaiter(this, void 0, void 0, function* () {
             const stmt = yield this.adapter.prepare(this.query);
-            let results = yield stmt.all(this.Parameters);
-            // This is a fix for a bug where id's passed as numbers don't match string ids in the db
-            if (results.length === 0 && this.Parameters.id) {
-                this.Parameters.id = this.Parameters.id.toString();
-                results = (yield stmt.all(this.Parameters));
-            }
+            const results = yield stmt.all(this.Parameters);
             return results.map(res => new Record(res, this.adapter, this.Table));
         });
     }
+    convertParamsToObject(params) {
+        const paramObject = {};
+        if (Array.isArray(params)) {
+            params.forEach(param => {
+                paramObject[param.column] = param.value;
+            });
+        }
+        else {
+            Object.assign(paramObject, params);
+        }
+        return this.convertIdToString(paramObject);
+    }
+    convertIdToString(params) {
+        if (params.id && typeof params.id === 'number') {
+            return Object.assign(Object.assign({}, params), { id: params.id.toString() });
+        }
+        return params;
+    }
     /**
      * Execute a SELECT query and return the first matching row as a Record object
      * Returns undefined if no rows match the query

package/dist/Table.d.ts

@@ -1,5 +1,5 @@
 import IDatabaseAdapter from "./interfaces/IDatabaseAdapter.js";
-import { DefaultQueryOptions, QueryOptions, QueryParameters, ReadableTableColumnInfo, TableColumnInfo } from "./types/index.js";
+import { QueryOptions, ReadableTableColumnInfo, TableColumnInfo, DefaultQueryOptions, QueryWhereParameters } from "./types/index.js";
 import Record from "./Record.js";
 /**
  * Table class for interacting with a specific database table
@@ -153,6 +153,6 @@ export default class Table {
      * ]);
      * ```
      */
-    Insert<Type>(values: QueryParameters): Promise<Record<Type> | undefined>;
+    Insert<Type>(values: QueryWhereParameters): Promise<Record<Type> | undefined>;
 }
 //# sourceMappingURL=Table.d.ts.map

package/dist/Table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Table.d.ts","sourceRoot":"","sources":["../src/Table.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAChE,OAAO,EACH,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,uBAAuB,EAEvB,eAAe,EAClB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,MAAM,MAAM,aAAa,CAAC;AAGjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAE3C;;;;;OAKG;IACH,OAAO;IAKP;;;;;;;;OAQG;WACiB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,cAAc,UAAQ,GAAG,OAAO,CAAC,KAAK,CAAC;IAe3G;;;;OAIG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;;;;;;;OAUG;IACU,sBAAsB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAIjE;;;;;;;;;;OAUG;IACU,8BAA8B,IAAI,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAWpE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMlC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,OAAO,CAAC,IAAI,EACrB,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,GAC7C,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;IAoB1B;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,MAAM,CAAC,IAAI,EACpB,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,GAC7C,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAWpC;;;;;;;;;;OAUG;IACU,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAM5C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACU,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;CA0FxF"}
+{"version":3,"file":"Table.d.ts","sourceRoot":"","sources":["../src/Table.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAChE,OAAO,EACH,YAAY,EACZ,uBAAuB,EAEvB,eAAe,EACf,mBAAmB,EAEnB,oBAAoB,EACvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,MAAM,MAAM,aAAa,CAAC;AAGjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAE3C;;;;;OAKG;IACH,OAAO;IAKP;;;;;;;;OAQG;WACiB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,cAAc,UAAQ,GAAG,OAAO,CAAC,KAAK,CAAC;IAe3G;;;;OAIG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;;;;;;;OAUG;IACU,sBAAsB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAIjE;;;;;;;;;;OAUG;IACU,8BAA8B,IAAI,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAWpE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMlC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,OAAO,CAAC,IAAI,EACrB,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,GAC7C,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;IAoB1B;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,MAAM,CAAC,IAAI,EACpB,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,GAC7C,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAWpC;;;;;;;;;;OAUG;IACU,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAM5C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACU,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;CAgG7F"}

package/dist/Table.js

@@ -230,7 +230,7 @@ export default class Table {
      */
     Insert(values) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             const columns = Object.keys(values);
             if (columns.length === 0) {
                 throw new Error("Cannot insert record with no columns");
@@ -239,8 +239,14 @@ export default class Table {
             const query = new Query(this, queryStr, this.adapter);
             query.Parameters = values;
             const result = yield query.Run();
+            let recordId;
             // For PostgreSQL compatibility: use 'id' from values if lastInsertRowid is undefined
-            const recordId = (_a = result === null || result === void 0 ? void 0 : result.lastInsertRowid) !== null && _a !== void 0 ? _a : values.id;
+            if (Array.isArray(values)) {
+                recordId = (_a = result === null || result === void 0 ? void 0 : result.lastInsertRowid) !== null && _a !== void 0 ? _a : values.map(v => v.column === 'id' ? v.value : undefined);
+            }
+            else {
+                recordId = (_b = result === null || result === void 0 ? void 0 : result.lastInsertRowid) !== null && _b !== void 0 ? _b : values.id;
+            }
             if (recordId === undefined) {
                 return undefined;
             }

package/dist/abstract/Model.d.ts

@@ -1,5 +1,5 @@
 import IDatabaseAdapter from "../interfaces/IDatabaseAdapter.js";
-import { QueryParameters } from "../types/query.js";
+import { QueryCondition } from "../types/query.js";
 import Table from "../Table.js";
 import Record from "../Record.js";
 export default abstract class Model<T extends object> {
@@ -10,7 +10,7 @@ export default abstract class Model<T extends object> {
     private RecordGet;
     get(): Promise<T | undefined>;
     all(): Promise<T[]>;
-    where(QueryParameters: QueryParameters): this;
+    where(QueryCondition: QueryCondition): this;
     create(data: T): Promise<Record<T> | undefined>;
     update(data: T): Promise<void>;
     delete(): Promise<void>;

package/dist/abstract/Model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Model.d.ts","sourceRoot":"","sources":["../../src/abstract/Model.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,MAAM,aAAa,CAAC;AAChC,OAAO,MAAM,MAAM,cAAc,CAAC;AAElC,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,KAAK,CAAC,CAAC,SAAS,MAAM;IAChD,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,WAAW,CAAuB;gBAEvB,KAAK,EAAE,KAAK;WAIX,OAAO,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,EAE/C,IAAI,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,CAAC,EAC7B,OAAO,EAAE,gBAAgB,GAC1B,OAAO,CAAC,CAAC,CAAC;YAKC,SAAS;IAIV,GAAG,IAAI,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAK7B,GAAG,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAKzB,KAAK,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAKvC,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAI/C,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAO9B,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAMvC"}
+{"version":3,"file":"Model.d.ts","sourceRoot":"","sources":["../../src/abstract/Model.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAwB,MAAM,mBAAmB,CAAC;AACzE,OAAO,KAAK,MAAM,aAAa,CAAC;AAChC,OAAO,MAAM,MAAM,cAAc,CAAC;AAElC,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,KAAK,CAAC,CAAC,SAAS,MAAM;IAChD,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,WAAW,CAAsB;gBAEtB,KAAK,EAAE,KAAK;WAIX,OAAO,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,EAE/C,IAAI,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,CAAC,EAC7B,OAAO,EAAE,gBAAgB,GAC1B,OAAO,CAAC,CAAC,CAAC;YAKC,SAAS;IAIV,GAAG,IAAI,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAK7B,GAAG,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAKzB,KAAK,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI;IAKrC,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAI/C,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAO9B,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAMvC"}

package/dist/abstract/Model.js

@@ -36,8 +36,8 @@ export default class Model {
             return records.map(record => record.values);
         });
     }
-    where(QueryParameters) {
-        this.QueryParams = QueryParameters;
+    where(QueryCondition) {
+        this.QueryParams = QueryCondition;
         return this;
     }
     create(data) {

package/dist/helpers/QueryStatementBuilder.d.ts

@@ -1,4 +1,4 @@
-import { DefaultQueryOptions, QueryOptions, QueryParameters, Join } from "../types/index.js";
+import { DefaultQueryOptions, QueryOptions, QueryCondition, Join, QueryWhereParameters } from "../types/index.js";
 import Table from "Table";
 /**
  * QueryStatementBuilder - Utility class for building SQL query strings
@@ -77,7 +77,7 @@ export default class QueryStatementBuilder {
      * // Note: The actual values will be bound separately using the Parameters object
      * ```
      */
-    static BuildInsert(table: Table, record: QueryParameters): string;
+    static BuildInsert(table: Table, record: QueryWhereParameters): string;
     /**
      * Build an UPDATE SQL statement with SET clause and WHERE conditions
      *
@@ -104,7 +104,7 @@ export default class QueryStatementBuilder {
      * // "UPDATE users SET status = @status WHERE status = @status AND last_login = @last_login"
      * ```
      */
-    static BuildUpdate(table: Table, record: QueryParameters, where: QueryParameters): string;
+    static BuildUpdate(table: Table, record: QueryCondition, where: QueryCondition): string;
     /**
      * Build a DELETE SQL statement with WHERE conditions
      *
@@ -125,7 +125,7 @@ export default class QueryStatementBuilder {
      * // "DELETE FROM users WHERE status = @status AND last_login = @last_login"
      * ```
      */
-    static BuildDelete(table: Table, where: QueryParameters): string;
+    static BuildDelete(table: Table, where: QueryCondition): string;
     /**
      * Build a COUNT SQL statement to count rows, optionally with WHERE conditions
      *
@@ -147,7 +147,7 @@ export default class QueryStatementBuilder {
      * // "SELECT COUNT(*) as count FROM users WHERE status = @status AND age = @age"
      * ```
      */
-    static BuildCount(table: Table, where?: QueryParameters): string;
+    static BuildCount(table: Table, where?: QueryCondition): string;
     /**
      * Build a WHERE clause from parameter conditions (helper method)
      *
@@ -176,7 +176,9 @@ export default class QueryStatementBuilder {
      * // ""
      * ```
      */
-    static BuildWhere(where?: QueryParameters): string;
+    static BuildWhere(where?: QueryCondition): string;
+    private static BuildWhereWithOperators;
+    private static BuildWhereSimple;
     /**
      * Build a SELECT statement with JOIN operations (INNER, LEFT, RIGHT, FULL)
      *
@@ -271,7 +273,7 @@ export default class QueryStatementBuilder {
      *
      * @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
+     * @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
@@ -294,7 +296,7 @@ export default class QueryStatementBuilder {
      * // "ON users.id = orders.user_id AND users.company_id = orders.company_id"
      * ```
      */
-    static BuildJoinOnPart(table: Table, joinTable: Table, on: QueryParameters | QueryParameters[]): string;
+    static BuildJoinOnPart(table: Table, joinTable: Table, on: QueryWhereParameters | QueryWhereParameters[]): string;
     /**
      * Build query options clause (ORDER BY, LIMIT, OFFSET) (helper method)
      *

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

@@ -1 +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,mBAAmB,CAAC;AAC7F,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"}
+{"version":3,"file":"QueryStatementBuilder.d.ts","sourceRoot":"","sources":["../../src/helpers/QueryStatementBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,cAAc,EAAE,IAAI,EAAmB,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACnI,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,oBAAoB,GAAG,MAAM;IAY7E;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACW,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,GAAG,MAAM;IAW9F;;;;;;;;;;;;;;;;;;;OAmBG;WACW,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,cAAc,GAAG,MAAM;IAStE;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,cAAc,GAAG,MAAM;IAQtE;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;WACW,UAAU,CAAC,KAAK,CAAC,EAAE,cAAc,GAAG,MAAM;IAgBxD,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAStC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAK/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;IAcT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;WACW,eAAe,CACzB,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,KAAK,EAChB,EAAE,EAAE,oBAAoB,GAAG,oBAAoB,EAAE,GAClD,MAAM;IAWT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;CAiBjE"}

package/dist/helpers/QueryStatementBuilder.js

@@ -208,14 +208,30 @@ export default class QueryStatementBuilder {
      * ```
      */
     static BuildWhere(where) {
-        if (!where || Object.keys(where).length === 0)
+        if (!where || (Array.isArray(where) && where.length === 0) || Object.keys(where).length === 0)
             return "";
+        const isSimpleObject = !Array.isArray(where) && typeof where === 'object' && where !== null;
         const queryParts = [];
-        const whereClauses = Object.keys(where).map(col => `${col} = @${col}`);
         queryParts.push("WHERE");
-        queryParts.push(whereClauses.join(" AND "));
+        if (isSimpleObject) {
+            queryParts.push(this.BuildWhereSimple(where));
+        }
+        else {
+            queryParts.push(this.BuildWhereWithOperators(where));
+        }
         return queryParts.join(" ");
     }
+    static BuildWhereWithOperators(where) {
+        const queryParts = where.map(condition => {
+            const operator = condition.operator || "=";
+            return `${condition.column} ${operator} @${condition.column.trim()}`;
+        });
+        return queryParts.join(" AND ");
+    }
+    static BuildWhereSimple(where) {
+        const queryParts = Object.keys(where).map(col => `${col} = @${col}`);
+        return queryParts.join(" AND ");
+    }
     /**
      * Build a SELECT statement with JOIN operations (INNER, LEFT, RIGHT, FULL)
      *
@@ -329,7 +345,7 @@ export default class QueryStatementBuilder {
      *
      * @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
+     * @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

package/dist/types/query.d.ts

@@ -1,10 +1,16 @@
-export type QueryParameters = {
+export type QueryWhereParameters = {
     [key: string]: QueryValues;
 };
+export type QueryParameters = {
+    column: string;
+    operator: '=' | '!=' | '<' | '<=' | '>' | '>=' | 'LIKE' | 'IN' | 'NOT IN';
+    value: QueryValues;
+};
+export type QueryCondition = QueryWhereParameters | QueryParameters[];
 export type QueryValues = string | number | boolean | null | bigint;
 export type DefaultQueryOptions = {
     select?: string;
-    where?: QueryParameters;
+    where?: QueryCondition;
 };
 export type QueryOptions = {
     orderBy?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/types/query.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,CAAA;AAEnE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,eAAe,CAAC;CAC3B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/types/query.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAAG;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC;CAC9B,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;IAC1E,KAAK,EAAE,WAAW,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,oBAAoB,GAAG,eAAe,EAAE,CAAC;AAEtE,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,CAAA;AAEnE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,cAAc,CAAC;CAC1B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/dist/types/table.d.ts

@@ -1,4 +1,4 @@
-import { QueryParameters } from "index";
+import { QueryWhereParameters } from "index";
 import Table from "../Table.js";
 export type TableColumnInfo = {
     cid: number;
@@ -24,6 +24,6 @@ export type ColumnDefinition = {
 export type Join = {
     fromTable: Table;
     joinType: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
-    on: QueryParameters | QueryParameters[];
+    on: QueryWhereParameters | QueryWhereParameters[];
 };
 //# sourceMappingURL=table.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/types/table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAExC,OAAO,KAAK,MAAM,aAAa,CAAC;AAEhC,MAAM,MAAM,eAAe,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACf,SAAS,EAAE,KAAK,CAAC;IACjB,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC9C,EAAE,EAAE,eAAe,GAAG,eAAe,EAAE,CAAC;CAC3C,CAAA"}
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/types/table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,KAAK,MAAM,aAAa,CAAC;AAEhC,MAAM,MAAM,eAAe,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACf,SAAS,EAAE,KAAK,CAAC;IACjB,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC9C,EAAE,EAAE,oBAAoB,GAAG,oBAAoB,EAAE,CAAC;CACrD,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamkirbki/database-handler-core",
-  "version": "3.1.2",
+  "version": "3.1.4",
   "author": "iamkirbki",
   "description": "Core database abstractions and interfaces",
   "license": "ISC",

package/dist/helpers/Validator.d.ts

@@ -1,210 +0,0 @@
-import { QueryParameters, TableColumnInfo } from "../types/index.js";
-/**
- * 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

@@ -1 +0,0 @@
-{"version":3,"file":"Validator.d.ts","sourceRoot":"","sources":["../../src/helpers/Validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;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/helpers/Validator.js

@@ -1,345 +0,0 @@
-/**
- * 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
- * ```
- */
-class Validator {
-    /**
-     * 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) {
-        this.ValidateName(name, "Table");
-    }
-    /**
-     * 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) {
-        this.ValidateName(name, "Column");
-    }
-    /**
-     * 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
-    */
-    static ValidateName(name, type) {
-        if (!name || typeof name !== "string") {
-            throw new Error(`${type} name must be a non-empty string.`);
-        }
-        if (name.includes(",")) {
-            throw new Error(`${type} name cannot contain commas.`);
-        }
-        if (/[^a-zA-Z0-9_]/.test(name)) {
-            throw new Error(`${type} name must only contain letters, numbers, and underscores.`);
-        }
-    }
-    /**
-     * 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) {
-        if (!type || typeof type !== "string") {
-            throw new Error("Column type must be a non-empty string.");
-        }
-        const cleanedType = type
-            .toUpperCase()
-            .replace(/\([0-9 , a-zA-Z]*\)/g, "") // Remove (255), (10,2), etc.
-            .replace(new RegExp(`\\b(${this.sqlKeywords.join("|")})\\b`, "gi"), "")
-            .trim();
-        if (!this.validTypes.includes(cleanedType)) {
-            throw new Error(`Invalid column type "${type}". Valid types are: ${this.validTypes.join(", ")}.`);
-        }
-    }
-    /**
-     * 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, TableColumnInformation) {
-        if (!query || typeof query !== "string" || query.trim() === "") {
-            throw new Error("Query must be a non-empty string.");
-        }
-        const forbiddenPatterns = [
-            /;\s*drop\s+table/i,
-            /;\s*delete\s+from/i,
-            /;\s*update\s+/i,
-            /;\s*insert\s+into/i,
-            /;\s*alter\s+table/i
-        ];
-        for (const pattern of forbiddenPatterns) {
-            if (pattern.test(query)) {
-                throw new Error("Query contains forbidden operations.");
-            }
-        }
-        const fieldPattern = /@([a-zA-Z0-9_]+)/g;
-        let match;
-        let requiredFields = TableColumnInformation
-            .filter(col => col.notnull === 1);
-        while ((match = fieldPattern.exec(query)) !== null) {
-            const fieldName = match[1];
-            const found = TableColumnInformation.some(col => col.name === fieldName);
-            if (!found) {
-                throw new Error(`Query references unknown field "@${fieldName}".`);
-            }
-            requiredFields = requiredFields.filter(col => col.name != fieldName);
-        }
-        if (requiredFields.length > 0 && /insert\s+into/i.test(query)) {
-            const fieldNames = requiredFields.map(col => col.name).join(", ");
-            throw new Error(`Query is missing required fields: ${fieldNames}.`);
-        }
-    }
-    /**
-     * 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, parameters, TableColumnInformation) {
-        for (const [key, value] of Object.entries(parameters)) {
-            const columnInfo = TableColumnInformation.find(col => col.name === key);
-            if (!columnInfo) {
-                throw new Error(`Parameter "${key}" does not match any column in the table.`);
-            }
-            if (columnInfo.notnull === 1 && (value === null || value === undefined)) {
-                throw new Error(`Parameter "${key}" cannot be null or undefined for a NOT NULL column.`);
-            }
-            const parameterType = typeof value;
-            const columnType = columnInfo.type;
-            const isValidType = Validator.CompareTypes(columnType, parameterType);
-            if (!isValidType) {
-                throw new Error(`Parameter "${key}" has type "${parameterType}" which does not match column type "${columnType}".`);
-            }
-            const fieldPattern = /@([a-zA-Z0-9_]+)/g;
-            let match;
-            while ((match = fieldPattern.exec(query)) !== null) {
-                const fieldName = match[1];
-                const found = parameters[fieldName] !== undefined;
-                if (!found) {
-                    throw new Error(`Missing parameter for column "${fieldName}".`);
-                }
-            }
-        }
-    }
-    /**
-     * 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, parameterType) {
-        if (!columnType || !parameterType) {
-            return false;
-        }
-        const lowerType = columnType.toLowerCase();
-        // SQLite text types (TEXT, VARCHAR, CHAR, etc.)
-        if (lowerType.includes('text') || lowerType.includes('char')) {
-            return parameterType === 'string' || parameterType === 'number';
-        }
-        // SQLite integer and real/float types (INTEGER, INT, TINYINT, SMALLINT, REAL, FLOAT, DOUBLE etc.)
-        if (lowerType.includes('int') || lowerType.includes('real') || lowerType.includes('float') || lowerType.includes('double')) {
-            return parameterType === 'number';
-        }
-        // Boolean
-        if (lowerType.includes('bool')) {
-            return parameterType === 'boolean';
-        }
-        // BLOB types
-        if (lowerType.includes('blob')) {
-            return parameterType === 'object'; // Buffer or Uint8Array
-        }
-        // UUID with validation
-        if (lowerType === 'uuid' && parameterType === 'string') {
-            return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(parameterType);
-        }
-        // Default: allow any type if not explicitly restricted
-        // This handles custom SQLite types gracefully
-        return true;
-    }
-}
-/**
- * List of valid SQLite column types
- * Includes numeric, text, binary, date/time types and compatibility types for other SQL dialects
- */
-Validator.validTypes = [
-    // Numeric types
-    "INTEGER", "INT", "TINYINT", "SMALLINT", "MEDIUMINT", "BIGINT", "UNSIGNED BIG INT",
-    "INT2", "INT8", "NUMERIC", "DECIMAL", "BOOLEAN", "FLOAT", "DOUBLE", "DOUBLE PRECISION", "REAL",
-    // Text types
-    "TEXT", "CHARACTER", "CHAR", "VARCHAR", "VARYING CHARACTER", "NCHAR",
-    "NATIVE CHARACTER", "NVARCHAR", "CLOB",
-    // Binary types
-    "BLOB", "BINARY", "VARBINARY",
-    // Date/time types
-    "DATE", "DATETIME", "TIME", "TIMESTAMP",
-    // Other types (for compatibility with other SQL dialects)
-    "ENUM", "SET", "YEAR", "JSON", "GEOMETRY", "POINT", "LINESTRING", "POLYGON",
-    "MULTIPOINT", "MULTILINESTRING", "MULTIPOLYGON", "GEOMETRYCOLLECTION"
-];
-/**
- * List of SQL keywords that are valid in column type definitions
- * These keywords are stripped when validating the base column type
- */
-Validator.sqlKeywords = [
-    "NOT",
-    "NULL",
-    "PRIMARY",
-    "KEY",
-    "AUTOINCREMENT",
-    "UNIQUE",
-    "CHECK",
-    "DEFAULT",
-    "COLLATE",
-    "REFERENCES"
-];
-export default Validator;