@iamkirbki/database-handler-core 3.1.4 → 4.0.0

package/dist/Record.d.ts

@@ -1,125 +0,0 @@
-import { inspect } from "util";
-import Table from "./Table.js";
-import IDatabaseAdapter from "./interfaces/IDatabaseAdapter.js";
-/**
- * Record class represents a single database row with methods for updates and deletion
- * Automatically returned by Table.Records() and Table.Record() methods
- *
- * @example
- * ```typescript
- * const user = table.Record({ where: { id: 1 } });
- *
- * // Access values
- * console.log(user?.values);
- *
- * // Update the record
- * user?.Update({ name: 'John Doe', age: 31 });
- *
- * // Delete the record
- * user?.Delete();
- *
- * // JSON serialization works automatically
- * console.log(JSON.stringify(user)); // {"id": 1, "name": "John Doe", ...}
- * ```
- */
-export default class Record<ColumnValuesType> {
-    private readonly adapter;
-    private _values;
-    private readonly _table;
-    /**
-     * Creates a Record instance (typically called internally by Table methods)
-     *
-     * @param values - Object containing column names and their values
-     * @param db - Database connection instance
-     * @param tableName - Name of the table this record belongs to
-     */
-    constructor(values: ColumnValuesType, adapter: IDatabaseAdapter, table: Table);
-    /**
-     * Get the raw values object for this record
-     *
-     * @returns Object containing all column values
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * console.log(user?.values); // { id: 1, name: 'John', email: 'john@example.com' }
-     * ```
-     */
-    get values(): ColumnValuesType;
-    /**
-     * Update this record in the database
-     * Updates both the database and the local values
-     *
-     * @template TEntity - Record type that must include an 'id' property (number or string)
-     * @param newValues - Object with column names and new values to update
-     * @throws Error if the record doesn't have an 'id' field
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * user?.Update({ name: 'Jane Doe', age: 28 });
-     * // Database is updated and user.values reflects the changes
-     * ```
-     */
-    Update(newValues: object): Promise<void>;
-    /**
-     * Delete this record from the database
-     * Uses all current field values as WHERE clause conditions
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * user?.Delete();
-     * // Record is permanently deleted from the database
-     * ```
-     */
-    Delete(): Promise<void>;
-    /**
-     * Returns the values object when JSON.stringify() is called
-     * Allows seamless JSON serialization of Record objects
-     *
-     * @returns The values object
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * console.log(JSON.stringify(user));
-     * // Output: {"id":1,"name":"John","email":"john@example.com"}
-     * ```
-     */
-    toJSON(): ColumnValuesType;
-    /**
-     * Returns a formatted string representation of the record
-     *
-     * @returns Pretty-printed JSON string of the values
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * console.log(user?.toString());
-     * // Output:
-     * // {
-     * //   "id": 1,
-     * //   "name": "John",
-     * //   "email": "john@example.com"
-     * // }
-     * ```
-     */
-    toString(): string;
-    /**
-     * Custom inspect method for console.log() and Node.js REPL
-     * Makes Record objects display their values directly instead of the class structure
-     *
-     * @returns The values object for display
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * console.log(user);
-     * // Output: { id: 1, name: 'John', email: 'john@example.com' }
-     * // Instead of: Record { _db: ..., _values: {...}, _tableName: '...' }
-     * ```
-     */
-    [inspect.custom](): ColumnValuesType;
-}
-//# sourceMappingURL=Record.d.ts.map

package/dist/Record.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Record.d.ts","sourceRoot":"","sources":["../src/Record.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,KAAK,MAAM,YAAY,CAAC;AAG/B,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAGhE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM,CAAC,gBAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B;;;;;;OAMG;gBACS,MAAM,EAAE,gBAAgB,EAAE,OAAO,EAAE,gBAAgB,EAAE,KAAK,EAAE,KAAK;IAM7E;;;;;;;;;;OAUG;IACH,IAAW,MAAM,IAAI,gBAAgB,CAEpC;IAED;;;;;;;;;;;;;;OAcG;IACU,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BrD;;;;;;;;;;OAUG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAUpC;;;;;;;;;;;;OAYG;IACI,MAAM,IAAI,gBAAgB;IAIjC;;;;;;;;;;;;;;;;OAgBG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;;;;;;;;;;;OAaG;IACH,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,gBAAgB;CAGvC"}

package/dist/Record.js

