inibase 1.0.0-rc.60 → 1.0.0-rc.61

package/README.md

@@ -64,44 +64,6 @@ const users = await db.get("user", { favoriteFoods: "![]Pizza,Burger" });
 
 This structure ensures efficient storage, retrieval, and updates, making our system scalable and high-performing for diverse datasets and applications.
 
-## Config (.env)
-
-The `.env` file supports the following parameters
-
-```ini
-# Don't add this line, it's an auto generated secret key, will be using for encrypting the IDs
-INIBASE_SECRET=
-
-INIBASE_COMPRESSION=false
-INIBASE_CACHE=false
-
-# Prepend new items to the beginning of file
-INIBASE_REVERSE=false
-```
-
-## Benchmark
-
-### Bulk
-
-|        | 10              | 100             | 1000            |
-|--------|-----------------|-----------------|-----------------|
-| POST   | 11 ms (0.65 mb) | 19 ms (1.00 mb) | 85 ms (4.58 mb) |
-| GET    | 14 ms (2.77 mb) | 12 ms (3.16 mb) | 34 ms (1.38 mb) |
-| PUT    | 6 ms (1.11 mb)  | 5 ms (1.37 mb)  | 10 ms (1.12 mb) |
-| DELETE | 17 ms (1.68 mb) | 14 ms (5.45 mb) | 25 ms (5.94 mb) |
-
-### Single
-
-|        | 10                | 100                | 1000               |
-|--------|-------------------|--------------------|--------------------|
-| POST   | 43 ms (4.70 mb)   | 387 ms (6.36 mb)   | 5341 ms (24.73 mb) |
-| GET    | 99 ms (12.51 mb)  | 846 ms (30.68 mb)  | 7103 ms (30.86 mb) |
-| PUT    | 33 ms (10.29 mb)  | 312 ms (11.06 mb)  | 3539 ms (14.87 mb) |
-| DELETE | 134 ms (13.50 mb) | 1224 ms (16.57 mb) | 7339 ms (11.46 mb) |
-
-> Testing by default with `user` table, with username, email, password fields _so results include password encryption process_ <br>
-> To run benchmarks, install *typescript* & *tsx* globally and run `benchmark` `benchmark:bulk` `benchmark:single`
-
 ## Inibase CLI
 
 ```shell
@@ -145,48 +107,75 @@ delete <tableName> -w <ID|LineNumber|Criteria>
 ## Examples
 
 <details>
-<summary>Schema</summary>
+<summary>Tables</summary>
 <blockquote>
 
 <details>
-<summary>Create Schema</summary>
+<summary>Config</summary>
 <blockquote>
 
+```ts
+interface {
+  compression: boolean;
+  cache: boolean;
+  prepend: boolean;
+}
+```
+</blockquote>
+</details>
+
 <details>
-<summary>Using schema.json file</summary>
+<summary>Schema</summary>
 <blockquote>
-Inside the table folder
 
-1. Create empty folders `.cache` `.tmp`
-2. Create `schema.json` file
-
-```jsonc
-[
-  {
-    // Give a unique ID number for each field
-    "id": 1,
-    "key": "username",
-    "type": "string"
-  },
-  {
-    "id": 2,
-    "key": "email",
-    "type": "email"
-  },
-]
+```ts
+interface {
+  id: number; // stored as a Number but displayed as a hashed ID
+  key: string;
+  required?: boolean;
+  unique?: boolean;
+  type: "string" | "number" | "boolean" | "date" | "email" | "url" | "password" | "html" | "ip" | "json" | "id";
+}
+interface Table {
+  id: number;
+  key: string;
+  required?: boolean;
+  type: "table";
+  table: string;
+}
+interface Array {
+  id: number;
+  key: string;
+  required?: boolean;
+  type: "array";
+  children: string|string[];
+}
+interface ObjectOrArrayOfObjects {
+  id: number;
+  key: string;
+  required?: boolean;
+  type: "object" | "array";
+  children: Schema;
+}
 ```
 </blockquote>
 </details>
 
 <details>
