How to define GraphQL Schema?

{
  "data": {
    "resource": {
      "nodes": [
        {
          "id": "1",
          "title": "Title 1"
        },
        {
          "id": "2",
          "title": "Title 2"
        }
      ],
      "totalCount": 2
    }
  }
}

{
  "data": {
    "resource": {
      "nodes": [
        {
          "id": "1",
          "title": "Title 1"
        },
        {
          "id": "2",
          "title": "Title 2"
        }
      ],
      "totalCount": 2
    }
  }
}

{
  "data": {
    "vehicles": {
      "nodes": [
        {
          "id": "1",
          "vin": "VIN1",
          "make": "Make1",
          "model": "Model1",
          "year": "Year1",
          "driver": {
            "id": "1",
            "name": "Name1",
            "email": "Email1",
            "licenseNumber": "LicenseNumber1"
          },
          "gateway": {
            "id": "1",
            "serialNumber": "SerialNumber1",
            "firmwareVersion": "FirmwareVersion1"
          }
        },
        {
          "id": "2",
          "vin": "VIN2",
          "make": "Make2",
          "model": "Model2",
          "year": "Year2",
          "driver": {
            "id": "2",
            "name": "Name2",
            "email": "Email2",
            "licenseNumber": "LicenseNumber2"
          },
          "gateway": {
            "id": "2",
            "serialNumber": "SerialNumber2",
            "firmwareVersion": "FirmwareVersion2"
          }
        }
      ],
      "totalCount": 2
    }
  }
}

{
  "data": {
    "vehicles": {
      "nodes": [
        {
          "id": "1",
          "vin": "VIN1",
          "make": "Make1",
          "model": "Model1",
          "year": "Year1",
          "driver": {
            "id": "1",
            "name": "Name1",
            "email": "Email1",
            "licenseNumber": "LicenseNumber1"
          },
          "gateway": {
            "id": "1",
            "serialNumber": "SerialNumber1",
            "firmwareVersion": "FirmwareVersion1"
          }
        },
        {
          "id": "2",
          "vin": "VIN2",
          "make": "Make2",
          "model": "Model2",
          "year": "Year2",
          "driver": {
            "id": "2",
            "name": "Name2",
            "email": "Email2",
            "licenseNumber": "LicenseNumber2"
          },
          "gateway": {
            "id": "2",
            "serialNumber": "SerialNumber2",
            "firmwareVersion": "FirmwareVersion2"
          }
        }
      ],
      "totalCount": 2
    }
  }
}

