chain-db-ts 1.0.0-rc.1 → 1.0.0-rc.3

package/features/constants.js

@@ -3,7 +3,7 @@ export var DEFAULT_API_SERVER = 'http://localhost:2818';
 export var API_BASE = '/api/v1';
 export var CONNECT = "".concat(API_BASE, "/database/connect");
 export var GET_TABLE = function (table) { return "".concat(API_BASE, "/table/").concat(table); };
-export var UPDATE_LAST_ITEM = function (table) { return "".concat(API_BASE, "/table/").concat(table, "/update"); };
+export var UPDATE_ITEM = function (table) { return "".concat(API_BASE, "/table/").concat(table, "/update"); };
 export var PERSIST_NEW_DATA = function (table) { return "".concat(API_BASE, "/table/").concat(table, "/persist"); };
 export var GET_HISTORY = function (table, limit) {
     if (limit === void 0) { limit = 25; }
@@ -11,4 +11,5 @@ export var GET_HISTORY = function (table, limit) {
 };
 export var FIND_WHERE_BASIC = function (table) { return "".concat(API_BASE, "/table/").concat(table, "/find"); };
 export var FIND_WHERE_ADVANCED = function (table) { return "".concat(API_BASE, "/table/").concat(table, "/find-advanced"); };
+export var GET_DOC = function (table, doc_id) { return "".concat(API_BASE, "/table/").concat(table, "/doc/").concat(doc_id); };
 export var WEB_SOCKET_EVENTS = "".concat(API_BASE, "/events");

package/features/table-doc.d.ts

@@ -0,0 +1,37 @@
+import { ChainDB } from './chain-db';
+import { DocId, TableDoc } from './types';
+/**
+ * Implementation of TableDoc interface
+ * Represents a specific document from a table
+ */
+export declare class TableDocImpl<Model> implements TableDoc<Model> {
+    /**
+     * The document data
+     */
+    doc: DocId<Model>;
+    /**
+     * The document ID
+     */
+    private doc_id;
+    private tableName;
+    private db;
+    constructor(tableName: string, doc_id: string, data: DocId<Model>, db: ChainDB);
+    /**
+     * Update the document data
+     * This will update the specific document without creating a new one
+     */
+    update(): Promise<void>;
+    /**
+     * Refetch the document data from the database
+     * Useful when the document might have been updated by another application
+     */
+    refetch(): Promise<void>;
+    /**
+     * Get the table name this document belongs to
+     */
+    getTableName(): string;
+    /**
+     * Check if the table is empty
+     */
+    isEmpty(): boolean;
+}

package/features/table-doc.js

@@ -0,0 +1,129 @@
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import axios from 'axios';
+import { UPDATE_ITEM, GET_DOC } from './constants';
+import { post } from './utils';
+/**
+ * Implementation of TableDoc interface
+ * Represents a specific document from a table
+ */
+var TableDocImpl = /** @class */ (function () {
+    function TableDocImpl(tableName, doc_id, data, db) {
+        this.tableName = tableName;
+        this.doc_id = doc_id;
+        this.doc = data;
+        this.db = db;
+    }
+    /**
+     * Update the document data
+     * This will update the specific document without creating a new one
+     */
+    TableDocImpl.prototype.update = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, body, response, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = "".concat(this.db.server).concat(UPDATE_ITEM(this.tableName));
+                        body = {
+                            data: this.doc,
+                            doc_id: this.doc_id
+                        };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, post(url, body, this.db.auth)];
+                    case 2:
+                        response = _a.sent();
+                        if (!response.data.success) {
+                            throw new Error(response.data.message);
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        throw new Error("Something went wrong updating document ".concat(this.doc_id, ": ").concat(e_1.message || String(e_1)));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Refetch the document data from the database
+     * Useful when the document might have been updated by another application
+     */
+    TableDocImpl.prototype.refetch = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = "".concat(this.db.server).concat(GET_DOC(this.tableName, this.doc_id));
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, axios.get(url, { headers: { Authorization: "Basic ".concat(this.db.auth) } })];
+                    case 2:
+                        response = _a.sent();
+                        if (!response.data.success) {
+                            throw new Error(response.data.message);
+                        }
+                        // Update the table data with the latest data from the database
+                        this.doc = response.data.data;
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_2 = _a.sent();
+                        throw new Error("Something went wrong refetching document ".concat(this.doc_id, ": ").concat(e_2.message || String(e_2)));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get the table name this document belongs to
+     */
+    TableDocImpl.prototype.getTableName = function () {
+        return this.tableName;
+    };
+    /**
+     * Check if the table is empty
+     */
+    TableDocImpl.prototype.isEmpty = function () {
+        return Object.keys(this.doc).length === 0;
+    };
+    return TableDocImpl;
+}());
+export { TableDocImpl };

