@iamkirbki/database-handler-core 3.1.3 → 4.0.0

package/dist/base/Table.js

@@ -0,0 +1,128 @@
+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 Query from "../base/Query.js";
+import QueryStatementBuilder from "../helpers/QueryStatementBuilder.js";
+import Container from "../runtime/Container.js";
+/** Table class for interacting with a database table */
+export default class Table {
+    /** Private constructor - use Table.create() */
+    constructor(name) {
+        this._adapter = Container.getInstance().getAdapter();
+        this._name = name;
+    }
+    /** Get the table name */
+    get Name() {
+        return this._name;
+    }
+    /** Get raw column information */
+    TableColumnInformation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._adapter.tableColumnInformation(this._name);
+        });
+    }
+    /** Get readable, formatted column information */
+    ReadableTableColumnInformation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const columns = yield this.TableColumnInformation();
+            return columns.map((col) => ({
+                name: col.name,
+                type: col.type,
+                nullable: col.notnull === 0,
+                isPrimaryKey: col.pk === 1,
+                defaultValue: col.dflt_value,
+            }));
+        });
+    }
+    Drop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryStr = `DROP TABLE IF EXISTS "${this._name}";`;
+            const query = new Query(this, queryStr, this._adapter);
+            yield query.Run();
+        });
+    }
+    /** Fetch records with optional filtering, ordering, and pagination */
+    Records(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryStr = QueryStatementBuilder.BuildSelect(this, {
+                select: options === null || options === void 0 ? void 0 : options.select,
+                where: options === null || options === void 0 ? void 0 : options.where,
+                orderBy: options === null || options === void 0 ? void 0 : options.orderBy,
+                limit: options === null || options === void 0 ? void 0 : options.limit,
+                offset: options === null || options === void 0 ? void 0 : options.offset,
+            });
+            const query = new Query(this, queryStr, this._adapter);
+            if ((options === null || options === void 0 ? void 0 : options.where) && Object.keys(options.where).length > 0)
+                query.Parameters = options.where;
+            const results = yield query.All();
+            // Wrap each result in a Record object
+            return results;
+        });
+    }
+    /** Fetch a single record from the table */
+    Record(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield this.Records({
+                select: options === null || options === void 0 ? void 0 : options.select,
+                where: options === null || options === void 0 ? void 0 : options.where,
+                orderBy: options === null || options === void 0 ? void 0 : options.orderBy,
+                limit: 1
+            });
+            return results[0];
+        });
+    }
+    /** Get the total count of records */
+    RecordsCount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stmt = yield this._adapter.prepare(`SELECT COUNT(*) as count FROM "${this._name}";`);
+            const count = yield stmt.get({});
+            return parseInt(count.count) || 0;
+        });
+    }
+    /** Insert a record into the table */
+    Insert(values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const columns = Object.keys(values);
+            if (columns.length === 0) {
+                throw new Error("Cannot insert record with no columns");
+            }
+            const queryStr = QueryStatementBuilder.BuildInsert(this, values);
+            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
+            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;
+            }
+            return this.Record({
+                where: { id: recordId }
+            });
+        });
+    }
+    /** Perform JOIN operations with other tables */
+    Join(Joins, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryString = QueryStatementBuilder.BuildJoin(this, Joins, options);
+            const query = new Query(this, queryString, this._adapter);
+            // Set parameters if WHERE clause is present
+            if (options === null || options === void 0 ? void 0 : options.where) {
+                query.Parameters = options.where;
+            }
+            return yield query.All();
+        });
+    }
+}

package/dist/helpers/QueryStatementBuilder.d.ts

@@ -1,37 +1,6 @@
 import { DefaultQueryOptions, QueryOptions, QueryCondition, Join, QueryWhereParameters } from "../types/index.js";