const { data, isLoading, isError  } = useList({
    resource: "vehicles_list",
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

const { data, isLoading, isError  } = useList({
    resource: "vehicles_list",
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

query VehiclesList {
    vehicles {
      id
      vin
      make
      model
      year
      driver {
        id
        name
        email
        licenseNumber
      }
      gateway {
        id
        serialNumber
        firmwareVersion
      }
    }
}

query VehiclesList {
    vehicles {
      id
      vin
      make
      model
      year
      driver {
        id
        name
        email
        licenseNumber
      }
      gateway {
        id
        serialNumber
        firmwareVersion
      }
    }
}

const { data, isLoading, isError  } = useList({
    resource: "vehicles",
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

const { data, isLoading, isError  } = useList({
    resource: "vehicles",
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

console.log(data);
console.log(isError);

console.log(data);
console.log(isError);

interface IVehicle {
  id: string;
  vin: string;
  make: string;
  model: string;
  year: string;
  driver: {
    id: string;
    name: string;
    email: string;
    licenseNumber: string;
  };
  gateway: {
    id: string;
    serialNumber: string;
    firmwareVersion: string;
  };
}

interface IVehicleData {
  nodes: IVehicle[];
}

const { data, isLoading, isError } = useList<IVehicleData>({
  resource: "vehicles",
  meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

console.log(data?.nodes);

interface IVehicle {
  id: string;
  vin: string;
  make: string;
  model: string;
  year: string;
  driver: {
    id: string;
    name: string;
    email: string;
    licenseNumber: string;
  };
  gateway: {
    id: string;
    serialNumber: string;
    firmwareVersion: string;
  };
}

interface IVehicleData {
  nodes: IVehicle[];
}

const { data, isLoading, isError } = useList<IVehicleData>({
  resource: "vehicles",
  meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

console.log(data?.nodes);

interface IVehicle {
  id: string;
  vin: string;
  make: string;
  model: string;
  year: string;
  driver: {
    id: string;
    name: string;
    email: string;
    licenseNumber: string;
  };
  gateway: {
    id: string;
    serialNumber: string;
    firmwareVersion: string;
  };
}

interface IVehicleData {
  nodes: IVehicle[];
  totalCount: number;
}

const { data, isLoading, isError } = useList<IVehicleData>({
  resource: "vehicles",
  meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

console.log(data?.nodes);

interface IVehicle {
  id: string;
  vin: string;
  make: string;
  model: string;
  year: string;
  driver: {
    id: string;
    name: string;
    email: string;
    licenseNumber: string;
  };
  gateway: {
    id: string;
    serialNumber: string;
    firmwareVersion: string;
  };
}

interface IVehicleData {
  nodes: IVehicle[];
  totalCount: number;
}

const { data, isLoading, isError } = useList<IVehicleData>({
  resource: "vehicles",
  meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

console.log(data?.nodes);

console.log(data?.nodes); // logs the array of vehicles
console.log(data?.totalCount); // logs the total number of vehicles

console.log(data?.nodes); // logs the array of vehicles
console.log(data?.totalCount); // logs the total number of vehicles

let { data } = useList<IVehicleData>({
  resource: "vehicles",
  meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

data = data?.data;

console.log(data?.nodes); // logs the array of vehicles
console.log(data?.totalCount); // logs the total number of vehicles

let { data } = useList<IVehicleData>({
  resource: "vehicles",
  meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

data = data?.data;

console.log(data?.nodes); // logs the array of vehicles
console.log(data?.totalCount); // logs the total number of vehicles

const { data } = useList<IVehicleData>({
  resource: "vehicles",
  meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

console.log(data?.data.nodes); // logs the array of vehicles
console.log(data?.data.totalCount); // logs the total number of vehicles

const { data } = useList<IVehicleData>({
  resource: "vehicles",
  meta: { gqlQuery: VEHICLES_LIST_QUERY },
});

console.log(data?.data.nodes); // logs the array of vehicles
console.log(data?.data.totalCount); // logs the total number of vehicles

@strawberry.type
class VehicleConnection:
    nodes: List[VehicleType]
    total: int  # Change this from totalCount to total

@strawberry.type
class Query:
    @strawberry.field
    async def vehicles(self, info: strawberry.Info, where: Optional[JSON] = None, sort: Optional[str] = None, start: Optional[int] = None, limit: Optional[int] = None) -> VehicleConnection:
        query = Vehicle.objects.all()

        # Apply filtering
        if where:
            query = query.filter(**where)

        # Apply sorting
        if sort:
            query = query.order_by(sort)

        # Apply pagination
        if start is not None and limit is not None:
            query = query[start:start + limit]

        total = await sync_to_async(query.count)()  # Change this from totalCount to total
        vehicle_list = await sync_to_async(list)(query)
        return VehicleConnection(nodes=vehicle_list, total=total)  # Change this from totalCount to total

@strawberry.type
class VehicleConnection:
    nodes: List[VehicleType]
    total: int  # Change this from totalCount to total

@strawberry.type
class Query:
    @strawberry.field
    async def vehicles(self, info: strawberry.Info, where: Optional[JSON] = None, sort: Optional[str] = None, start: Optional[int] = None, limit: Optional[int] = None) -> VehicleConnection:
        query = Vehicle.objects.all()

        # Apply filtering
        if where:
            query = query.filter(**where)

        # Apply sorting
        if sort:
            query = query.order_by(sort)

        # Apply pagination
        if start is not None and limit is not None:
            query = query[start:start + limit]

        total = await sync_to_async(query.count)()  # Change this from totalCount to total
        vehicle_list = await sync_to_async(list)(query)
        return VehicleConnection(nodes=vehicle_list, total=total)  # Change this from totalCount to total

const {{ data }} = useList<IVehicleData>({{
  resource: "vehicles",
  meta: {{ gqlQuery: VEHICLES_LIST_QUERY }},
}});

console.log(data?.data.nodes); // logs the array of vehicles
console.log(data?.total); // logs the total number of vehicles

const {{ data }} = useList<IVehicleData>({{
  resource: "vehicles",
  meta: {{ gqlQuery: VEHICLES_LIST_QUERY }},
}});

console.log(data?.data.nodes); // logs the array of vehicles
console.log(data?.total); // logs the total number of vehicles

import { GraphQLClient } from "graphql-request";
import { dataProvider as baseDataProvider } from "@refine/graphql";

const client = new GraphQLClient(API_URL, {
  fetch: (url: string, options: RequestInit) => {
    const token = localStorage.getItem("token"); // Ensure you get the token from a secure place
    return fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        Authorization: `Bearer ${token}`,
      },
    });
  },
});

const baseData = baseDataProvider(client);

const dataProvider = {
  ...baseData,
  getList: async (resource, params) => {
    const response = await baseData.getList(resource, params);

    // Adapt the server response to the format that Refine expects
    return {
      data: response.data.nodes,
      total: response.data.total,
    };
  },
};

export default dataProvider;

import { GraphQLClient } from "graphql-request";
import { dataProvider as baseDataProvider } from "@refine/graphql";

const client = new GraphQLClient(API_URL, {
  fetch: (url: string, options: RequestInit) => {
    const token = localStorage.getItem("token"); // Ensure you get the token from a secure place
    return fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        Authorization: `Bearer ${token}`,
      },
    });
  },
});

const baseData = baseDataProvider(client);

const dataProvider = {
  ...baseData,
  getList: async (resource, params) => {
    const response = await baseData.getList(resource, params);

    // Adapt the server response to the format that Refine expects
    return {
      data: response.data.nodes,
      total: response.data.total,
    };
  },
};

export default dataProvider;

import dataProvider from "./dataProvider";
const App = () => (
  <Admin dataProvider={dataProvider}>
    {/* Your resources and routes */}
  </Admin>
);

import dataProvider from "./dataProvider";
const App = () => (
  <Admin dataProvider={dataProvider}>
    {/* Your resources and routes */}
  </Admin>
);

import strawberry
from strawberry.django import auto

@strawberry.type
class Vehicle:
    id: auto
    vin: auto
    make: auto
    model: auto
    year: auto

@strawberry.type
class VehicleConnection:
    nodes: List[Vehicle]
    totalCount: int
@strawberry.type
class Query:
    @strawberry.field
    def vehicles(self, info, start: int = 0, limit: int = 10, sort: Optional[str] = None, where: Optional[JSON] = None) -> VehicleConnection:
        # Fetch, sort, filter, and paginate vehicles based on the arguments
        # ...
        return VehicleConnection(nodes=vehicles, totalCount=total_count)

import strawberry
from strawberry.django import auto

@strawberry.type
class Vehicle:
    id: auto
    vin: auto
    make: auto
    model: auto
    year: auto

@strawberry.type
class VehicleConnection:
    nodes: List[Vehicle]
    totalCount: int
@strawberry.type
class Query:
    @strawberry.field
    def vehicles(self, info, start: int = 0, limit: int = 10, sort: Optional[str] = None, where: Optional[JSON] = None) -> VehicleConnection:
        # Fetch, sort, filter, and paginate vehicles based on the arguments
        # ...
        return VehicleConnection(nodes=vehicles, totalCount=total_count)

import { useList } from "@refine/core";
import { gql } from "graphql-request";
import { GetFieldsFromList, VehiclesListQuery } from "./your-types-file"; // replace with your actual types file

export const VEHICLES_LIST_QUERY = gql`
query vehicles($where: JSON) {
  vehicles(where: $where) {
    totalCount
    nodes {
      id
      vin
      make
      model
      year
      driver {
        id
        name
        email
        licenseNumber
      }
      gateway {
        id
        serialNumber
        firmwareVersion
      }
    }
  }
}
`;

const VehicleList = () => {
  const { data, isLoading, isError } = useList<GetFieldsFromList<VehiclesListQuery>>({
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
  });

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (isError) {
    return <div>Something went wrong!</div>;
  }

  return (
    <ul>
      {data?.data.nodes.map((vehicle) => (
        <li key={vehicle.id}>
          {vehicle.make} {vehicle.model} ({vehicle.year})
        </li>
      ))}
    </ul>
  );
};

export default VehicleList;

import { useList } from "@refine/core";
import { gql } from "graphql-request";
import { GetFieldsFromList, VehiclesListQuery } from "./your-types-file"; // replace with your actual types file

export const VEHICLES_LIST_QUERY = gql`
query vehicles($where: JSON) {
  vehicles(where: $where) {
    totalCount
    nodes {
      id
      vin
      make
      model
      year
      driver {
        id
        name
        email
        licenseNumber
      }
      gateway {
        id
        serialNumber
        firmwareVersion
      }
    }
  }
}
`;

const VehicleList = () => {
  const { data, isLoading, isError } = useList<GetFieldsFromList<VehiclesListQuery>>({
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
  });

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (isError) {
    return <div>Something went wrong!</div>;
  }

  return (
    <ul>
      {data?.data.nodes.map((vehicle) => (
        <li key={vehicle.id}>
          {vehicle.make} {vehicle.model} ({vehicle.year})
        </li>
      ))}
    </ul>
  );
};

export default VehicleList;

import { useList } from "@refine/core";
import { gql } from "graphql-request";
import { GetFieldsFromList, VehiclesListQuery } from "./your-types-file"; // replace with your actual types file

export const VEHICLES_LIST_QUERY = gql`
query vehicles($where: JSON, $sort: String, $start: Int, $limit: Int) {
  vehicles(where: $where, sort: $sort, start: $start, limit: $limit) {
    totalCount
    nodes {
      id
      vin
      make
      model
      year
      driver {
        id
        name
        email
        licenseNumber
      }
      gateway {
        id
        serialNumber
        firmwareVersion
      }
    }
  }
}
`;

const VehicleList = () => {
  const { data, isLoading, isError } = useList<GetFieldsFromList<VehiclesListQuery>>({
    resource: "vehicles",
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
    variables: {
      where: { /* your where condition */ },
      sort: "id:asc", // replace with your sort condition
      start: 0, // replace with your start index
      limit: 10, // replace with your limit
    },
  });

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (isError) {
    return <div>Something went wrong!</div>;
  }

  return (
    <ul>
      {data?.data.nodes.map((vehicle) => (
        <li key={vehicle.id}>
          {vehicle.make} {vehicle.model} ({vehicle.year})
        </li>
      ))}
    </ul>
  );
};

export default VehicleList;

import { useList } from "@refine/core";
import { gql } from "graphql-request";
import { GetFieldsFromList, VehiclesListQuery } from "./your-types-file"; // replace with your actual types file

export const VEHICLES_LIST_QUERY = gql`
query vehicles($where: JSON, $sort: String, $start: Int, $limit: Int) {
  vehicles(where: $where, sort: $sort, start: $start, limit: $limit) {
    totalCount
    nodes {
      id
      vin
      make
      model
      year
      driver {
        id
        name
        email
        licenseNumber
      }
      gateway {
        id
        serialNumber
        firmwareVersion
      }
    }
  }
}
`;

const VehicleList = () => {
  const { data, isLoading, isError } = useList<GetFieldsFromList<VehiclesListQuery>>({
    resource: "vehicles",
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
    variables: {
      where: { /* your where condition */ },
      sort: "id:asc", // replace with your sort condition
      start: 0, // replace with your start index
      limit: 10, // replace with your limit
    },
  });

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (isError) {
    return <div>Something went wrong!</div>;
  }

  return (
    <ul>
      {data?.data.nodes.map((vehicle) => (
        <li key={vehicle.id}>
          {vehicle.make} {vehicle.model} ({vehicle.year})
        </li>
      ))}
    </ul>
  );
};

export default VehicleList;

import { useList } from "@refine/core";
import { gql } from "graphql-request";
import { GetFieldsFromList, VehiclesListQuery } from "./your-types-file"; // replace with your actual types file

export const VEHICLES_LIST_QUERY = gql`
query vehicles($where: JSON, $sort: String, $start: Int, $limit: Int) {
  vehicles(where: $where, sort: $sort, start: $start, limit: $limit) {
    totalCount
    nodes {
      id
      vin
      make
      model
      year
      driver {
        id
        name
        email
        licenseNumber
      }
      gateway {
        id
        serialNumber
        firmwareVersion
      }
    }
  }
}
`;

const VehicleList = () => {
  const { data, isLoading, isError } = useList<GetFieldsFromList<VehiclesListQuery>>({
    resource: "vehicles",
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
    filters: { /* your where condition */ },
    sorters: [{ field: "id", order: "asc" }], // replace with your sort condition
    pagination: { current: 1, pageSize: 10 }, // replace with your start index and limit
  });

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (isError) {
    return <div>Something went wrong!</div>;
  }

  return (
    <ul>
      {data?.data.nodes.map((vehicle) => (
        <li key={vehicle.id}>
          {vehicle.make} {vehicle.model} ({vehicle.year})
        </li>
      ))}
    </ul>
  );
};

export default VehicleList;

import { useList } from "@refine/core";
import { gql } from "graphql-request";
import { GetFieldsFromList, VehiclesListQuery } from "./your-types-file"; // replace with your actual types file

export const VEHICLES_LIST_QUERY = gql`
query vehicles($where: JSON, $sort: String, $start: Int, $limit: Int) {
  vehicles(where: $where, sort: $sort, start: $start, limit: $limit) {
    totalCount
    nodes {
      id
      vin
      make
      model
      year
      driver {
        id
        name
        email
        licenseNumber
      }
      gateway {
        id
        serialNumber
        firmwareVersion
      }
    }
  }
}
`;

const VehicleList = () => {
  const { data, isLoading, isError } = useList<GetFieldsFromList<VehiclesListQuery>>({
    resource: "vehicles",
    meta: { gqlQuery: VEHICLES_LIST_QUERY },
    filters: { /* your where condition */ },
    sorters: [{ field: "id", order: "asc" }], // replace with your sort condition
    pagination: { current: 1, pageSize: 10 }, // replace with your start index and limit
  });

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (isError) {
    return <div>Something went wrong!</div>;
  }

  return (
    <ul>
      {data?.data.nodes.map((vehicle) => (
        <li key={vehicle.id}>
          {vehicle.make} {vehicle.model} ({vehicle.year})
        </li>
      ))}
    </ul>
  );
};

export default VehicleList;

@strawberry.type
class Query:
    @strawberry.field
    async def vehicles(self, info: strawberry.Info, where: Optional[JSON] = None, sort: Optional[str] = None, start: Optional[int] = None, limit: Optional[int] = None) -> VehicleConnection:
        query = Vehicle.objects.all()
        
        # Apply filtering
        if where:
            # Convert the where object into a format that Django understands
            django_where = {f"{where['field']}__{where['operator']}": where['value']}
            query = query.filter(**django_where)
        
        # Apply sorting
        if sort:
            query = query.order_by(sort)

        # Apply pagination
        if start is not None and limit is not None:
            query = query[start:start + limit]

        totalCount = await sync_to_async(query.count)()
        vehicles = await sync_to_async(list)(query)
        return VehicleConnection(nodes=vehicles, totalCount=totalCount)

@strawberry.type
class Query:
    @strawberry.field
    async def vehicles(self, info: strawberry.Info, where: Optional[JSON] = None, sort: Optional[str] = None, start: Optional[int] = None, limit: Optional[int] = None) -> VehicleConnection:
        query = Vehicle.objects.all()
        
        # Apply filtering
        if where:
            # Convert the where object into a format that Django understands
            django_where = {f"{where['field']}__{where['operator']}": where['value']}
            query = query.filter(**django_where)
        
        # Apply sorting
        if sort:
            query = query.order_by(sort)

        # Apply pagination
        if start is not None and limit is not None:
            query = query[start:start + limit]

        totalCount = await sync_to_async(query.count)()
        vehicles = await sync_to_async(list)(query)
        return VehicleConnection(nodes=vehicles, totalCount=totalCount)

filters: [
  {
    field: "year",
    operator: "contains",
    value: "2020",
  },
],

filters: [
  {
    field: "year",
    operator: "contains",
    value: "2020",
  },
],

@strawberry.type
class Query:
    @strawberry.field
    async def vehicles(self, info: strawberry.Info, where: Optional[List[JSON]] = None, sort: Optional[str] = None, start: Optional[int] = None, limit: Optional[int] = None) -> VehicleConnection:
        query = Vehicle.objects.all()
        
        # Apply filtering
        if where:
            for condition in where:
                # Convert the condition into a format that Django understands
                django_where = {f"{condition['field']}__{condition['operator']}": condition['value']}
                query = query.filter(**django_where)
        
        # Apply sorting
        if sort:
            query = query.order_by(sort)

        # Apply pagination
        if start is not None and limit is not None:
            query = query[start:start + limit]

        totalCount = await sync_to_async(query.count)()
        vehicles = await sync_to_async(list)(query)
        return VehicleConnection(nodes=vehicles, totalCount=totalCount)

@strawberry.type
class Query:
    @strawberry.field
    async def vehicles(self, info: strawberry.Info, where: Optional[List[JSON]] = None, sort: Optional[str] = None, start: Optional[int] = None, limit: Optional[int] = None) -> VehicleConnection:
        query = Vehicle.objects.all()
        
        # Apply filtering
        if where:
            for condition in where:
                # Convert the condition into a format that Django understands
                django_where = {f"{condition['field']}__{condition['operator']}": condition['value']}
                query = query.filter(**django_where)
        
        # Apply sorting
        if sort:
            query = query.order_by(sort)

        # Apply pagination
        if start is not None and limit is not None:
            query = query[start:start + limit]

        totalCount = await sync_to_async(query.count)()
        vehicles = await sync_to_async(list)(query)
        return VehicleConnection(nodes=vehicles, totalCount=totalCount)

@strawberry.type
class Query:
    @strawberry.field
    async def vehicles(self, info: strawberry.Info, where: Optional[JSON] = None, sort: Optional[str] = None, start: Optional[int] = None, limit: Optional[int] = None) -> VehicleConnection:
        query = Vehicle.objects.all()
        
        # Apply filtering
        if where:
            for key, value in where.items():
                # Split the key into field and operator
                field, operator = key.split("_", 1)
                # Convert the condition into a format that Django understands
                django_where = {f"{field}__{operator}": value}
                query = query.filter(**django_where)
        
        # Apply sorting
        if sort:
            query = query.order_by(sort)

        # Apply pagination
        if start is not None and limit is not None:
            query = query[start:start + limit]

        totalCount = await sync_to_async(query.count)()
        vehicles = await sync_to_async(list)(query)
        return VehicleConnection(nodes=vehicles, totalCount=totalCount)

@strawberry.type
class Query:
    @strawberry.field
    async def vehicles(self, info: strawberry.Info, where: Optional[JSON] = None, sort: Optional[str] = None, start: Optional[int] = None, limit: Optional[int] = None) -> VehicleConnection:
        query = Vehicle.objects.all()
        
        # Apply filtering
        if where:
            for key, value in where.items():
                # Split the key into field and operator
                field, operator = key.split("_", 1)
                # Convert the condition into a format that Django understands
                django_where = {f"{field}__{operator}": value}
                query = query.filter(**django_where)
        
        # Apply sorting
        if sort:
            query = query.order_by(sort)

        # Apply pagination
        if start is not None and limit is not None:
            query = query[start:start + limit]

        totalCount = await sync_to_async(query.count)()
        vehicles = await sync_to_async(list)(query)
        return VehicleConnection(nodes=vehicles, totalCount=totalCount)

updateMutation({
  resource: "users",
  id,
  values: { name: value },
  mutationMode: "optimistic",
  successNotification: false,
  meta: {
    gqlMutation: ACCOUNT_SETTINGS_UPDATE_USER_MUTATION,
  },
});

updateMutation({
  resource: "users",
  id,
  values: { name: value },
  mutationMode: "optimistic",
  successNotification: false,
  meta: {
    gqlMutation: ACCOUNT_SETTINGS_UPDATE_USER_MUTATION,
  },
});