package/features/table.d.ts

@@ -1,25 +1,23 @@
 import { ChainDB } from './chain-db';
-import { Criteria, CriteriaAdvanced } from './types';
+import { Criteria, CriteriaAdvanced, DocId, TableDoc } from './types';
 declare class Table<Model> {
-    table: Model;
+    /**
+     * The current document data
+     */
+    currentDoc: Model;
     private name;
     private db;
     constructor(name: string, db: ChainDB);
     /**
-     * Persist table data changes
-     */
-    persist(): Promise<void>;
-    /**
-     * Update data of the last table's item (or create a new item if there is none).
-     * This ensures that no new item is created.
+     * Persist table's document data changes
      */
-    update(): Promise<void>;
+    persist(): Promise<DocId<Model>>;
     /**
      * Get the history of changes. A list of transactions from the most recent to the most old
      * in a range of depth
      * @param limit
      */
-    getHistory(limit: number): Promise<Model[]>;
+    getHistory(limit: number): Promise<DocId<Model>[]>;
     /**
      * Refetch the table data
      */
@@ -52,7 +50,7 @@ declare class Table<Model> {
      *   score: 100
      * })
      */
-    findWhere(criteria: Criteria<Model>, limit?: number, reverse?: boolean): Promise<Model[]>;
+    findWhere(criteria: Criteria<Model>, limit?: number, reverse?: boolean): Promise<DocId<Model>[]>;
     /**
      * Find items in the table using advanced criteria with operators
      * @param criteria Array of criteria to filter items. Each criteria contains:
@@ -81,6 +79,16 @@ declare class Table<Model> {
      *   }
      * ])
      */
-    findWhereAdvanced(criteria: CriteriaAdvanced<Model>[], limit?: number, reverse?: boolean): Promise<Model[]>;
+    findWhereAdvanced(criteria: CriteriaAdvanced<Model>[], limit?: number, reverse?: boolean): Promise<DocId<Model>[]>;
+    /**
+     * Get the current document ID
+     */
+    getCurrentDocId(): string;
+    /**
+     * Get a specific document by its ID
+     * @param doc_id The document ID to retrieve
+     * @returns A TableDoc instance with the specific document data
+     */
+    getDoc(doc_id: string): Promise<TableDoc<Model>>;
 }
 export default Table;

package/features/table.js

@@ -35,17 +35,18 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import axios from 'axios';
-import { FIND_WHERE_ADVANCED, FIND_WHERE_BASIC, GET_HISTORY, GET_TABLE, PERSIST_NEW_DATA, UPDATE_LAST_ITEM, } from './constants';
+import { FIND_WHERE_ADVANCED, FIND_WHERE_BASIC, GET_HISTORY, GET_TABLE, PERSIST_NEW_DATA, GET_DOC } from './constants';
 import { post } from './utils';
