diff --git a/packages/nc-gui/components/smartsheet/Pagination.vue b/packages/nc-gui/components/smartsheet/Pagination.vue
index 7cc08d7d3e..4bd45cd171 100644
--- a/packages/nc-gui/components/smartsheet/Pagination.vue
+++ b/packages/nc-gui/components/smartsheet/Pagination.vue
@@ -2,9 +2,11 @@
 import { ChangePageInj, PaginationDataInj, computed, iconMap, inject, isRtlLang, useI18n } from '#imports'
 import type { Language } from '~/lib'
 
-const props = defineProps<{
+interface Props {
   alignCountOnRight?: boolean
-}>()
+}
+
+const { alignCountOnRight } = defineProps<Props>()
 
 const { locale } = useI18n()
 
diff --git a/packages/nc-gui/components/smartsheet/header/Icon.vue b/packages/nc-gui/components/smartsheet/header/Icon.vue
index ff56b943ea..159ef471b0 100644
--- a/packages/nc-gui/components/smartsheet/header/Icon.vue
+++ b/packages/nc-gui/components/smartsheet/header/Icon.vue
@@ -1,8 +1,8 @@
 <script lang="ts" setup>
-import { ColumnType, isVirtualCol } from 'nocodb-sdk'
+import type { ColumnType } from 'nocodb-sdk'
+import { isVirtualCol } from 'nocodb-sdk'
 
 const { column } = defineProps<{ column: ColumnType }>()
-
 </script>
 
 <template>