-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)"
- * ```
- */
+import Table from "../base/Table";
+/** Utility class for building SQL query strings */
 export default class QueryStatementBuilder {
     /**
      * Build a SELECT SQL statement with optional filtering, ordering, and pagination
@@ -177,8 +146,8 @@ export default class QueryStatementBuilder {
      * ```
      */
     static BuildWhere(where?: QueryCondition): string;
-    private static BuildWhereWithOperators;
-    private static BuildWhereSimple;
+    private static buildWhereWithOperators;
+    private static buildWhereSimple;
     /**
      * Build a SELECT statement with JOIN operations (INNER, LEFT, RIGHT, FULL)
      *

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,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"}
+{"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,sBAAsB,CAAC;AACtI,OAAO,KAAK,MAAM,kBAAkB,CAAC;AAErC,mDAAmD;AACnD,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,GAC7C,MAAM;IAWT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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

@@ -1,35 +1,4 @@
-/**
- * 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)"
- * ```
- */
+/** Utility class for building SQL query strings */
 export default class QueryStatementBuilder {
     /**
      * Build a SELECT SQL statement with optional filtering, ordering, and pagination
@@ -214,21 +183,21 @@ export default class QueryStatementBuilder {
         const queryParts = [];
         queryParts.push("WHERE");
         if (isSimpleObject) {
-            queryParts.push(this.BuildWhereSimple(where));
+            queryParts.push(this.buildWhereSimple(where));
         }
         else {
-            queryParts.push(this.BuildWhereWithOperators(where));
+            queryParts.push(this.buildWhereWithOperators(where));
         }
         return queryParts.join(" ");
     }
-    static BuildWhereWithOperators(where) {
+    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) {
+    static buildWhereSimple(where) {
         const queryParts = Object.keys(where).map(col => `${col} = @${col}`);
         return queryParts.join(" AND ");
     }
@@ -330,7 +299,7 @@ export default class QueryStatementBuilder {
         const joinsArray = Array.isArray(joins) ? joins : [joins];
         let currentTable = fromTable;
         for (const join of joinsArray) {
-            queryParts.push(`${join.joinType} JOIN ${join.fromTable.Name}`);
+            queryParts.push(`${join.joinType} JOIN "${join.fromTable.Name}"`);
             queryParts.push(this.BuildJoinOnPart(currentTable, join.fromTable, join.on));
             currentTable = join.fromTable;
         }

package/dist/index.d.ts

@@ -44,16 +44,20 @@
  *
  * @packageDocumentation
  */
-import Database from "./Database.js";
-import Table from "./Table.js";
-import Record from "./Record.js";
-import Query from "./Query.js";
+import Database from "./base/Database.js";
+import Table from "./base/Table.js";
+import Record from "./base/Record.js";
+import Query from "./base/Query.js";
+import Model from "./abstract/Model.js";
+import SchemaTableBuilder from "./abstract/SchemaTableBuilder.js";
+import AbstractSchemaBuilder from "./interfaces/ISchemaBuilder.js";
+import Repository from "./runtime/Repository.js";
+import Container from "./runtime/Container.js";
 import IDatabaseAdapter from "./interfaces/IDatabaseAdapter.js";
 import IStatementAdapter from "./interfaces/IStatementAdapter.js";
-import Model from "./abstract/Model.js";
-import Controller from "./abstract/Controller.js";
-export * from "./abstract/Migration.js";
-export * from "./abstract/Schema.js";
-export { Database, Model, IDatabaseAdapter, IStatementAdapter, Table, Query, Record, Controller };
+import IController from "./interfaces/IController.js";
+import IMigration from "./interfaces/IMigration.js";
+import ISchemaBuilder from "./interfaces/ISchemaBuilder.js";
+export { Database, Model, Table, Query, Record, Repository, Container, SchemaTableBuilder, AbstractSchemaBuilder, IDatabaseAdapter, IStatementAdapter, IController, IMigration, ISchemaBuilder, };
 export * from "./types/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,KAAK,MAAM,YAAY,CAAC;AAE/B,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAChE,OAAO,iBAAiB,MAAM,mCAAmC,CAAC;AAElE,OAAO,KAAK,MAAM,qBAAqB,CAAC;AACxC,OAAO,UAAU,MAAM,0BAA0B,CAAC;AAElD,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAErC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;AAClG,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,QAAQ,MAAM,oBAAoB,CAAC;AAC1C,OAAO,KAAK,MAAM,iBAAiB,CAAC;AACpC,OAAO,MAAM,MAAM,kBAAkB,CAAC;AACtC,OAAO,KAAK,MAAM,iBAAiB,CAAC;AAEpC,OAAO,KAAK,MAAM,qBAAqB,CAAC;AACxC,OAAO,kBAAkB,MAAM,kCAAkC,CAAC;AAClE,OAAO,qBAAqB,MAAM,oCAAoC,CAAC;AAEvE,OAAO,UAAU,MAAM,yBAAyB,CAAC;AACjD,OAAO,SAAS,MAAM,wBAAwB,CAAC;AAE/C,OAAO,gBAAgB,MAAM,sCAAsC,CAAC;AACpE,OAAO,iBAAiB,MAAM,uCAAuC,CAAC;AACtE,OAAO,WAAW,MAAM,iCAAiC,CAAC;AAC1D,OAAO,UAAU,MAAM,gCAAgC,CAAC;AACxD,OAAO,cAAc,MAAM,oCAAoC,CAAC;AAEhE,OAAO,EACH,QAAQ,EACR,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,UAAU,EACV,SAAS,EAET,kBAAkB,EAClB,qBAAqB,EAErB,gBAAgB,EAChB,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,cAAc,GACjB,CAAC;AAEF,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -44,13 +44,13 @@
  *
  * @packageDocumentation
  */
-import Database from "./Database.js";
-import Table from "./Table.js";
-import Record from "./Record.js";
-import Query from "./Query.js";
+import Database from "./base/Database.js";
+import Table from "./base/Table.js";
+import Record from "./base/Record.js";
+import Query from "./base/Query.js";
 import Model from "./abstract/Model.js";
-import Controller from "./abstract/Controller.js";
-export * from "./abstract/Migration.js";
-export * from "./abstract/Schema.js";
-export { Database, Model, Table, Query, Record, Controller };
+import SchemaTableBuilder from "./abstract/SchemaTableBuilder.js";
+import Repository from "./runtime/Repository.js";
+import Container from "./runtime/Container.js";
+export { Database, Model, Table, Query, Record, Repository, Container, SchemaTableBuilder, };
 export * from "./types/index.js";

package/dist/interfaces/IController.d.ts

@@ -0,0 +1,8 @@
+export default interface IController<M> {
+    index(): Promise<M[]>;
+    show(id: string): Promise<M | undefined>;
+    create(data: object): Promise<M>;
+    update(id: string, data: object): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+//# sourceMappingURL=IController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IController.d.ts","sourceRoot":"","sources":["../../src/interfaces/IController.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,WAAW,WAAW,CAAC,CAAC;IAClC,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IACtB,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IACzC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC"}

package/dist/interfaces/IController.js

@@ -0,0 +1 @@
+export {};

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

@@ -1 +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,wBAAwB,CAAC;AAEvD,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"}
+{"version":3,"file":"IDatabaseAdapter.d.ts","sourceRoot":"","sources":["../../src/interfaces/IDatabaseAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,iBAAiB,MAAM,wBAAwB,CAAC;AAEvD,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/IMigration.d.ts

@@ -0,0 +1,6 @@
+import IDatabaseAdapter from "./IDatabaseAdapter.js";
+export default interface IMigration {
+    up(db: IDatabaseAdapter): Promise<void>;
+    down(db: IDatabaseAdapter): Promise<void>;
+}
+//# sourceMappingURL=IMigration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IMigration.d.ts","sourceRoot":"","sources":["../../src/interfaces/IMigration.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,OAAO,WAAW,UAAU;IAC/B,EAAE,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7C"}

package/dist/interfaces/IMigration.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ISchemaBuilder.d.ts

@@ -0,0 +1,7 @@
+import SchemaTableBuilder from "../abstract/SchemaTableBuilder.js";
+export default interface AbstractSchemaBuilder {
+    createTable(name: string, callback: (table: SchemaTableBuilder) => void): Promise<void>;
+    dropTable(name: string): Promise<void>;
+    alterTable(oldName: string, callback: (table: SchemaTableBuilder) => void): Promise<void>;
+}
+//# sourceMappingURL=ISchemaBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ISchemaBuilder.d.ts","sourceRoot":"","sources":["../../src/interfaces/ISchemaBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,MAAM,sCAAsC,CAAC;AAEtE,MAAM,CAAC,OAAO,WAAW,qBAAqB;IAC1C,WAAW,CACP,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAC9C,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,SAAS,CACL,IAAI,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,UAAU,CACN,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAC9C,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB"}

package/dist/interfaces/ISchemaBuilder.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/Container.d.ts

@@ -0,0 +1,12 @@
+import IDatabaseAdapter from "../interfaces/IDatabaseAdapter.js";
+declare class Container {
+    private static _instance;
+    private _adapters;
+    private _defaultAdapter?;
+    private constructor();
+    static getInstance(): Container;
+    registerAdapter(name: string, adapter: IDatabaseAdapter, isDefault?: boolean): void;
+    getAdapter(name?: string): IDatabaseAdapter;
+}
+export default Container;
+//# sourceMappingURL=Container.d.ts.map

package/dist/runtime/Container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Container.d.ts","sourceRoot":"","sources":["../../src/runtime/Container.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,sCAAsC,CAAC;AAEpE,cAAM,SAAS;IACX,OAAO,CAAC,MAAM,CAAC,SAAS,CAAY;IACpC,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,eAAe,CAAC,CAAmB;IAE3C,OAAO;WAEO,WAAW,IAAI,SAAS;IAO/B,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,UAAQ,GAAG,IAAI;IAOjF,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB;CASrD;AAED,eAAe,SAAS,CAAC"}

package/dist/runtime/Container.js

@@ -0,0 +1,29 @@
+class Container {
+    constructor() {
+        this._adapters = new Map();
+    }
+    static getInstance() {
+        if (!Container._instance) {
+            Container._instance = new Container();
+        }
+        return Container._instance;
+    }
+    registerAdapter(name, adapter, isDefault = false) {
+        this._adapters.set(name, adapter);
+        if (isDefault || !this._defaultAdapter) {
+            this._defaultAdapter = adapter;
+        }
+    }
+    getAdapter(name) {
+        if (name) {
+            const adapter = this._adapters.get(name);
+            if (!adapter)
+                throw new Error(`Adapter '${name}' not found`);
+            return adapter;
+        }
+        if (!this._defaultAdapter)
+            throw new Error("No default adapter set");
+        return this._defaultAdapter;
+    }
+}
+export default Container;

package/dist/runtime/Repository.d.ts

@@ -0,0 +1,17 @@
+import type Model from "../abstract/Model.js";
+import { columnType, QueryCondition } from "../types/index";
+export default class Repository<Type extends columnType, ModelType extends Model<Type>> {
+    private static _instances;
+    private models;
+    private Table;
+    constructor(tableName: string, ModelClass: ModelType);
+    static getInstance<ModelType extends columnType>(ModelClass: new () => Model<ModelType>, tableName: string): Repository<ModelType, Model<ModelType>>;
+    syncModel(model: ModelType): void;
+    getModel(name: string): ModelType;
+    save(attributes: Partial<Type>, oldAttributes: Partial<Type>): Promise<void>;
+    get(conditions: QueryCondition, Model: Model<Type>): Promise<Type | null>;
+    update(attributes: Partial<Type>): Promise<this>;
+    all(Model: Model<Type>): Promise<Type[]>;
+    private join;
+}
+//# sourceMappingURL=Repository.d.ts.map

package/dist/runtime/Repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Repository.d.ts","sourceRoot":"","sources":["../../src/runtime/Repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,yBAAyB,CAAC;AAEjD,OAAO,EAAE,UAAU,EAAQ,cAAc,EAAY,MAAM,mBAAmB,CAAC;AAE/E,MAAM,CAAC,OAAO,OAAO,UAAU,CAAC,IAAI,SAAS,UAAU,EAAE,SAAS,SAAS,KAAK,CAAC,IAAI,CAAC;IAClF,OAAO,CAAC,MAAM,CAAC,UAAU,CAAqE;IAC9F,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,KAAK,CAAO;gBAER,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS;WAMtC,WAAW,CAAC,SAAS,SAAS,UAAU,EAClD,UAAU,EAAE,UAAU,KAAK,CAAC,SAAS,CAAC,EACtC,SAAS,EAAE,MAAM,GAClB,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAWnC,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAKjC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;IAI3B,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5E,GAAG,CAAC,UAAU,EAAE,cAAc,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAWzE,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAehD,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;YAQvC,IAAI;CAoBrB"}

package/dist/runtime/Repository.js

@@ -0,0 +1,101 @@
+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 Table from "../base/Table.js";
+class Repository {
+    constructor(tableName, ModelClass) {
+        var _a;
+        this.models = new Map();
+        const modelPk = ((_a = ModelClass.primaryKey) === null || _a === void 0 ? void 0 : _a.toString()) || ModelClass.constructor.name;
+        this.models.set(modelPk, ModelClass);
+        this.Table = new Table(tableName);
+    }
+    static getInstance(ModelClass, tableName) {
+        const className = ModelClass.name;
+        if (!this._instances.has(className)) {
+            const instance = new Repository(tableName, new ModelClass());
+            this._instances.set(className, instance);
+            return instance;
+        }
+        return this._instances.get(className);
+    }
+    syncModel(model) {
+        var _a;
+        const modelPk = ((_a = model.primaryKey) === null || _a === void 0 ? void 0 : _a.toString()) || model.constructor.name;
+        this.models.set(modelPk, model);
+    }
+    getModel(name) {
+        return this.models.get(name);
+    }
+    save(attributes, oldAttributes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataToSave = Object.assign(Object.assign({}, oldAttributes), attributes);
+            yield this.Table.Insert(dataToSave);
+        });
+    }
+    get(conditions, Model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let record;
+            if (Model.JoinedEntities.length > 0) {
+                record = yield this.join(Model, conditions);
+            }
+            else {
+                record = yield this.Table.Record({ where: conditions });
+            }
+            return record ? record.values : null;
+        });
+    }
+    update(attributes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const primaryKey = this.models.values().next().value.Configuration.primaryKey;
+            const pkValue = attributes[primaryKey];
+            if (pkValue) {
+                const record = yield this.Table.Record({ where: { [primaryKey]: pkValue } });
+                if (record) {
+                    yield record.Update(attributes);
+                }
+            }
+            else {
+                throw new Error("Primary key value is required for update.");
+            }
+            return this;
+        });
+    }
+    all(Model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Model.JoinedEntities.length > 0) {
+                return yield this.join(Model);
+            }
+            else {
+                return yield this.Table.Records().then(records => records.map(record => record.values));
+            }
+        });
+    }
+    join(Model, conditions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const Join = Model.JoinedEntities.map(join => {
+                const relation = Model.Relations.find(rel => rel.model.Configuration.table.toLowerCase() === join.toLowerCase());
+                if (!relation) {
+                    throw new Error(`Relation for joined entity ${join} not found.`);
+                }
+                const JoinType = relation.type === 'hasOne' || relation.type === 'belongsTo' ? 'INNER' : 'LEFT';
+                return {
+                    fromTable: new Table(relation.model.Configuration.table),
+                    joinType: JoinType,
+                    on: [
+                        { [relation.foreignKey]: relation.localKey }
+                    ]
+                };
+            });
+            return (yield this.Table.Join(Join, { where: conditions })).map(record => record.values);
+        });
+    }
+}
+Repository._instances = new Map();
+export default Repository;