@@ -1,174 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { inspect } from "util";
-import Query from "./Query.js";
-/**
- * Record class represents a single database row with methods for updates and deletion
- * Automatically returned by Table.Records() and Table.Record() methods
- *
- * @example
- * ```typescript
- * const user = table.Record({ where: { id: 1 } });
- *
- * // Access values
- * console.log(user?.values);
- *
- * // Update the record
- * user?.Update({ name: 'John Doe', age: 31 });
- *
- * // Delete the record
- * user?.Delete();
- *
- * // JSON serialization works automatically
- * console.log(JSON.stringify(user)); // {"id": 1, "name": "John Doe", ...}
- * ```
- */
-export default class Record {
-    /**
-     * Creates a Record instance (typically called internally by Table methods)
-     *
-     * @param values - Object containing column names and their values
-     * @param db - Database connection instance
-     * @param tableName - Name of the table this record belongs to
-     */
-    constructor(values, adapter, table) {
-        this._values = {};
-        this._values = values;
-        this.adapter = adapter;
-        this._table = table;
-    }
-    /**
-     * Get the raw values object for this record
-     *
-     * @returns Object containing all column values
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * console.log(user?.values); // { id: 1, name: 'John', email: 'john@example.com' }
-     * ```
-     */
-    get values() {
-        return this._values;
-    }
-    ;
-    /**
-     * Update this record in the database
-     * Updates both the database and the local values
-     *
-     * @template TEntity - Record type that must include an 'id' property (number or string)
-     * @param newValues - Object with column names and new values to update
-     * @throws Error if the record doesn't have an 'id' field
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * user?.Update({ name: 'Jane Doe', age: 28 });
-     * // Database is updated and user.values reflects the changes
-     * ```
-     */
-    Update(newValues) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const setClauses = Object.keys(newValues)
-                .map(key => `${key} = @${key}`)
-                .join(", ");
-            const originalValues = this._values;
-            if (originalValues.updated_at !== undefined) {
-                newValues.updated_at = new Date().toISOString();
-            }
-            const whereClauses = Object.keys(originalValues)
-                .map(key => `${key} = @where_${key}`)
-                .join(" AND ");
-            const query = `UPDATE "${this._table.Name}" SET ${setClauses} WHERE ${whereClauses};`;
-            const _query = new Query(this._table, query, this.adapter);
-            const params = Object.assign({}, newValues);
-            Object.entries(originalValues).forEach(([key, value]) => {
-                params[`where_${key}`] = value;
-            });
-            _query.Parameters = params;
-            yield _query.Run();
-            this._values = Object.assign(Object.assign({}, this._values), newValues);
-        });
-    }
-    /**
-     * Delete this record from the database
-     * Uses all current field values as WHERE clause conditions
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * user?.Delete();
-     * // Record is permanently deleted from the database
-     * ```
-     */
-    Delete() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const whereClauses = Object.keys(this._values)
-                .map(key => `${key} = @${key}`)
-                .join(" AND ");
-            const _query = new Query(this._table, `DELETE FROM "${this._table.Name}" WHERE ${whereClauses};`, this.adapter);
-            _query.Parameters = Object.assign({}, this._values);
-            yield _query.Run();
-        });
-    }
-    /**
-     * Returns the values object when JSON.stringify() is called
-     * Allows seamless JSON serialization of Record objects
-     *
-     * @returns The values object
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * console.log(JSON.stringify(user));
-     * // Output: {"id":1,"name":"John","email":"john@example.com"}
-     * ```
-     */
-    toJSON() {
-        return this._values;
-    }
-    /**
-     * Returns a formatted string representation of the record
-     *
-     * @returns Pretty-printed JSON string of the values
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * console.log(user?.toString());
-     * // Output:
-     * // {
-     * //   "id": 1,
-     * //   "name": "John",
-     * //   "email": "john@example.com"
-     * // }
-     * ```
-     */
-    toString() {
-        return JSON.stringify(this._values, null, 2);
-    }
-    /**
-     * Custom inspect method for console.log() and Node.js REPL
-     * Makes Record objects display their values directly instead of the class structure
-     *
-     * @returns The values object for display
-     *
-     * @example
-     * ```typescript
-     * const user = table.Record({ where: { id: 1 } });
-     * console.log(user);
-     * // Output: { id: 1, name: 'John', email: 'john@example.com' }
-     * // Instead of: Record { _db: ..., _values: {...}, _tableName: '...' }
-     * ```
-     */
-    [inspect.custom]() {
-        return this._values;
-    }
-}

package/dist/Table.d.ts