diff --git a/packages/nc-gui/components/tabs/Smartsheet.vue b/packages/nc-gui/components/tabs/Smartsheet.vue
index 50166d2e2c..a9a61a2958 100644
--- a/packages/nc-gui/components/tabs/Smartsheet.vue
+++ b/packages/nc-gui/components/tabs/Smartsheet.vue
@@ -72,7 +72,7 @@ const onDrop = async (event: DragEvent) => {
   event.preventDefault()
   try {
     // Access the dropped data
-    const data = JSON.parse(event.dataTransfer?.getData('text/json')!)
+    const data = JSON.parse(event.dataTransfer!.getData('text/json'))
     // Do something with the received data
 
     // if dragged item is not from the same base, return
diff --git a/packages/nc-gui/components/virtual-cell/components/ItemChip.vue b/packages/nc-gui/components/virtual-cell/components/ItemChip.vue
index 13ada13c8c..025b4521e9 100644
--- a/packages/nc-gui/components/virtual-cell/components/ItemChip.vue
+++ b/packages/nc-gui/components/virtual-cell/components/ItemChip.vue
@@ -9,7 +9,6 @@ import {
   inject,
   isAttachment,
   ref,
-  renderValue,
   useExpandedFormDetached,
   useLTARStoreOrThrow,
 } from '#imports'
diff --git a/packages/nc-gui/components/virtual-cell/components/ListChildItems.vue b/packages/nc-gui/components/virtual-cell/components/ListChildItems.vue
index da00e1b780..db6e4a7ef3 100644
--- a/packages/nc-gui/components/virtual-cell/components/ListChildItems.vue
+++ b/packages/nc-gui/components/virtual-cell/components/ListChildItems.vue
@@ -13,7 +13,6 @@ import {
   iconMap,
   inject,
   ref,
-  renderValue,
   useLTARStoreOrThrow,
   useSmartsheetRowStoreOrThrow,
   useVModel,
diff --git a/packages/nc-gui/components/virtual-cell/components/ListItems.vue b/packages/nc-gui/components/virtual-cell/components/ListItems.vue
index 30a9589c78..dd9a4a2e90 100644
--- a/packages/nc-gui/components/virtual-cell/components/ListItems.vue
+++ b/packages/nc-gui/components/virtual-cell/components/ListItems.vue
@@ -12,7 +12,6 @@ import {
   inject,
   isDrawerExist,
   ref,
-  renderValue,
   useLTARStoreOrThrow,
   useSelectedCellKeyupListener,
   useSmartsheetRowStoreOrThrow,
diff --git a/packages/nc-gui/composables/useMultiSelect/index.ts b/packages/nc-gui/composables/useMultiSelect/index.ts
index 39a717737c..f48204ffd7 100644
--- a/packages/nc-gui/composables/useMultiSelect/index.ts
+++ b/packages/nc-gui/composables/useMultiSelect/index.ts
@@ -26,7 +26,6 @@ import {
   useI18n,
   useMetas,
   useProject,
-  useUIPermission,
 } from '#imports'
 
 const MAIN_MOUSE_PRESSED = 0
@@ -80,9 +79,6 @@ export function useMultiSelect(
     () => !(activeCell.row === null || activeCell.col === null || isNaN(activeCell.row) || isNaN(activeCell.col)),
   )
 
-  const { isUIAllowed } = useUIPermission()
-  const hasEditPermission = $computed(() => isUIAllowed('xcDatatableEditable'))
-
   function makeActive(row: number, col: number) {
     if (activeCell.row === row && activeCell.col === col) {
       return
diff --git a/packages/nc-gui/package-lock.json b/packages/nc-gui/package-lock.json
index 7ccbf09e52..dc0198bb4f 100644
--- a/packages/nc-gui/package-lock.json
+++ b/packages/nc-gui/package-lock.json
@@ -110,7 +110,7 @@
       }
     },
     "../nocodb-sdk": {
-      "version": "0.109.5",
+      "version": "0.109.6",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "axios": "^0.21.1",
diff --git a/packages/nc-lib-gui/package.json b/packages/nc-lib-gui/package.json
index ca7291370c..bc6b9e6e18 100644
--- a/packages/nc-lib-gui/package.json
+++ b/packages/nc-lib-gui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "nc-lib-gui",
-  "version": "0.109.5",
+  "version": "0.109.6",
   "description": "NocoDB GUI",
   "author": {
     "name": "NocoDB",
diff --git a/packages/nocodb-sdk/package-lock.json b/packages/nocodb-sdk/package-lock.json
index dda8da70f5..c647526d52 100644
--- a/packages/nocodb-sdk/package-lock.json
+++ b/packages/nocodb-sdk/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "nocodb-sdk",
-  "version": "0.109.5",
+  "version": "0.109.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "nocodb-sdk",
-      "version": "0.109.5",
+      "version": "0.109.6",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "axios": "^0.21.1",
diff --git a/packages/nocodb-sdk/package.json b/packages/nocodb-sdk/package.json
index 2fc6ecc0a5..ce941f5c5e 100644
--- a/packages/nocodb-sdk/package.json
+++ b/packages/nocodb-sdk/package.json
@@ -1,6 +1,6 @@
 {
   "name": "nocodb-sdk",
-  "version": "0.109.5",
+  "version": "0.109.6",
   "description": "NocoDB SDK",
   "main": "build/main/index.js",
   "typings": "build/main/index.d.ts",
diff --git a/packages/nocodb/package-lock.json b/packages/nocodb/package-lock.json
index b8da539dec..6774504e4d 100644
--- a/packages/nocodb/package-lock.json
+++ b/packages/nocodb/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "nocodb",
-  "version": "0.109.5",
+  "version": "0.109.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "nocodb",
-      "version": "0.109.5",
+      "version": "0.109.6",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "@google-cloud/storage": "^5.7.2",
@@ -80,7 +80,7 @@
         "mysql2": "^3.2.0",
         "nanoid": "^3.1.20",
         "nc-help": "^0.2.87",
-        "nc-lib-gui": "0.109.5",
+        "nc-lib-gui": "0.109.6",
         "nc-plugin": "^0.1.3",
         "ncp": "^2.0.0",
         "nocodb-sdk": "file:../nocodb-sdk",
@@ -191,7 +191,7 @@
       }
     },
     "../nocodb-sdk": {
-      "version": "0.109.5",
+      "version": "0.109.6",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "axios": "^0.21.1",
@@ -13158,9 +13158,9 @@
       }
     },
     "node_modules/nc-lib-gui": {
-      "version": "0.109.5",
-      "resolved": "https://registry.npmjs.org/nc-lib-gui/-/nc-lib-gui-0.109.5.tgz",
-      "integrity": "sha512-A6za8yFO167OVd2MnGrzEFAOQ5Nx9UJ5zpk1iH7FC427TEHJOAbvlOYMVa3s7Pb8wjYKhZ5Mr4sBldtY0cKaHA==",
+      "version": "0.109.6",
+      "resolved": "https://registry.npmjs.org/nc-lib-gui/-/nc-lib-gui-0.109.6.tgz",
+      "integrity": "sha512-HX0JuimDTgpliJowNDctjHGvsbkO8SZ1dq/i+WEIce1nlgxdBrOM+/79UlGMaeLWMb3RuU7zNLxpxYvvdoFs4w==",
       "dependencies": {
         "express": "^4.17.1"
       }
@@ -28474,9 +28474,9 @@
       }
     },
     "nc-lib-gui": {
-      "version": "0.109.5",
-      "resolved": "https://registry.npmjs.org/nc-lib-gui/-/nc-lib-gui-0.109.5.tgz",
-      "integrity": "sha512-A6za8yFO167OVd2MnGrzEFAOQ5Nx9UJ5zpk1iH7FC427TEHJOAbvlOYMVa3s7Pb8wjYKhZ5Mr4sBldtY0cKaHA==",
+      "version": "0.109.6",
+      "resolved": "https://registry.npmjs.org/nc-lib-gui/-/nc-lib-gui-0.109.6.tgz",
+      "integrity": "sha512-HX0JuimDTgpliJowNDctjHGvsbkO8SZ1dq/i+WEIce1nlgxdBrOM+/79UlGMaeLWMb3RuU7zNLxpxYvvdoFs4w==",
       "requires": {
         "express": "^4.17.1"
       }
diff --git a/packages/nocodb/package.json b/packages/nocodb/package.json
index 2a1c30f8ca..51e37a6a4e 100644
--- a/packages/nocodb/package.json
+++ b/packages/nocodb/package.json
@@ -1,6 +1,6 @@
 {
   "name": "nocodb",
-  "version": "0.109.5",
+  "version": "0.109.6",
   "description": "NocoDB Backend",
   "main": "dist/bundle.js",
   "author": {
@@ -113,7 +113,7 @@
     "mysql2": "^3.2.0",
     "nanoid": "^3.1.20",
     "nc-help": "^0.2.87",
-    "nc-lib-gui": "0.109.5",
+    "nc-lib-gui": "0.109.6",
     "nc-plugin": "^0.1.3",
     "ncp": "^2.0.0",
     "nocodb-sdk": "file:../nocodb-sdk",
diff --git a/packages/nocodb/src/app.module.ts b/packages/nocodb/src/app.module.ts
index 9bc91efdc0..75ff9f6649 100644
--- a/packages/nocodb/src/app.module.ts
+++ b/packages/nocodb/src/app.module.ts
@@ -29,7 +29,6 @@ import type { MiddlewareConsumer } from '@nestjs/common';
     JobsModule,
     NestJsEventEmitter.forRoot(),
   ],
-  controllers: [],
   providers: [
     AuthService,
     {
diff --git a/packages/nocodb/src/controllers/data-table.controller.spec.ts b/packages/nocodb/src/controllers/data-table.controller.spec.ts
new file mode 100644
index 0000000000..cb22816371
--- /dev/null
+++ b/packages/nocodb/src/controllers/data-table.controller.spec.ts
@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DataTableController } from './data-table.controller';
+
+describe('DataTableController', () => {
+  let controller: DataTableController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [DataTableController],
+    }).compile();
+
+    controller = module.get<DataTableController>(DataTableController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});
diff --git a/packages/nocodb/src/controllers/data-table.controller.ts b/packages/nocodb/src/controllers/data-table.controller.ts
new file mode 100644
index 0000000000..5d6b6ec573
--- /dev/null
+++ b/packages/nocodb/src/controllers/data-table.controller.ts
@@ -0,0 +1,189 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  Param,
+  Patch,
+  Post,
+  Query,
+  Request,
+  Response,
+  UseGuards,
+} from '@nestjs/common';
+import { GlobalGuard } from '../guards/global/global.guard';
+import { parseHrtimeToSeconds } from '../helpers';
+import {
+  Acl,
+  ExtractProjectIdMiddleware,
+} from '../middlewares/extract-project-id/extract-project-id.middleware';
+import { DataTableService } from '../services/data-table.service';
+
+@Controller()
+@UseGuards(ExtractProjectIdMiddleware, GlobalGuard)
+export class DataTableController {
+  constructor(private readonly dataTableService: DataTableService) {}
+
+  // todo: Handle the error case where view doesnt belong to model
+  @Get('/api/v1/tables/:modelId/rows')
+  @Acl('dataList')
+  async dataList(
+    @Request() req,
+    @Response() res,
+    @Param('modelId') modelId: string,
+    @Query('viewId') viewId: string,
+  ) {
+    const startTime = process.hrtime();
+    const responseData = await this.dataTableService.dataList({
+      query: req.query,
+      modelId: modelId,
+      viewId: viewId,
+    });
+    const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(startTime));
+    res.setHeader('xc-db-response', elapsedSeconds);
+    res.json(responseData);
+  }
+
+  @Get(['/api/v1/tables/:modelId/rows/count'])
+  @Acl('dataCount')
+  async dataCount(
+    @Request() req,
+    @Response() res,
+    @Param('modelId') modelId: string,
+    @Query('viewId') viewId: string,
+  ) {
+    const countResult = await this.dataTableService.dataCount({
+      query: req.query,
+      modelId,
+      viewId,
+    });
+
+    res.json(countResult);
+  }
+
+  @Post(['/api/v1/tables/:modelId/rows'])
+  @HttpCode(200)
+  @Acl('dataInsert')
+  async dataInsert(
+    @Request() req,
+    @Param('modelId') modelId: string,
+    @Query('viewId') viewId: string,
+    @Body() body: any,
+  ) {
+    return await this.dataTableService.dataInsert({
+      modelId: modelId,
+      body: body,
+      viewId,
+      cookie: req,
+    });
+  }
+
+  @Patch(['/api/v1/tables/:modelId/rows'])
+  @Acl('dataUpdate')
+  async dataUpdate(
+    @Request() req,
+    @Param('modelId') modelId: string,
+    @Query('viewId') viewId: string,
+    @Param('rowId') rowId: string,
+  ) {
+    return await this.dataTableService.dataUpdate({
+      modelId: modelId,
+      body: req.body,
+      cookie: req,
+      viewId,
+    });
+  }
+
+  @Delete(['/api/v1/tables/:modelId/rows'])
+  @Acl('dataDelete')
+  async dataDelete(
+    @Request() req,
+    @Param('modelId') modelId: string,
+    @Query('viewId') viewId: string,
+    @Param('rowId') rowId: string,
+  ) {
+    return await this.dataTableService.dataDelete({
+      modelId: modelId,
+      cookie: req,
+      viewId,
+      body: req.body,
+    });
+  }
+
+  @Get(['/api/v1/tables/:modelId/rows/:rowId'])
+  @Acl('dataRead')
+  async dataRead(
+    @Request() req,
+    @Param('modelId') modelId: string,
+    @Query('viewId') viewId: string,
+    @Param('rowId') rowId: string,
+  ) {
+    return await this.dataTableService.dataRead({
+      modelId,
+      rowId: rowId,
+      query: req.query,
+      viewId,
+    });
+  }
+
+  @Get(['/api/v1/tables/:modelId/links/:columnId/rows/:rowId'])
+  @Acl('nestedDataList')
+  async nestedDataList(
+    @Request() req,
+    @Param('modelId') modelId: string,
+    @Query('viewId') viewId: string,
+    @Param('columnId') columnId: string,
+    @Param('rowId') rowId: string,
+  ) {
+    return await this.dataTableService.nestedDataList({
+      modelId,
+      rowId: rowId,
+      query: req.query,
+      viewId,
+      columnId,
+    });
+  }
+
+  @Post(['/api/v1/tables/:modelId/links/:columnId/rows/:rowId'])
+  @Acl('nestedDataLink')
+  async nestedLink(
+    @Request() req,
+    @Param('modelId') modelId: string,
+    @Query('viewId') viewId: string,
+    @Param('columnId') columnId: string,
+    @Param('rowId') rowId: string,
+    @Body() refRowIds: string | string[] | number | number[],
+  ) {
+    return await this.dataTableService.nestedLink({
+      modelId,
+      rowId: rowId,
+      query: req.query,
+      viewId,
+      columnId,
+      refRowIds,
+      cookie: req,
+    });
+  }
+
+  @Delete(['/api/v1/tables/:modelId/links/:columnId/rows/:rowId'])
+  @Acl('nestedDataUnlink')
+  async nestedUnlink(
+    @Request() req,
+    @Param('modelId') modelId: string,
+    @Query('viewId') viewId: string,
+    @Param('columnId') columnId: string,
+    @Param('rowId') rowId: string,
+    @Body() refRowIds: string | string[] | number | number[],
+  ) {
+    return await this.dataTableService.nestedUnlink({
+      modelId,
+      rowId: rowId,
+      query: req.query,
+      viewId,
+      columnId,
+      refRowIds,
+      cookie: req,
+    });
+  }
+}
diff --git a/packages/nocodb/src/controllers/test/TestResetService/index.ts b/packages/nocodb/src/controllers/test/TestResetService/index.ts
index ddf1d8d108..6b7e0d7df8 100644
--- a/packages/nocodb/src/controllers/test/TestResetService/index.ts
+++ b/packages/nocodb/src/controllers/test/TestResetService/index.ts
@@ -1,6 +1,6 @@
 import axios from 'axios';
 import Project from '../../../models/Project';
-import NcConnectionMgrv2 from '../../../utils/common/NcConnectionMgrv2';
+// import NcConnectionMgrv2 from '../../../utils/common/NcConnectionMgrv2';
 import Noco from '../../../Noco';
 import User from '../../../models/User';
 import NocoCache from '../../../cache/NocoCache';
diff --git a/packages/nocodb/src/db/BaseModelSqlv2.ts b/packages/nocodb/src/db/BaseModelSqlv2.ts
index 81856cd50f..be00605a3d 100644
--- a/packages/nocodb/src/db/BaseModelSqlv2.ts
+++ b/packages/nocodb/src/db/BaseModelSqlv2.ts
@@ -18,6 +18,7 @@ import { customAlphabet } from 'nanoid';
 import DOMPurify from 'isomorphic-dompurify';
 import { v4 as uuidv4 } from 'uuid';
 import { Knex } from 'knex';
+import { extractLimitAndOffset } from '../helpers';
 import { NcError } from '../helpers/catchError';
 import getAst from '../helpers/getAst';
 import {
@@ -43,6 +44,7 @@ import genRollupSelectv2 from './genRollupSelectv2';
 import conditionV2 from './conditionV2';
 import sortV2 from './sortV2';
 import { customValidators } from './util/customValidators';
+import Transaction = Knex.Transaction;
 import type { XKnex } from './CustomKnex';
 import type {
   XcFilter,
@@ -58,7 +60,6 @@ import type {
   SelectOption,
 } from '../models';
 import type { SortType } from 'nocodb-sdk';
-import Transaction = Knex.Transaction;
 
 dayjs.extend(utc);
 dayjs.extend(timezone);
@@ -1511,20 +1512,12 @@ class BaseModelSqlv2 {
   }
 
   _getListArgs(args: XcFilterWithAlias): XcFilter {
-    const obj: XcFilter = {};
-    obj.where = args.where || args.w || '';
+    const obj: XcFilter = extractLimitAndOffset(args);
+    obj.where = args.filter || args.where || args.w || '';
     obj.having = args.having || args.h || '';
     obj.shuffle = args.shuffle || args.r || '';
     obj.condition = args.condition || args.c || {};
     obj.conditionGraph = args.conditionGraph || {};
-    obj.limit = Math.max(
-      Math.min(
-        args.limit || args.l || this.config.limitDefault,
-        this.config.limitMax,
-      ),
-      this.config.limitMin,
-    );
-    obj.offset = Math.max(+(args.offset || args.o) || 0, 0);
     obj.fields = args.fields || args.f;
     obj.sort = args.sort || args.s;
     return obj;
@@ -2244,12 +2237,14 @@ class BaseModelSqlv2 {
       foreign_key_checks = true,
       skip_hooks = false,
       raw = false,
+      insertOneByOneAsFallback = false,
     }: {
       chunkSize?: number;
       cookie?: any;
       foreign_key_checks?: boolean;
       skip_hooks?: boolean;
       raw?: boolean;
+      insertOneByOneAsFallback?: boolean;
     } = {},
   ) {
     let trx;
@@ -2403,12 +2398,28 @@ class BaseModelSqlv2 {
         }
       }
 
-      const response =
-        this.isPg || this.isMssql
-          ? await trx
-              .batchInsert(this.tnPath, insertDatas, chunkSize)
-              .returning(this.model.primaryKey?.column_name)
-          : await trx.batchInsert(this.tnPath, insertDatas, chunkSize);
+      let response;
+
+      // insert one by one as fallback to get ids for sqlite and mysql
+      if (insertOneByOneAsFallback && (this.isSqlite || this.isMySQL)) {
+        // sqlite and mysql doesnt support returning, so insert one by one and return ids
+        response = [];
+
+        const aiPkCol = this.model.primaryKeys.find((pk) => pk.ai);
+
+        for (const insertData of insertDatas) {
+          const query = trx(this.tnPath).insert(insertData);
+          const id = (await query)[0];
+          response.push(aiPkCol ? { [aiPkCol.title]: id } : id);
+        }
+      } else {
+        response =
+          this.isPg || this.isMssql
+            ? await trx
+                .batchInsert(this.tnPath, insertDatas, chunkSize)
+                .returning(this.model.primaryKey?.column_name)
+            : await trx.batchInsert(this.tnPath, insertDatas, chunkSize);
+      }
 
       if (!foreign_key_checks) {
         if (this.isPg) {
@@ -2433,7 +2444,11 @@ class BaseModelSqlv2 {
 
   async bulkUpdate(
     datas: any[],
-    { cookie, raw = false }: { cookie?: any; raw?: boolean } = {},
+    {
+      cookie,
+      raw = false,
+      throwExceptionIfNotExist = false,
+    }: { cookie?: any; raw?: boolean; throwExceptionIfNotExist?: boolean } = {},
   ) {
     let transaction;
     try {
@@ -2476,9 +2491,12 @@ class BaseModelSqlv2 {
 
       if (!raw) {
         for (const pkValues of updatePkValues) {
-          newData.push(
-            await this.readByPk(pkValues, false, {}, { ignoreView: true }),
-          );
+          const oldRecord = await this.readByPk(pkValues);
+          if (!oldRecord && throwExceptionIfNotExist)
+            NcError.unprocessableEntity(
+              `Record with pk ${JSON.stringify(pkValues)} not found`,
+            );
+          newData.push(oldRecord);
         }
       }
 
@@ -2553,7 +2571,13 @@ class BaseModelSqlv2 {
     }
   }
 
-  async bulkDelete(ids: any[], { cookie }: { cookie?: any } = {}) {
+  async bulkDelete(
+    ids: any[],
+    {
+      cookie,
+      throwExceptionIfNotExist = false,
+    }: { cookie?: any; throwExceptionIfNotExist?: boolean } = {},
+  ) {
     let transaction;
     try {
       const deleteIds = await Promise.all(
@@ -2570,9 +2594,14 @@ class BaseModelSqlv2 {
           // pk not specified - bypass
           continue;
         }
-        deleted.push(
-          await this.readByPk(pkValues, false, {}, { ignoreView: true }),
-        );
+
+        const oldRecord = await this.readByPk(pkValues);
+        if (!oldRecord && throwExceptionIfNotExist)
+          NcError.unprocessableEntity(
+            `Record with pk ${JSON.stringify(pkValues)} not found`,
+          );
+        deleted.push(oldRecord);
+
         res.push(d);
       }
 
@@ -2635,12 +2664,6 @@ class BaseModelSqlv2 {
 
       transaction = await this.dbDriver.transaction();
 
-      if (base.is_meta && execQueries.length > 0) {
-        for (const execQuery of execQueries) {
-          await execQuery(transaction, idsVals);
-        }
-      }
-
       for (const d of res) {
         await transaction(this.tnPath).del().where(d);
       }
@@ -2685,8 +2708,8 @@ class BaseModelSqlv2 {
         qb,
         this.dbDriver,
       );
-
       const execQueries: ((trx: Transaction, qb: any) => Promise<any>)[] = [];
+      // qb.del();
 
       for (const column of this.model.columns) {
         if (column.uidt !== UITypes.LinkToAnotherRecord) continue;
@@ -2706,18 +2729,16 @@ class BaseModelSqlv2 {
         await parentTable.getColumns();
 
         const childTn = this.getTnPath(childTable);
-        const parentTn = this.getTnPath(parentTable);
 
         switch (colOptions.type) {
           case 'mm':
             {
               const vChildCol = await colOptions.getMMChildColumn();
-              const vParentCol = await colOptions.getMMParentColumn();
               const vTable = await colOptions.getMMModel();
 
               const vTn = this.getTnPath(vTable);
 
-              execQueries.push((trx, qb) =>
+              execQueries.push(() =>
                 this.dbDriver(vTn)
                   .where({
                     [vChildCol.column_name]: this.dbDriver(childTn)
@@ -2781,7 +2802,6 @@ class BaseModelSqlv2 {
 
       return count;
     } catch (e) {
-      if (trx) await trx.rollback();
       throw e;
     }
   }
@@ -2977,104 +2997,12 @@ class BaseModelSqlv2 {
       modelId: this.model.id,
       tnPath: this.tnPath,
     });
-
-    /*
-    const view = await View.get(this.viewId);
-
-    // handle form view data submission
-    if (
-      (hookName === 'after.insert' || hookName === 'after.bulkInsert') &&
-      view.type === ViewTypes.FORM
-    ) {
-      try {
-        const formView = await view.getView<FormView>();
-        const { columns } = await FormView.getWithInfo(formView.fk_view_id);
-        const allColumns = await this.model.getColumns();
-        const fieldById = columns.reduce(
-          (o: Record<string, any>, f: Record<string, any>) => ({
-            ...o,
-            [f.fk_column_id]: f,
-          }),
-          {},
-        );
-        let order = 1;
-        const filteredColumns = allColumns
-          ?.map((c: Record<string, any>) => ({
-            ...c,
-            fk_column_id: c.id,
-            fk_view_id: formView.fk_view_id,
-            ...(fieldById[c.id] ? fieldById[c.id] : {}),
-            order: (fieldById[c.id] && fieldById[c.id].order) || order++,
-            id: fieldById[c.id] && fieldById[c.id].id,
-          }))
-          .sort(
-            (a: Record<string, any>, b: Record<string, any>) =>
-              a.order - b.order,
-          )
-          .filter(
-            (f: Record<string, any>) =>
-              f.show &&
-              f.uidt !== UITypes.Rollup &&
-              f.uidt !== UITypes.Lookup &&
-              f.uidt !== UITypes.Formula &&
-              f.uidt !== UITypes.QrCode &&
-              f.uidt !== UITypes.Barcode &&
-              f.uidt !== UITypes.SpecificDBType,
-          )
-          .sort(
-            (a: Record<string, any>, b: Record<string, any>) =>
-              a.order - b.order,
-          )
-          .map((c: Record<string, any>) => ({
-            ...c,
-            required: !!(c.required || 0),
-          }));
-
-        const emails = Object.entries(JSON.parse(formView?.email) || {})
-          .filter((a) => a[1])
-          .map((a) => a[0]);
-        if (emails?.length) {
-          const transformedData = _transformSubmittedFormDataForEmail(
-            newData,
-            formView,
-            filteredColumns,
-          );
-          (await NcPluginMgrv2.emailAdapter(false))?.mailSend({
-            to: emails.join(','),
-            subject: 'NocoDB Form',
-            html: ejs.render(formSubmissionEmailTemplate, {
-              data: transformedData,
-              tn: this.tnPath,
-              _tn: this.model.title,
-            }),
-          });
-        }
-      } catch (e) {
-        console.log(e);
-      }
-    }
-
-    try {
-      const [event, operation] = hookName.split('.');
-      const hooks = await Hook.list({
-        fk_model_id: this.model.id,
-        event,
-        operation,
-      });
-      for (const hook of hooks) {
-        if (hook.active) {
-          invokeWebhook(hook, this.model, view, prevData, newData, req?.user);
-        }
-      }
-    } catch (e) {
-      console.log('hooks :: error', hookName, e);
-    }*/
   }
 
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   protected async errorInsert(e, data, trx, cookie) {}
 
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   protected async errorUpdate(e, data, trx, cookie) {}
 
   // todo: handle composite primary key
@@ -3088,7 +3016,7 @@ class BaseModelSqlv2 {
     );
   }
 
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   protected async errorDelete(e, id, trx, cookie) {}
 
   async validate(columns) {
@@ -3809,6 +3737,464 @@ class BaseModelSqlv2 {
     }
     return data;
   }
+
+  async addLinks({
+    cookie,
+    childIds,
+    colId,
+    rowId,
+  }: {
+    cookie: any;
+    childIds: (string | number)[];
+    colId: string;
+    rowId: string;
+  }) {
+    const columns = await this.model.getColumns();
+    const column = columns.find((c) => c.id === colId);
+
+    if (!column || column.uidt !== UITypes.LinkToAnotherRecord)
+      NcError.notFound(`Link column ${colId} not found`);
+
+    const row = await this.dbDriver(this.tnPath)
+      .where(await this._wherePk(rowId))
+      .first();
+
+    // validate rowId
+    if (!row) {
+      NcError.notFound(`Row with id '${rowId}' not found`);
+    }
+
+    if (!childIds.length) return;
+
+    const colOptions = await column.getColOptions<LinkToAnotherRecordColumn>();
+
+    const childColumn = await colOptions.getChildColumn();
+    const parentColumn = await colOptions.getParentColumn();
+    const parentTable = await parentColumn.getModel();
+    const childTable = await childColumn.getModel();
+    await childTable.getColumns();
+    await parentTable.getColumns();
+
+    const childTn = this.getTnPath(childTable);
+    const parentTn = this.getTnPath(parentTable);
+
+    switch (colOptions.type) {
+      case RelationTypes.MANY_TO_MANY:
+        {
+          const vChildCol = await colOptions.getMMChildColumn();
+          const vParentCol = await colOptions.getMMParentColumn();
+          const vTable = await colOptions.getMMModel();
+
+          const vTn = this.getTnPath(vTable);
+
+          let insertData: Record<string, any>[];
+
+          // validate Ids
+          {
+            const childRowsQb = this.dbDriver(parentTn)
+              .select(parentColumn.column_name)
+              .select(`${vTable.table_name}.${vChildCol.column_name}`)
+              .leftJoin(vTn, (qb) => {
+                qb.on(
+                  `${vTable.table_name}.${vParentCol.column_name}`,
+                  `${parentTable.table_name}.${parentColumn.column_name}`,
+                ).andOn(
+                  `${vTable.table_name}.${vChildCol.column_name}`,
+                  row[childColumn.column_name],
+                );
+              });
+            // .where(_wherePk(parentTable.primaryKeys, childId))
+
+            if (parentTable.primaryKeys.length > 1) {
+              childRowsQb.where((qb) => {
+                for (const childId of childIds) {
+                  qb.orWhere(_wherePk(parentTable.primaryKeys, childId));
+                }
+              });
+            } else {
+              childRowsQb.whereIn(parentTable.primaryKey.column_name, childIds);
+            }
+
+            if (parentTable.primaryKey.column_name !== parentColumn.column_name)
+              childRowsQb.select(parentTable.primaryKey.column_name);
+
+            const childRows = await childRowsQb;
+
+            if (childRows.length !== childIds.length) {
+              const missingIds = childIds.filter(
+                (id) =>
+                  !childRows.find((r) => r[parentColumn.column_name] === id),
+              );
+
+              NcError.unprocessableEntity(
+                `Child record with id [${missingIds.join(', ')}] not found`,
+              );
+            }
+
+            insertData = childRows
+              // skip existing links
+              .filter((childRow) => !childRow[vChildCol.column_name])
+              // generate insert data for new links
+              .map((childRow) => ({
+                [vParentCol.column_name]: childRow[parentColumn.column_name],
+                [vChildCol.column_name]: row[childColumn.column_name],
+              }));
+
+            // if no new links, return true
+            if (!insertData.length) return true;
+          }
+
+          // if (this.isSnowflake) {
+          //   const parentPK = this.dbDriver(parentTn)
+          //     .select(parentColumn.column_name)
+          //     // .where(_wherePk(parentTable.primaryKeys, childId))
+          //     .whereIn(parentTable.primaryKey.column_name, childIds)
+          //     .first();
+          //
+          //   const childPK = this.dbDriver(childTn)
+          //     .select(childColumn.column_name)
+          //     .where(_wherePk(childTable.primaryKeys, rowId))
+          //     .first();
+          //
+          //   await this.dbDriver.raw(
+          //     `INSERT INTO ?? (??, ??) SELECT (${parentPK.toQuery()}), (${childPK.toQuery()})`,
+          //     [vTn, vParentCol.column_name, vChildCol.column_name],
+          //   );
+          // } else {
+          //   await this.dbDriver(vTn).insert({
+          //     [vParentCol.column_name]: this.dbDriver(parentTn)
+          //       .select(parentColumn.column_name)
+          //       // .where(_wherePk(parentTable.primaryKeys, childId))
+          //       .where(parentTable.primaryKey.column_name, childIds)
+          //       .first(),
+          //     [vChildCol.column_name]: this.dbDriver(childTn)
+          //       .select(childColumn.column_name)
+          //       .where(_wherePk(childTable.primaryKeys, rowId))
+          //       .first(),
+          //   });
+
+          // todo: use bulk insert
+          await this.dbDriver(vTn).insert(insertData);
+          // }
+        }
+        break;
+      case RelationTypes.HAS_MANY:
+        {
+          // validate Ids
+          {
+            const childRowsQb = this.dbDriver(childTn).select(
+              childTable.primaryKey.column_name,
+            );
+
+            if (childTable.primaryKeys.length > 1) {
+              childRowsQb.where((qb) => {
+                for (const childId of childIds) {
+                  qb.orWhere(_wherePk(childTable.primaryKeys, childId));
+                }
+              });
+            } else {
+              childRowsQb.whereIn(parentTable.primaryKey.column_name, childIds);
+            }
+
+            const childRows = await childRowsQb;
+
+            if (childRows.length !== childIds.length) {
+              const missingIds = childIds.filter(
+                (id) =>
+                  !childRows.find((r) => r[parentColumn.column_name] === id),
+              );
+
+              NcError.unprocessableEntity(
+                `Child record with id [${missingIds.join(', ')}] not found`,
+              );
+            }
+          }
+
+          await this.dbDriver(childTn)
+            .update({
+              [childColumn.column_name]: this.dbDriver.from(
+                this.dbDriver(parentTn)
+                  .select(parentColumn.column_name)
+                  .where(_wherePk(parentTable.primaryKeys, rowId))
+                  .first()
+                  .as('___cn_alias'),
+              ),
+            })
+            // .where(_wherePk(childTable.primaryKeys, childId));
+            .whereIn(childTable.primaryKey.column_name, childIds);
+        }
+        break;
+      case RelationTypes.BELONGS_TO:
+        {
+          // validate Ids
+          {
+            const childRowsQb = this.dbDriver(parentTn)
+              .select(parentTable.primaryKey.column_name)
+              .where(_wherePk(parentTable.primaryKeys, childIds[0]))
+              .first();
+
+            const childRow = await childRowsQb;
+
+            if (!childRow) {
+              NcError.unprocessableEntity(
+                `Child record with id [${childIds[0]}] not found`,
+              );
+            }
+          }
+
+          await this.dbDriver(childTn)
+            .update({
+              [childColumn.column_name]: this.dbDriver.from(
+                this.dbDriver(parentTn)
+                  .select(parentColumn.column_name)
+                  .where(_wherePk(parentTable.primaryKeys, childIds[0]))
+                  // .whereIn(parentTable.primaryKey.column_name, childIds)
+                  .first()
+                  .as('___cn_alias'),
+              ),
+            })
+            .where(_wherePk(childTable.primaryKeys, rowId));
+        }
+        break;
+    }
+
+    // const response = await this.readByPk(rowId);
+    // await this.afterInsert(response, this.dbDriver, cookie);
+    // await this.afterAddChild(rowId, childId, cookie);
+  }
+
+  async removeLinks({
+    cookie,
+    childIds,
+    colId,
+    rowId,
+  }: {
+    cookie: any;
+    childIds: (string | number)[];
+    colId: string;
+    rowId: string;
+  }) {
+    const columns = await this.model.getColumns();
+    const column = columns.find((c) => c.id === colId);
+
+    if (!column || column.uidt !== UITypes.LinkToAnotherRecord)
+      NcError.notFound(`Link column ${colId} not found`);
+
+    const row = await this.dbDriver(this.tnPath)
+      .where(await this._wherePk(rowId))
+      .first();
+
+    // validate rowId
+    if (!row) {
+      NcError.notFound(`Row with id '${rowId}' not found`);
+    }
+
+    if (!childIds.length) return;
+
+    const colOptions = await column.getColOptions<LinkToAnotherRecordColumn>();
+
+    const childColumn = await colOptions.getChildColumn();
+    const parentColumn = await colOptions.getParentColumn();
+    const parentTable = await parentColumn.getModel();
+    const childTable = await childColumn.getModel();
+    await childTable.getColumns();
+    await parentTable.getColumns();
+
+    const childTn = this.getTnPath(childTable);
+    const parentTn = this.getTnPath(parentTable);
+
+    const prevData = await this.readByPk(rowId);
+
+    switch (colOptions.type) {
+      case RelationTypes.MANY_TO_MANY:
+        {
+          const vChildCol = await colOptions.getMMChildColumn();
+          const vParentCol = await colOptions.getMMParentColumn();
+          const vTable = await colOptions.getMMModel();
+
+          // validate Ids
+          {
+            const childRowsQb = this.dbDriver(parentTn)
+              .select(parentColumn.column_name)
+              // .where(_wherePk(parentTable.primaryKeys, childId))
+              .whereIn(parentTable.primaryKey.column_name, childIds);
+
+            if (parentTable.primaryKey.column_name !== parentColumn.column_name)
+              childRowsQb.select(parentTable.primaryKey.column_name);
+
+            const childRows = await childRowsQb;
+
+            if (childRows.length !== childIds.length) {
+              const missingIds = childIds.filter(
+                (id) =>
+                  !childRows.find((r) => r[parentColumn.column_name] === id),
+              );
+
+              NcError.unprocessableEntity(
+                `Child record with id [${missingIds.join(', ')}] not found`,
+              );
+            }
+          }
+
+          const vTn = this.getTnPath(vTable);
+
+          await this.dbDriver(vTn)
+            .where({
+              [vChildCol.column_name]: this.dbDriver(childTn)
+                .select(childColumn.column_name)
+                .where(_wherePk(childTable.primaryKeys, rowId))
+                .first(),
+            })
+            .whereIn(
+              [vParentCol.column_name],
+              this.dbDriver(parentTn)
+                .select(parentColumn.column_name)
+                .whereIn(parentTable.primaryKey.column_name, childIds),
+            )
+            .delete();
+        }
+        break;
+      case RelationTypes.HAS_MANY:
+        {
+          // validate Ids
+          {
+            const childRowsQb = this.dbDriver(childTn)
+              .select(childTable.primaryKey.column_name)
+              .whereIn(childTable.primaryKey.column_name, childIds);
+
+            const childRows = await childRowsQb;
+
+            if (childRows.length !== childIds.length) {
+              const missingIds = childIds.filter(
+                (id) =>
+                  !childRows.find((r) => r[parentColumn.column_name] === id),
+              );
+
+              NcError.unprocessableEntity(
+                `Child record with id [${missingIds.join(', ')}] not found`,
+              );
+            }
+          }
+
+          await this.dbDriver(childTn)
+            // .where({
+            //   [childColumn.cn]: this.dbDriver(parentTable.tn)
+            //     .select(parentColumn.cn)
+            //     .where(parentTable.primaryKey.cn, rowId)
+            //     .first()
+            // })
+            // .where(_wherePk(childTable.primaryKeys, childId))
+            .whereIn(childTable.primaryKey.column_name, childIds)
+            .update({ [childColumn.column_name]: null });
+        }
+        break;
+      case RelationTypes.BELONGS_TO:
+        {
+          // validate Ids
+          {
+            if (childIds.length > 1)
+              NcError.unprocessableEntity(
+                'Request must contain only one parent id',
+              );
+
+            const childRowsQb = this.dbDriver(parentTn)
+              .select(parentTable.primaryKey.column_name)
+              .where(_wherePk(parentTable.primaryKeys, childIds[0]))
+              .first();
+
+            const childRow = await childRowsQb;
+
+            if (!childRow) {
+              NcError.unprocessableEntity(
+                `Child record with id [${childIds[0]}] not found`,
+              );
+            }
+          }
+
+          await this.dbDriver(childTn)
+            // .where({
+            //   [childColumn.cn]: this.dbDriver(parentTable.tn)
+            //     .select(parentColumn.cn)
+            //     .where(parentTable.primaryKey.cn, childId)
+            //     .first()
+            // })
+            // .where(_wherePk(childTable.primaryKeys, rowId))
+            .where(childTable.primaryKey.column_name, rowId)
+            .update({ [childColumn.column_name]: null });
+        }
+        break;
+    }
+
+    // const newData = await this.readByPk(rowId);
+    // await this.afterUpdate(prevData, newData, this.dbDriver, cookie);
+    // await this.afterRemoveChild(rowId, childIds, cookie);
+  }
+
+  async btRead(
+    { colId, id }: { colId; id },
+    args: { limit?; offset?; fieldSet?: Set<string> } = {},
+  ) {
+    try {
+      const { where, sort } = this._getListArgs(args as any);
+      // todo: get only required fields
+
+      const relColumn = (await this.model.getColumns()).find(
+        (c) => c.id === colId,
+      );
+
+      const row = await this.dbDriver(this.tnPath)
+        .where(await this._wherePk(id))
+        .first();
+
+      // validate rowId
+      if (!row) {
+        NcError.notFound(`Row with id ${id} not found`);
+      }
+
+      const parentCol = await (
+        (await relColumn.getColOptions()) as LinkToAnotherRecordColumn
+      ).getParentColumn();
+      const parentTable = await parentCol.getModel();
+      const chilCol = await (
+        (await relColumn.getColOptions()) as LinkToAnotherRecordColumn
+      ).getChildColumn();
+      const childTable = await chilCol.getModel();
+
+      const parentModel = await Model.getBaseModelSQL({
+        model: parentTable,
+        dbDriver: this.dbDriver,
+      });
+      await childTable.getColumns();
+
+      const childTn = this.getTnPath(childTable);
+      const parentTn = this.getTnPath(parentTable);
+
+      const qb = this.dbDriver(parentTn);
+      await this.applySortAndFilter({ table: parentTable, where, qb, sort });
+
+      qb.where(
+        parentCol.column_name,
+        this.dbDriver(childTn)
+          .select(chilCol.column_name)
+          // .where(parentTable.primaryKey.cn, p)
+          .where(_wherePk(childTable.primaryKeys, id)),
+      );
+
+      await parentModel.selectObject({ qb, fieldsSet: args.fieldSet });
+
+      const parent = (await this.execAndParse(qb, childTable))?.[0];
+
+      const proto = await parentModel.getProto();
+
+      if (parent) {
+        parent.__proto__ = proto;
+      }
+      return parent;
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+  }
 }
 
 function extractSortsObject(
diff --git a/packages/nocodb/src/db/sql-client/lib/mssql/MssqlClient.ts b/packages/nocodb/src/db/sql-client/lib/mssql/MssqlClient.ts
index 6e08545867..732d4aada7 100644
--- a/packages/nocodb/src/db/sql-client/lib/mssql/MssqlClient.ts
+++ b/packages/nocodb/src/db/sql-client/lib/mssql/MssqlClient.ts
@@ -2101,7 +2101,7 @@ class MssqlClient extends KnexClient {
                 table = table.onUpdate(relation.ur);
               }
               if (relation.dr) {
-                table = table.onDelete(relation.dr);
+                table.onDelete(relation.dr);
               }
             })
             .toQuery());
@@ -2192,28 +2192,31 @@ class MssqlClient extends KnexClient {
             table = table.onUpdate(args.onUpdate);
           }
           if (args.onDelete) {
-            table = table.onDelete(args.onDelete);
+            table.onDelete(args.onDelete);
           }
         },
       );
 
-      const upStatement =
-        this.querySeparator() +
-        (await this.sqlClient.schema
-          .table(this.getTnPath(args.childTable), function (table) {
-            table = table
-              .foreign(args.childColumn, foreignKeyName)
-              .references(args.parentColumn)
-              .on(self.getTnPath(args.parentTable));
+      const upQb = this.sqlClient.schema.table(
+        this.getTnPath(args.childTable),
+        function (table) {
+          table = table
+            .foreign(args.childColumn, foreignKeyName)
+            .references(args.parentColumn)
+            .on(self.getTnPath(args.parentTable));
 
-            if (args.onUpdate) {
-              table = table.onUpdate(args.onUpdate);
-            }
-            if (args.onDelete) {
-              table = table.onDelete(args.onDelete);
-            }
-          })
-          .toQuery());
+          if (args.onUpdate) {
+            table = table.onUpdate(args.onUpdate);
+          }
+          if (args.onDelete) {
+            table.onDelete(args.onDelete);
+          }
+        },
+      );
+
+      await upQb;
+
+      const upStatement = this.querySeparator() + upQb.toQuery();
 
       this.emit(`Success : ${upStatement}`);
 
@@ -2221,7 +2224,7 @@ class MssqlClient extends KnexClient {
         this.querySeparator() +
         this.sqlClient.schema
           .table(this.getTnPath(args.childTable), function (table) {
-            table = table.dropForeign(args.childColumn, foreignKeyName);
+            table.dropForeign(args.childColumn, foreignKeyName);
           })
           .toQuery();
 
diff --git a/packages/nocodb/src/db/sql-client/lib/oracle/OracleClient.ts b/packages/nocodb/src/db/sql-client/lib/oracle/OracleClient.ts
index 573eef665b..21deda8581 100644
--- a/packages/nocodb/src/db/sql-client/lib/oracle/OracleClient.ts
+++ b/packages/nocodb/src/db/sql-client/lib/oracle/OracleClient.ts
@@ -1914,7 +1914,7 @@ class OracleClient extends KnexClient {
    * @returns {String} message
    */
   async totalRecords(_args: any = {}): Promise<Result> {
-    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const func = this.totalRecords.name;
     throw new Error('Function not supported for oracle yet');
   }
diff --git a/packages/nocodb/src/db/sql-client/lib/pg/PgClient.ts b/packages/nocodb/src/db/sql-client/lib/pg/PgClient.ts
index 9d6623dfa2..f98216277c 100644
--- a/packages/nocodb/src/db/sql-client/lib/pg/PgClient.ts
+++ b/packages/nocodb/src/db/sql-client/lib/pg/PgClient.ts
@@ -2359,7 +2359,7 @@ class PGClient extends KnexClient {
                 table = table.onUpdate(relation.ur);
               }
               if (relation.dr) {
-                table = table.onDelete(relation.dr);
+                table.onDelete(relation.dr);
               }
             })
             .toQuery());
diff --git a/packages/nocodb/src/db/sql-client/lib/snowflake/SnowflakeClient.ts b/packages/nocodb/src/db/sql-client/lib/snowflake/SnowflakeClient.ts
index 167b7954c8..00bcb96549 100644
--- a/packages/nocodb/src/db/sql-client/lib/snowflake/SnowflakeClient.ts
+++ b/packages/nocodb/src/db/sql-client/lib/snowflake/SnowflakeClient.ts
@@ -1970,23 +1970,24 @@ class SnowflakeClient extends KnexClient {
       relationsList = relationsList.data.list;
 
       for (const relation of relationsList) {
-        downQuery +=
-          this.querySeparator() +
-          (await this.sqlClient.schema
-            .table(relation.tn, function (table) {
-              table = table
-                .foreign(relation.cn, null)
-                .references(relation.rcn)
-                .on(relation.rtn);
-
-              if (relation.ur) {
-                table = table.onUpdate(relation.ur);
-              }
-              if (relation.dr) {
-                table = table.onDelete(relation.dr);
-              }
-            })
-            .toQuery());
+        const downQb = this.sqlClient.schema.table(
+          relation.tn,
+          function (table) {
+            table = table
+              .foreign(relation.cn, null)
+              .references(relation.rcn)
+              .on(relation.rtn);
+
+            if (relation.ur) {
+              table = table.onUpdate(relation.ur);
+            }
+            if (relation.dr) {
+              table.onDelete(relation.dr);
+            }
+          },
+        );
+        await downQb;
+        downQuery += this.querySeparator() + downQb.toQuery();
       }
 
       let indexList: any = await this.indexList(args);
@@ -2060,8 +2061,6 @@ class SnowflakeClient extends KnexClient {
     const foreignKeyName = args.foreignKeyName || null;
 
     try {
-      // s = await this.sqlClient.schema.index(Object.keys(args.columns));
-
       await this.sqlClient.schema.table(args.childTable, (table) => {
         table = table
           .foreign(args.childColumn, foreignKeyName)
@@ -2072,27 +2071,27 @@ class SnowflakeClient extends KnexClient {
           table = table.onUpdate(args.onUpdate);
         }
         if (args.onDelete) {
-          table = table.onDelete(args.onDelete);
+          table.onDelete(args.onDelete);
         }
       });
 
-      const upStatement =
-        this.querySeparator() +
-        (await this.sqlClient.schema
-          .table(args.childTable, (table) => {
-            table = table
-              .foreign(args.childColumn, foreignKeyName)
-              .references(args.parentColumn)
-              .on(this.getTnPath(args.parentTable));
+      const upQb = this.sqlClient.schema.table(args.childTable, (table) => {
+        table = table
+          .foreign(args.childColumn, foreignKeyName)
+          .references(args.parentColumn)
+          .on(this.getTnPath(args.parentTable));
 
-            if (args.onUpdate) {
-              table = table.onUpdate(args.onUpdate);
-            }
-            if (args.onDelete) {
-              table = table.onDelete(args.onDelete);
-            }
-          })
-          .toQuery());
+        if (args.onUpdate) {
+          table = table.onUpdate(args.onUpdate);
+        }
+        if (args.onDelete) {
+          table.onDelete(args.onDelete);
+        }
+      });
+
+      await upQb;
+
+      const upStatement = this.querySeparator() + upQb.toQuery();
 
       this.emit(`Success : ${upStatement}`);
 
@@ -2100,7 +2099,7 @@ class SnowflakeClient extends KnexClient {
         this.querySeparator() +
         this.sqlClient.schema
           .table(args.childTable, (table) => {
-            table = table.dropForeign(args.childColumn, foreignKeyName);
+            table.dropForeign(args.childColumn, foreignKeyName);
           })
           .toQuery();
 
diff --git a/packages/nocodb/src/db/sql-client/lib/sqlite/SqliteClient.ts b/packages/nocodb/src/db/sql-client/lib/sqlite/SqliteClient.ts
index 00ecca611d..1b82233962 100644
--- a/packages/nocodb/src/db/sql-client/lib/sqlite/SqliteClient.ts
+++ b/packages/nocodb/src/db/sql-client/lib/sqlite/SqliteClient.ts
@@ -1866,6 +1866,7 @@ class SqliteClient extends KnexClient {
 
       /* Filter relations for current table */
       if (args.tn) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         relations = relations.filter(
           (r) => r.tn === args.tn || r.rtn === args.tn,
         );
diff --git a/packages/nocodb/src/db/sql-data-mapper/lib/BaseModel.ts b/packages/nocodb/src/db/sql-data-mapper/lib/BaseModel.ts
index 4da3d275f9..c9cd89b6b3 100644
--- a/packages/nocodb/src/db/sql-data-mapper/lib/BaseModel.ts
+++ b/packages/nocodb/src/db/sql-data-mapper/lib/BaseModel.ts
@@ -321,7 +321,7 @@ abstract class BaseModel {
    * @returns {Object} Table row data
    */
   // @ts-ignore
-  async readByPk(id, { conditionGraph }) {
+  async readByPk(id) {
     try {
       return await this._run(
         this.$db.select().where(this._wherePk(id)).first(),
@@ -704,10 +704,7 @@ abstract class BaseModel {
    */
   async exists(id, _) {
     try {
-      return (
-        Object.keys(await this.readByPk(id, { conditionGraph: null }))
-          .length !== 0
-      );
+      return Object.keys(await this.readByPk(id)).length !== 0;
     } catch (e) {
       console.log(e);
       throw e;
@@ -1341,7 +1338,7 @@ abstract class BaseModel {
    * @param {Object} data - insert data
    * @param {Object} trx? - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async beforeInsert(data, trx?: any, cookie?: {}) {}
 
   /**
@@ -1350,7 +1347,7 @@ abstract class BaseModel {
    * @param {Object} response - inserted data
    * @param {Object} trx? - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async afterInsert(response, trx?: any, cookie?: {}) {}
 
   /**
@@ -1360,7 +1357,7 @@ abstract class BaseModel {
    * @param {Object} data - insert data
    * @param {Object} trx? - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async errorInsert(err, data, trx?: any, cookie?: {}) {}
 
   /**
@@ -1369,7 +1366,7 @@ abstract class BaseModel {
    * @param {Object} data - update data
    * @param {Object} trx? - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async beforeUpdate(data, trx?: any, cookie?: {}) {}
 
   /**
@@ -1378,7 +1375,7 @@ abstract class BaseModel {
    * @param {Object} response - updated data
    * @param {Object} trx? - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async afterUpdate(response, trx?: any, cookie?: {}) {}
 
   /**
@@ -1388,7 +1385,7 @@ abstract class BaseModel {
    * @param {Object} data - update data
    * @param {Object} trx? - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async errorUpdate(err, data, trx?: any, cookie?: {}) {}
 
   /**
@@ -1397,7 +1394,7 @@ abstract class BaseModel {
    * @param {Object} data - delete data
    * @param {Object} trx? - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async beforeDelete(data, trx?: any, cookie?: {}) {}
 
   /**
@@ -1406,7 +1403,7 @@ abstract class BaseModel {
    * @param {Object} response - Deleted data
    * @param {Object} trx? - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async afterDelete(response, trx?: any, cookie?: {}) {}
 
   /**
@@ -1416,7 +1413,7 @@ abstract class BaseModel {
    * @param {Object} data - delete data
    * @param {Object} trx? - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async errorDelete(err, data, trx?: any, cookie?: {}) {}
 
   /**
@@ -1425,7 +1422,7 @@ abstract class BaseModel {
    * @param {Object[]} data - insert data
    * @param {Object} trx - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async beforeInsertb(data, trx?: any) {}
 
   /**
@@ -1434,7 +1431,7 @@ abstract class BaseModel {
    * @param {Object[]} response - inserted data
    * @param {Object} trx - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async afterInsertb(response, trx?: any) {}
 
   /**
@@ -1444,7 +1441,7 @@ abstract class BaseModel {
    * @param {Object} data - delete data
    * @param {Object} trx - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async errorInsertb(err, data, trx?: any) {}
 
   /**
@@ -1453,7 +1450,7 @@ abstract class BaseModel {
    * @param {Object[]} data - update data
    * @param {Object} trx - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async beforeUpdateb(data, trx?: any) {}
 
   /**
@@ -1462,7 +1459,7 @@ abstract class BaseModel {
    * @param {Object[]} response - updated data
    * @param {Object} trx - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async afterUpdateb(response, trx?: any) {}
 
   /**
@@ -1472,7 +1469,7 @@ abstract class BaseModel {
    * @param {Object[]} data - delete data
    * @param {Object} trx - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async errorUpdateb(err, data, trx?: any) {}
 
   /**
@@ -1481,7 +1478,7 @@ abstract class BaseModel {
    * @param {Object[]} data - delete data
    * @param {Object} trx - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async beforeDeleteb(data, trx?: any) {}
 
   /**
@@ -1490,7 +1487,7 @@ abstract class BaseModel {
    * @param {Object[]} response - deleted data
    * @param {Object} trx - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async afterDeleteb(response, trx?: any) {}
 
   /**
@@ -1500,12 +1497,13 @@ abstract class BaseModel {
    * @param {Object[]} data - delete data
    * @param {Object} trx - knex transaction reference
    */
-  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async errorDeleteb(err, data, trx?: any) {}
 }
 
 export interface XcFilter {
   where?: string;
+  filter?: string;
   having?: string;
   condition?: any;
   conditionGraph?: any;
diff --git a/packages/nocodb/src/db/sql-migrator/lib/KnexMigrator.ts b/packages/nocodb/src/db/sql-migrator/lib/KnexMigrator.ts
index 5f1c6bb291..ce84302552 100644
--- a/packages/nocodb/src/db/sql-migrator/lib/KnexMigrator.ts
+++ b/packages/nocodb/src/db/sql-migrator/lib/KnexMigrator.ts
@@ -137,6 +137,7 @@ export default class KnexMigrator extends SqlMigrator {
         ),
       );
       // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const dirStat = await promisify(fs.stat)(
         path.join(
           this.toolDir,
@@ -232,6 +233,7 @@ export default class KnexMigrator extends SqlMigrator {
       );
 
       // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const metaStat = await promisify(fs.stat)(
         path.join(
           this.toolDir,
diff --git a/packages/nocodb/src/db/sql-migrator/lib/KnexMigratorv2.ts b/packages/nocodb/src/db/sql-migrator/lib/KnexMigratorv2.ts
index 8fd7949e59..9a11b462cb 100644
--- a/packages/nocodb/src/db/sql-migrator/lib/KnexMigratorv2.ts
+++ b/packages/nocodb/src/db/sql-migrator/lib/KnexMigratorv2.ts
@@ -114,6 +114,7 @@ export default class KnexMigratorv2 {
   }*/
 
   // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async _initDbOnFs(base: Base) {
     // this.emit(
     //   'Creating folder: ',
diff --git a/packages/nocodb/src/filters/global-exception/global-exception.filter.ts b/packages/nocodb/src/filters/global-exception/global-exception.filter.ts
index ac9b6e5692..7f8ac8adc5 100644
--- a/packages/nocodb/src/filters/global-exception/global-exception.filter.ts
+++ b/packages/nocodb/src/filters/global-exception/global-exception.filter.ts
@@ -8,6 +8,7 @@ import {
   NotFound,
   NotImplemented,
   Unauthorized,
+  UnprocessableEntity,
 } from '../../helpers/catchError';
 import type { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
 import type { Response } from 'express';
@@ -15,6 +16,7 @@ import type { Response } from 'express';
 @Catch()
 export class GlobalExceptionFilter implements ExceptionFilter {
   private logger = new Logger(GlobalExceptionFilter.name);
+
   catch(exception: any, host: ArgumentsHost) {
     const ctx = host.switchToHttp();
     const response = ctx.getResponse<Response>();
@@ -58,6 +60,8 @@ export class GlobalExceptionFilter implements ExceptionFilter {
       return response
         .status(400)
         .json({ msg: exception.message, errors: exception.errors });
+    } else if (exception instanceof UnprocessableEntity) {
+      return response.status(422).json({ msg: exception.message });
     }
 
     // handle different types of exceptions
diff --git a/packages/nocodb/src/helpers/PagedResponse.ts b/packages/nocodb/src/helpers/PagedResponse.ts
index 1600d749dd..97f8e3b658 100644
--- a/packages/nocodb/src/helpers/PagedResponse.ts
+++ b/packages/nocodb/src/helpers/PagedResponse.ts
@@ -1,11 +1,6 @@
+import { extractLimitAndOffset } from '.';
 import type { PaginatedType } from 'nocodb-sdk';
 
-const config: any = {
-  limitDefault: Math.max(+process.env.DB_QUERY_LIMIT_DEFAULT || 25, 1),
-  limitMin: Math.max(+process.env.DB_QUERY_LIMIT_MIN || 1, 1),
-  limitMax: Math.max(+process.env.DB_QUERY_LIMIT_MAX || 1000, 1),
-};
-
 export class PagedResponseImpl<T> {
   constructor(
     list: T[],
@@ -17,12 +12,7 @@ export class PagedResponseImpl<T> {
       o?: number;
     } = {},
   ) {
-    const limit = Math.max(
-      Math.min(args.limit || args.l || config.limitDefault, config.limitMax),
-      config.limitMin,
-    );
-
-    const offset = Math.max(+(args.offset || args.o) || 0, 0);
+    const { offset, limit } = extractLimitAndOffset(args);
 
     let count = args.count ?? null;
 
@@ -40,8 +30,17 @@ export class PagedResponseImpl<T> {
         this.pageInfo.page ===
         (Math.ceil(this.pageInfo.totalRows / this.pageInfo.pageSize) || 1);
     }
+
+    if (offset && offset >= count) {
+      this.errors = [
+        {
+          message: 'Offset is beyond the total number of rows',
+        },
+      ];
+    }
   }
 
   list: Array<T>;
   pageInfo: PaginatedType;
+  errors?: any[];
 }
diff --git a/packages/nocodb/src/helpers/apiMetrics.ts b/packages/nocodb/src/helpers/apiMetrics.ts
index 494105cd66..10dbd3b737 100644
--- a/packages/nocodb/src/helpers/apiMetrics.ts
+++ b/packages/nocodb/src/helpers/apiMetrics.ts
@@ -3,7 +3,7 @@ import type { Request } from 'express';
 
 const countMap = {};
 
-// @ts-ignore
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const metrics = async (req: Request, c = 150) => {
   if (!req?.route?.path) return;
   const event = `a:api:${req.route.path}:${req.method}`;
diff --git a/packages/nocodb/src/helpers/catchError.ts b/packages/nocodb/src/helpers/catchError.ts
index 279d042828..0165fae6c7 100644
--- a/packages/nocodb/src/helpers/catchError.ts
+++ b/packages/nocodb/src/helpers/catchError.ts
@@ -413,6 +413,8 @@ export default function (
         return res.status(501).json({ msg: e.message });
       } else if (e instanceof AjvError) {
         return res.status(400).json({ msg: e.message, errors: e.errors });
+      } else if (e instanceof UnprocessableEntity) {
+        return res.status(422).json({ msg: e.message });
       }
       next(e);
     }
@@ -431,6 +433,8 @@ export class InternalServerError extends Error {}
 
 export class NotImplemented extends Error {}
 
+export class UnprocessableEntity extends Error {}
+
 export class AjvError extends Error {
   constructor(param: { message: string; errors: ErrorObject[] }) {
     super(param.message);
@@ -468,4 +472,8 @@ export class NcError {
   static ajvValidationError(param: { message: string; errors: ErrorObject[] }) {
     throw new AjvError(param);
   }
+
+  static unprocessableEntity(message = 'Unprocessable entity') {
+    throw new UnprocessableEntity(message);
+  }
 }
diff --git a/packages/nocodb/src/helpers/extractLimitAndOffset.ts b/packages/nocodb/src/helpers/extractLimitAndOffset.ts
new file mode 100644
index 0000000000..1cf5072aa3
--- /dev/null
+++ b/packages/nocodb/src/helpers/extractLimitAndOffset.ts
@@ -0,0 +1,39 @@
+const config = {
+  limitDefault: Math.max(+process.env.DB_QUERY_LIMIT_DEFAULT || 25, 1),
+  limitMin: Math.max(+process.env.DB_QUERY_LIMIT_MIN || 1, 1),
+  limitMax: Math.max(+process.env.DB_QUERY_LIMIT_MAX || 1000, 1),
+};
+
+export function extractLimitAndOffset(
+  args: {
+    limit?: number | string;
+    offset?: number | string;
+    l?: number | string;
+    o?: number | string;
+  } = {},
+) {
+  const obj: {
+    limit?: number;
+    offset?: number;
+  } = {};
+
+  // use default value if invalid limit
+  // for example, if limit is not a number, it will be ignored
+  // if limit is less than 1, it will be ignored
+  const limit = +(args.limit || args.l);
+  obj.limit = Math.max(
+    Math.min(
+      limit && limit > 0 && Number.isInteger(limit)
+        ? limit
+        : config.limitDefault,
+      config.limitMax,
+    ),
+    config.limitMin,
+  );
+
+  // skip any invalid offset, ignore negative and non-integer values
+  const offset = +(args.offset || args.o) || 0;
+  obj.offset = Math.max(Number.isInteger(offset) ? offset : 0, 0);
+
+  return obj;
+}
diff --git a/packages/nocodb/src/helpers/index.ts b/packages/nocodb/src/helpers/index.ts
index ee77b070e2..adf2eeecba 100644
--- a/packages/nocodb/src/helpers/index.ts
+++ b/packages/nocodb/src/helpers/index.ts
@@ -2,5 +2,6 @@ import { populateMeta } from './populateMeta';
 export * from './columnHelpers';
 export * from './apiHelpers';
 export * from './cacheHelpers';
+export * from './extractLimitAndOffset';
 
 export { populateMeta };
diff --git a/packages/nocodb/src/helpers/webhookHelpers.ts b/packages/nocodb/src/helpers/webhookHelpers.ts
index c0fc56a448..400db86b71 100644
--- a/packages/nocodb/src/helpers/webhookHelpers.ts
+++ b/packages/nocodb/src/helpers/webhookHelpers.ts
@@ -271,7 +271,7 @@ export async function invokeWebhook(
       return;
     }
 
-    if (hook.condition) {
+    if (hook.condition && !testHook) {
       if (isBulkOperation) {
         const filteredData = [];
         for (const data of newData) {
diff --git a/packages/nocodb/src/meta/migrations/v1/nc_011_remove_old_ses_plugin.ts b/packages/nocodb/src/meta/migrations/v1/nc_011_remove_old_ses_plugin.ts
index fb36849426..5d69ffe71b 100644
--- a/packages/nocodb/src/meta/migrations/v1/nc_011_remove_old_ses_plugin.ts
+++ b/packages/nocodb/src/meta/migrations/v1/nc_011_remove_old_ses_plugin.ts
@@ -5,7 +5,7 @@ const up = async (knex: Knex) => {
   await knex('nc_plugins').del().where({ title: 'SES' });
 };
 
-const down = async (knex: Knex) => {
+const down = async (_: Knex) => {
   // await knex('nc_plugins').insert([ses]);
 };
 
diff --git a/packages/nocodb/src/models/Model.ts b/packages/nocodb/src/models/Model.ts
index 00eed04002..099f8fc0d4 100644
--- a/packages/nocodb/src/models/Model.ts
+++ b/packages/nocodb/src/models/Model.ts
@@ -65,6 +65,7 @@ export default class Model implements TableType {
   }
 
   // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public async getViews(force = false, ncMeta = Noco.ncMeta): Promise<View[]> {
     this.views = await View.listWithInfo(this.id, ncMeta);
     return this.views;
diff --git a/packages/nocodb/src/models/View.ts b/packages/nocodb/src/models/View.ts
index 9a4fd88f2f..3135666e86 100644
--- a/packages/nocodb/src/models/View.ts
+++ b/packages/nocodb/src/models/View.ts
@@ -1,4 +1,3 @@
-import { title } from 'process';
 import { isSystemColumn, UITypes, ViewTypes } from 'nocodb-sdk';
 import Noco from '../Noco';
 import {
diff --git a/packages/nocodb/src/modules/datas/datas.module.ts b/packages/nocodb/src/modules/datas/datas.module.ts
index d08854bf89..9ee4adeecf 100644
--- a/packages/nocodb/src/modules/datas/datas.module.ts
+++ b/packages/nocodb/src/modules/datas/datas.module.ts
@@ -3,8 +3,10 @@ import { MulterModule } from '@nestjs/platform-express';
 import multer from 'multer';
 import { NC_ATTACHMENT_FIELD_SIZE } from '../../constants';
 import { DataAliasController } from '../../controllers/data-alias.controller';
+import { DataTableController } from '../../controllers/data-table.controller';
 import { PublicDatasExportController } from '../../controllers/public-datas-export.controller';
 import { PublicDatasController } from '../../controllers/public-datas.controller';
+import { DataTableService } from '../../services/data-table.service';
 import { DatasService } from '../../services/datas.service';
 import { DatasController } from '../../controllers/datas.controller';
 import { BulkDataAliasController } from '../../controllers/bulk-data-alias.controller';
@@ -29,6 +31,7 @@ import { PublicDatasService } from '../../services/public-datas.service';
   controllers: [
     ...(process.env.NC_WORKER_CONTAINER !== 'true'
       ? [
+          DataTableController,
           DatasController,
           BulkDataAliasController,
           DataAliasController,
@@ -41,6 +44,7 @@ import { PublicDatasService } from '../../services/public-datas.service';
       : []),
   ],
   providers: [
+    DataTableService,
     DatasService,
     BulkDataAliasService,
     DataAliasNestedService,
diff --git a/packages/nocodb/src/modules/jobs/jobs/at-import/at-import.controller.ts b/packages/nocodb/src/modules/jobs/jobs/at-import/at-import.controller.ts
index d1d2a54857..11a84b2d9a 100644
--- a/packages/nocodb/src/modules/jobs/jobs/at-import/at-import.controller.ts
+++ b/packages/nocodb/src/modules/jobs/jobs/at-import/at-import.controller.ts
@@ -65,7 +65,7 @@ export class AtImportController {
 
   @Post('/api/v1/db/meta/syncs/:syncId/abort')
   @HttpCode(200)
-  async abortImport(@Request() req) {
+  async abortImport(@Request() _) {
     return {};
   }
 }
diff --git a/packages/nocodb/src/modules/jobs/jobs/at-import/at-import.processor.ts b/packages/nocodb/src/modules/jobs/jobs/at-import/at-import.processor.ts
index 36f6ce6509..d1f679c19b 100644
--- a/packages/nocodb/src/modules/jobs/jobs/at-import/at-import.processor.ts
+++ b/packages/nocodb/src/modules/jobs/jobs/at-import/at-import.processor.ts
@@ -348,32 +348,6 @@ export class AtImportProcessor {
       }
     };
 
-    const nc_DumpTableSchema = async () => {
-      console.log('[');
-      // const ncTblList = await api.base.tableList(
-      //   ncCreatedProjectSchema.id,
-      //   syncDB.baseId
-      // );
-
-      const ncTblList = { list: [] };
-      ncTblList['list'] = await this.tablesService.getAccessibleTables({
-        projectId: ncCreatedProjectSchema.id,
-        baseId: syncDB.baseId,
-        roles: userRole,
-      });
-
-      for (let i = 0; i < ncTblList.list.length; i++) {
-        // const ncTbl = await api.dbTable.read(ncTblList.list[i].id);
-        const ncTbl = await this.tablesService.getTableWithAccessibleViews({
-          tableId: ncTblList.list[i].id,
-          user: syncDB.user,
-        });
-        console.log(JSON.stringify(ncTbl, null, 2));
-        console.log(',');
-      }
-      console.log(']');
-    };
-
     // retrieve nc column schema from using aTbl field ID as reference
     //
     const nc_getColumnSchema = async (aTblFieldId) => {
@@ -1563,45 +1537,6 @@ export class AtImportProcessor {
       return rec;
     };
 
-    const nocoReadDataSelected = async (projName, table, callback, fields) => {
-      return new Promise((resolve, reject) => {
-        base(table.title)
-          .select({
-            pageSize: 100,
-            // maxRecords: 100,
-            fields: fields,
-          })
-          .eachPage(
-            async function page(records, fetchNextPage) {
-              // This function (`page`) will get called for each page of records.
-              // records.forEach(record => callback(table, record));
-              logBasic(
-                `:: ${table.title} / ${fields} : ${
-                  recordCnt + 1
-                } ~ ${(recordCnt += 100)}`,
-              );
-              await Promise.all(
-                records.map((r) => callback(projName, table, r, fields)),
-              );
-
-              // To fetch the next page of records, call `fetchNextPage`.
-              // If there are more records, `page` will get called again.
-              // If there are no more records, `done` will get called.
-              fetchNextPage();
-            },
-            function done(err) {
-              if (err) {
-                console.error(err);
-                reject(err);
-              }
-              resolve(null);
-            },
-          );
-      });
-    };
-
-    //////////
-
     const nc_isLinkExists = (airtableFieldId) => {
       return !!ncLinkMappingTable.find(
         (x) => x.aTbl.typeOptions.symmetricColumnId === airtableFieldId,
@@ -1879,9 +1814,7 @@ export class AtImportProcessor {
               req: { user: syncDB.user, clientIp: '' },
             })
             .catch((e) =>
-              e.response?.data?.msg
-                ? logBasic(`NOTICE: ${e.response.data.msg}`)
-                : console.log(e),
+              e.message ? logBasic(`NOTICE: ${e.message}`) : console.log(e),
             ),
         );
         recordPerfStats(_perfStart, 'auth.projectUserAdd');
@@ -2294,7 +2227,6 @@ export class AtImportProcessor {
     };
 
     ///////////////////////////////////////////////////////////////////////////////
-    let recordCnt = 0;
     try {
       logBasic('SDK initialized');
       logDetailed('Project initialization started');
@@ -2376,7 +2308,6 @@ export class AtImportProcessor {
 
       if (syncDB.options.syncData) {
         try {
-          // await nc_DumpTableSchema();
           const _perfStart = recordPerfStart();
           const ncTblList = { list: [] };
           ncTblList['list'] = await this.tablesService.getAccessibleTables({
@@ -2406,8 +2337,6 @@ export class AtImportProcessor {
               });
             recordPerfStats(_perfStart, 'dbTable.read');
 
-            recordCnt = 0;
-
             recordsMap[ncTbl.id] = await importData({
               projectName: syncDB.projectName,
               table: ncTbl,
@@ -2471,12 +2400,12 @@ export class AtImportProcessor {
         await generateMigrationStats(aTblSchema);
       }
     } catch (e) {
-      if (e.response?.data?.msg) {
+      if (e.message) {
         T.event({
           event: 'a:airtable-import:error',
-          data: { error: e.response.data.msg },
+          data: { error: e.message },
         });
-        throw new Error(e.response.data.msg);
+        throw new Error(e.message);
       }
       throw e;
     }
diff --git a/packages/nocodb/src/modules/jobs/jobs/export-import/import.service.ts b/packages/nocodb/src/modules/jobs/jobs/export-import/import.service.ts
index ad4b83a82b..a4a0b2e4e6 100644
--- a/packages/nocodb/src/modules/jobs/jobs/export-import/import.service.ts
+++ b/packages/nocodb/src/modules/jobs/jobs/export-import/import.service.ts
@@ -1214,6 +1214,7 @@ export class ImportService {
               storageAdapter as any
             ).fileReadByStream(linkFile);
 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
             handledLinks = await this.importLinkFromCsvStream({
               idMap,
               linkStream: linkReadStream,
diff --git a/packages/nocodb/src/plugins/storage/Local.ts b/packages/nocodb/src/plugins/storage/Local.ts
index f0dbebf2a4..7d49e54f70 100644
--- a/packages/nocodb/src/plugins/storage/Local.ts
+++ b/packages/nocodb/src/plugins/storage/Local.ts
@@ -3,6 +3,7 @@ import path from 'path';
 import { promisify } from 'util';
 import mkdirp from 'mkdirp';
 import axios from 'axios';
+import { NcError } from '../../helpers/catchError';
 import { getToolDir } from '../../utils/nc-config';
 import type { IStorageAdapterV2, XcFile } from 'nc-plugin';
 import type { Readable } from 'stream';
@@ -11,7 +12,7 @@ export default class Local implements IStorageAdapterV2 {
   constructor() {}
 
   public async fileCreate(key: string, file: XcFile): Promise<any> {
-    const destPath = path.join(getToolDir(), ...key.split('/'));
+    const destPath = this.validateAndNormalisePath(key);
     try {
       await mkdirp(path.dirname(destPath));
       const data = await promisify(fs.readFile)(file.path);
@@ -24,7 +25,7 @@ export default class Local implements IStorageAdapterV2 {
   }
 
   async fileCreateByUrl(key: string, url: string): Promise<any> {
-    const destPath = path.join(getToolDir(), ...key.split('/'));
+    const destPath = this.validateAndNormalisePath(key);
     return new Promise((resolve, reject) => {
       axios
         .get(url, {
@@ -71,7 +72,7 @@ export default class Local implements IStorageAdapterV2 {
     stream: Readable,
   ): Promise<void> {
     return new Promise((resolve, reject) => {
-      const destPath = path.join(getToolDir(), ...key.split('/'));
+      const destPath = this.validateAndNormalisePath(key);
       try {
         mkdirp(path.dirname(destPath)).then(() => {
           const writableStream = fs.createWriteStream(destPath);
@@ -86,12 +87,12 @@ export default class Local implements IStorageAdapterV2 {
   }
 
   public async fileReadByStream(key: string): Promise<Readable> {
-    const srcPath = path.join(getToolDir(), ...key.split('/'));
+    const srcPath = this.validateAndNormalisePath(key);
     return fs.createReadStream(srcPath, { encoding: 'utf8' });
   }
 
   public async getDirectoryList(key: string): Promise<string[]> {
-    const destDir = path.join(getToolDir(), ...key.split('/'));
+    const destDir = this.validateAndNormalisePath(key);
     return fs.promises.readdir(destDir);
   }
 
@@ -103,7 +104,7 @@ export default class Local implements IStorageAdapterV2 {
   public async fileRead(filePath: string): Promise<any> {
     try {
       const fileData = await fs.promises.readFile(
-        path.join(getToolDir(), ...filePath.split('/')),
+        this.validateAndNormalisePath(filePath, true),
       );
       return fileData;
     } catch (e) {
@@ -118,4 +119,29 @@ export default class Local implements IStorageAdapterV2 {
   test(): Promise<boolean> {
     return Promise.resolve(false);
   }
+
+  // method for validate/normalise the path for avoid path traversal attack
+  protected validateAndNormalisePath(
+    fileOrFolderPath: string,
+    throw404 = false,
+  ): string {
+    // Get the absolute path to the base directory
+    const absoluteBasePath = path.resolve(getToolDir(), 'nc');
+
+    // Get the absolute path to the file
+    const absolutePath = path.resolve(
+      path.join(getToolDir(), ...fileOrFolderPath.split('/')),
+    );
+
+    // Check if the resolved path is within the intended directory
+    if (!absolutePath.startsWith(absoluteBasePath)) {
+      if (throw404) {
+        NcError.notFound();
+      } else {
+        NcError.badRequest('Invalid path');
+      }
+    }
+
+    return absolutePath;
+  }
 }
diff --git a/packages/nocodb/src/services/auth.service.ts b/packages/nocodb/src/services/auth.service.ts
index 287cb16391..a03e82de4e 100644
--- a/packages/nocodb/src/services/auth.service.ts
+++ b/packages/nocodb/src/services/auth.service.ts
@@ -40,8 +40,8 @@ export class AuthService {
       email: _email,
       firstname,
       lastname,
-      token,
-      ignore_subscribe,
+      // token,
+      // ignore_subscribe,
     } = createUserDto as any;
 
     let { password } = createUserDto;
diff --git a/packages/nocodb/src/services/data-table.service.spec.ts b/packages/nocodb/src/services/data-table.service.spec.ts
new file mode 100644
index 0000000000..cf61df154f
--- /dev/null
+++ b/packages/nocodb/src/services/data-table.service.spec.ts
@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DataTableService } from './data-table.service';
+
+describe('DataTableService', () => {
+  let service: DataTableService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [DataTableService],
+    }).compile();
+
+    service = module.get<DataTableService>(DataTableService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});
diff --git a/packages/nocodb/src/services/data-table.service.ts b/packages/nocodb/src/services/data-table.service.ts
new file mode 100644
index 0000000000..262961abac
--- /dev/null
+++ b/packages/nocodb/src/services/data-table.service.ts
@@ -0,0 +1,434 @@
+import { Injectable } from '@nestjs/common';
+import { RelationTypes, UITypes } from 'nocodb-sdk';
+import { nocoExecute } from 'nc-help';
+import { NcError } from '../helpers/catchError';
+import getAst from '../helpers/getAst';
+import { PagedResponseImpl } from '../helpers/PagedResponse';
+import { Base, Column, Model, View } from '../models';
+import NcConnectionMgrv2 from '../utils/common/NcConnectionMgrv2';
+import { DatasService } from './datas.service';
+import type { LinkToAnotherRecordColumn } from '../models';
+
+@Injectable()
+export class DataTableService {
+  constructor(private datasService: DatasService) {}
+
+  async dataList(param: {
+    projectId?: string;
+    modelId: string;
+    query: any;
+    viewId?: string;
+  }) {
+    const { model, view } = await this.getModelAndView(param);
+
+    return await this.datasService.getDataList({
+      model,
+      view,
+      query: param.query,
+    });
+  }
+
+  async dataRead(param: {
+    projectId?: string;
+    modelId: string;
+    rowId: string;
+    viewId?: string;
+    query: any;
+  }) {
+    const { model, view } = await this.getModelAndView(param);
+
+    const base = await Base.get(model.base_id);
+
+    const baseModel = await Model.getBaseModelSQL({
+      id: model.id,
+      viewId: view?.id,
+      dbDriver: await NcConnectionMgrv2.get(base),
+    });
+
+    const row = await baseModel.readByPk(param.rowId, false, param.query);
+
+    if (!row) {
+      NcError.notFound('Row not found');
+    }
+
+    return row;
+  }
+
+  async dataInsert(param: {
+    projectId?: string;
+    viewId?: string;
+    modelId: string;
+    body: any;
+    cookie: any;
+  }) {
+    const { model, view } = await this.getModelAndView(param);
+    const base = await Base.get(model.base_id);
+
+    const baseModel = await Model.getBaseModelSQL({
+      id: model.id,
+      viewId: view?.id,
+      dbDriver: await NcConnectionMgrv2.get(base),
+    });
+
+    // if array then do bulk insert
+    const result = await baseModel.bulkInsert(
+      Array.isArray(param.body) ? param.body : [param.body],
+      { cookie: param.cookie, insertOneByOneAsFallback: true },
+    );
+
+    return Array.isArray(param.body) ? result : result[0];
+  }
+
+  async dataUpdate(param: {
+    projectId?: string;
+    modelId: string;
+    viewId?: string;
+    // rowId: string;
+    body: any;
+    cookie: any;
+  }) {
+    const { model, view } = await this.getModelAndView(param);
+
+    await this.checkForDuplicateRow({ rows: param.body, model });
+
+    const base = await Base.get(model.base_id);
+
+    const baseModel = await Model.getBaseModelSQL({
+      id: model.id,
+      viewId: view?.id,
+      dbDriver: await NcConnectionMgrv2.get(base),
+    });
+
+    const res = await baseModel.bulkUpdate(
+      Array.isArray(param.body) ? param.body : [param.body],
+      { cookie: param.cookie, throwExceptionIfNotExist: true },
+    );
+
+    return this.extractIdObj({ body: param.body, model });
+  }
+
+  async dataDelete(param: {
+    projectId?: string;
+    modelId: string;
+    viewId?: string;
+    // rowId: string;
+    cookie: any;
+    body: any;
+  }) {
+    const { model, view } = await this.getModelAndView(param);
+
+    await this.checkForDuplicateRow({ rows: param.body, model });
+
+    const base = await Base.get(model.base_id);
+    const baseModel = await Model.getBaseModelSQL({
+      id: model.id,
+      viewId: view?.id,
+      dbDriver: await NcConnectionMgrv2.get(base),
+    });
+
+    await baseModel.bulkDelete(
+      Array.isArray(param.body) ? param.body : [param.body],
+      { cookie: param.cookie, throwExceptionIfNotExist: true },
+    );
+
+    return this.extractIdObj({ body: param.body, model });
+  }
+
+  async dataCount(param: {
+    projectId?: string;
+    viewId?: string;
+    modelId: string;
+    query: any;
+  }) {
+    const { model, view } = await this.getModelAndView(param);
+
+    const base = await Base.get(model.base_id);
+
+    const baseModel = await Model.getBaseModelSQL({
+      id: model.id,
+      viewId: view?.id,
+      dbDriver: await NcConnectionMgrv2.get(base),
+    });
+
+    const countArgs: any = { ...param.query };
+    try {
+      countArgs.filterArr = JSON.parse(countArgs.filterArrJson);
+    } catch (e) {}
+
+    const count: number = await baseModel.count(countArgs);
+
+    return { count };
+  }
+
+  private async getModelAndView(param: {
+    projectId?: string;
+    viewId?: string;
+    modelId: string;
+  }) {
+    const model = await Model.get(param.modelId);
+
+    if (!model) {
+      NcError.notFound(`Table with id '${param.modelId}' not found`);
+    }
+
+    if (param.projectId && model.project_id !== param.projectId) {
+      throw new Error('Table not belong to project');
+    }
+
+    let view: View;
+
+    if (param.viewId) {
+      view = await View.get(param.viewId);
+      if (!view || (view.fk_model_id && view.fk_model_id !== param.modelId)) {
+        NcError.unprocessableEntity(`View with id '${param.viewId}' not found`);
+      }
+    }
+
+    return { model, view };
+  }
+
+  private async extractIdObj({
+    model,
+    body,
+  }: {
+    body: Record<string, any> | Record<string, any>[];
+    model: Model;
+  }) {
+    const pkColumns = await model
+      .getColumns()
+      .then((cols) => cols.filter((col) => col.pk));
+
+    const result = (Array.isArray(body) ? body : [body]).map((row) => {
+      return pkColumns.reduce((acc, col) => {
+        acc[col.title] = row[col.title];
+        return acc;
+      }, {});
+    });
+
+    return Array.isArray(body) ? result : result[0];
+  }
+
+  private async checkForDuplicateRow({
+    rows,
+    model,
+  }: {
+    rows: any[] | any;
+    model: Model;
+  }) {
+    if (!rows || !Array.isArray(rows) || rows.length === 1) {
+      return;
+    }
+
+    await model.getColumns();
+
+    const keys = new Set();
+
+    for (const row of rows) {
+      let pk;
+      // if only one primary key then extract the value
+      if (model.primaryKeys.length === 1) pk = row[model.primaryKey.title];
+      // if composite primary key then join the values with ___
+      else pk = model.primaryKeys.map((pk) => row[pk.title]).join('___');
+      // if duplicate then throw error
+      if (keys.has(pk)) {
+        NcError.unprocessableEntity('Duplicate row with id ' + pk);
+      }
+      keys.add(pk);
+    }
+  }
+
+  async nestedDataList(param: {
+    viewId: string;
+    modelId: string;
+    query: any;
+    rowId: string | string[] | number | number[];
+    columnId: string;
+  }) {
+    const { model, view } = await this.getModelAndView(param);
+    const base = await Base.get(model.base_id);
+
+    const baseModel = await Model.getBaseModelSQL({
+      id: model.id,
+      viewId: view?.id,
+      dbDriver: await NcConnectionMgrv2.get(base),
+    });
+
+    if (!(await baseModel.exist(param.rowId))) {
+      NcError.notFound(`Row with id '${param.rowId}' not found`);
+    }
+
+    const column = await this.getColumn(param);
+
+    const colOptions = await column.getColOptions<LinkToAnotherRecordColumn>();
+
+    const relatedModel = await colOptions.getRelatedTable();
+
+    const { ast, dependencyFields } = await getAst({
+      model: relatedModel,
+      query: param.query,
+      extractOnlyPrimaries: !(param.query?.f || param.query?.fields),
+    });
+
+    const listArgs: any = dependencyFields;
+    try {
+      listArgs.filterArr = JSON.parse(listArgs.filterArrJson);
+    } catch (e) {}
+    try {
+      listArgs.sortArr = JSON.parse(listArgs.sortArrJson);
+    } catch (e) {}
+
+    let data: any[];
+    let count: number;
+    if (colOptions.type === RelationTypes.MANY_TO_MANY) {
+      data = await baseModel.mmList(
+        {
+          colId: column.id,
+          parentId: param.rowId,
+        },
+        listArgs as any,
+      );
+      count = (await baseModel.mmListCount({
+        colId: column.id,
+        parentId: param.rowId,
+      })) as number;
+    } else if (colOptions.type === RelationTypes.HAS_MANY) {
+      data = await baseModel.hmList(
+        {
+          colId: column.id,
+          id: param.rowId,
+        },
+        listArgs as any,
+      );
+      count = (await baseModel.hmListCount({
+        colId: column.id,
+        id: param.rowId,
+      })) as number;
+    } else {
+      data = await baseModel.btRead(
+        {
+          colId: column.id,
+          id: param.rowId,
+        },
+        param.query as any,
+      );
+    }
+
+    data = await nocoExecute(ast, data, {}, listArgs);
+
+    if (colOptions.type === RelationTypes.BELONGS_TO) return data;
+
+    return new PagedResponseImpl(data, {
+      count,
+      ...param.query,
+    });
+  }
+
+  private async getColumn(param: { modelId: string; columnId: string }) {
+    const column = await Column.get({ colId: param.columnId });
+
+    if (!column)
+      NcError.notFound(`Column with id '${param.columnId}' not found`);
+
+    if (column.fk_model_id !== param.modelId)
+      NcError.badRequest('Column not belong to model');
+
+    if (column.uidt !== UITypes.LinkToAnotherRecord)
+      NcError.badRequest('Column is not LTAR');
+    return column;
+  }
+
+  async nestedLink(param: {
+    cookie: any;
+    viewId: string;
+    modelId: string;
+    columnId: string;
+    query: any;
+    refRowIds: string | string[] | number | number[];
+    rowId: string;
+  }) {
+    this.validateIds(param.refRowIds);
+
+    const { model, view } = await this.getModelAndView(param);
+
+    const base = await Base.get(model.base_id);
+
+    const baseModel = await Model.getBaseModelSQL({
+      id: model.id,
+      viewId: view?.id,
+      dbDriver: await NcConnectionMgrv2.get(base),
+    });
+
+    const column = await this.getColumn(param);
+
+    await baseModel.addLinks({
+      colId: column.id,
+      childIds: Array.isArray(param.refRowIds)
+        ? param.refRowIds
+        : [param.refRowIds],
+      rowId: param.rowId,
+      cookie: param.cookie,
+    });
+
+    return true;
+  }
+
+  async nestedUnlink(param: {
+    cookie: any;
+    viewId: string;
+    modelId: string;
+    columnId: string;
+    query: any;
+    refRowIds: string | string[] | number | number[];
+    rowId: string;
+  }) {
+    this.validateIds(param.refRowIds);
+
+    const { model, view } = await this.getModelAndView(param);
+    if (!model)
+      NcError.notFound('Table with id ' + param.modelId + ' not found');
+
+    const base = await Base.get(model.base_id);
+
+    const baseModel = await Model.getBaseModelSQL({
+      id: model.id,
+      viewId: view?.id,
+      dbDriver: await NcConnectionMgrv2.get(base),
+    });
+
+    const column = await this.getColumn(param);
+
+    await baseModel.removeLinks({
+      colId: column.id,
+      childIds: Array.isArray(param.refRowIds)
+        ? param.refRowIds
+        : [param.refRowIds],
+      rowId: param.rowId,
+      cookie: param.cookie,
+    });
+
+    return true;
+  }
+
+  private validateIds(rowIds: any[] | any) {
+    if (Array.isArray(rowIds)) {
+      const map = new Map<string, boolean>();
+      const set = new Set<string>();
+      for (const rowId of rowIds) {
+        if (rowId === undefined || rowId === null)
+          NcError.unprocessableEntity('Invalid row id ' + rowId);
+        if (map.has(rowId)) {
+          set.add(rowId);
+        } else {
+          map.set(rowId, true);
+        }
+      }
+
+      if (set.size > 0)
+        NcError.unprocessableEntity(
+          'Child record with id [' + [...set].join(', ') + '] are duplicated',
+        );
+    } else if (rowIds === undefined || rowIds === null) {
+      NcError.unprocessableEntity('Invalid row id ' + rowIds);
+    }
+  }
+}
diff --git a/packages/nocodb/src/services/datas.service.ts b/packages/nocodb/src/services/datas.service.ts
index d1e1c89705..3c7cf474ad 100644
--- a/packages/nocodb/src/services/datas.service.ts
+++ b/packages/nocodb/src/services/datas.service.ts
@@ -117,7 +117,7 @@ export class DatasService {
 
   async getDataList(param: {
     model: Model;
-    view: View;
+    view?: View;
     query: any;
     baseModel?: BaseModelSqlv2;
   }) {
diff --git a/packages/nocodb/src/services/tables.service.ts b/packages/nocodb/src/services/tables.service.ts
index b656efe362..4f27fb5b0b 100644
--- a/packages/nocodb/src/services/tables.service.ts
+++ b/packages/nocodb/src/services/tables.service.ts
@@ -14,13 +14,7 @@ import getColumnPropsFromUIDT from '../helpers/getColumnPropsFromUIDT';
 import getColumnUiType from '../helpers/getColumnUiType';
 import getTableNameAlias, { getColumnNameAlias } from '../helpers/getTableName';
 import mapDefaultDisplayValue from '../helpers/mapDefaultDisplayValue';
-import {
-  Audit,
-  Column,
-  Model,
-  ModelRoleVisibility,
-  Project,
-} from '../models';
+import { Audit, Column, Model, ModelRoleVisibility, Project } from '../models';
 import Noco from '../Noco';
 import NcConnectionMgrv2 from '../utils/common/NcConnectionMgrv2';
 import { validatePayload } from '../helpers';
diff --git a/packages/nocodb/src/utils/common/XcAudit.ts b/packages/nocodb/src/utils/common/XcAudit.ts
index 1c5573f704..bb20ef57ef 100644
--- a/packages/nocodb/src/utils/common/XcAudit.ts
+++ b/packages/nocodb/src/utils/common/XcAudit.ts
@@ -9,5 +9,6 @@ export default class XcAudit {
   private static app: Noco;
 
   // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public static async log(data: { project }) {}
 }
diff --git a/packages/nocodb/tests/unit/factory/column.ts b/packages/nocodb/tests/unit/factory/column.ts
index 1b9617f7b9..0655e25c18 100644
--- a/packages/nocodb/tests/unit/factory/column.ts
+++ b/packages/nocodb/tests/unit/factory/column.ts
@@ -1,13 +1,13 @@
 import { UITypes } from 'nocodb-sdk';
 import request from 'supertest';
-import Column from '../../../src/models/Column';
-import FormViewColumn from '../../../src/models/FormViewColumn';
-import GalleryViewColumn from '../../../src/models/GalleryViewColumn';
-import GridViewColumn from '../../../src/models/GridViewColumn';
 import Model from '../../../src/models/Model';
-import Project from '../../../src/models/Project';
-import View from '../../../src/models/View';
-import { isSqlite, isPg } from '../init/db';
+import { isPg, isSqlite } from '../init/db';
+import type Column from '../../../src/models/Column';
+import type FormViewColumn from '../../../src/models/FormViewColumn';
+import type GalleryViewColumn from '../../../src/models/GalleryViewColumn';
+import type GridViewColumn from '../../../src/models/GridViewColumn';
+import type Project from '../../../src/models/Project';
+import type View from '../../../src/models/View';
 
 const defaultColumns = function (context) {
   return [
@@ -46,6 +46,122 @@ const defaultColumns = function (context) {
   ];
 };
 
+const customColumns = function (type: string, options: any = {}) {
+  switch (type) {
+    case 'textBased':
+      return [
+        {
+          column_name: 'Id',
+          title: 'Id',
+          uidt: UITypes.ID,
+        },
+        {
+          column_name: 'SingleLineText',
+          title: 'SingleLineText',
+          uidt: UITypes.SingleLineText,
+        },
+        {
+          column_name: 'MultiLineText',
+          title: 'MultiLineText',
+          uidt: UITypes.LongText,
+        },
+        {
+          column_name: 'Email',
+          title: 'Email',
+          uidt: UITypes.Email,
+        },
+        {
+          column_name: 'Phone',
+          title: 'Phone',
+          uidt: UITypes.PhoneNumber,
+        },
+        {
+          column_name: 'Url',
+          title: 'Url',
+          uidt: UITypes.URL,
+        },
+      ];
+    case 'numberBased':
+      return [
+        {
+          column_name: 'Id',
+          title: 'Id',
+          uidt: UITypes.ID,
+        },
+        {
+          column_name: 'Number',
+          title: 'Number',
+          uidt: UITypes.Number,
+        },
+        {
+          column_name: 'Decimal',
+          title: 'Decimal',
+          uidt: UITypes.Decimal,
+        },
+        {
+          column_name: 'Currency',
+          title: 'Currency',
+          uidt: UITypes.Currency,
+        },
+        {
+          column_name: 'Percent',
+          title: 'Percent',
+          uidt: UITypes.Percent,
+        },
+        {
+          column_name: 'Duration',
+          title: 'Duration',
+          uidt: UITypes.Duration,
+        },
+        {
+          column_name: 'Rating',
+          title: 'Rating',
+          uidt: UITypes.Rating,
+        },
+      ];
+    case 'dateBased':
+      return [
+        {
+          column_name: 'Id',
+          title: 'Id',
+          uidt: UITypes.ID,
+        },
+        {
+          column_name: 'Date',
+          title: 'Date',
+          uidt: UITypes.Date,
+        },
+        {
+          column_name: 'DateTime',
+          title: 'DateTime',
+          uidt: UITypes.DateTime,
+        },
+      ];
+    case 'selectBased':
+      return [
+        {
+          column_name: 'Id',
+          title: 'Id',
+          uidt: UITypes.ID,
+        },
+        {
+          column_name: 'SingleSelect',
+          title: 'SingleSelect',
+          uidt: UITypes.SingleSelect,
+          dtxp: "'jan','feb','mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'",
+        },
+        {
+          column_name: 'MultiSelect',
+          title: 'MultiSelect',
+          uidt: UITypes.MultiSelect,
+          dtxp: "'jan','feb','mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'",
+        },
+      ];
+    case 'custom':
+      return [{ title: 'Id', column_name: 'Id', uidt: UITypes.ID }, ...options];
+  }
+};
+
 const createColumn = async (context, table, columnAttr) => {
   await request(context.app)
     .post(`/api/v1/db/meta/tables/${table.id}/columns`)
@@ -55,7 +171,7 @@ const createColumn = async (context, table, columnAttr) => {
     });
 
   const column: Column = (await table.getColumns()).find(
-    (column) => column.title === columnAttr.title
+    (column) => column.title === columnAttr.title,
   );
   return column;
 };
@@ -76,7 +192,7 @@ const createRollupColumn = async (
     table: Model;
     relatedTableName: string;
     relatedTableColumnTitle: string;
-  }
+  },
 ) => {
   const childBases = await project.getBases();
   const childTable = await Model.getByIdOrName({
@@ -86,13 +202,13 @@ const createRollupColumn = async (
   });
   const childTableColumns = await childTable.getColumns();
   const childTableColumn = await childTableColumns.find(
-    (column) => column.title === relatedTableColumnTitle
+    (column) => column.title === relatedTableColumnTitle,
   );
 
   const ltarColumn = (await table.getColumns()).find(
     (column) =>
       column.uidt === UITypes.LinkToAnotherRecord &&
-      column.colOptions?.fk_related_model_id === childTable.id
+      column.colOptions?.fk_related_model_id === childTable.id,
   );
 
   const rollupColumn = await createColumn(context, table, {
@@ -122,7 +238,7 @@ const createLookupColumn = async (
     table: Model;
     relatedTableName: string;
     relatedTableColumnTitle: string;
-  }
+  },
 ) => {
   const childBases = await project.getBases();
   const childTable = await Model.getByIdOrName({
@@ -132,19 +248,19 @@ const createLookupColumn = async (
   });
   const childTableColumns = await childTable.getColumns();
   const childTableColumn = await childTableColumns.find(
-    (column) => column.title === relatedTableColumnTitle
+    (column) => column.title === relatedTableColumnTitle,
   );
 
   if (!childTableColumn) {
     throw new Error(
-      `Could not find column ${relatedTableColumnTitle} in ${relatedTableName}`
+      `Could not find column ${relatedTableColumnTitle} in ${relatedTableName}`,
     );
   }
 
   const ltarColumn = (await table.getColumns()).find(
     (column) =>
       column.uidt === UITypes.LinkToAnotherRecord &&
-      column.colOptions?.fk_related_model_id === childTable.id
+      column.colOptions?.fk_related_model_id === childTable.id,
   );
   const lookupColumn = await createColumn(context, table, {
     title: title,
@@ -168,15 +284,15 @@ const createQrCodeColumn = async (
     title: string;
     table: Model;
     referencedQrValueTableColumnTitle: string;
-  }
+  },
 ) => {
   const referencedQrValueTableColumnId = await table
     .getColumns()
     .then(
       (cols) =>
         cols.find(
-          (column) => column.title == referencedQrValueTableColumnTitle
-        )['id']
+          (column) => column.title == referencedQrValueTableColumnTitle,
+        )['id'],
     );
 
   const qrCodeColumn = await createColumn(context, table, {
@@ -198,15 +314,15 @@ const createBarcodeColumn = async (
     title: string;
     table: Model;
     referencedBarcodeValueTableColumnTitle: string;
-  }
+  },
 ) => {
   const referencedBarcodeValueTableColumnId = await table
     .getColumns()
     .then(
       (cols) =>
         cols.find(
-          (column) => column.title == referencedBarcodeValueTableColumnTitle
-        )['id']
+          (column) => column.title == referencedBarcodeValueTableColumnTitle,
+        )['id'],
     );
 
   const barcodeColumn = await createColumn(context, table, {
@@ -230,7 +346,7 @@ const createLtarColumn = async (
     parentTable: Model;
     childTable: Model;
     type: string;
-  }
+  },
 ) => {
   const ltarColumn = await createColumn(context, parentTable, {
     title: title,
@@ -246,7 +362,7 @@ const createLtarColumn = async (
 
 const updateViewColumn = async (
   context,
-  { view, column, attr }: { column: Column; view: View; attr: any }
+  { view, column, attr }: { column: Column; view: View; attr: any },
 ) => {
   const res = await request(context.app)
     .patch(`/api/v1/db/meta/views/${view.id}/columns/${column.id}`)
@@ -263,6 +379,7 @@ const updateViewColumn = async (
 };
 
 export {
+  customColumns,
   defaultColumns,
   createColumn,
   createQrCodeColumn,
diff --git a/packages/nocodb/tests/unit/factory/row.ts b/packages/nocodb/tests/unit/factory/row.ts
index 1883f185fe..8bfd7f2fc8 100644
--- a/packages/nocodb/tests/unit/factory/row.ts
+++ b/packages/nocodb/tests/unit/factory/row.ts
@@ -1,11 +1,12 @@
-import { ColumnType, UITypes } from 'nocodb-sdk';
+import { UITypes } from 'nocodb-sdk';
 import request from 'supertest';
-import Column from '../../../src/models/Column';
-import Filter from '../../../src/models/Filter';
 import Model from '../../../src/models/Model';
-import Project from '../../../src/models/Project';
-import Sort from '../../../src/models/Sort';
 import NcConnectionMgrv2 from '../../../src/utils/common/NcConnectionMgrv2';
+import type { ColumnType } from 'nocodb-sdk';
+import type Column from '../../../src/models/Column';
+import type Filter from '../../../src/models/Filter';
+import type Project from '../../../src/models/Project';
+import type Sort from '../../../src/models/Sort';
 
 const rowValue = (column: ColumnType, index: number) => {
   switch (column.uidt) {
@@ -175,9 +176,17 @@ const rowMixedValue = (column: ColumnType, index: number) => {
     case UITypes.Date:
       // set startDate as 400 days before today
       // eslint-disable-next-line no-case-declarations
-      const result = new Date();
-      result.setDate(result.getDate() - 400 + index);
-      return result.toISOString().slice(0, 10);
+      const d1 = new Date();
+      d1.setDate(d1.getDate() - 400 + index);
+      return d1.toISOString().slice(0, 10);
+    case UITypes.DateTime:
+      // set startDate as 400 days before today
+      // eslint-disable-next-line no-case-declarations
+      const d2 = new Date();
+      d2.setDate(d2.getDate() - 400 + index);
+      // set time to 12:00:00
+      d2.setHours(12, 0, 0, 0);
+      return d2.toISOString();
     case UITypes.URL:
       return urls[index % urls.length];
     case UITypes.SingleSelect:
@@ -228,7 +237,7 @@ const listRow = async ({
 
 const getOneRow = async (
   context,
-  { project, table }: { project: Project; table: Model }
+  { project, table }: { project: Project; table: Model },
 ) => {
   const response = await request(context.app)
     .get(`/api/v1/db/data/noco/${project.id}/${table.id}/find-one`)
@@ -266,7 +275,7 @@ const createRow = async (
     project: Project;
     table: Model;
     index?: number;
-  }
+  },
 ) => {
   const columns = await table.getColumns();
   const rowData = generateDefaultRowAttributes({ columns, index });
@@ -289,7 +298,7 @@ const createBulkRows = async (
     project: Project;
     table: Model;
     values: any[];
-  }
+  },
 ) => {
   await request(context.app)
     .post(`/api/v1/db/data/bulk/noco/${project.id}/${table.id}`)
@@ -317,7 +326,7 @@ const createChildRow = async (
     rowId?: string;
     childRowId?: string;
     type: string;
-  }
+  },
 ) => {
   if (!rowId) {
     const row = await createRow(context, { project, table });
@@ -331,7 +340,7 @@ const createChildRow = async (
 
   await request(context.app)
     .post(
-      `/api/v1/db/data/noco/${project.id}/${table.id}/${rowId}/${type}/${column.title}/${childRowId}`
+      `/api/v1/db/data/noco/${project.id}/${table.id}/${rowId}/${type}/${column.title}/${childRowId}`,
     )
     .set('xc-auth', context.token);
 
diff --git a/packages/nocodb/tests/unit/factory/view.ts b/packages/nocodb/tests/unit/factory/view.ts
index 578b156423..a6193f9df8 100644
--- a/packages/nocodb/tests/unit/factory/view.ts
+++ b/packages/nocodb/tests/unit/factory/view.ts
@@ -1,9 +1,20 @@
 import { ViewTypes } from 'nocodb-sdk';
 import request from 'supertest';
-import Model from '../../../src/models/Model';
 import View from '../../../src/models/View';
+import type Model from '../../../src/models/Model';
 
-const createView = async (context, {title, table, type}: {title: string, table: Model, type: ViewTypes}) => {
+const createView = async (
+  context,
+  {
+    title,
+    table,
+    type,
+  }: {
+    title: string;
+    table: Model;
+    type: ViewTypes;
+  },
+) => {
   const viewTypeStr = (type) => {
     switch (type) {
       case ViewTypes.GALLERY:
@@ -26,13 +37,70 @@ const createView = async (context, {title, table, type}: {title: string, table:
       title,
       type,
     });
-  if(response.status !== 200) {
-    throw new Error('createView',response.body.message);
+  if (response.status !== 200) {
+    throw new Error('createView', response.body.message);
   }
 
-  const view = await View.getByTitleOrId({fk_model_id: table.id, titleOrId:title}) as View;
+  const view = (await View.getByTitleOrId({
+    fk_model_id: table.id,
+    titleOrId: title,
+  })) as View;
+  return view;
+};
 
-  return view
-}
+const updateView = async (
+  context,
+  {
+    table,
+    view,
+    filter = [],
+    sort = [],
+    field = [],
+  }: {
+    table: Model;
+    view: View;
+    filter?: any[];
+    sort?: any[];
+    field?: any[];
+  },
+) => {
+  if (filter.length) {
+    for (let i = 0; i < filter.length; i++) {
+      await request(context.app)
+        .post(`/api/v1/db/meta/views/${view.id}/filters`)
+        .set('xc-auth', context.token)
+        .send(filter[i])
+        .expect(200);
+    }
+  }
+
+  if (sort.length) {
+    for (let i = 0; i < sort.length; i++) {
+      await request(context.app)
+        .post(`/api/v1/db/meta/views/${view.id}/sorts`)
+        .set('xc-auth', context.token)
+        .send(sort[i])
+        .expect(200);
+    }
+  }
+
+  if (field.length) {
+    for (let i = 0; i < field.length; i++) {
+      const columns = await table.getColumns();
+      const viewColumns = await view.getColumns();
+
+      const columnId = columns.find((c) => c.title === field[i]).id;
+      const viewColumnId = viewColumns.find(
+        (c) => c.fk_column_id === columnId,
+      ).id;
+      // configure view to hide selected fields
+      await request(context.app)
+        .patch(`/api/v1/db/meta/views/${view.id}/columns/${viewColumnId}`)
+        .set('xc-auth', context.token)
+        .send({ show: false })
+        .expect(200);
+    }
+  }
+};
 
-export {createView}
+export { createView, updateView };
diff --git a/packages/nocodb/tests/unit/init/index.ts b/packages/nocodb/tests/unit/init/index.ts
index 5081543ed7..f456e25c56 100644
--- a/packages/nocodb/tests/unit/init/index.ts
+++ b/packages/nocodb/tests/unit/init/index.ts
@@ -25,7 +25,7 @@ const serverInit = async () => {
 
 const isFirstTimeRun = () => !server;
 
-export default async function () {
+export default async function (isSakila = true) {
   const { default: TestDbMngr } = await import('../TestDbMngr');
 
   if (isFirstTimeRun()) {
@@ -33,7 +33,10 @@ export default async function () {
     server = await serverInit();
   }
 
-  await cleanUpSakila();
+  if (isSakila) {
+    await cleanUpSakila();
+  }
+
   await cleanupMeta();
 
   const { token } = await createUser({ app: server }, { roles: 'editor' });
diff --git a/packages/nocodb/tests/unit/rest/index.test.ts b/packages/nocodb/tests/unit/rest/index.test.ts
index e7954e4a35..469add0a82 100644
--- a/packages/nocodb/tests/unit/rest/index.test.ts
+++ b/packages/nocodb/tests/unit/rest/index.test.ts
@@ -8,6 +8,7 @@ import tableRowTests from './tests/tableRow.test';
 import viewRowTests from './tests/viewRow.test';
 import attachmentTests from './tests/attachment.test';
 import filterTest from './tests/filter.test';
+import newDataApisTest from './tests/newDataApis.test';
 
 function restTests() {
   authTests();
@@ -19,6 +20,7 @@ function restTests() {
   columnTypeSpecificTests();
   attachmentTests();
   filterTest();
+  newDataApisTest();
 }
 
 export default function () {
diff --git a/packages/nocodb/tests/unit/rest/tests/newDataApis.test.ts b/packages/nocodb/tests/unit/rest/tests/newDataApis.test.ts
new file mode 100644
index 0000000000..7e3ab6dd08
--- /dev/null
+++ b/packages/nocodb/tests/unit/rest/tests/newDataApis.test.ts
@@ -0,0 +1,2867 @@
+/**
+ * Records List
+ *  - default
+ *  - pageSize
+ *  - limit
+ *  - offset
+ *  - fields, single
+ *  - fields, multiple
+ *  - sort, ascending
+ *  - sort, descending
+ *  - sort, multiple
+ *  - filter, single
+ *  - filter, multiple
+ *  - field type : number based (number, currency, percent, decimal, rating, duration)
+ *  - field type : text based (text, longtext, email, phone, url)
+ *  - field type : select based (single select, multi select)
+ *  - field type : date based (date, datetime, time)
+ *  - field type : virtual (link, lookup, rollup, formula)
+ *  - field type : misc (checkbox, attachment, barcode, qrcode, json)
+ *  - viewID
+ *  - viewID, explicit fields
+ *  - viewID, explicit sort
+ *  - viewID, explicit filter
+ *  # Error handling
+ *    - invalid table ID
+ *    - invalid view ID
+ *    - invalid field name
+ *    - invalid sort condition
+ *    - invalid filter condition
+ *    - invalid pageSize
+ *    - invalid limit
+ *    - invalid offset
+ *
+ *
+ * Records Create
+ *  - field type : number based (number, currency, percent, decimal, rating, duration)
+ *  - field type : text based (text, longtext, email, phone, url)
+ *  - field type : select based (single select, multi select)
+ *  - field type : date based (date, datetime, time)
+ *  - field type : virtual (link)
+ *  - field type : misc (checkbox, attachment, barcode, qrcode, json)
+ *  - bulk insert
+ *  - bulk insert-all
+ *  # Error handling
+ *    - invalid table ID
+ *    - invalid field type
+ *    - invalid field value (when validation enabled : email, url, phone number, rating, select fields, text fields, number fields, date fields)
+ *    - invalid payload size
+ *
+ *
+ * Record read
+ *  - field type : number based (number, currency, percent, decimal, rating, duration)
+ *  - field type : text based (text, longtext, email, phone, url)
+ *  - field type : select based (single select, multi select)
+ *  - field type : date based (date, datetime, time)
+ *  - field type : virtual (link, lookup, rollup, formula)
+ *  - field type : misc (checkbox, attachment, barcode, qrcode, json)
+ *  # Error handling
+ *    - invalid table ID
+ *    - invalid record ID
+ *
+ *
+ * Record update
+ * - field type : number based (number, currency, percent, decimal, rating, duration)
+ * - field type : text based (text, longtext, email, phone, url)
+ * - field type : select based (single select, multi select)
+ * - field type : date based (date, datetime, time)
+ * - field type : virtual (link)
+ * - field type : misc (checkbox, attachment, barcode, qrcode, json)
+ * - bulk update
+ * - bulk update-all
+ * # Error handling
+ *    - invalid table ID
+ *    - invalid record ID
+ *
+ * Record delete
+ * - default
+ * - bulk delete
+ * # Error handling
+ *    - invalid table ID
+ *    - invalid record ID
+ */
+
+import 'mocha';
+import { UITypes, ViewTypes } from 'nocodb-sdk';
+import { expect } from 'chai';
+import request from 'supertest';
+import init from '../../init';
+import { createProject, createSakilaProject } from '../../factory/project';
+import { createTable, getTable } from '../../factory/table';
+import { createBulkRows, listRow, rowMixedValue } from '../../factory/row';
+import {
+  createLookupColumn,
+  createLtarColumn,
+  createRollupColumn,
+  customColumns,
+} from '../../factory/column';
+import { createView, updateView } from '../../factory/view';
+
+import { isPg } from '../../init/db';
+import type { ColumnType } from 'nocodb-sdk';
+import type Project from '../../../../src/models/Project';
+import type Model from '../../../../src/models/Model';
+
+const debugMode = false;
+
+let context;
+let project: Project;
+let table: Model;
+let columns: any[];
+let insertedRecords: any[] = [];
+
+let sakilaProject: Project;
+let customerTable: Model;
+let customerColumns;
+let actorTable: Model;
+let actorColumns;
+let countryTable: Model;
+let countryColumns;
+let cityTable: Model;
+let cityColumns;
+
+// Optimisation scope for time reduction
+// 1. BeforeEach can be changed to BeforeAll for List and Read APIs
+
+///////////////////////////////////////////////////////////////////////////////
+// Utility routines
+
+const verifyColumnsInRsp = (row, columns: ColumnType[]) => {
+  const responseColumnsListStr = Object.keys(row).sort().join(',');
+  const expectedColumnsListStr = columns
+    .map((c) => c.title)
+    .sort()
+    .join(',');
+
+  return responseColumnsListStr === expectedColumnsListStr;
+};
+
+async function ncAxiosGet({
+  url = `/api/v1/tables/${table.id}/rows`,
+  query = {},
+  status = 200,
+}: { url?: string; query?: any; status?: number } = {}) {
+  const response = await request(context.app)
+    .get(url)
+    .set('xc-auth', context.token)
+    .query(query)
+    .send({});
+  expect(response.status).to.equal(status);
+  return response;
+}
+async function ncAxiosPost({
+  url = `/api/v1/tables/${table.id}/rows`,
+  body = {},
+  status = 200,
+}: { url?: string; body?: any; status?: number } = {}) {
+  const response = await request(context.app)
+    .post(url)
+    .set('xc-auth', context.token)
+    .send(body);
+  expect(response.status).to.equal(status);
+  return response;
+}
+async function ncAxiosPatch({
+  url = `/api/v1/tables/${table.id}/rows`,
+  body = {},
+  status = 200,
+}: { url?: string; body?: any; status?: number } = {}) {
+  const response = await request(context.app)
+    .patch(url)
+    .set('xc-auth', context.token)
+    .send(body);
+  expect(response.status).to.equal(status);
+  return response;
+}
+async function ncAxiosDelete({
+  url = `/api/v1/tables/${table.id}/rows`,
+  body = {},
+  status = 200,
+}: { url?: string; body?: any; status?: number } = {}) {
+  const response = await request(context.app)
+    .delete(url)
+    .set('xc-auth', context.token)
+    .send(body);
+  expect(response.status).to.equal(status);
+  return response;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+async function ncAxiosLinkGet({
+  urlParams: { tableId, linkId, rowId },
+  query = {},
+  status = 200,
+  msg,
+}: { urlParams?: any; query?: any; status?: number; msg?: string } = {}) {
+  const urlParams = { tableId, linkId, rowId };
+  const url = `/api/v1/tables/${urlParams.tableId}/links/${urlParams.linkId}/rows/${urlParams.rowId}`;
+  const response = await request(context.app)
+    .get(url)
+    .set('xc-auth', context.token)
+    .query(query)
+    .send({});
+  if (debugMode && status !== response.status)
+    console.log('#### expected', status, 'received', response.status);
+  else expect(response.status).to.equal(status);
+
+  // print error codes
+  if (debugMode && status !== 200) {
+    console.log('#### ', response.body.msg);
+  }
+  if (!debugMode && msg) expect(response.body.msg).to.equal(msg);
+
+  return response;
+}
+async function ncAxiosLinkAdd({
+  urlParams: { tableId, linkId, rowId },
+  body = {},
+  status = 201,
+  msg,
+}: { urlParams?: any; body?: any; status?: number; msg?: string } = {}) {
+  const urlParams = { tableId, linkId, rowId };
+  const url = `/api/v1/tables/${urlParams.tableId}/links/${urlParams.linkId}/rows/${urlParams.rowId}`;
+  const response = await request(context.app)
+    .post(url)
+    .set('xc-auth', context.token)
+    .send(body);
+
+  if (debugMode && status !== response.status)
+    console.log('#### expected', status, 'received', response.status);
+  else expect(response.status).to.equal(status);
+
+  // print error codes
+  if (debugMode && status !== 201) {
+    console.log('#### ', response.body.msg);
+  }
+
+  if (!debugMode && msg) expect(response.body.msg).to.equal(msg);
+
+  return response;
+}
+async function ncAxiosLinkRemove({
+  urlParams: { tableId, linkId, rowId },
+  body = {},
+  status = 200,
+  msg,
+}: { urlParams?: any; body?: any; status?: number; msg?: string } = {}) {
+  const urlParams = { tableId, linkId, rowId };
+  const url = `/api/v1/tables/${urlParams.tableId}/links/${urlParams.linkId}/rows/${urlParams.rowId}`;
+  const response = await request(context.app)
+    .delete(url)
+    .set('xc-auth', context.token)
+    .send(body);
+  if (debugMode && status !== response.status)
+    console.log('#### expected', status, 'received', response.status);
+  else expect(response.status).to.equal(status);
+
+  // print error codes
+  if (debugMode && status !== 200) {
+    console.log('#### ', response.body.msg);
+  }
+  if (!debugMode && msg) expect(response.body.msg).to.equal(msg);
+
+  return response;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// generic table, sakila based
+function generalDb() {
+  beforeEach(async function () {
+    context = await init();
+
+    sakilaProject = await createSakilaProject(context);
+    project = await createProject(context);
+
+    customerTable = await getTable({
+      project: sakilaProject,
+      name: 'customer',
+    });
+    customerColumns = await customerTable.getColumns();
+
+    actorTable = await getTable({
+      project: sakilaProject,
+      name: 'actor',
+    });
+    actorColumns = await actorTable.getColumns();
+
+    countryTable = await getTable({
+      project: sakilaProject,
+      name: 'country',
+    });
+    countryColumns = await countryTable.getColumns();
+
+    cityTable = await getTable({
+      project: sakilaProject,
+      name: 'city',
+    });
+    cityColumns = await cityTable.getColumns();
+  });
+
+  it('Nested List - Link to another record', async function () {
+    const expectedRecords = [
+      [
+        {
+          CityId: 251,
+          City: 'Kabul',
+        },
+      ],
+      [
+        {
+          CityId: 59,
+          City: 'Batna',
+        },
+        {
+          CityId: 63,
+          City: 'Bchar',
+        },
+        {
+          CityId: 483,
+          City: 'Skikda',
+        },
+      ],
+      [
+        {
+          CityId: 516,
+          City: 'Tafuna',
+        },
+      ],
+      [
+        {
+          CityId: 67,
+          City: 'Benguela',
+        },
+        {
+          CityId: 360,
+          City: 'Namibe',
+        },
+      ],
+    ];
+
+    // read first 4 records
+    const records = await ncAxiosGet({
+      url: `/api/v1/tables/${countryTable.id}/rows`,
+      query: {
+        limit: 4,
+      },
+    });
+    expect(records.body.list.length).to.equal(4);
+
+    // extract LTAR column "City List"
+    const cityList = records.body.list.map((r) => r['City List']);
+    expect(cityList).to.deep.equal(expectedRecords);
+  });
+
+  it('Nested List - Lookup', async function () {
+    const lookupColumn = await createLookupColumn(context, {
+      project: sakilaProject,
+      title: 'Lookup',
+      table: countryTable,
+      relatedTableName: cityTable.table_name,
+      relatedTableColumnTitle: 'City',
+    });
+
+    const expectedRecords = [
+      ['Kabul'],
+      ['Batna', 'Bchar', 'Skikda'],
+      ['Tafuna'],
+      ['Benguela', 'Namibe'],
+    ];
+
+    // read first 4 records
+    const records = await ncAxiosGet({
+      url: `/api/v1/tables/${countryTable.id}/rows`,
+      query: {
+        limit: 4,
+      },
+    });
+    expect(records.body.list.length).to.equal(4);
+
+    // extract Lookup column
+    const lookupData = records.body.list.map((record) => record.Lookup);
+    expect(lookupData).to.deep.equal(expectedRecords);
+  });
+
+  it('Nested List - Rollup', async function () {
+    const rollupColumn = await createRollupColumn(context, {
+      project: sakilaProject,
+      title: 'Rollup',
+      table: countryTable,
+      relatedTableName: cityTable.table_name,
+      relatedTableColumnTitle: 'City',
+      rollupFunction: 'count',
+    });
+
+    const expectedRecords = [1, 3, 1, 2];
+    const expectedRecordsPg = ['1', '3', '1', '2'];
+
+    // read first 4 records
+    const records = await ncAxiosGet({
+      url: `/api/v1/tables/${countryTable.id}/rows`,
+      query: {
+        limit: 4,
+      },
+    });
+    expect(records.body.list.length).to.equal(4);
+
+    // extract Lookup column
+    const rollupData = records.body.list.map((record) => record.Rollup);
+    if (isPg(context)) {
+      expect(rollupData).to.deep.equal(expectedRecordsPg);
+    } else {
+      expect(rollupData).to.deep.equal(expectedRecords);
+    }
+  });
+
+  it('Nested Read - Link to another record', async function () {
+    const records = await ncAxiosGet({
+      url: `/api/v1/tables/${countryTable.id}/rows/1`,
+    });
+
+    // extract LTAR column "City List"
+    expect(records.body['City List']).to.deep.equal([
+      {
+        CityId: 251,
+        City: 'Kabul',
+      },
+    ]);
+  });
+
+  it('Nested Read - Lookup', async function () {
+    const lookupColumn = await createLookupColumn(context, {
+      project: sakilaProject,
+      title: 'Lookup',
+      table: countryTable,
+      relatedTableName: cityTable.table_name,
+      relatedTableColumnTitle: 'City',
+    });
+
+    const records = await ncAxiosGet({
+      url: `/api/v1/tables/${countryTable.id}/rows/1`,
+    });
+    expect(records.body.Lookup).to.deep.equal(['Kabul']);
+  });
+
+  it('Nested Read - Rollup', async function () {
+    const rollupColumn = await createRollupColumn(context, {
+      project: sakilaProject,
+      title: 'Rollup',
+      table: countryTable,
+      relatedTableName: cityTable.table_name,
+      relatedTableColumnTitle: 'City',
+      rollupFunction: 'count',
+    });
+
+    const records = await ncAxiosGet({
+      url: `/api/v1/tables/${countryTable.id}/rows/1`,
+    });
+    if (isPg(context)) {
+      expect(records.body.Rollup).to.equal('1');
+    } else {
+      expect(records.body.Rollup).to.equal(1);
+    }
+  });
+}
+
+function textBased() {
+  // prepare data for test cases
+  beforeEach(async function () {
+    context = await init(false);
+    project = await createProject(context);
+    table = await createTable(context, project, {
+      table_name: 'textBased',
+      title: 'TextBased',
+      columns: customColumns('textBased'),
+    });
+
+    // retrieve column meta
+    columns = await table.getColumns();
+
+    // build records
+    const rowAttributes = [];
+    for (let i = 0; i < 400; i++) {
+      const row = {
+        SingleLineText: rowMixedValue(columns[1], i),
+        MultiLineText: rowMixedValue(columns[2], i),
+        Email: rowMixedValue(columns[3], i),
+        Phone: rowMixedValue(columns[4], i),
+        Url: rowMixedValue(columns[5], i),
+      };
+      rowAttributes.push(row);
+    }
+
+    // insert records
+    // creating bulk records using older set of APIs
+    await createBulkRows(context, {
+      project,
+      table,
+      values: rowAttributes,
+    });
+
+    // retrieve inserted records
+    insertedRecords = await listRow({ project, table });
+
+    // verify length of unfiltered records to be 400
+    expect(insertedRecords.length).to.equal(400);
+  });
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  // LIST
+  //
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  it('List: default', async function () {
+    const rsp = await ncAxiosGet();
+
+    const expectedPageInfo = {
+      totalRows: 400,
+      page: 1,
+      pageSize: 25,
+      isFirstPage: true,
+      isLastPage: false,
+    };
+    expect(rsp.body.pageInfo).to.deep.equal(expectedPageInfo);
+
+    // verify if all the columns are present in the response
+    expect(verifyColumnsInRsp(rsp.body.list[0], columns)).to.equal(true);
+
+    // verify column data
+    const expectedData = insertedRecords.slice(0, 1);
+    expect(JSON.stringify(rsp.body.list[0])).to.deep.equal(
+      JSON.stringify(expectedData[0]),
+    );
+  });
+
+  it('List: offset, limit', async function () {
+    const rsp = await ncAxiosGet({ query: { offset: 200, limit: 100 } });
+
+    const expectedPageInfo = {
+      totalRows: 400,
+      page: 3,
+      pageSize: 100,
+      isFirstPage: false,
+      isLastPage: false,
+    };
+    expect(rsp.body.pageInfo).to.deep.equal(expectedPageInfo);
+  });
+
+  it('List: fields, single', async function () {
+    const rsp = await ncAxiosGet({
+      query: { fields: 'SingleLineText' },
+    });
+
+    expect(
+      verifyColumnsInRsp(rsp.body.list[0], [{ title: 'SingleLineText' }]),
+    ).to.equal(true);
+  });
+
+  it('List: fields, multiple', async function () {
+    const rsp = await ncAxiosGet({
+      query: { fields: ['SingleLineText', 'MultiLineText'] },
+    });
+
+    expect(
+      verifyColumnsInRsp(rsp.body.list[0], [
+        { title: 'SingleLineText' },
+        { title: 'MultiLineText' },
+      ]),
+    ).to.equal(true);
+  });
+
+  it('List: sort, ascending', async function () {
+    const sortColumn = columns.find((c) => c.title === 'SingleLineText');
+    const rsp = await ncAxiosGet({
+      query: { sort: 'SingleLineText', limit: 400 },
+    });
+
+    expect(verifyColumnsInRsp(rsp.body.list[0], columns)).to.equal(true);
+    const sortedArray = rsp.body.list.map((r) => r[sortColumn.title]);
+    expect(sortedArray).to.deep.equal(sortedArray.sort());
+  });
+
+  it('List: sort, descending', async function () {
+    const sortColumn = columns.find((c) => c.title === 'SingleLineText');
+    const rsp = await ncAxiosGet({
+      query: { sort: '-SingleLineText', limit: 400 },
+    });
+
+    expect(verifyColumnsInRsp(rsp.body.list[0], columns)).to.equal(true);
+    const descSortedArray = rsp.body.list.map((r) => r[sortColumn.title]);
+    expect(descSortedArray).to.deep.equal(descSortedArray.sort().reverse());
+  });
+
+  it('List: sort, multiple', async function () {
+    const rsp = await ncAxiosGet({
+      query: {
+        sort: ['-SingleLineText', '-MultiLineText'],
+        limit: 400,
+      },
+    });
+
+    expect(verifyColumnsInRsp(rsp.body.list[0], columns)).to.equal(true);
+    // Combination of SingleLineText & MultiLineText should be in descending order
+    const sortedArray = rsp.body.list.map(
+      (r) => r.SingleLineText + r.MultiLineText,
+    );
+    expect(sortedArray).to.deep.equal(sortedArray.sort().reverse());
+  });
+
+  it('List: filter, single', async function () {
+    const rsp = await ncAxiosGet({
+      query: {
+        where: '(SingleLineText,eq,Afghanistan)',
+        limit: 400,
+      },
+    });
+
+    expect(verifyColumnsInRsp(rsp.body.list[0], columns)).to.equal(true);
+    const filteredArray = rsp.body.list.map((r) => r.SingleLineText);
+    expect(filteredArray).to.deep.equal(filteredArray.fill('Afghanistan'));
+  });
+
+  it('List: filter, multiple', async function () {
+    const rsp = await ncAxiosGet({
+      query: {
+        where:
+          '(SingleLineText,eq,Afghanistan)~and(MultiLineText,eq,Allahabad, India)',
+        limit: 400,
+      },
+    });
+
+    expect(verifyColumnsInRsp(rsp.body.list[0], columns)).to.equal(true);
+    const filteredArray = rsp.body.list.map(
+      (r) => r.SingleLineText + ' ' + r.MultiLineText,
+    );
+    expect(filteredArray).to.deep.equal(
+      filteredArray.fill('Afghanistan Allahabad, India'),
+    );
+  });
+
+  it('List: view ID', async function () {
+    const gridView = await createView(context, {
+      title: 'grid0',
+      table,
+      type: ViewTypes.GRID,
+    });
+
+    const fk_column_id = columns.find((c) => c.title === 'SingleLineText').id;
+    await updateView(context, {
+      table,
+      view: gridView,
+      filter: [
+        {
+          comparison_op: 'eq',
+          fk_column_id,
+          logical_op: 'or',
+          value: 'Afghanistan',
+        },
+      ],
+    });
+
+    // fetch records from view
+    let rsp = await ncAxiosGet({ query: { viewId: gridView.id } });
+    expect(rsp.body.pageInfo.totalRows).to.equal(31);
+
+    await updateView(context, {
+      table,
+      view: gridView,
+      filter: [
+        {
+          comparison_op: 'eq',
+          fk_column_id,
+          logical_op: 'or',
+          value: 'Austria',
+        },
+      ],
+    });
+
+    // fetch records from view
+    rsp = await ncAxiosGet({
+      query: {
+        viewId: gridView.id,
+      },
+    });
+    expect(rsp.body.pageInfo.totalRows).to.equal(61);
+
+    // Sort by SingleLineText
+    await updateView(context, {
+      table,
+      view: gridView,
+      sort: [
+        {
+          direction: 'asc',
+          fk_column_id,
+          push_to_top: true,
+        },
+      ],
+    });
+
+    // fetch records from view
+    rsp = await ncAxiosGet({
+      query: {
+        viewId: gridView.id,
+      },
+    });
+    expect(rsp.body.pageInfo.totalRows).to.equal(61);
+
+    // verify sorted order
+    // Would contain all 'Afghanistan' as we have 31 records for it
+    expect(verifyColumnsInRsp(rsp.body.list[0], columns)).to.equal(true);
+    const filteredArray = rsp.body.list.map((r) => r.SingleLineText);
+    expect(filteredArray).to.deep.equal(filteredArray.fill('Afghanistan'));
+
+    await updateView(context, {
+      table,
+      view: gridView,
+      field: ['SingleLineText'],
+    });
+
+    // fetch records from view
+    rsp = await ncAxiosGet({
+      query: {
+        viewId: gridView.id,
+      },
+    });
+    const displayColumns = columns.filter((c) => c.title !== 'SingleLineText');
+    expect(verifyColumnsInRsp(rsp.body.list[0], displayColumns)).to.equal(true);
+  });
+
+  async function prepareViewForTests() {
+    const gridView = await createView(context, {
+      title: 'grid0',
+      table,
+      type: ViewTypes.GRID,
+    });
+
+    const fk_column_id = columns.find((c) => c.title === 'SingleLineText').id;
+    await updateView(context, {
+      table,
+      view: gridView,
+      filter: [
+        {
+          comparison_op: 'eq',
+          fk_column_id,
+          logical_op: 'or',
+          value: 'Afghanistan',
+        },
+        {
+          comparison_op: 'eq',
+          fk_column_id,
+          logical_op: 'or',
+          value: 'Austria',
+        },
+      ],
+      sort: [
+        {
+          direction: 'asc',
+          fk_column_id,
+          push_to_top: true,
+        },
+      ],
+      field: ['MultiLineText', 'Email'],
+    });
+
+    // fetch records from view
+    const rsp = await ncAxiosGet({ query: { viewId: gridView.id } });
+    expect(rsp.body.pageInfo.totalRows).to.equal(61);
+    const displayColumns = columns.filter(
+      (c) => c.title !== 'MultiLineText' && c.title !== 'Email',
+    );
+    expect(verifyColumnsInRsp(rsp.body.list[0], displayColumns)).to.equal(true);
+    return gridView;
+  }
+
+  it('List: view ID + sort', async function () {
+    const gridView = await prepareViewForTests();
+
+    const rsp = await ncAxiosGet({
+      query: {
+        viewId: gridView.id,
+        sort: 'Url',
+        limit: 100,
+      },
+    });
+    const displayColumns = columns.filter(
+      (c) => c.title !== 'MultiLineText' && c.title !== 'Email',
+    );
+    expect(rsp.body.pageInfo.totalRows).to.equal(61);
+    expect(verifyColumnsInRsp(rsp.body.list[0], displayColumns)).to.equal(true);
+    const sortedArray = rsp.body.list.map((r) => r['Url']);
+    expect(sortedArray).to.deep.equal(sortedArray.sort());
+  });
+
+  it('List: view ID + filter', async function () {
+    const gridView = await prepareViewForTests();
+
+    const rsp = await ncAxiosGet({
+      query: {
+        viewId: gridView.id,
+        where: '(Phone,eq,1-541-754-3010)',
+        limit: 100,
+      },
+    });
+    const displayColumns = columns.filter(
+      (c) => c.title !== 'MultiLineText' && c.title !== 'Email',
+    );
+    expect(rsp.body.pageInfo.totalRows).to.equal(7);
+    expect(verifyColumnsInRsp(rsp.body.list[0], displayColumns)).to.equal(true);
+    const filteredArray = rsp.body.list.map((r) => r['Phone']);
+    expect(filteredArray).to.deep.equal(filteredArray.fill('1-541-754-3010'));
+  });
+
+  it('List: view ID + fields', async function () {
+    const gridView = await prepareViewForTests();
+
+    const rsp = await ncAxiosGet({
+      query: {
+        viewId: gridView.id,
+        fields: ['Phone', 'MultiLineText', 'SingleLineText', 'Email'],
+        limit: 100,
+      },
+    });
+    expect(rsp.body.pageInfo.totalRows).to.equal(61);
+    expect(
+      verifyColumnsInRsp(rsp.body.list[0], [
+        { title: 'Phone' },
+        { title: 'SingleLineText' },
+      ]),
+    ).to.equal(true);
+  });
+
+  // Error handling
+  it('List: invalid ID', async function () {
+    // Invalid table ID
+    await ncAxiosGet({
+      url: `/api/v1/tables/123456789/rows`,
+      status: 404,
+    });
+
+    // Invalid view ID
+    await ncAxiosGet({
+      query: {
+        viewId: '123456789',
+      },
+      status: 422,
+    });
+  });
+
+  it('List: invalid limit & offset', async function () {
+    const expectedPageInfo = {
+      totalRows: 400,
+      page: 1,
+      pageSize: 25,
+      isFirstPage: true,
+      isLastPage: false,
+    };
+
+    // Invalid limit : falls back to default value
+    let rsp = await ncAxiosGet({
+      query: {
+        limit: -100,
+      },
+      status: 200,
+    });
+    expect(rsp.body.pageInfo).to.deep.equal(expectedPageInfo);
+
+    rsp = await ncAxiosGet({
+      query: {
+        limit: 'abc',
+      },
+      status: 200,
+    });
+    expect(rsp.body.pageInfo).to.deep.equal(expectedPageInfo);
+
+    // Invalid offset : falls back to default value
+    rsp = await ncAxiosGet({
+      query: {
+        offset: -100,
+      },
+      status: 200,
+    });
+    expect(rsp.body.pageInfo).to.deep.equal(expectedPageInfo);
+
+    rsp = await ncAxiosGet({
+      query: {
+        offset: 'abc',
+      },
+      status: 200,
+    });
+    expect(rsp.body.pageInfo).to.deep.equal(expectedPageInfo);
+
+    // Offset > totalRows : returns empty list
+    rsp = await ncAxiosGet({
+      query: {
+        offset: 10000,
+      },
+      status: 200,
+    });
+    expect(rsp.body.list.length).to.equal(0);
+  });
+
+  it('List: invalid sort, filter, fields', async function () {
+    // expect to ignore invalid sort, filter, fields
+
+    await ncAxiosGet({
+      query: {
+        sort: 'abc',
+      },
+    });
+    await ncAxiosGet({
+      query: {
+        where: 'abc',
+      },
+    });
+    await ncAxiosGet({
+      query: {
+        fields: 'abc',
+      },
+    });
+  });
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  // CREATE
+  //
+
+  /////////////////////////////////////////////////////////////////////////////
+  const newRecord = {
+    SingleLineText: 'abc',
+    MultiLineText: 'abc abc \n abc \r abc \t abc 1234!@#$%^&*()_+',
+    Email: 'a@b.com',
+    Url: 'https://www.abc.com',
+    Phone: '1-234-567-8910',
+  };
+
+  it('Create: all fields', async function () {
+    const rsp = await ncAxiosPost({ body: newRecord });
+
+    expect(rsp.body).to.deep.equal({ Id: 401 });
+  });
+
+  it('Create: few fields left out', async function () {
+    const newRecord = {
+      SingleLineText: 'abc',
+      MultiLineText: 'abc abc \n abc \r abc \t abc 1234!@#$%^&*()_+',
+    };
+    const rsp = await ncAxiosPost({ body: newRecord });
+
+    // fields left out should be null
+    expect(rsp.body).to.deep.equal({ Id: 401 });
+  });
+
+  it('Create: bulk', async function () {
+    const rsp = await ncAxiosPost({ body: [newRecord, newRecord, newRecord] });
+
+    expect(rsp.body).to.deep.equal([{ Id: 401 }, { Id: 402 }, { Id: 403 }]);
+  });
+
+  // Error handling
+  it('Create: invalid ID', async function () {
+    // Invalid table ID
+    await ncAxiosPost({
+      url: `/api/v1/tables/123456789/rows`,
+      status: 404,
+    });
+
+    // Invalid data - create should not specify ID
+    await ncAxiosPost({
+      body: { ...newRecord, Id: 300 },
+      status: 400,
+    });
+    // Invalid data - number instead of string
+    // await ncAxiosPost({
+    //   body: { ...newRecord, SingleLineText: 300 },
+    //   status: 400,
+    // });
+  });
+
+  // TBD : default value handling
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  // READ
+  //
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  it('Read: all fields', async function () {
+    const rsp = await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/100`,
+    });
+  });
+
+  it('Read: invalid ID', async function () {
+    // Invalid table ID
+    await ncAxiosGet({
+      url: `/api/v1/tables/123456789/rows/100`,
+      status: 404,
+    });
+    // Invalid row ID
+    await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/1000`,
+      status: 404,
+    });
+  });
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  // UPDATE
+  //
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  it('Update: all fields', async function () {
+    const rsp = await ncAxiosPatch({
+      body: [
+        {
+          Id: 1,
+          ...newRecord,
+        },
+      ],
+    });
+    expect(rsp.body).to.deep.equal([{ Id: 1 }]);
+  });
+
+  it('Update: partial', async function () {
+    const recordBeforeUpdate = await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/1`,
+    });
+
+    const rsp = await ncAxiosPatch({
+      body: [
+        {
+          Id: 1,
+          SingleLineText: 'some text',
+          MultiLineText: 'some more text',
+        },
+      ],
+    });
+    expect(rsp.body).to.deep.equal([{ Id: 1 }]);
+
+    const recordAfterUpdate = await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/1`,
+    });
+    expect(recordAfterUpdate.body).to.deep.equal({
+      ...recordBeforeUpdate.body,
+      SingleLineText: 'some text',
+      MultiLineText: 'some more text',
+    });
+  });
+
+  it('Update: bulk', async function () {
+    const rsp = await ncAxiosPatch({
+      body: [
+        {
+          Id: 1,
+          SingleLineText: 'some text',
+          MultiLineText: 'some more text',
+        },
+        {
+          Id: 2,
+          SingleLineText: 'some text',
+          MultiLineText: 'some more text',
+        },
+      ],
+    });
+    expect(rsp.body).to.deep.equal([{ Id: 1 }, { Id: 2 }]);
+  });
+
+  // Error handling
+
+  it('Update: invalid ID', async function () {
+    // Invalid table ID
+    await ncAxiosPatch({
+      url: `/api/v1/tables/123456789/rows`,
+      body: { Id: 100, SingleLineText: 'some text' },
+      status: 404,
+    });
+    // Invalid row ID
+    await ncAxiosPatch({
+      body: { Id: 123456789, SingleLineText: 'some text' },
+      status: 422,
+    });
+  });
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  // DELETE
+  //
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  it('Delete: single', async function () {
+    const rsp = await ncAxiosDelete({ body: [{ Id: 1 }] });
+    expect(rsp.body).to.deep.equal([{ Id: 1 }]);
+
+    // check that it's gone
+    await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/1`,
+      status: 404,
+    });
+  });
+
+  it('Delete: bulk', async function () {
+    const rsp = await ncAxiosDelete({ body: [{ Id: 1 }, { Id: 2 }] });
+    expect(rsp.body).to.deep.equal([{ Id: 1 }, { Id: 2 }]);
+
+    // check that it's gone
+    await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/1`,
+      status: 404,
+    });
+    await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/2`,
+      status: 404,
+    });
+  });
+
+  // Error handling
+
+  it('Delete: invalid ID', async function () {
+    // Invalid table ID
+    await ncAxiosDelete({
+      url: `/api/v1/tables/123456789/rows`,
+      body: { Id: 100 },
+      status: 404,
+    });
+    // Invalid row ID
+    await ncAxiosDelete({ body: { Id: '123456789' }, status: 422 });
+  });
+}
+
+function numberBased() {
+  // prepare data for test cases
+  beforeEach(async function () {
+    context = await init();
+    project = await createProject(context);
+    table = await createTable(context, project, {
+      table_name: 'numberBased',
+      title: 'numberBased',
+      columns: customColumns('numberBased'),
+    });
+
+    // retrieve column meta
+    columns = await table.getColumns();
+
+    // build records
+    const rowAttributes = [];
+    for (let i = 0; i < 400; i++) {
+      const row = {
+        Number: rowMixedValue(columns[1], i),
+        Decimal: rowMixedValue(columns[2], i),
+        Currency: rowMixedValue(columns[3], i),
+        Percent: rowMixedValue(columns[4], i),
+        Duration: rowMixedValue(columns[5], i),
+        Rating: rowMixedValue(columns[6], i),
+      };
+      rowAttributes.push(row);
+    }
+
+    // insert records
+    await createBulkRows(context, {
+      project,
+      table,
+      values: rowAttributes,
+    });
+
+    // retrieve inserted records
+    insertedRecords = await listRow({ project, table });
+
+    // verify length of unfiltered records to be 400
+    expect(insertedRecords.length).to.equal(400);
+  });
+
+  const records = [
+    {
+      Id: 1,
+      Number: 33,
+      Decimal: 33.3,
+      Currency: 33.3,
+      Percent: 33,
+      Duration: 10,
+      Rating: 0,
+    },
+    {
+      Id: 2,
+      Number: null,
+      Decimal: 456.34,
+      Currency: 456.34,
+      Percent: null,
+      Duration: 20,
+      Rating: 1,
+    },
+    {
+      Id: 3,
+      Number: 456,
+      Decimal: 333.3,
+      Currency: 333.3,
+      Percent: 456,
+      Duration: 30,
+      Rating: 2,
+    },
+    {
+      Id: 4,
+      Number: 333,
+      Decimal: null,
+      Currency: null,
+      Percent: 333,
+      Duration: 40,
+      Rating: 3,
+    },
+    {
+      Id: 5,
+      Number: 267,
+      Decimal: 267.5674,
+      Currency: 267.5674,
+      Percent: 267,
+      Duration: 50,
+      Rating: null,
+    },
+    {
+      Id: 6,
+      Number: 34,
+      Decimal: 34,
+      Currency: 34,
+      Percent: 34,
+      Duration: 60,
+      Rating: 0,
+    },
+    {
+      Id: 7,
+      Number: 8754,
+      Decimal: 8754,
+      Currency: 8754,
+      Percent: 8754,
+      Duration: null,
+      Rating: 4,
+    },
+    {
+      Id: 8,
+      Number: 3234,
+      Decimal: 3234.547,
+      Currency: 3234.547,
+      Percent: 3234,
+      Duration: 70,
+      Rating: 5,
+    },
+    {
+      Id: 9,
+      Number: 44,
+      Decimal: 44.2647,
+      Currency: 44.2647,
+      Percent: 44,
+      Duration: 80,
+      Rating: 0,
+    },
+    {
+      Id: 10,
+      Number: 33,
+      Decimal: 33.98,
+      Currency: 33.98,
+      Percent: 33,
+      Duration: 90,
+      Rating: 1,
+    },
+  ];
+
+  const recordsPg = [
+    {
+      Id: 1,
+      Number: '33',
+      Decimal: '33.3',
+      Currency: '33.3',
+      Percent: 33,
+      Duration: '10',
+      Rating: 0,
+    },
+    {
+      Id: 2,
+      Number: null,
+      Decimal: '456.34',
+      Currency: '456.34',
+      Percent: null,
+      Duration: '20',
+      Rating: 1,
+    },
+    {
+      Id: 3,
+      Number: '456',
+      Decimal: '333.3',
+      Currency: '333.3',
+      Percent: 456,
+      Duration: '30',
+      Rating: 2,
+    },
+    {
+      Id: 4,
+      Number: '333',
+      Decimal: null,
+      Currency: null,
+      Percent: 333,
+      Duration: '40',
+      Rating: 3,
+    },
+    {
+      Id: 5,
+      Number: '267',
+      Decimal: '267.5674',
+      Currency: '267.5674',
+      Percent: 267,
+      Duration: '50',
+      Rating: null,
+    },
+    {
+      Id: 6,
+      Number: '34',
+      Decimal: '34',
+      Currency: '34',
+      Percent: 34,
+      Duration: '60',
+      Rating: 0,
+    },
+    {
+      Id: 7,
+      Number: '8754',
+      Decimal: '8754',
+      Currency: '8754',
+      Percent: 8754,
+      Duration: null,
+      Rating: 4,
+    },
+    {
+      Id: 8,
+      Number: '3234',
+      Decimal: '3234.547',
+      Currency: '3234.547',
+      Percent: 3234,
+      Duration: '70',
+      Rating: 5,
+    },
+    {
+      Id: 9,
+      Number: '44',
+      Decimal: '44.2647',
+      Currency: '44.2647',
+      Percent: 44,
+      Duration: '80',
+      Rating: 0,
+    },
+    {
+      Id: 10,
+      Number: '33',
+      Decimal: '33.98',
+      Currency: '33.98',
+      Percent: 33,
+      Duration: '90',
+      Rating: 1,
+    },
+  ];
+
+  it('Number based- List & CRUD', async function () {
+    // list 10 records
+    let rsp = await ncAxiosGet({
+      query: {
+        limit: 10,
+      },
+    });
+    const pageInfo = {
+      totalRows: 400,
+      page: 1,
+      pageSize: 10,
+      isFirstPage: true,
+      isLastPage: false,
+    };
+    expect(rsp.body.pageInfo).to.deep.equal(pageInfo);
+    if (isPg(context)) {
+      expect(rsp.body.list).to.deep.equal(recordsPg);
+    } else {
+      expect(rsp.body.list).to.deep.equal(records);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // insert 10 records
+    // remove Id's from record array
+    records.forEach((r) => delete r.Id);
+    rsp = await ncAxiosPost({
+      body: records,
+    });
+
+    // prepare array with 10 Id's, from 401 to 410
+    const ids = [];
+    for (let i = 401; i <= 410; i++) {
+      ids.push({ Id: i });
+    }
+    expect(rsp.body).to.deep.equal(ids);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // read record with Id 401
+    rsp = await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/401`,
+    });
+    if (isPg(context)) {
+      expect(rsp.body).to.deep.equal({ ...recordsPg[0], Id: 401 });
+    } else {
+      expect(rsp.body).to.deep.equal({ ...records[0], Id: 401 });
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // update record with Id 401 to 404
+    const updatedRecord = {
+      Number: 55,
+      Decimal: 55.5,
+      Currency: 55.5,
+      Percent: 55,
+      Duration: 55,
+      Rating: 5,
+    };
+    const updatedRecordPg = {
+      Number: '55',
+      Decimal: '55.5',
+      Currency: '55.5',
+      Percent: 55,
+      Duration: '55',
+      Rating: 5,
+    };
+
+    const updatedRecords = [
+      {
+        Id: 401,
+        ...updatedRecord,
+      },
+      {
+        Id: 402,
+        ...updatedRecord,
+      },
+      {
+        Id: 403,
+        ...updatedRecord,
+      },
+      {
+        Id: 404,
+        ...updatedRecord,
+      },
+    ];
+    const updatedRecordsPg = [
+      {
+        Id: 401,
+        ...updatedRecordPg,
+      },
+      {
+        Id: 402,
+        ...updatedRecordPg,
+      },
+      {
+        Id: 403,
+        ...updatedRecordPg,
+      },
+      {
+        Id: 404,
+        ...updatedRecordPg,
+      },
+    ];
+
+    rsp = await ncAxiosPatch({
+      body: updatedRecords,
+    });
+    expect(rsp.body).to.deep.equal(
+      updatedRecords.map((record) => ({ Id: record.Id })),
+    );
+
+    // verify updated records
+    rsp = await ncAxiosGet({
+      query: {
+        limit: 4,
+        offset: 400,
+      },
+    });
+    if (isPg(context)) {
+      expect(rsp.body.list).to.deep.equal(updatedRecordsPg);
+    } else {
+      expect(rsp.body.list).to.deep.equal(updatedRecords);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // delete record with ID 401 to 404
+    rsp = await ncAxiosDelete({
+      body: updatedRecords.map((record) => ({ Id: record.Id })),
+    });
+    expect(rsp.body).to.deep.equal(
+      updatedRecords.map((record) => ({ Id: record.Id })),
+    );
+  });
+}
+
+function selectBased() {
+  // prepare data for test cases
+  beforeEach(async function () {
+    context = await init();
+    project = await createProject(context);
+    table = await createTable(context, project, {
+      table_name: 'selectBased',
+      title: 'selectBased',
+      columns: customColumns('selectBased'),
+    });
+
+    // retrieve column meta
+    columns = await table.getColumns();
+
+    // build records
+    const rowAttributes = [];
+    for (let i = 0; i < 400; i++) {
+      const row = {
+        SingleSelect: rowMixedValue(columns[1], i),
+        MultiSelect: rowMixedValue(columns[2], i),
+      };
+      rowAttributes.push(row);
+    }
+
+    // insert records
+    await createBulkRows(context, {
+      project,
+      table,
+      values: rowAttributes,
+    });
+
+    // retrieve inserted records
+    insertedRecords = await listRow({ project, table });
+
+    // verify length of unfiltered records to be 400
+    expect(insertedRecords.length).to.equal(400);
+  });
+
+  const records = [
+    {
+      Id: 1,
+      SingleSelect: 'jan',
+      MultiSelect: 'jan,feb,mar',
+    },
+    {
+      Id: 2,
+      SingleSelect: 'feb',
+      MultiSelect: 'apr,may,jun',
+    },
+    {
+      Id: 3,
+      SingleSelect: 'mar',
+      MultiSelect: 'jul,aug,sep',
+    },
+    {
+      Id: 4,
+      SingleSelect: 'apr',
+      MultiSelect: 'oct,nov,dec',
+    },
+    {
+      Id: 5,
+      SingleSelect: 'may',
+      MultiSelect: 'jan,feb,mar',
+    },
+    {
+      Id: 6,
+      SingleSelect: 'jun',
+      MultiSelect: null,
+    },
+    {
+      Id: 7,
+      SingleSelect: 'jul',
+      MultiSelect: 'jan,feb,mar',
+    },
+    {
+      Id: 8,
+      SingleSelect: 'aug',
+      MultiSelect: 'apr,may,jun',
+    },
+    {
+      Id: 9,
+      SingleSelect: 'sep',
+      MultiSelect: 'jul,aug,sep',
+    },
+    {
+      Id: 10,
+      SingleSelect: 'oct',
+      MultiSelect: 'oct,nov,dec',
+    },
+  ];
+
+  it('Select based- List & CRUD', async function () {
+    // list 10 records
+    let rsp = await ncAxiosGet({
+      query: {
+        limit: 10,
+      },
+    });
+    const pageInfo = {
+      totalRows: 400,
+      page: 1,
+      pageSize: 10,
+      isFirstPage: true,
+      isLastPage: false,
+    };
+    expect(rsp.body.pageInfo).to.deep.equal(pageInfo);
+    expect(rsp.body.list).to.deep.equal(records);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // insert 10 records
+    // remove Id's from record array
+    records.forEach((r) => delete r.Id);
+    rsp = await ncAxiosPost({
+      body: records,
+    });
+
+    // prepare array with 10 Id's, from 401 to 410
+    const ids = [];
+    for (let i = 401; i <= 410; i++) {
+      ids.push({ Id: i });
+    }
+    expect(rsp.body).to.deep.equal(ids);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // read record with Id 401
+    rsp = await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/401`,
+    });
+    expect(rsp.body).to.deep.equal({ Id: 401, ...records[0] });
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // update record with Id 401 to 404
+    const updatedRecord = {
+      SingleSelect: 'jan',
+      MultiSelect: 'jan,feb,mar',
+    };
+    const updatedRecords = [
+      {
+        Id: 401,
+        ...updatedRecord,
+      },
+      {
+        Id: 402,
+        ...updatedRecord,
+      },
+      {
+        Id: 403,
+        ...updatedRecord,
+      },
+      {
+        Id: 404,
+        ...updatedRecord,
+      },
+    ];
+    rsp = await ncAxiosPatch({
+      body: updatedRecords,
+    });
+    expect(rsp.body).to.deep.equal(
+      updatedRecords.map((record) => ({ Id: record.Id })),
+    );
+
+    // verify updated records
+    rsp = await ncAxiosGet({
+      query: {
+        limit: 4,
+        offset: 400,
+      },
+    });
+    expect(rsp.body.list).to.deep.equal(updatedRecords);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // delete record with ID 401 to 404
+    rsp = await ncAxiosDelete({
+      body: updatedRecords.map((record) => ({ Id: record.Id })),
+    });
+    expect(rsp.body).to.deep.equal(
+      updatedRecords.map((record) => ({ Id: record.Id })),
+    );
+  });
+}
+
+function dateBased() {
+  // prepare data for test cases
+  beforeEach(async function () {
+    context = await init();
+    project = await createProject(context);
+    table = await createTable(context, project, {
+      table_name: 'dateBased',
+      title: 'dateBased',
+      columns: customColumns('dateBased'),
+    });
+
+    // retrieve column meta
+    columns = await table.getColumns();
+
+    // build records
+    // 800: one year before to one year after
+    const rowAttributes = [];
+    for (let i = 0; i < 800; i++) {
+      const row = {
+        Date: rowMixedValue(columns[1], i),
+        DateTime: rowMixedValue(columns[2], i),
+      };
+      rowAttributes.push(row);
+    }
+
+    // insert records
+    await createBulkRows(context, {
+      project,
+      table,
+      values: rowAttributes,
+    });
+
+    // retrieve inserted records
+    insertedRecords = await listRow({ project, table });
+
+    // verify length of unfiltered records to be 800
+    expect(insertedRecords.length).to.equal(800);
+  });
+
+  it('Date based- List & CRUD', async function () {
+    // list 10 records
+    let rsp = await ncAxiosGet({
+      query: {
+        limit: 10,
+      },
+    });
+    const pageInfo = {
+      totalRows: 800,
+      page: 1,
+      pageSize: 10,
+      isFirstPage: true,
+      isLastPage: false,
+    };
+
+    expect(rsp.body.pageInfo).to.deep.equal(pageInfo);
+
+    // extract first 10 records from inserted records
+    const records = insertedRecords.slice(0, 10);
+    expect(JSON.stringify(rsp.body.list)).to.deep.equal(
+      JSON.stringify(records),
+    );
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // insert 10 records
+    // remove Id's from record array
+    records.forEach((r) => delete r.Id);
+    rsp = await ncAxiosPost({
+      body: records,
+    });
+
+    // prepare array with 10 Id's, from 801 to 810
+    const ids = [];
+    for (let i = 801; i <= 810; i++) {
+      ids.push({ Id: i });
+    }
+    expect(rsp.body).to.deep.equal(ids);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // read record with Id 801
+    rsp = await ncAxiosGet({
+      url: `/api/v1/tables/${table.id}/rows/801`,
+    });
+    expect(rsp.body).to.deep.equal({ Id: 801, ...records[0] });
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // update record with Id 801 to 804
+    const updatedRecord = {
+      Date: '2022-04-25',
+      DateTime: '2022-04-25 08:30:00+00:00',
+    };
+    const updatedRecords = [
+      {
+        Id: 801,
+        ...updatedRecord,
+      },
+      {
+        Id: 802,
+        ...updatedRecord,
+      },
+      {
+        Id: 803,
+        ...updatedRecord,
+      },
+      {
+        Id: 804,
+        ...updatedRecord,
+      },
+    ];
+    rsp = await ncAxiosPatch({
+      body: updatedRecords,
+    });
+    expect(rsp.body).to.deep.equal(
+      updatedRecords.map((record) => ({ Id: record.Id })),
+    );
+
+    // verify updated records
+    rsp = await ncAxiosGet({
+      query: {
+        limit: 4,
+        offset: 800,
+      },
+    });
+    expect(rsp.body.list).to.deep.equal(updatedRecords);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // delete record with ID 801 to 804
+    rsp = await ncAxiosDelete({
+      body: updatedRecords.map((record) => ({ Id: record.Id })),
+    });
+    expect(rsp.body).to.deep.equal(
+      updatedRecords.map((record) => ({ Id: record.Id })),
+    );
+  });
+}
+
+function linkBased() {
+  let tblCity: Model;
+  let tblCountry: Model;
+  let tblActor: Model;
+  let tblFilm: Model;
+
+  let columnsFilm;
+  let columnsActor;
+  let columnsCountry;
+  let columnsCity;
+
+  async function prepareRecords(title: string, count: number) {
+    const records = [];
+    for (let i = 1; i <= count; i++) {
+      records.push({
+        Id: i,
+        [title]: `${title} ${i}`,
+      });
+    }
+    return records;
+  }
+
+  // prepare data for test cases
+  beforeEach(async function () {
+    context = await init();
+    project = await createProject(context);
+
+    const columns = [
+      {
+        title: 'Title',
+        column_name: 'Title',
+        uidt: UITypes.SingleLineText,
+        pv: true,
+      },
+    ];
+
+    try {
+      // Prepare City table
+      columns[0].title = 'City';
+      columns[0].column_name = 'City';
+      tblCity = await createTable(context, project, {
+        title: 'City',
+        table_name: 'City',
+        columns: customColumns('custom', columns),
+      });
+      const cityRecords = await prepareRecords('City', 100);
+
+      // insert records
+      await createBulkRows(context, {
+        project,
+        table: tblCity,
+        values: cityRecords,
+      });
+
+      insertedRecords = await listRow({ project, table: tblCity });
+
+      // Prepare Country table
+      columns[0].title = 'Country';
+      columns[0].column_name = 'Country';
+      tblCountry = await createTable(context, project, {
+        title: 'Country',
+        table_name: 'Country',
+        columns: customColumns('custom', columns),
+      });
+      const countryRecords = await prepareRecords('Country', 100);
+      // insert records
+      await createBulkRows(context, {
+        project,
+        table: tblCountry,
+        values: countryRecords,
+      });
+
+      // Prepare Actor table
+      columns[0].title = 'Actor';
+      columns[0].column_name = 'Actor';
+      tblActor = await createTable(context, project, {
+        title: 'Actor',
+        table_name: 'Actor',
+        columns: customColumns('custom', columns),
+      });
+      const actorRecords = await prepareRecords('Actor', 100);
+      await createBulkRows(context, {
+        project,
+        table: tblActor,
+        values: actorRecords,
+      });
+
+      // Prepare Movie table
+      columns[0].title = 'Film';
+      columns[0].column_name = 'Film';
+      tblFilm = await createTable(context, project, {
+        title: 'Film',
+        table_name: 'Film',
+        columns: customColumns('custom', columns),
+      });
+      const filmRecords = await prepareRecords('Film', 100);
+      await createBulkRows(context, {
+        project,
+        table: tblFilm,
+        values: filmRecords,
+      });
+
+      // Create links
+      // Country <hm> City
+      await createLtarColumn(context, {
+        title: 'Cities',
+        parentTable: tblCountry,
+        childTable: tblCity,
+        type: 'hm',
+      });
+      await createLtarColumn(context, {
+        title: 'Films',
+        parentTable: tblActor,
+        childTable: tblFilm,
+        type: 'mm',
+      });
+
+      columnsFilm = await tblFilm.getColumns();
+      columnsActor = await tblActor.getColumns();
+      columnsCountry = await tblCountry.getColumns();
+      columnsCity = await tblCity.getColumns();
+    } catch (e) {
+      console.log(e);
+    }
+  });
+
+  function getColumnId(columns, title: string) {
+    return columns.find((c) => c.title === title).id;
+  }
+
+  it('Has-Many ', async function () {
+    // Create hm link between Country and City
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: [1, 2, 3, 4, 5],
+      status: 201,
+    });
+
+    // verify in Country table
+    let rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+    });
+
+    // page Info
+    const pageInfo = {
+      totalRows: 5,
+      page: 1,
+      pageSize: 25,
+      isFirstPage: true,
+      isLastPage: true,
+    };
+    expect(rsp.body.pageInfo).to.deep.equal(pageInfo);
+
+    // links
+    expect(rsp.body.list).to.deep.equal([
+      { Id: 1, City: 'City 1' },
+      { Id: 2, City: 'City 2' },
+      { Id: 3, City: 'City 3' },
+      { Id: 4, City: 'City 4' },
+      { Id: 5, City: 'City 5' },
+    ]);
+
+    ///////////////////////////////////////////////////////////////////
+
+    // verify in City table
+    for (let i = 1; i <= 10; i++) {
+      rsp = await ncAxiosLinkGet({
+        urlParams: {
+          tableId: tblCity.id,
+          linkId: getColumnId(columnsCity, 'Country'),
+          rowId: i,
+        },
+      });
+      if (i <= 5) {
+        expect(rsp.body).to.deep.equal({
+          Id: 1,
+          Country: `Country 1`,
+        });
+      } else {
+        expect(rsp.body).to.deep.equal({});
+      }
+    }
+
+    // Update hm link between Country and City
+    // List them for a record & verify in both tables
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: [6, 7],
+    });
+
+    // verify in Country table
+    rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+    });
+    expect(rsp.body.list).to.deep.equal([
+      { Id: 1, City: 'City 1' },
+      { Id: 2, City: 'City 2' },
+      { Id: 3, City: 'City 3' },
+      { Id: 4, City: 'City 4' },
+      { Id: 5, City: 'City 5' },
+      { Id: 6, City: 'City 6' },
+      { Id: 7, City: 'City 7' },
+    ]);
+
+    // verify in City table
+    for (let i = 1; i <= 10; i++) {
+      rsp = await ncAxiosLinkGet({
+        urlParams: {
+          tableId: tblCity.id,
+          linkId: getColumnId(columnsCity, 'Country'),
+          rowId: i,
+        },
+      });
+      if (i <= 7) {
+        expect(rsp.body).to.deep.equal({
+          Id: 1,
+          Country: `Country 1`,
+        });
+      } else {
+        expect(rsp.body).to.deep.equal({});
+      }
+    }
+
+    // Delete hm link between Country and City
+    // List them for a record & verify in both tables
+    await ncAxiosLinkRemove({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: [1, 3, 5, 7],
+    });
+
+    // verify in Country table
+    rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+    });
+    expect(rsp.body.list).to.deep.equal([
+      { Id: 2, City: 'City 2' },
+      { Id: 4, City: 'City 4' },
+      { Id: 6, City: 'City 6' },
+    ]);
+    // verify in City table
+    for (let i = 1; i <= 10; i++) {
+      rsp = await ncAxiosLinkGet({
+        urlParams: {
+          tableId: tblCity.id,
+          linkId: getColumnId(columnsCity, 'Country'),
+          rowId: i,
+        },
+      });
+
+      if (i % 2 === 0 && i <= 6) {
+        expect(rsp.body).to.deep.equal({
+          Id: 1,
+          Country: `Country 1`,
+        });
+      } else {
+        expect(rsp.body).to.deep.equal({});
+      }
+    }
+  });
+
+  // Create mm link between Actor and Film
+  // List them for a record & verify in both tables
+
+  function initArraySeq(i, count) {
+    return Array.from({ length: count }, (_, index) => i + index);
+  }
+
+  it('Create Many-Many ', async function () {
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+      body: [
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+      ],
+    });
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblFilm.id,
+        linkId: getColumnId(columnsFilm, 'Actor List'),
+        rowId: 1,
+      },
+      body: [
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+      ],
+    });
+
+    // verify in Actor table
+    let rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+    });
+
+    // page info
+    const pageInfo = {
+      totalRows: 20,
+      page: 1,
+      pageSize: 25,
+      isFirstPage: true,
+      isLastPage: true,
+    };
+    expect(rsp.body.pageInfo).to.deep.equal(pageInfo);
+
+    // Links
+    expect(rsp.body.list.length).to.equal(20);
+    for (let i = 1; i <= 20; i++) {
+      expect(rsp.body.list[i - 1]).to.deep.equal({
+        Id: i,
+        Film: `Film ${i}`,
+      });
+    }
+
+    // Second record
+    rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 2,
+      },
+    });
+    expect(rsp.body.list.length).to.equal(1);
+    expect(rsp.body.list[0]).to.deep.equal({
+      Id: 1,
+      Film: `Film 1`,
+    });
+
+    // verify in Film table
+    rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblFilm.id,
+        linkId: getColumnId(columnsFilm, 'Actor List'),
+        rowId: 1,
+      },
+    });
+    expect(rsp.body.list.length).to.equal(20);
+    for (let i = 1; i <= 20; i++) {
+      expect(rsp.body.list[i - 1]).to.deep.equal({
+        Id: i,
+        Actor: `Actor ${i}`,
+      });
+    }
+
+    // Update mm link between Actor and Film
+    // List them for a record & verify in both tables
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+      body: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30],
+    });
+
+    // verify in Actor table
+    rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+    });
+    expect(rsp.body.list.length).to.equal(25);
+    // paginated response, limit to 25
+    for (let i = 1; i <= 25; i++) {
+      expect(rsp.body.list[i - 1]).to.deep.equal({
+        Id: i,
+        Film: `Film ${i}`,
+      });
+    }
+
+    // verify in Film table
+    for (let i = 21; i <= 30; i++) {
+      const rsp = await ncAxiosLinkGet({
+        urlParams: {
+          tableId: tblFilm.id,
+          linkId: getColumnId(columnsFilm, 'Actor List'),
+          rowId: i,
+        },
+      });
+      expect(rsp.body.list.length).to.equal(1);
+      expect(rsp.body.list[0]).to.deep.equal({
+        Id: 1,
+        Actor: `Actor 1`,
+      });
+    }
+
+    // Delete mm link between Actor and Film
+    // List them for a record & verify in both tables
+    await ncAxiosLinkRemove({
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+      body: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29],
+    });
+
+    // verify in Actor table
+    rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+    });
+    expect(rsp.body.list.length).to.equal(15);
+    for (let i = 2; i <= 30; i += 2) {
+      expect(rsp.body.list[i / 2 - 1]).to.deep.equal({
+        Id: i,
+        Film: `Film ${i}`,
+      });
+    }
+
+    // verify in Film table
+    for (let i = 2; i <= 30; i++) {
+      const rsp = await ncAxiosLinkGet({
+        urlParams: {
+          tableId: tblFilm.id,
+          linkId: getColumnId(columnsFilm, 'Actor List'),
+          rowId: i,
+        },
+      });
+      if (i % 2 === 0) {
+        expect(rsp.body.list.length).to.equal(1);
+        expect(rsp.body.list[0]).to.deep.equal({
+          Id: 1,
+          Actor: `Actor 1`,
+        });
+      } else {
+        expect(rsp.body.list.length).to.equal(0);
+      }
+    }
+  });
+
+  // Other scenarios
+  // Has-many : change an existing link to a new one
+  it('HM: Change an existing link to a new one', async function () {
+    // add a link
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: [1, 2, 3],
+    });
+
+    // update the link
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 2,
+      },
+      body: [2, 3],
+    });
+
+    // verify record 1
+    let rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+    });
+    expect(rsp.body.list.length).to.equal(1);
+    expect(rsp.body.list).to.deep.equal([{ Id: 1, City: 'City 1' }]);
+
+    rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 2,
+      },
+    });
+    expect(rsp.body.list.length).to.equal(2);
+    expect(rsp.body.list).to.deep.equal([
+      { Id: 2, City: 'City 2' },
+      { Id: 3, City: 'City 3' },
+    ]);
+  });
+
+  // limit & offset verification
+  it('Limit & offset verification', async function () {
+    // add a link
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: initArraySeq(1, 50),
+    });
+
+    // verify record 1
+    let rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      query: {
+        limit: 10,
+        offset: 0,
+      },
+    });
+    expect(rsp.body.list.length).to.equal(10);
+    expect(rsp.body.list).to.deep.equal([
+      { Id: 1, City: 'City 1' },
+      { Id: 2, City: 'City 2' },
+      { Id: 3, City: 'City 3' },
+      { Id: 4, City: 'City 4' },
+      { Id: 5, City: 'City 5' },
+      { Id: 6, City: 'City 6' },
+      { Id: 7, City: 'City 7' },
+      { Id: 8, City: 'City 8' },
+      { Id: 9, City: 'City 9' },
+      { Id: 10, City: 'City 10' },
+    ]);
+
+    rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      query: {
+        limit: 5,
+        offset: 10,
+      },
+    });
+    expect(rsp.body.list.length).to.equal(5);
+    expect(rsp.body.list).to.deep.equal([
+      { Id: 11, City: 'City 11' },
+      { Id: 12, City: 'City 12' },
+      { Id: 13, City: 'City 13' },
+      { Id: 14, City: 'City 14' },
+      { Id: 15, City: 'City 15' },
+    ]);
+
+    rsp = await ncAxiosLinkGet({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      query: {
+        limit: 100,
+        offset: 45,
+      },
+    });
+    expect(rsp.body.list.length).to.equal(5);
+    expect(rsp.body.list).to.deep.equal([
+      { Id: 46, City: 'City 46' },
+      { Id: 47, City: 'City 47' },
+      { Id: 48, City: 'City 48' },
+      { Id: 49, City: 'City 49' },
+      { Id: 50, City: 'City 50' },
+    ]);
+  });
+
+  async function nestedAddTests(validParams, relationType?) {
+    // Link Add: Invalid table ID
+    if (debugMode) console.log('Link Add: Invalid table ID');
+    await ncAxiosLinkAdd({
+      ...validParams,
+      urlParams: { ...validParams.urlParams, tableId: 9999 },
+      status: 404,
+      msg: "Table with id '9999' not found",
+    });
+
+    // Link Add: Invalid link ID
+    if (debugMode) console.log('Link Add: Invalid link ID');
+    await ncAxiosLinkAdd({
+      ...validParams,
+      urlParams: { ...validParams.urlParams, linkId: 9999 },
+      status: 404,
+      msg: "Column with id '9999' not found",
+    });
+
+    // Link Add: Invalid Source row ID
+    if (debugMode) console.log('Link Add: Invalid Source row ID');
+    await ncAxiosLinkAdd({
+      ...validParams,
+      urlParams: { ...validParams.urlParams, rowId: 9999 },
+      status: 404,
+      msg: "Row with id '9999' not found",
+    });
+
+    // Body parameter error
+    //
+
+    // Link Add: Invalid body parameter - empty body : ignore
+    if (debugMode)
+      console.log('Link Add: Invalid body parameter - empty body : ignore');
+    await ncAxiosLinkAdd({
+      ...validParams,
+      body: [],
+      status: 201,
+    });
+
+    if (relationType === 'bt') {
+      // Link Add: Invalid body parameter - row id invalid
+      if (debugMode)
+        console.log('Link Add: Invalid body parameter - row id invalid');
+      await ncAxiosLinkAdd({
+        ...validParams,
+        body: [999, 998],
+        status: 422,
+        msg: 'Child record with id [999] not found',
+      });
+    } else {
+      // Link Add: Invalid body parameter - row id invalid
+      if (debugMode)
+        console.log('Link Add: Invalid body parameter - row id invalid');
+      await ncAxiosLinkAdd({
+        ...validParams,
+        body: [999, 998, 997],
+        status: 422,
+        msg: 'Child record with id [999, 998, 997] not found',
+      });
+
+      // Link Add: Invalid body parameter - repeated row id
+      if (debugMode)
+        console.log('Link Add: Invalid body parameter - repeated row id');
+      await ncAxiosLinkAdd({
+        ...validParams,
+        body: [1, 2, 1, 2],
+        status: 422,
+        msg: 'Child record with id [1, 2] are duplicated',
+      });
+    }
+  }
+
+  async function nestedRemoveTests(validParams, relationType?) {
+    // Link Remove: Invalid table ID
+    if (debugMode) console.log('Link Remove: Invalid table ID');
+    await ncAxiosLinkRemove({
+      ...validParams,
+      urlParams: { ...validParams.urlParams, tableId: 9999 },
+      status: 404,
+      msg: "Table with id '9999' not found",
+    });
+
+    // Link Remove: Invalid link ID
+    if (debugMode) console.log('Link Remove: Invalid link ID');
+    await ncAxiosLinkRemove({
+      ...validParams,
+      urlParams: { ...validParams.urlParams, linkId: 9999 },
+      status: 404,
+      msg: "Column with id '9999' not found",
+    });
+
+    // Link Remove: Invalid Source row ID
+    if (debugMode) console.log('Link Remove: Invalid Source row ID');
+    await ncAxiosLinkRemove({
+      ...validParams,
+      urlParams: { ...validParams.urlParams, rowId: 9999 },
+      status: 404,
+      msg: "Row with id '9999' not found",
+    });
+
+    // Body parameter error
+    //
+
+    // Link Remove: Invalid body parameter - empty body : ignore
+    if (debugMode)
+      console.log('Link Remove: Invalid body parameter - empty body : ignore');
+    await ncAxiosLinkRemove({
+      ...validParams,
+      body: [],
+      status: 200,
+    });
+
+    if (relationType === 'bt') {
+      // Link Remove: Invalid body parameter - row id invalid
+      if (debugMode)
+        console.log('Link Remove: Invalid body parameter - row id invalid');
+      await ncAxiosLinkRemove({
+        ...validParams,
+        body: [999, 998],
+        status: 422,
+        msg: 'Request must contain only one parent id',
+      });
+    } else {
+      // Link Remove: Invalid body parameter - row id invalid
+      if (debugMode)
+        console.log('Link Remove: Invalid body parameter - row id invalid');
+      await ncAxiosLinkRemove({
+        ...validParams,
+        body: [999, 998],
+        status: 422,
+        msg: 'Child record with id [999, 998] not found',
+      });
+
+      // Link Remove: Invalid body parameter - repeated row id
+      if (debugMode)
+        console.log('Link Remove: Invalid body parameter - repeated row id');
+      await ncAxiosLinkRemove({
+        ...validParams,
+        body: [1, 2, 1, 2],
+        status: 422,
+        msg: 'Child record with id [1, 2] are duplicated',
+      });
+    }
+  }
+
+  async function nestedListTests(validParams) {
+    // Link List: Invalid table ID
+    if (debugMode) console.log('Link List: Invalid table ID');
+    await ncAxiosLinkGet({
+      ...validParams,
+      urlParams: { ...validParams.urlParams, tableId: 9999 },
+      status: 404,
+      msg: "Table with id '9999' not found",
+    });
+
+    // Link List: Invalid link ID
+    if (debugMode) console.log('Link List: Invalid link ID');
+    await ncAxiosLinkGet({
+      ...validParams,
+      urlParams: { ...validParams.urlParams, linkId: 9999 },
+      status: 404,
+      msg: "Column with id '9999' not found",
+    });
+
+    // Link List: Invalid Source row ID
+    if (debugMode) console.log('Link List: Invalid Source row ID');
+    await ncAxiosLinkGet({
+      ...validParams,
+      urlParams: { ...validParams.urlParams, rowId: 9999 },
+      status: 404,
+      msg: "Row with id '9999' not found",
+    });
+
+    // Query parameter error
+    //
+
+    // Link List: Invalid query parameter - negative offset
+    if (debugMode)
+      console.log('Link List: Invalid query parameter - negative offset');
+    await ncAxiosLinkGet({
+      ...validParams,
+      query: { ...validParams.query, offset: -1 },
+      status: 200,
+    });
+
+    // Link List: Invalid query parameter - string offset
+    if (debugMode)
+      console.log('Link List: Invalid query parameter - string offset');
+    await ncAxiosLinkGet({
+      ...validParams,
+      query: { ...validParams.query, offset: 'abcd' },
+      status: 200,
+    });
+
+    // Link List: Invalid query parameter - offset > total rows
+    if (debugMode)
+      console.log('Link List: Invalid query parameter - offset > total rows');
+    await ncAxiosLinkGet({
+      ...validParams,
+      query: { ...validParams.query, offset: 9999 },
+      status: 200,
+    });
+
+    // Link List: Invalid query parameter - negative limit
+    if (debugMode)
+      console.log('Link List: Invalid query parameter - negative limit');
+    await ncAxiosLinkGet({
+      ...validParams,
+      query: { ...validParams.query, limit: -1 },
+      status: 200,
+    });
+
+    // Link List: Invalid query parameter - string limit
+    if (debugMode)
+      console.log('Link List: Invalid query parameter - string limit');
+    await ncAxiosLinkGet({
+      ...validParams,
+      query: { ...validParams.query, limit: 'abcd' },
+      status: 200,
+    });
+
+    // Link List: Invalid query parameter - limit > total rows
+    if (debugMode)
+      console.log('Link List: Invalid query parameter - limit > total rows');
+    await ncAxiosLinkGet({
+      ...validParams,
+      query: { ...validParams.query, limit: 9999 },
+      status: 200,
+    });
+  }
+
+  // Error handling (has-many)
+  it('Error handling : HM: Nested ADD', async function () {
+    const validParams = {
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+      status: 201,
+    };
+
+    await nestedAddTests(validParams);
+  });
+
+  it('Error handling : HM: Nested REMOVE', async function () {
+    // Prepare data
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+      status: 201,
+    });
+
+    const validParams = {
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: [1, 2, 3],
+      status: 200,
+    };
+
+    await nestedRemoveTests(validParams);
+  });
+
+  it('Error handling : HM: Nested List', async function () {
+    // Prepare data
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+      status: 201,
+    });
+
+    const validParams = {
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      query: {
+        offset: 0,
+        limit: 10,
+      },
+      status: 200,
+    };
+
+    await nestedListTests(validParams);
+  });
+
+  // Error handling (belongs to)
+  it('Error handling : BT: Nested ADD', async function () {
+    const validParams = {
+      urlParams: {
+        tableId: tblCity.id,
+        linkId: getColumnId(columnsCity, 'Country'),
+        rowId: 1,
+      },
+      body: [1],
+      status: 201,
+    };
+
+    await nestedAddTests(validParams, 'bt');
+  });
+
+  it('Error handling : BT: Nested REMOVE', async function () {
+    // Prepare data
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblCity.id,
+        linkId: getColumnId(columnsCity, 'Country'),
+        rowId: 1,
+      },
+      body: [1],
+      status: 201,
+    });
+
+    const validParams = {
+      urlParams: {
+        tableId: tblCity.id,
+        linkId: getColumnId(columnsCity, 'Country'),
+        rowId: 1,
+      },
+      body: [1],
+      status: 200,
+    };
+
+    await nestedRemoveTests(validParams, 'bt');
+  });
+
+  it('Error handling : BT: Nested List', async function () {
+    // Prepare data
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblCity.id,
+        linkId: getColumnId(columnsCity, 'Country'),
+        rowId: 1,
+      },
+      body: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+      status: 201,
+    });
+
+    const validParams = {
+      urlParams: {
+        tableId: tblCity.id,
+        linkId: getColumnId(columnsCity, 'Country'),
+        rowId: 1,
+      },
+      query: {
+        offset: 0,
+        limit: 10,
+      },
+      status: 200,
+    };
+
+    await nestedListTests(validParams);
+  });
+
+  // Error handling (many-many)
+  it('Error handling : MM: Nested ADD', async function () {
+    const validParams = {
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+      body: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+      status: 201,
+    };
+
+    await nestedAddTests(validParams);
+  });
+
+  it('Error handling : MM: Nested REMOVE', async function () {
+    // Prepare data
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+      body: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+      status: 201,
+    });
+
+    const validParams = {
+      urlParams: {
+        tableId: tblCountry.id,
+        linkId: getColumnId(columnsCountry, 'Cities'),
+        rowId: 1,
+      },
+      body: [1, 2, 3],
+      status: 200,
+    };
+
+    await nestedRemoveTests(validParams);
+  });
+
+  it('Error handling : MM: Nested List', async function () {
+    // Prepare data
+    await ncAxiosLinkAdd({
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+      body: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+      status: 201,
+    });
+
+    const validParams = {
+      urlParams: {
+        tableId: tblActor.id,
+        linkId: getColumnId(columnsActor, 'Films'),
+        rowId: 1,
+      },
+      query: {
+        offset: 0,
+        limit: 10,
+      },
+      status: 200,
+    };
+
+    await nestedListTests(validParams);
+  });
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+
+export default function () {
+  // standalone tables
+  describe('Text based', textBased);
+  describe('Numerical', numberBased);
+  describe('Select based', selectBased);
+  describe('Date based', dateBased);
+  describe('Link based', linkBased);
+
+  // based out of sakila db, for link based tests
+  describe('General', generalDb);
+}
+
+///////////////////////////////////////////////////////////////////////////////