package/dist/types/index.d.ts

@@ -1,10 +1,7 @@
 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 type ModelWithTimestamps = {
-    created_at?: string;
-    updated_at?: string;
-};
 export * from './query.js';
 export * from './table.js';
+export * from './model.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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,MAAM,MAAM,mBAAmB,GAAG;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAA;AAED,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}
+{"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,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/dist/types/index.js

@@ -3,3 +3,4 @@
 // Retrieved 2025-11-19, License - CC BY-SA 4.0
 export * from './query.js';
 export * from './table.js';
+export * from './model.js';

package/dist/types/model.d.ts

@@ -0,0 +1,71 @@
+/** Model configuration and types */
+import Model from "../abstract/Model";
+import { columnType } from "./index";
+export type ModelEventType = 'retrieved' | 'creating' | 'created' | 'updating' | 'updated' | 'saving' | 'saved' | 'deleting' | 'deleted' | 'restoring' | 'restored' | 'forceDeleting' | 'forceDeleted';
+export type ModelEventHandler<T> = (model: T) => void | Promise<void>;
+export interface ModelObserver<T> {
+    retrieved?(model: T): void | Promise<void>;
+    creating?(model: T): void | Promise<void>;
+    created?(model: T): void | Promise<void>;
+    updating?(model: T): void | Promise<void>;
+    updated?(model: T): void | Promise<void>;
+    saving?(model: T): void | Promise<void>;
+    saved?(model: T): void | Promise<void>;
+    deleting?(model: T): void | Promise<void>;
+    deleted?(model: T): void | Promise<void>;
+    restoring?(model: T): void | Promise<void>;
+    restored?(model: T): void | Promise<void>;
+    forceDeleting?(model: T): void | Promise<void>;
+    forceDeleted?(model: T): void | Promise<void>;
+}
+export interface ModelScope {
+    (query: any): void;
+}
+export interface ModelConfig {
+    /** Table name - defaults to lowercase class name */
+    table: string;
+    /** Primary key column - defaults to 'id' */
+    primaryKey: string;
+    /** Whether to auto-increment primary key - defaults to true */
+    incrementing?: boolean;
+    /** Primary key type - defaults to 'number' */
+    keyType?: 'string' | 'number';
+    /** Enable automatic timestamp management - defaults to true */
+    timestamps?: boolean;
+    /** Created at column name - defaults to 'created_at' */
+    createdAtColumn?: string;
+    /** Updated at column name - defaults to 'updated_at' */
+    updatedAtColumn?: string;
+    /** Deleted at column name for soft deletes - defaults to 'deleted_at' */
+    deletedAtColumn?: string;
+    /** Database connection name */
+    connection?: string;
+    /** Mass assignable attributes (whitelist) */
+    fillable?: string[];
+    /** Guarded attributes (blacklist) - defaults to ['*'] if fillable is empty */
+    guarded?: string[];
+    /** Hidden attributes when serializing */
+    hidden?: string[];
+    /** Visible attributes when serializing (overrides hidden) */
+    visible?: string[];
+    /** Append computed attributes when serializing */
+    appends?: string[];
+    /** Default attribute values */
+    attributes?: Record<string, any>;
+    /** Date format for serialization */
+    dateFormat?: string;
+}
+export type relation = {
+    type: 'hasOne' | 'hasMany' | 'belongsTo';
+    model: unknown & Model<columnType>;
+    foreignKey: string;
+    localKey?: string;
+};
+export interface SoftDeletable {
+    deleted_at?: string | Date | null;
+}
+export type ModelWithTimestamps = {
+    created_at?: string;
+    updated_at?: string;
+};
+//# sourceMappingURL=model.d.ts.map