-<summary>Using built-in function</summary>
+<summary>Create Table</summary>
 <blockquote>
 
 ```js
 import Inibase from "inibase";
 const db = new Inibase("/databaseName");
 
-const userSchema = [
+const userTableConfig = {
+  compression: true,
+  cache: true,
+  prepend: false
+}
+
+const userTableSchema = [
   {
     key: "username",
     type: "string",
@@ -252,14 +241,15 @@ const userSchema = [
   },
 ];
 
-await db.setTableSchema("user", userSchema);
+await db.createTable("user", userTableSchema, userTableConfig);
 ```
 </blockquote>
 </details>
 
-</blockquote>
-</details>
-
+<details>
+<summary>Update Table</summary>
+<blockquote>
+  
 <details>
 <summary>Add field</summary>
 <blockquote>
@@ -268,10 +258,10 @@ await db.setTableSchema("user", userSchema);
 import Inibase from "inibase";
 const db = new Inibase("/databaseName");
 
-const userSchema = await db.getTableSchema("user");
-const newUserSchema = [...userSchema, {key: "phone2", type: "number", required: false}];
+const userTableSchema = (await db.getTable("user")).schema;
+const newUserTableSchema = [...userTableSchema, {key: "phone2", type: "number", required: false}];
 
-await db.setTableSchema("user", newUserSchema);
+await db.updateTable("user", newUserTableSchema);
 ```
 </blockquote>
 </details>
@@ -286,13 +276,33 @@ import { setField } from "inibase/utils";
 
 const db = new Inibase("/databaseName");
 
-const userSchema = await db.getTableSchema("user");
-setField("username", userSchema, {key: "full_name"});
-await db.setTableSchema("user", newUserSchema);
+const userTableSchema = (await db.getTable("user")).schema;
+setField("username", userTableSchema, {key: "fullName"});
+await db.updateTable("user", newUserTableSchema);
 ```
 </blockquote>
 </details>
 
+<details>
+<summary>Remove field</summary>
+<blockquote>
+
+```js
+import Inibase from "inibase";
+import { unsetField } from "inibase/utils";
+
+const db = new Inibase("/databaseName");
+
+const userTableSchema = (await db.getTable("user")).schema;
+unsetField("fullName", userTableSchema);
+await db.updateTable("user", newUserTableSchema);
+```
+</blockquote>
+</details>
+
+</blockquote>
+</details>
+
 <details>
 <summary>Join Tables</summary>
 <blockquote>
@@ -301,7 +311,7 @@ await db.setTableSchema("user", newUserSchema);
 import Inibase from "inibase";
 const db = new Inibase("/databaseName");
 