@@ -1,158 +0,0 @@
-import IDatabaseAdapter from "./interfaces/IDatabaseAdapter.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
- * Provides methods for querying, inserting, and retrieving table metadata
- *
- * @example
- * ```typescript
- * const users = db.Table('users');
- *
- * // Get all records
- * const allUsers = users.Records();
- *
- * // Get filtered records
- * const activeUsers = users.Records({
- *   where: { status: 'active' }
- * });
- *
- * // Insert a record
- * users.Insert({ name: 'John', email: 'john@example.com' });
- * ```
- */
-export default class Table {
-    private readonly name;
-    private readonly adapter;
-    /**
-     * Private constructor - use Table.create() instead
-     *
-     * @param name - Name of the table
-     * @param adapter - Database adapter instance
-     */
-    private constructor();
-    /**
-     * Create a Table instance (async factory method)
-     *
-     * @param name - Name of the table
-     * @param adapter - Database adapter instance
-     * @param skipValidation - Skip table existence validation (used when creating new tables)
-     * @returns Table instance
-     * @throws Error if the table does not exist in the database
-     */
-    static create(name: string, adapter: IDatabaseAdapter, skipValidation?: boolean): Promise<Table>;
-    /**
-     * Get the name of the table
-     *
-     * @returns The table name
-     */
-    get Name(): string;
-    /**
-     * Get raw column information from SQLite PRAGMA
-     *
-     * @returns Array of column metadata from SQLite
-     *
-     * @example
-     * ```typescript
-     * const columns = await table.TableColumnInformation();
-     * // [{ cid: 0, name: 'id', type: 'INTEGER', notnull: 0, dflt_value: null, pk: 1 }, ...]
-     * ```
-     */
-    TableColumnInformation(): Promise<TableColumnInfo[]>;
-    /**
-     * Get readable, formatted column information
-     *
-     * @returns Array of formatted column metadata with readable properties
-     *
-     * @example
-     * ```typescript
-     * const columns = await table.ReadableTableColumnInformation();
-     * // [{ name: 'id', type: 'INTEGER', nullable: false, isPrimaryKey: true, defaultValue: null }, ...]
-     * ```
-     */
-    ReadableTableColumnInformation(): Promise<ReadableTableColumnInfo[]>;
-    Drop(): Promise<void>;
-    /**
-     * Fetch records from the table with optional filtering, ordering, and pagination
-     * @param options Query options for selecting records
-     * @returns Array of records matching the criteria
-     *
-     * @example
-     * // Get all records
-     * table.Records();
-     *
-     * @example
-     * // Get specific columns with filters
-     * table.Records({
-     *   select: 'id, name',
-     *   where: { status: 'active', age: 25 }
-     * });
-     *
-     * @example
-     * // With ordering and pagination
-     * table.Records({
-     *   orderBy: 'created_at DESC',
-     *   limit: 10,
-     *   offset: 20
-     * });
-     */
-    Records<Type>(options?: DefaultQueryOptions & QueryOptions): Promise<Record<Type>[]>;
-    /**
-     * Fetch a single record from the table
-     *
-     * @param options - Query options for selecting a record
-     * @param options.select - Columns to select (default: "*")
-     * @param options.where - Filter conditions as key-value pairs
-     * @param options.orderBy - SQL ORDER BY clause (e.g., "created_at DESC")
-     * @returns Single Record instance or undefined if not found
-     *
-     * @example
-     * ```typescript
-     * // Get record by ID
-     * const user = table.Record({ where: { id: 1 } });
-     *
-     * // Get most recent record
-     * const latest = table.Record({ orderBy: 'created_at DESC' });
-     *
-     * // Update the record
-     * user?.update({ status: 'inactive' });
-     * ```
-     */
-    Record<Type>(options?: DefaultQueryOptions & QueryOptions): Promise<Record<Type> | undefined>;
-    /**
-     * Get the total count of records in the table
-     *
-     * @returns Number of records in the table
-     *
-     * @example
-     * ```typescript
-     * const totalUsers = table.RecordsCount;
-     * console.log(`Total users: ${totalUsers}`);
-     * ```
-     */
-    RecordsCount(): Promise<number>;
-    /**
-     * Insert one or multiple records into the table
-     * Validates data types against table schema before insertion
-     *
-     * @param values - Single object or array of objects to insert
-     * @returns Insert result with lastInsertRowid and changes count
-     * @throws Error if values is empty or contains no columns
-     * @throws Error if validation fails (wrong types, missing required fields)
-     *
-     * @example
-     * ```typescript
-     * // Insert single record
-     * const result = table.Insert({ name: 'John', age: 30 });
-     * console.log(`Inserted row ID: ${result.lastInsertRowid}`);
-     *
-     * // Insert multiple records (uses transaction for atomicity)
-     * table.Insert([
-     *   { name: 'John', age: 30 },
-     *   { name: 'Jane', age: 25 }
-     * ]);
-     * ```
-     */
-    Insert<Type>(values: QueryWhereParameters): Promise<Record<Type> | undefined>;
-}
-//# sourceMappingURL=Table.d.ts.map

package/dist/Table.d.ts.map

@@ -1 +0,0 @@
-{"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"}