sheets-orm/dist/orm.js

Mengakses Google Sheets seperti database dengan query mirip ORM

"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.GoogleSheetsORM = void 0;
const googleSheets_1 = require("./googleSheets");
class GoogleSheetsORM {
    getSheets() {
        return __awaiter(this, void 0, void 0, function* () {
            return yield (0, googleSheets_1.getSheets)();
        });
    }
    constructor(spreadsheetId, sheetName) {
        this.spreadsheetId = spreadsheetId;
        this.sheetName = sheetName;
    }
    /** 🟢 Register Hooks */
    onBeforeInsert(hook) {
        this.beforeInsertHook = hook;
    }
    onAfterInsert(hook) {
        this.afterInsertHook = hook;
    }
    onBeforeUpdate(hook) {
        this.beforeUpdateHook = hook;
    }
    onAfterUpdate(hook) {
        this.afterUpdateHook = hook;
    }
    /** 🟢 Get all records with optional filtering & pagination */
    findAll(filter, limit, offset) {
        return __awaiter(this, void 0, void 0, function* () {
            const sheets = yield this.getSheets();
            const response = yield sheets.spreadsheets.values.get({
                spreadsheetId: this.spreadsheetId,
                range: this.sheetName,
            });
            const rows = response.data.values;
            if (!rows || rows.length === 0)
                return [];
            const headers = rows[0]; // First row is header
            let records = rows
                .slice(1)
                .map((row) => Object.fromEntries(headers.map((key, index) => [key, row[index] || null])));
            // 🟢 Filter Data if avaible!
            if (filter) {
                records = records.filter((record) => Object.entries(filter).every(([key, value]) => record[key] === value));
            }
            // 🔢 Pagination (Limit & Offset)
            if (offset !== undefined)
                records = records.slice(offset);
            if (limit !== undefined)
                records = records.slice(0, limit);
            return records;
        });
    }
    /** 🔍 Find a single record by column */
    findOne(column, value) {
        return __awaiter(this, void 0, void 0, function* () {
            const records = yield this.findAll();
            return records.find((record) => record[column] === value) || null;
        });
    }
    /** ➕ Insert new data with validation & hook */
    insert(data) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!data.id || !data.name || data.age === undefined) {
                throw new Error("Invalid data format: 'id', 'name', and 'age' are required");
            }
            if (this.beforeInsertHook)
                yield this.beforeInsertHook(data);
            const sheets = yield this.getSheets();
            const existingRecords = yield this.findAll();
            const headers = existingRecords.length > 0
                ? Object.keys(existingRecords[0])
                : Object.keys(data);
            const newRow = headers.map((header) => data[header] || "");
            yield sheets.spreadsheets.values.append({
                spreadsheetId: this.spreadsheetId,
                range: this.sheetName,
                valueInputOption: "RAW",
                requestBody: {
                    values: [newRow],
                },
            });
            if (this.afterInsertHook)
                yield this.afterInsertHook(data);
        });
    }
    /** ✏️ Update record by column with validation & hook */
    update(column, value, newData) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.beforeUpdateHook)
                yield this.beforeUpdateHook(newData);
            const sheets = yield this.getSheets();
            const records = yield this.findAll();
            const headers = Object.keys(records[0]);
            const index = records.findIndex((record) => record[column] === value);
            if (index === -1)
                return false;
            Object.assign(records[index], newData);
            const updatedRows = [
                headers,
                ...records.map((record) => headers.map((header) => record[header] || "")),
            ];
            yield sheets.spreadsheets.values.update({
                spreadsheetId: this.spreadsheetId,
                range: this.sheetName,
                valueInputOption: "RAW",
                requestBody: {
                    values: updatedRows,
                },
            });
            if (this.afterUpdateHook)
                yield this.afterUpdateHook(newData);
            return true;
        });
    }
    /** 🗑️ Delete record by column */
    delete(column, value) {
        return __awaiter(this, void 0, void 0, function* () {
            const sheets = yield this.getSheets();
            const records = yield this.findAll();
            const headers = Object.keys(records[0]);
            const filteredRecords = records.filter((record) => record[column] !== value);
            if (filteredRecords.length === records.length)
                return false;
            const updatedRows = [
                headers,
                ...filteredRecords.map((record) => headers.map((header) => record[header] || "")),
            ];
            yield sheets.spreadsheets.values.update({
                spreadsheetId: this.spreadsheetId,
                range: this.sheetName,
                valueInputOption: "RAW",
                requestBody: {
                    values: updatedRows,
                },
            });
            return true;
        });
    }
}
exports.GoogleSheetsORM = GoogleSheetsORM;
//# sourceMappingURL=orm.js.map