-const productSchema = [
+const productTableSchema = [
   {
     key: "title",
     type: "string",
@@ -319,9 +329,9 @@ const productSchema = [
   },
 ];
 
-await db.setTableSchema("product", productSchema);
+await db.createTable("product", productTableSchema);
 
-const productData = [
+const productTableData = [
   {
     title: "Product 1",
     price: 16,
@@ -334,7 +344,7 @@ const productData = [
   },
 ];
 
-const product = await db.post("product", productData);
+const product = await db.post("product", productTableData);
 // [
 //   {
 //     "id": "1d88385d4b1581f8fb059334dec30f4c",
@@ -373,7 +383,7 @@ const product = await db.post("product", productData);
 import Inibase from "inibase";
 const db = new Inibase("/databaseName");
 
-const userData = [
+const userTableData = [
   {
     username: "user1",
     email: "user1@example.com",
@@ -408,7 +418,7 @@ const userData = [
   },
 ];
 
-const users = await db.post("user", userData);
+const users = await db.post("user", userTableData);
 // [
 //   {
 //     "id": "1d88385d4b1581f8fb059334dec30f4c",
@@ -664,6 +674,29 @@ await db.sort("user", {age: -1, username: "asc"});
 </blockquote>
 </details>
 
+## Benchmark
+
+### Bulk
+
+|        | 10              | 100             | 1000            |
+|--------|-----------------|-----------------|-----------------|
+| POST   | 11 ms (0.65 mb) | 19 ms (1.00 mb) | 85 ms (4.58 mb) |
+| GET    | 14 ms (2.77 mb) | 12 ms (3.16 mb) | 34 ms (1.38 mb) |
+| PUT    | 6 ms (1.11 mb)  | 5 ms (1.37 mb)  | 10 ms (1.12 mb) |
+| DELETE | 17 ms (1.68 mb) | 14 ms (5.45 mb) | 25 ms (5.94 mb) |
+
+### Single
+
+|        | 10                | 100                | 1000               |
+|--------|-------------------|--------------------|--------------------|
+| POST   | 43 ms (4.70 mb)   | 387 ms (6.36 mb)   | 5341 ms (24.73 mb) |
+| GET    | 99 ms (12.51 mb)  | 846 ms (30.68 mb)  | 7103 ms (30.86 mb) |
+| PUT    | 33 ms (10.29 mb)  | 312 ms (11.06 mb)  | 3539 ms (14.87 mb) |
+| DELETE | 134 ms (13.50 mb) | 1224 ms (16.57 mb) | 7339 ms (11.46 mb) |
+
+> Testing by default with `user` table, with username, email, password fields _so results include password encryption process_ <br>
+> To run benchmarks, install *typescript* & *[tsx](https://github.com/privatenumber/tsx)* globally and run `benchmark` `benchmark:bulk` `benchmark:single`
+
 ## Roadmap
 
 - [x] Actions:
@@ -671,7 +704,7 @@ await db.sort("user", {age: -1, username: "asc"});
     - [x] Pagination
     - [x] Criteria
     - [x] Columns
-    - [x] Sort (using UNIX commands)
+    - [x] Sort
   - [x] POST
   - [x] PUT
   - [x] DELETE

package/dist/file.d.ts

@@ -2,8 +2,8 @@
 import type { ComparisonOperator, FieldType, Schema } from "./index.js";
 export declare const lock: (folderPath: string, prefix?: string) => Promise<void>;
 export declare const unlock: (folderPath: string, prefix?: string) => Promise<void>;
-export declare const write: (filePath: string, data: any, disableCompression?: boolean) => Promise<void>;
-export declare const read: (filePath: string, disableCompression?: boolean) => Promise<string>;
+export declare const write: (filePath: string, data: any) => Promise<void>;
+export declare const read: (filePath: string) => Promise<string>;
 /**
  * Checks if a file or directory exists at the specified path.
  *
@@ -68,7 +68,7 @@ export declare const replace: (filePath: string, replacements: string | number |
  * @returns Promise<string[]>. Modifies the file by appending data.
  *
  */
-export declare const append: (filePath: string, data: string | number | (string | number)[]) => Promise<string[]>;
+export declare const append: (filePath: string, data: string | number | (string | number)[], prepend?: boolean) => Promise<string[]>;
 /**
  * Asynchronously removes specified lines from a file.
  *

package/dist/file.js

@@ -1,13 +1,12 @@
-import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, mkdir, } from "node:fs/promises";
+import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { createGzip, createGunzip, gunzipSync, gzipSync } from "node:zlib";
-import { dirname, join } from "node:path";
-import { detectFieldType, isArrayOfObjects, isJSON, isNumber, isObject, } from "./utils.js";
-import { encodeID, compare, exec } from "./utils.server.js";
-import * as Config from "./config.js";
+import { createGzip, createGunzip } from "node:zlib";
+import { join } from "node:path";
 import Inison from "inison";
+import { detectFieldType, isArrayOfObjects, isJSON, isNumber, isObject, } from "./utils.js";
+import { encodeID, compare, exec, gzip, gunzip } from "./utils.server.js";
 export const lock = async (folderPath, prefix) => {
     let lockFile = null;
     const lockFilePath = join(folderPath, `${prefix ?? ""}.locked`);
@@ -29,17 +28,14 @@ export const unlock = async (folderPath, prefix) => {
     }
     catch { }
 };
-export const write = async (filePath, data, disableCompression = false) => {
-    await mkdir(dirname(filePath), { recursive: true });
-    await writeFile(filePath, Config.isCompressionEnabled && !disableCompression
-        ? gzipSync(String(data))
-        : String(data));
+export const write = async (filePath, data) => {
+    await writeFile(filePath, filePath.endsWith(".gz") ? await gzip(data) : data);
 };
-export const read = async (filePath, disableCompression = false) => Config.isCompressionEnabled && !disableCompression
-    ? gunzipSync(await readFile(filePath)).toString()
-    : (await readFile(filePath)).toString();
-const _pipeline = async (rl, writeStream, transform) => {
-    if (Config.isCompressionEnabled)
+export const read = async (filePath) => filePath.endsWith(".gz")
+    ? (await gunzip(await readFile(filePath, "utf8"))).toString()
+    : await readFile(filePath, "utf8");
+const _pipeline = async (filePath, rl, writeStream, transform) => {
+    if (filePath.endsWith(".gz"))
         await pipeline(rl, transform, createGzip(), writeStream);
     else
         await pipeline(rl, transform, writeStream);
@@ -50,8 +46,8 @@ const _pipeline = async (rl, writeStream, transform) => {
  * @param fileHandle - The file handle from which to create a read stream.
  * @returns A readline.Interface instance configured with the provided file stream.
  */
-const readLineInternface = (fileHandle) => createInterface({
-    input: Config.isCompressionEnabled
+const createReadLineInternface = (filePath, fileHandle) => createInterface({
+    input: filePath.endsWith(".gz")
         ? fileHandle.createReadStream().pipe(createGunzip())
         : fileHandle.createReadStream(),
     crlfDelay: Number.POSITIVE_INFINITY,
@@ -185,7 +181,7 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
     let rl = null;
     try {
         fileHandle = await open(filePath, "r");
-        rl = readLineInternface(fileHandle);
+        rl = createReadLineInternface(filePath, fileHandle);
         const lines = {};
         let linesCount = 0;
         if (!lineNumbers) {
@@ -194,17 +190,17 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
                 lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
             }
         }
-        else if (lineNumbers === -1) {
-            let lastLine = null;
-            for await (const line of rl) {
-                linesCount++;
-                lastLine = line;
-            }
-            if (lastLine)
-                lines[linesCount] = decode(lastLine, fieldType, fieldChildrenType, secretKey);
+        else if (lineNumbers == -1) {
+            const command = filePath.endsWith(".gz")
+                ? `zcat ${filePath} | sed -n '$p'`
+                : `sed -n '$p' ${filePath}`, foundedLine = (await exec(command)).stdout.trim();
+            if (foundedLine)
+                lines[linesCount] = decode(foundedLine, fieldType, fieldChildrenType, secretKey);
         }
         else {
             lineNumbers = Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers];
+            if (lineNumbers.some(Number.isNaN))
+                throw new Error("UNVALID_LINE_NUMBERS");
             if (readWholeFile) {
                 const lineNumbersArray = new Set(lineNumbers);
                 for await (const line of rl) {
@@ -216,9 +212,9 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
                 }
                 return [lines, linesCount];
             }
-            const command = Config.isCompressionEnabled
+            const command = filePath.endsWith(".gz")
                 ? `zcat ${filePath} | sed -n '${lineNumbers.join("p;")}p'`
-                : `sed -n '${lineNumbers.join("p;")}p' ${filePath}`, foundedLines = (await exec(command)).stdout.trim().split(/\r?\n/);
+                : `sed -n '${lineNumbers.join("p;")}p' ${filePath}`, foundedLines = (await exec(command)).stdout.trim().split("\n");
             let index = 0;
             for (const line of foundedLines) {
                 lines[lineNumbers[index]] = decode(line, fieldType, fieldChildrenType, secretKey);
@@ -253,8 +249,8 @@ export const replace = async (filePath, replacements) => {
             let linesCount = 0;
             fileHandle = await open(filePath, "r");
             fileTempHandle = await open(fileTempPath, "w");
-            rl = readLineInternface(fileHandle);
-            await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+            rl = createReadLineInternface(filePath, fileHandle);
+            await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
                 transform(line, encoding, callback) {
                     linesCount++;
                     const replacement = isObject(replacements)
@@ -297,10 +293,10 @@ export const replace = async (filePath, replacements) => {
  * @returns Promise<string[]>. Modifies the file by appending data.
  *
  */
-export const append = async (filePath, data) => {
+export const append = async (filePath, data, prepend) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
     if (await isExists(filePath)) {
-        if (!Config.isReverseEnabled && !Config.isCompressionEnabled) {
+        if (!prepend && !filePath.endsWith(".gz")) {
             await copyFile(filePath, fileTempPath);
             await appendFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
         }
@@ -311,9 +307,9 @@ export const append = async (filePath, data) => {
             try {
                 fileHandle = await open(filePath, "r");
                 fileTempHandle = await open(fileTempPath, "w");
-                rl = readLineInternface(fileHandle);
+                rl = createReadLineInternface(filePath, fileHandle);
                 let isAppended = false;
-                await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+                await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
                     transform(line, _, callback) {
                         if (!isAppended) {
                             isAppended = true;
@@ -332,7 +328,7 @@ export const append = async (filePath, data) => {
         }
     }
     else
-        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`, undefined);
+        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
     return [fileTempPath, filePath];
 };
 /**
@@ -348,9 +344,11 @@ export const remove = async (filePath, linesToDelete) => {
     linesToDelete = Array.isArray(linesToDelete)
         ? linesToDelete.map(Number)
         : [Number(linesToDelete)];
+    if (linesToDelete.some(Number.isNaN))
+        throw new Error("UNVALID_LINE_NUMBERS");
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
     if (linesToDelete.length < 1000) {
-        const command = Config.isCompressionEnabled
+        const command = filePath.endsWith(".gz")
             ? `zcat ${filePath} | sed "${linesToDelete.join("d;")}d" | gzip > ${fileTempPath}`
             : `sed "${linesToDelete.join("d;")}d" ${filePath} > ${fileTempPath}`;
         await exec(command);
@@ -361,8 +359,8 @@ export const remove = async (filePath, linesToDelete) => {
         const fileHandle = await open(filePath, "r");
         const fileTempHandle = await open(fileTempPath, "w");
         const linesToDeleteArray = new Set(linesToDelete);
-        const rl = readLineInternface(fileHandle);
-        await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+        const rl = createReadLineInternface(filePath, fileHandle);
+        await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
             transform(line, _, callback) {
                 linesCount++;
                 if (linesToDeleteArray.has(linesCount)) {
@@ -414,7 +412,7 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
         // Open the file for reading.
         fileHandle = await open(filePath, "r");
         // Create a Readline interface to read the file line by line.
-        rl = readLineInternface(fileHandle);
+        rl = createReadLineInternface(filePath, fileHandle);
         // Iterate through each line in the file.
         for await (const line of rl) {
             // Increment the line count for each line.
@@ -474,7 +472,7 @@ export const count = async (filePath) => {
         let rl = null;
         try {
             fileHandle = await open(filePath, "r");
-            rl = readLineInternface(fileHandle);
+            rl = createReadLineInternface(filePath, fileHandle);
             for await (const _ of rl)
                 linesCount++;
         }
@@ -497,7 +495,7 @@ export const count = async (filePath) => {
 export const sum = async (filePath, lineNumbers) => {
     let sum = 0;
     const fileHandle = await open(filePath, "r");
-    const rl = readLineInternface(fileHandle);
+    const rl = createReadLineInternface(filePath, fileHandle);
     if (lineNumbers) {
         let linesCount = 0;
         const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
@@ -529,7 +527,7 @@ export const sum = async (filePath, lineNumbers) => {
 export const max = async (filePath, lineNumbers) => {
     let max = 0;
     const fileHandle = await open(filePath, "r");
-    const rl = readLineInternface(fileHandle);
+    const rl = createReadLineInternface(filePath, fileHandle);
     if (lineNumbers) {
         let linesCount = 0;
         const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
@@ -566,7 +564,7 @@ export const max = async (filePath, lineNumbers) => {
 export const min = async (filePath, lineNumbers) => {
     let min = 0;
     const fileHandle = await open(filePath, "r");
-    const rl = readLineInternface(fileHandle);
+    const rl = createReadLineInternface(filePath, fileHandle);
     if (lineNumbers) {
         let linesCount = 0;
         const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);

package/dist/index.d.ts

@@ -23,6 +23,15 @@ export interface Options {
     columns?: string[] | string;
     order?: Record<string, "asc" | "desc">;
 }
+export interface Config {
+    compression: boolean;
+    cache: boolean;
+    prepend: boolean;
+}
+export interface TableObject {
+    schema?: Schema;
+    config: Config;
+}
 export type ComparisonOperator = "=" | "!=" | ">" | "<" | ">=" | "<=" | "*" | "!*" | "[]" | "![]";
 type pageInfo = {
     total?: number;
@@ -41,24 +50,25 @@ declare global {
         entries<T extends object>(o: T): Entries<T>;
     }
 }
-export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "NO_RESULTS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV";
+export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "NO_RESULTS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS";
 export type ErrorLang = "en";
 export default class Inibase {
-    folder: string;
-    database: string;
-    table: string | null;
     pageInfo: Record<string, pageInfo>;
+    salt: Buffer;
+    private databasePath;
+    private tables;
     private fileExtension;
     private checkIFunique;
     private totalItems;
-    salt: Buffer;
-    constructor(database: string, mainFolder?: string, _table?: string | null, _totalItems?: Record<string, number>, _pageInfo?: Record<string, pageInfo>, _isThreadEnabled?: boolean);
+    constructor(database: string, mainFolder?: string);
     private throwError;
     private getFileExtension;
     private _schemaToIdsPath;
-    setTableSchema(tableName: string, schema: Schema): Promise<void>;
+    createTable(tableName: string, schema?: Schema, config?: Config): Promise<void>;
+    updateTable(tableName: string, schema?: Schema, config?: Config): Promise<void>;
+    getTable(tableName: string): Promise<TableObject>;
     getTableSchema(tableName: string, encodeIDs?: boolean): Promise<Schema | undefined>;
-    private getSchemaWhenTableNotEmpty;
+    private throwErrorIfTableEmpty;
     private validateData;
     private formatField;
     private checkUnique;
@@ -66,15 +76,14 @@ export default class Inibase {
     private getDefaultValue;
     private _combineObjectsToArray;
     private _CombineData;
-    private _addPathToKeys;
     private joinPathesContents;
     private _getItemsFromSchemaHelper;
     private getItemsFromSchema;
     private applyCriteria;
     private _filterSchemaByColumns;
     clearCache(tablePath: string): Promise<void>;
-    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: true, onlyLinesNumbers?: undefined, tableSchema?: Schema, skipIdColumn?: boolean): Promise<Data | null>;
-    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: boolean | undefined, onlyLinesNumbers?: true, tableSchema?: Schema, skipIdColumn?: boolean): Promise<number[]>;
+    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: true, onlyLinesNumbers?: undefined, _skipIdColumn?: boolean): Promise<Data | null>;
+    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: boolean | undefined, onlyLinesNumbers?: true, _skipIdColumn?: boolean): Promise<number[]>;
     post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: boolean): Promise<void>;
     post(tableName: string, data: Data, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
     post(tableName: string, data: Data[], options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;