Fix filter transform with logic operators (#5269)

Various fixes

- Remote objects are read-only for now, we already hide and block most
of the write actions but the button that allows you to add a new record
in an empty collection was still visible.
- CreatedAt is not mandatory on remote objects (at least for now) so it
was breaking the show page, it now checks if createdAt exists and is not
null before trying to display the human readable format `Added x days
ago`
- The filters are overwritten in query-runner-args.factory.ts to handle
NUMBER field type, this was only working with filters like
```
      {
        "id": {
          "in": [
            1
          ]
        }
```
but not with more depth such as 
```
    "and": [
      {},
      {
        "id": {
          "in": [
            1
          ]
        }
      }
    ]
 ```
- Fixes CREATE FOREIGN TABLE raw query which was missing ",".

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/factories/query-runner-args.factory.ts

@@ -131,30 +131,46 @@ export class QueryRunnerArgsFactory {
       return;
     }
 
-    const createArgPromiseByArgKey = Object.entries(filter).map(
-      ([key, value]) => {
-        const fieldMetadata = fieldMetadataMap.get(key);
-
-        if (!fieldMetadata) {
-          return [key, value];
+    const overrideFilter = (filterObject: RecordFilter) => {
+      return Object.entries(filterObject).reduce((acc, [key, value]) => {
+        if (key === 'and' || key === 'or') {
+          acc[key] = value.map((nestedFilter: RecordFilter) =>
+            overrideFilter(nestedFilter),
+          );
+        } else if (key === 'not') {
+          acc[key] = overrideFilter(value);
+        } else {
+          acc[key] = this.transformValueByType(key, value, fieldMetadataMap);
         }
 
-        const createFilterByKey = Object.entries(value).map(
-          ([filterKey, filterValue]) => {
-            switch (fieldMetadata.type) {
-              case FieldMetadataType.NUMBER:
-                return [filterKey, Number(filterValue)];
-              default:
-                return [filterKey, filterValue];
-            }
-          },
+        return acc;
+      }, {});
+    };
+
+    return overrideFilter(filter);
+  }
+
+  private transformValueByType(
+    key: string,
+    value: any,
+    fieldMetadataMap: Map<string, FieldMetadataInterface>,
+  ) {
+    const fieldMetadata = fieldMetadataMap.get(key);
+
+    if (!fieldMetadata) {
+      return value;
+    }
+    switch (fieldMetadata.type) {
+      case 'NUMBER':
+        return Object.fromEntries(
+          Object.entries(value).map(([filterKey, filterValue]) => [
+            filterKey,
+            Number(filterValue),
+          ]),
         );
-
-        return [key, Object.fromEntries(createFilterByKey)];
-      },
-    );
-
-    return Object.fromEntries(createArgPromiseByArgKey);
+      default:
+        return value;
+    }
   }
 
   private async overrideValueByFieldMetadata(