diff --git a/packages/server/src/api/routes/tests/row.spec.ts b/packages/server/src/api/routes/tests/row.spec.ts
index 19d6595619..19f11a044a 100644
--- a/packages/server/src/api/routes/tests/row.spec.ts
+++ b/packages/server/src/api/routes/tests/row.spec.ts
@@ -940,103 +940,104 @@ describe.each([
       })
     })
 
-    describe("relations to same table", () => {
-      let relatedRows: Row[]
+    !isLucene &&
+      describe("relations to same table", () => {
+        let relatedRows: Row[]
 
-      beforeAll(async () => {
-        const relatedTable = await config.api.table.save(
-          defaultTable({
-            schema: {
-              name: { name: "name", type: FieldType.STRING },
-            },
-          })
-        )
-        const relatedTableId = relatedTable._id!
-        table = await config.api.table.save(
-          defaultTable({
-            schema: {
-              name: { name: "name", type: FieldType.STRING },
-              related1: {
-                type: FieldType.LINK,
-                name: "related1",
-                fieldName: "main1",
-                tableId: relatedTableId,
-                relationshipType: RelationshipType.MANY_TO_MANY,
+        beforeAll(async () => {
+          const relatedTable = await config.api.table.save(
+            defaultTable({
+              schema: {
+                name: { name: "name", type: FieldType.STRING },
               },
-              related2: {
-                type: FieldType.LINK,
-                name: "related2",
-                fieldName: "main2",
-                tableId: relatedTableId,
-                relationshipType: RelationshipType.MANY_TO_MANY,
+            })
+          )
+          const relatedTableId = relatedTable._id!
+          table = await config.api.table.save(
+            defaultTable({
+              schema: {
+                name: { name: "name", type: FieldType.STRING },
+                related1: {
+                  type: FieldType.LINK,
+                  name: "related1",
+                  fieldName: "main1",
+                  tableId: relatedTableId,
+                  relationshipType: RelationshipType.MANY_TO_MANY,
+                },
+                related2: {
+                  type: FieldType.LINK,
+                  name: "related2",
+                  fieldName: "main2",
+                  tableId: relatedTableId,
+                  relationshipType: RelationshipType.MANY_TO_MANY,
+                },
               },
-            },
-          })
-        )
-        relatedRows = await Promise.all([
-          config.api.row.save(relatedTableId, { name: "foo" }),
-          config.api.row.save(relatedTableId, { name: "bar" }),
-          config.api.row.save(relatedTableId, { name: "baz" }),
-          config.api.row.save(relatedTableId, { name: "boo" }),
-        ])
-      })
-
-      it("can create rows with both relationships", async () => {
-        const row = await config.api.row.save(table._id!, {
-          name: "test",
-          related1: [relatedRows[0]._id!],
-          related2: [relatedRows[1]._id!],
+            })
+          )
+          relatedRows = await Promise.all([
+            config.api.row.save(relatedTableId, { name: "foo" }),
+            config.api.row.save(relatedTableId, { name: "bar" }),
+            config.api.row.save(relatedTableId, { name: "baz" }),
+            config.api.row.save(relatedTableId, { name: "boo" }),
+          ])
         })
 
-        expect(row).toEqual(
-          expect.objectContaining({
+        it("can create rows with both relationships", async () => {
+          const row = await config.api.row.save(table._id!, {
             name: "test",
-            related1: [
-              {
-                _id: relatedRows[0]._id,
-                primaryDisplay: relatedRows[0].name,
-              },
-            ],
-            related2: [
-              {
-                _id: relatedRows[1]._id,
-                primaryDisplay: relatedRows[1].name,
-              },
-            ],
+            related1: [relatedRows[0]._id!],
+            related2: [relatedRows[1]._id!],
           })
-        )
-      })
 
-      it("can create rows with no relationships", async () => {
-        const row = await config.api.row.save(table._id!, {
-          name: "test",
+          expect(row).toEqual(
+            expect.objectContaining({
+              name: "test",
+              related1: [
+                {
+                  _id: relatedRows[0]._id,
+                  primaryDisplay: relatedRows[0].name,
+                },
+              ],
+              related2: [
+                {
+                  _id: relatedRows[1]._id,
+                  primaryDisplay: relatedRows[1].name,
+                },
+              ],
+            })
+          )
         })
 
-        expect(row.related1).toBeUndefined()
-        expect(row.related2).toBeUndefined()
-      })
-
-      it("can create rows with only one relationships field", async () => {
-        const row = await config.api.row.save(table._id!, {
-          name: "test",
-          related1: [],
-          related2: [relatedRows[1]._id!],
-        })
-
-        expect(row).toEqual(
-          expect.objectContaining({
+        it("can create rows with no relationships", async () => {
+          const row = await config.api.row.save(table._id!, {
             name: "test",
-            related2: [
-              {
-                _id: relatedRows[1]._id,
-                primaryDisplay: relatedRows[1].name,
-              },
-            ],
           })
-        )
-        expect(row.related1).toBeUndefined()
+
+          expect(row.related1).toBeUndefined()
+          expect(row.related2).toBeUndefined()
+        })
+
+        it("can create rows with only one relationships field", async () => {
+          const row = await config.api.row.save(table._id!, {
+            name: "test",
+            related1: [],
+            related2: [relatedRows[1]._id!],
+          })
+
+          expect(row).toEqual(
+            expect.objectContaining({
+              name: "test",
+              related2: [
+                {
+                  _id: relatedRows[1]._id,
+                  primaryDisplay: relatedRows[1].name,
+                },
+              ],
+            })
+          )
+          expect(row.related1).toBeUndefined()
+        })
       })
-    })
   })
 
   describe("get", () => {
@@ -1140,132 +1141,133 @@ describe.each([
         expect(rows).toHaveLength(1)
       })
 
-    describe("relations to same table", () => {
-      let relatedRows: Row[]
+    !isLucene &&
+      describe("relations to same table", () => {
+        let relatedRows: Row[]
 
-      beforeAll(async () => {
-        const relatedTable = await config.api.table.save(
-          defaultTable({
-            schema: {
-              name: { name: "name", type: FieldType.STRING },
-            },
-          })
-        )
-        const relatedTableId = relatedTable._id!
-        table = await config.api.table.save(
-          defaultTable({
-            schema: {
-              name: { name: "name", type: FieldType.STRING },
-              related1: {
-                type: FieldType.LINK,
-                name: "related1",
-                fieldName: "main1",
-                tableId: relatedTableId,
-                relationshipType: RelationshipType.MANY_TO_MANY,
+        beforeAll(async () => {
+          const relatedTable = await config.api.table.save(
+            defaultTable({
+              schema: {
+                name: { name: "name", type: FieldType.STRING },
               },
-              related2: {
-                type: FieldType.LINK,
-                name: "related2",
-                fieldName: "main2",
-                tableId: relatedTableId,
-                relationshipType: RelationshipType.MANY_TO_MANY,
+            })
+          )
+          const relatedTableId = relatedTable._id!
+          table = await config.api.table.save(
+            defaultTable({
+              schema: {
+                name: { name: "name", type: FieldType.STRING },
+                related1: {
+                  type: FieldType.LINK,
+                  name: "related1",
+                  fieldName: "main1",
+                  tableId: relatedTableId,
+                  relationshipType: RelationshipType.MANY_TO_MANY,
+                },
+                related2: {
+                  type: FieldType.LINK,
+                  name: "related2",
+                  fieldName: "main2",
+                  tableId: relatedTableId,
+                  relationshipType: RelationshipType.MANY_TO_MANY,
+                },
               },
-            },
-          })
-        )
-        relatedRows = await Promise.all([
-          config.api.row.save(relatedTableId, { name: "foo" }),
-          config.api.row.save(relatedTableId, { name: "bar" }),
-          config.api.row.save(relatedTableId, { name: "baz" }),
-          config.api.row.save(relatedTableId, { name: "boo" }),
-        ])
-      })
-
-      it("can edit rows with both relationships", async () => {
-        let row = await config.api.row.save(table._id!, {
-          name: "test",
-          related1: [relatedRows[0]._id!],
-          related2: [relatedRows[1]._id!],
+            })
+          )
+          relatedRows = await Promise.all([
+            config.api.row.save(relatedTableId, { name: "foo" }),
+            config.api.row.save(relatedTableId, { name: "bar" }),
+            config.api.row.save(relatedTableId, { name: "baz" }),
+            config.api.row.save(relatedTableId, { name: "boo" }),
+          ])
         })
 
-        row = await config.api.row.save(table._id!, {
-          ...row,
-          related1: [relatedRows[0]._id!, relatedRows[1]._id!],
-          related2: [relatedRows[2]._id!],
-        })
-
-        expect(row).toEqual(
-          expect.objectContaining({
+        it("can edit rows with both relationships", async () => {
+          let row = await config.api.row.save(table._id!, {
             name: "test",
-            related1: [
-              {
-                _id: relatedRows[1]._id,
-                primaryDisplay: relatedRows[1].name,
-              },
-              {
-                _id: relatedRows[0]._id,
-                primaryDisplay: relatedRows[0].name,
-              },
-            ],
-            related2: [
-              {
-                _id: relatedRows[2]._id,
-                primaryDisplay: relatedRows[2].name,
-              },
-            ],
+            related1: [relatedRows[0]._id!],
+            related2: [relatedRows[1]._id!],
           })
-        )
-      })
 
-      it("can drop existing relationship", async () => {
-        let row = await config.api.row.save(table._id!, {
-          name: "test",
-          related1: [relatedRows[0]._id!],
-          related2: [relatedRows[1]._id!],
+          row = await config.api.row.save(table._id!, {
+            ...row,
+            related1: [relatedRows[0]._id!, relatedRows[1]._id!],
+            related2: [relatedRows[2]._id!],
+          })
+
+          expect(row).toEqual(
+            expect.objectContaining({
+              name: "test",
+              related1: [
+                {
+                  _id: relatedRows[1]._id,
+                  primaryDisplay: relatedRows[1].name,
+                },
+                {
+                  _id: relatedRows[0]._id,
+                  primaryDisplay: relatedRows[0].name,
+                },
+              ],
+              related2: [
+                {
+                  _id: relatedRows[2]._id,
+                  primaryDisplay: relatedRows[2].name,
+                },
+              ],
+            })
+          )
         })
 
-        row = await config.api.row.save(table._id!, {
-          ...row,
-          related1: [],
-          related2: [relatedRows[2]._id!],
-        })
-
-        expect(row).toEqual(
-          expect.objectContaining({
+        it("can drop existing relationship", async () => {
+          let row = await config.api.row.save(table._id!, {
             name: "test",
-            related2: [
-              {
-                _id: relatedRows[2]._id,
-                primaryDisplay: relatedRows[2].name,
-              },
-            ],
+            related1: [relatedRows[0]._id!],
+            related2: [relatedRows[1]._id!],
           })
-        )
-        expect(row.related1).toBeUndefined()
-      })
 
-      it("can drop both relationships", async () => {
-        let row = await config.api.row.save(table._id!, {
-          name: "test",
-          related1: [relatedRows[0]._id!],
-          related2: [relatedRows[1]._id!],
+          row = await config.api.row.save(table._id!, {
+            ...row,
+            related1: [],
+            related2: [relatedRows[2]._id!],
+          })
+
+          expect(row).toEqual(
+            expect.objectContaining({
+              name: "test",
+              related2: [
+                {
+                  _id: relatedRows[2]._id,
+                  primaryDisplay: relatedRows[2].name,
+                },
+              ],
+            })
+          )
+          expect(row.related1).toBeUndefined()
         })
 
-        row = await config.api.row.save(table._id!, {
-          ...row,
-          related1: [],
-          related2: [],
-        })
-
-        expect(row).toEqual(
-          expect.objectContaining({
+        it("can drop both relationships", async () => {
+          let row = await config.api.row.save(table._id!, {
             name: "test",
+            related1: [relatedRows[0]._id!],
+            related2: [relatedRows[1]._id!],
           })
-        )
-        expect(row.related1).toBeUndefined()
-        expect(row.related2).toBeUndefined()
+
+          row = await config.api.row.save(table._id!, {
+            ...row,
+            related1: [],
+            related2: [],
+          })
+
+          expect(row).toEqual(
+            expect.objectContaining({
+              name: "test",
+            })
+          )
+          expect(row.related1).toBeUndefined()
+          expect(row.related2).toBeUndefined()
+        })
       })
-    })
   })
 
   describe("patch", () => {
@@ -1543,71 +1545,72 @@ describe.each([
       expect(res.length).toEqual(2)
     })
 
-    describe("relations to same table", () => {
-      let relatedRows: Row[]
+    !isLucene &&
+      describe("relations to same table", () => {
+        let relatedRows: Row[]
 
-      beforeAll(async () => {
-        const relatedTable = await config.api.table.save(
-          defaultTable({
-            schema: {
-              name: { name: "name", type: FieldType.STRING },
-            },
-          })
-        )
-        const relatedTableId = relatedTable._id!
-        table = await config.api.table.save(
-          defaultTable({
-            schema: {
-              name: { name: "name", type: FieldType.STRING },
-              related1: {
-                type: FieldType.LINK,
-                name: "related1",
-                fieldName: "main1",
-                tableId: relatedTableId,
-                relationshipType: RelationshipType.MANY_TO_MANY,
+        beforeAll(async () => {
+          const relatedTable = await config.api.table.save(
+            defaultTable({
+              schema: {
+                name: { name: "name", type: FieldType.STRING },
               },
-              related2: {
-                type: FieldType.LINK,
-                name: "related2",
-                fieldName: "main2",
-                tableId: relatedTableId,
-                relationshipType: RelationshipType.MANY_TO_MANY,
+            })
+          )
+          const relatedTableId = relatedTable._id!
+          table = await config.api.table.save(
+            defaultTable({
+              schema: {
+                name: { name: "name", type: FieldType.STRING },
+                related1: {
+                  type: FieldType.LINK,
+                  name: "related1",
+                  fieldName: "main1",
+                  tableId: relatedTableId,
+                  relationshipType: RelationshipType.MANY_TO_MANY,
+                },
+                related2: {
+                  type: FieldType.LINK,
+                  name: "related2",
+                  fieldName: "main2",
+                  tableId: relatedTableId,
+                  relationshipType: RelationshipType.MANY_TO_MANY,
+                },
               },
-            },
-          })
-        )
-        relatedRows = await Promise.all([
-          config.api.row.save(relatedTableId, { name: "foo" }),
-          config.api.row.save(relatedTableId, { name: "bar" }),
-          config.api.row.save(relatedTableId, { name: "baz" }),
-          config.api.row.save(relatedTableId, { name: "boo" }),
-        ])
-      })
-
-      it("can delete rows with both relationships", async () => {
-        const row = await config.api.row.save(table._id!, {
-          name: "test",
-          related1: [relatedRows[0]._id!],
-          related2: [relatedRows[1]._id!],
+            })
+          )
+          relatedRows = await Promise.all([
+            config.api.row.save(relatedTableId, { name: "foo" }),
+            config.api.row.save(relatedTableId, { name: "bar" }),
+            config.api.row.save(relatedTableId, { name: "baz" }),
+            config.api.row.save(relatedTableId, { name: "boo" }),
+          ])
         })
 
-        await config.api.row.delete(table._id!, { _id: row._id! })
+        it("can delete rows with both relationships", async () => {
+          const row = await config.api.row.save(table._id!, {
+            name: "test",
+            related1: [relatedRows[0]._id!],
+            related2: [relatedRows[1]._id!],
+          })
 
-        await config.api.row.get(table._id!, row._id!, { status: 404 })
-      })
+          await config.api.row.delete(table._id!, { _id: row._id! })
 
-      it("can delete rows with empty relationships", async () => {
-        const row = await config.api.row.save(table._id!, {
-          name: "test",
-          related1: [],
-          related2: [],
+          await config.api.row.get(table._id!, row._id!, { status: 404 })
         })
 
-        await config.api.row.delete(table._id!, { _id: row._id! })
+        it("can delete rows with empty relationships", async () => {
+          const row = await config.api.row.save(table._id!, {
+            name: "test",
+            related1: [],
+            related2: [],
+          })
 
-        await config.api.row.get(table._id!, row._id!, { status: 404 })
+          await config.api.row.delete(table._id!, { _id: row._id! })
+
+          await config.api.row.get(table._id!, row._id!, { status: 404 })
+        })
       })
-    })
   })
 
   describe("validate", () => {