+import { TableDocImpl } from './table-doc';
 var Table = /** @class */ (function () {
     function Table(name, db) {
         this.name = '';
-        this.table = {};
+        this.currentDoc = {};
         this.name = name;
         this.db = db;
     }
     /**
-     * Persist table data changes
+     * Persist table's document data changes
      */
     Table.prototype.persist = function () {
         return __awaiter(this, void 0, void 0, function () {
@@ -55,7 +56,7 @@ var Table = /** @class */ (function () {
                     case 0:
                         url = "".concat(this.db.server).concat(PERSIST_NEW_DATA(this.name));
                         body = {
-                            data: this.table
+                            data: this.currentDoc
                         };
                         _a.label = 1;
                     case 1:
@@ -66,7 +67,7 @@ var Table = /** @class */ (function () {
                         if (!response.data.success) {
                             throw new Error(response.data.message);
                         }
-                        return [3 /*break*/, 4];
+                        return [2 /*return*/, response.data.data];
                     case 3:
                         e_1 = _a.sent();
                         throw new Error("Something went wrong with persist operation: ".concat(e_1.message || String(e_1)));
@@ -75,38 +76,6 @@ var Table = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Update data of the last table's item (or create a new item if there is none).
-     * This ensures that no new item is created.
-     */
-    Table.prototype.update = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var url, body, response, e_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        url = "".concat(this.db.server).concat(UPDATE_LAST_ITEM(this.name));
-                        body = {
-                            data: this.table
-                        };
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, post(url, body, this.db.auth)];
-                    case 2:
-                        response = _a.sent();
-                        if (!response.data.success) {
-                            throw new Error(response.data.message);
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        e_2 = _a.sent();
-                        throw new Error("Something went wrong with update operation: ".concat(e_2.message || String(e_2)));
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
     /**
      * Get the history of changes. A list of transactions from the most recent to the most old
      * in a range of depth
@@ -114,7 +83,7 @@ var Table = /** @class */ (function () {
      */
     Table.prototype.getHistory = function (limit) {
         return __awaiter(this, void 0, void 0, function () {
-            var url, response, e_3;
+            var url, response, e_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -131,8 +100,8 @@ var Table = /** @class */ (function () {
                         // Return data. Only table fields, e.g.: [{fieldA: 'Hi', filedB: 22}]
                         return [2 /*return*/, response.data.data];
                     case 3:
-                        e_3 = _a.sent();
-                        throw new Error("Something went wrong with getHistory operation: ".concat(e_3.message || String(e_3)));
+                        e_2 = _a.sent();
+                        throw new Error("Something went wrong with getHistory operation: ".concat(e_2.message || String(e_2)));
                     case 4: return [2 /*return*/];
                 }
             });
@@ -143,7 +112,7 @@ var Table = /** @class */ (function () {
      */
     Table.prototype.refetch = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var url, response, e_4;
+            var url, response, e_3;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -154,11 +123,11 @@ var Table = /** @class */ (function () {
                         return [4 /*yield*/, axios.get(url, { headers: { Authorization: "Basic ".concat(this.db.auth) } })];
                     case 2:
                         response = _a.sent();
-                        this.table = response.data.data ? response.data.data : {};
+                        this.currentDoc = response.data.data ? response.data.data : {};
                         return [3 /*break*/, 4];
                     case 3:
-                        e_4 = _a.sent();
-                        throw new Error("Something went wrong with refetch operation: ".concat(e_4.message || String(e_4)));
+                        e_3 = _a.sent();
+                        throw new Error("Something went wrong with refetch operation: ".concat(e_3.message || String(e_3)));
                     case 4: return [2 /*return*/];
                 }
             });
@@ -168,7 +137,7 @@ var Table = /** @class */ (function () {
      * Check if the table is empty
      */
     Table.prototype.isEmpty = function () {
-        return Object.keys(this.table).length === 0;
+        return Object.keys(this.currentDoc).length === 0;
     };
     /**
      * Get the table's name
@@ -200,7 +169,7 @@ var Table = /** @class */ (function () {
         if (limit === void 0) { limit = 1000; }
         if (reverse === void 0) { reverse = true; }
         return __awaiter(this, void 0, void 0, function () {
-            var url, body, response, e_5;
+            var url, body, response, e_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -222,14 +191,13 @@ var Table = /** @class */ (function () {
                         // Return found data. Only table fields, e.g.: [{fieldA: 'Hi', filedB: 22}]
                         return [2 /*return*/, response.data.data];
                     case 3:
-                        e_5 = _a.sent();
-                        throw new Error("Something went wrong with findWhere operation: ".concat(e_5.message || String(e_5)));
+                        e_4 = _a.sent();
+                        throw new Error("Something went wrong with findWhere operation: ".concat(e_4.message || String(e_4)));
                     case 4: return [2 /*return*/];
                 }
             });
         });
     };
-    // TODO: Implement documentation
     /**
      * Find items in the table using advanced criteria with operators
      * @param criteria Array of criteria to filter items. Each criteria contains:
@@ -262,7 +230,7 @@ var Table = /** @class */ (function () {
         if (limit === void 0) { limit = 1000; }
         if (reverse === void 0) { reverse = true; }
         return __awaiter(this, void 0, void 0, function () {
-            var url, body, response, e_6;
+            var url, body, response, e_5;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -283,9 +251,48 @@ var Table = /** @class */ (function () {
                         }
                         // Return found data. Only table fields, e.g.: [{fieldA: 'Hi', filedB: 22}]
                         return [2 /*return*/, response.data.data];
+                    case 3:
+                        e_5 = _a.sent();
+                        throw new Error("Something went wrong with findWhereAdvanced operation: ".concat(e_5.message || String(e_5)));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get the current document ID
+     */
+    Table.prototype.getCurrentDocId = function () {
+        var _doc = this.currentDoc;
+        // Support to applications using older versions
+        return _doc.doc_id ? _doc.doc_id : '';
+    };
+    /**
+     * Get a specific document by its ID
+     * @param doc_id The document ID to retrieve
+     * @returns A TableDoc instance with the specific document data
+     */
+    Table.prototype.getDoc = function (doc_id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, e_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = "".concat(this.db.server).concat(GET_DOC(this.name, doc_id));
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, axios.get(url, { headers: { Authorization: "Basic ".concat(this.db.auth) } })];
+                    case 2:
+                        response = _a.sent();
+                        if (!response.data.success) {
+                            throw new Error(response.data.message);
+                        }
+                        // Create a TableDoc instance with the document data
+                        return [2 /*return*/, new TableDocImpl(this.name, doc_id, response.data.data, this.db)];
                     case 3:
                         e_6 = _a.sent();
-                        throw new Error("Something went wrong with findWhereAdvanced operation: ".concat(e_6.message || String(e_6)));
+                        throw new Error("Something went wrong with getDoc operation: ".concat(e_6.message || String(e_6)));
                     case 4: return [2 /*return*/];
                 }
             });

package/features/types.d.ts

@@ -51,3 +51,37 @@ export type EventData = {
     timestamp: number;
 };
 export type EventCallback = (data: EventData) => void;
+/**
+ * Represents a specific document from a table
+ * Contains only the necessary methods to work with a specific document
+ */
+export interface TableDoc<Model> {
+    /**
+     * The document data
+     */
+    doc: DocId<Model>;
+    /**
+     * Update the document data
+     * This will update the specific document without creating a new one
+     */
+    update(): Promise<void>;
+    /**
+     * Get the table name this document belongs to
+     */
+    getTableName(): string;
+    /**
+     * Refetch the document data from the database
+     * Useful when the document might have been updated by another application
+     */
+    refetch(): Promise<void>;
+    /**
+     * Check if the document is empty
+     */
+    isEmpty(): boolean;
+}
+export type DocId<Model> = Model & {
+    /**
+     * The document ID (unique identifier). Immutable.
+     */
+    readonly doc_id: string;
+};

package/index.d.ts

@@ -1,2 +1,4 @@
 export { ChainDB, connect } from './features/chain-db';
-export { BasicResponse, Operators, CriteriaAdvanced, Criteria, EventTypes, EventData, EventCallback, } from './features/types';
+export { BasicResponse, Operators, CriteriaAdvanced, Criteria, TableDoc, EventTypes, EventData, EventCallback, } from './features/types';
+export { default as Events } from './features/events';
+export { TableDocImpl } from './features/table-doc';

package/index.js

@@ -1,2 +1,4 @@
 export { ChainDB, connect } from './features/chain-db';
 export { Operators, EventTypes, } from './features/types';
+export { default as Events } from './features/events';
+export { TableDocImpl } from './features/table-doc';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chain-db-ts",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.3",
   "description": "Chain DB Client for Javascript/Typescript Node apps.",
   "main": "./dist/cjs/index.js",
   "module": "./index.js",

package/readme.md

@@ -1,6 +1,6 @@
-# Chain DB TypeScript Client
+# Chain DB TS / JS Client (Node)
 
-A TypeScript client for [Chain DB](https://github.com/wpdas/chain-db), a simple database that maintains a history of changes, allowing you to track how your data evolves over time.
+A TypeScript / JavaScript client for [Chain DB](https://github.com/wpdas/chain-db), a secure database system with built-in history tracking, offering AES-256-GCM encryption, atomic operations with rollback capability, and automatic backups.
 
 ## Installation
 
@@ -52,31 +52,70 @@ interface UserTable {
 
 ```typescript
 // Get a table instance
-// If the table already exists in the chain, its data will be loaded
+// If the table already exists in the chain, its data will be loaded. (data from the last record stored in the table)
 const greetingTable = await db.getTable<GreetingTable>('greeting')
 
-// Access the table data
-console.log(greetingTable.table) // e.g., { greeting: 'Hello' }
+// Access the current document data (the last record stored in the table)
+console.log(greetingTable.currentDoc) // e.g., { greeting: 'Hello' }
 ```
 
 ### Modifying and Persisting Data
 
 ```typescript
-// Modify the table data
-greetingTable.table.greeting = 'Hello, Chain DB!'
+// Modify the current document data
+greetingTable.currentDoc.greeting = 'Hello, Chain DB!'
 
-// Persist changes to database (creates a new record)
-await greetingTable.persist()
+// Persist changes to database (creates a new record with a new doc_id)
+const result = await greetingTable.persist()
+
+// The persist method returns the created document with its doc_id
+console.log(result.doc_id) // e.g., '550e8400-e29b-41d4-a716-446655440000'
+
+// You can also access the current document's ID directly
+const currentDocId = greetingTable.getCurrentDocId()
+console.log(currentDocId) // Same as result.doc_id
 ```
 
-### Updating the Last Item
+### Updating Item
 
 ```typescript
-// Update the last item without creating a new one
-greetingTable.table.greeting = 'Updated greeting'
-await greetingTable.update()
+// To update a specific document, first get it by ID
+const docId = '550e8400-e29b-41d4-a716-446655440000'
+const specificDoc = await greetingTable.getDoc(docId)
+
+// Then update its data
+specificDoc.doc.greeting = 'Updated greeting'
+await specificDoc.update()
 ```
 
+### Getting a Specific Document
+
+```typescript
+// Get a specific document by its ID (assuming we know a document ID)
+// The document ID is generated by ChainDB when data is persisted
+const docId = '550e8400-e29b-41d4-a716-446655440000' // Example ID
+const specificDoc = await greetingTable.getDoc(docId)
+
+// Access the document data
+console.log(specificDoc.doc) // e.g., { greeting: 'Hello from specific doc', doc_id: '550e8400-e29b-41d4-a716-446655440000' }
+
+// The doc_id is also available directly in the document object
+console.log(specificDoc.doc.doc_id) // '550e8400-e29b-41d4-a716-446655440000'
+
+// Update the specific document
+specificDoc.doc.greeting = 'Updated greeting for specific doc'
+await specificDoc.update() // Updates only this specific document
+
+// Refetch the document data if it might have been updated elsewhere
+await specificDoc.refetch()
+console.log(specificDoc.doc) // Updated data from the database
+
+// Get the table name this document belongs to
+const tableName = specificDoc.getTableName() // 'greeting'
+```
+
+Note: The `TableDoc` instance returned by `getDoc()` is a simplified version of a table that only allows updating the specific document. It cannot create new records with `persist()` or perform other table operations.
+
 ### Getting Table History
 
 ```typescript
@@ -214,7 +253,7 @@ async function main() {
 
   // Get the "greeting" table
   const greetingTable = await db.getTable<GreetingTable>('greeting')
-  console.log(greetingTable.table) // e.g., { greeting: 'Hi' }
+  console.log(greetingTable.currentDoc) // e.g., { greeting: 'Hi' }
 
   // Subscribe to table update events
   db.events().subscribe(EventTypes.TABLE_UPDATE, (eventData: EventData) => {
@@ -224,20 +263,42 @@ async function main() {
   })
 
   // Modify and persist data
-  greetingTable.table.greeting = 'Hello my dear!'
-  await greetingTable.persist() // Data is persisted on database
+  greetingTable.currentDoc.greeting = 'Hello my dear!'
+  const persistResult = await greetingTable.persist() // Data is persisted on database
+
+  // Get the doc_id of the newly created document
+  console.log('New document ID:', persistResult.doc_id)
+
+  // You can also get the current document ID directly from the table
+  const currentDocId = greetingTable.getCurrentDocId()
+  console.log('Current document ID:', currentDocId)
 
   // See the updated values
-  console.log(greetingTable.table) // { greeting: 'Hello my dear!' }
+  console.log(greetingTable.currentDoc) // { greeting: 'Hello my dear!', doc_id: '...' }
+
+  // Get a specific document by its ID
+  // We can use the ID we just got from the persist operation
+  const specificDoc = await greetingTable.getDoc(currentDocId)
+
+  // Access the document data and ID
+  console.log(specificDoc.doc) // { greeting: 'Hello my dear!', doc_id: '...' }
+  console.log(specificDoc.doc.doc_id) // Same as currentDocId
+
+  // Update a specific document
+  specificDoc.doc.greeting = 'Updated specific document'
+  await specificDoc.update() // Updates only this specific document
+
+  // Refetch the document to get the latest data
+  await specificDoc.refetch()
+  console.log(specificDoc.doc) // Latest data from the database
 
   // Get the last 100 changes
   const greetingHistory = await greetingTable.getHistory(100)
   console.log(greetingHistory)
   // [
+  //   { greeting: 'Updated specific document' },
   //   { greeting: 'Hello my dear!' },
   //   { greeting: 'Hi' },
-  //   { greeting: 'Ei, sou eu :D' },
-  //   { greeting: 'Heyo' },
   //   ...
   // ]