miniorm/dist/mid-core/model.js

A lightweight, minimal TypeScript ORM & query‑builder for MySQL, PostgreSQL and SQLite

"use strict";
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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Model = void 0;
const query_builder_1 = require("./query.builder");
class Model {
    constructor(dbName, table, opt) {
        var _a;
        this.dbName = dbName;
        if (typeof table == 'string')
            this.tableName = table;
        else {
            this.tableName = (_a = table.$table) !== null && _a !== void 0 ? _a : table.name.toLowerCase();
            this.entity = table;
        }
        this.queryBuilder = new query_builder_1.QueryBuilder(this.dbName, table, opt);
    }
    // Basic CRUD operations
    find() {
        return __awaiter(this, arguments, void 0, function* (opt = {}) {
            const qb = this.queryBuilder.select(opt.fields);
            if (opt.where)
                qb.where(...(opt.where || []));
            if (opt.order)
                qb.order(opt.order ? [opt.order[0]] : undefined, opt.order ? opt.order[1] : undefined);
            if (opt.limit)
                qb.limit(opt.limit);
            if (opt.offset)
                qb.offset(opt.offset);
            return yield qb.run();
        });
    }
    findAll() {
        return __awaiter(this, arguments, void 0, function* (fields = []) {
            return this.queryBuilder.select(fields).run();
        });
    }
    findOne() {
        return __awaiter(this, arguments, void 0, function* (opt = {}) {
            const qb = this.queryBuilder.select(opt.fields);
            if (opt.where)
                qb.where(...(opt.where || []));
            if (opt.order)
                qb.order(opt.order ? [opt.order[0]] : undefined, opt.order ? opt.order[1] : undefined);
            if (opt.limit)
                qb.limit(opt.limit);
            if (opt.offset)
                qb.offset(opt.offset);
            return yield qb.first();
        });
    }
    first() {
        return __awaiter(this, arguments, void 0, function* (opt = {}) {
            return yield this.findOne(opt);
        });
    }
    create(data) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.insert(data);
        });
    }
    update(data, ...whereConditions) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.update(data).where(...whereConditions).run();
        });
    }
    delete(...whereConditions) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.delete().where(...whereConditions).run();
        });
    }
    // Aggregation methods
    count(field) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.count(field);
        });
    }
    max(field) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.max(field);
        });
    }
    min(field) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.min(field);
        });
    }
    avg(field) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.avg(field);
        });
    }
    sum(field) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.sum(field);
        });
    }
    // Utility methods
    exists(...whereConditions) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.select().where(...whereConditions).exists();
        });
    }
    pluck(field) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.queryBuilder.pluck(field);
        });
    }
    // Raw query execution
    raw(query_1) {
        return __awaiter(this, arguments, void 0, function* (query, values = []) {
            return yield this.queryBuilder.raw(query, values);
        });
    }
    // Query builder access for more complex queries
    query() {
        var _a;
        return new query_builder_1.QueryBuilder(this.dbName, (_a = this.entity) !== null && _a !== void 0 ? _a : this.tableName);
    }
    // Connection management
    disconnect() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.queryBuilder.disconnect();
        });
    }
    reconnect() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.queryBuilder.reconnect();
            return this;
        });
    }
    // Debug helper
    debug(type = 'now', func) {
        this.queryBuilder.debug(type, func);
        return this;
    }
}
exports.Model = Model;