pankod/refine

View on GitHub

Showing 750 of 983 total issues

Function printUpdateWarningTable has 55 lines of code (exceeds 25 allowed). Consider refactoring.
Open

export const printUpdateWarningTable = async (
  params: UpdateWarningTableParams,
) => {
  const data = params?.data;
  const tableHead = Object.keys(data?.[0] || {});
Severity: Major
Found in packages/cli/src/components/update-warning-table/table.ts - About 2 hrs to fix

    Function createTree has 55 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    export const createTree = (
      resources: IResourceItem[],
      legacy = false,
    ): FlatTreeItem[] => {
      const root: Tree = {
    Severity: Major
    Found in packages/core/src/definitions/helpers/menu/create-tree.ts - About 2 hrs to fix

      Function parse has 54 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        parse: () => {
          const { query, asPath: pathname, isReady } = useRouter();
          const { resources } = useContext(ResourceContext);
      
          const cleanPathname = pathname.split("?")[0].split("#")[0];
      Severity: Major
      Found in packages/nextjs-router/src/pages/bindings.tsx - About 2 hrs to fix

        Function urlFields has 54 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          const urlFields = (field: InferField) => {
            if (field.type === "url") {
              const id = `id: "${field.key}"`;
              const accessorKey = getAccessorKey(field);
              const header = `header: ${translatePrettyString({
        Severity: Major
        Found in packages/inferencer/src/inferencers/headless/list.tsx - About 2 hrs to fix

          Function emailFields has 54 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            const emailFields = (field: InferField) => {
              if (field.type === "email") {
                const id = `id: "${field.key}"`;
                const accessorKey = getAccessorKey(field);
                const header = `header: ${translatePrettyString({
          Severity: Major
          Found in packages/inferencer/src/inferencers/headless/list.tsx - About 2 hrs to fix

            Function basicFields has 54 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              const basicFields = (field: InferField) => {
                if (
                  field &&
                  (field.type === "text" ||
                    field.type === "number" ||
            Severity: Major
            Found in packages/inferencer/src/inferencers/headless/list.tsx - About 2 hrs to fix

              Function basicInputFields has 53 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                const basicInputFields = (field: InferField) => {
                  if (
                    field.type === "text" ||
                    field.type === "url" ||
                    field.type === "email" ||
              Severity: Major
              Found in packages/inferencer/src/inferencers/antd/edit.tsx - About 2 hrs to fix

                Function booleanFields has 53 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  const booleanFields = (field: InferField) => {
                    if (field?.type) {
                      imports.push(["Checkbox", "@mui/material"]);
                
                      const fieldProperty = `field: "${field.key}"`;
                Severity: Major
                Found in packages/inferencer/src/inferencers/mui/list.tsx - About 2 hrs to fix

                  Function imageFields has 53 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    const imageFields = (field: InferField) => {
                      if (field.type === "image") {
                        const fieldProperty = `field: "${field.key}"`;
                  
                        const headerProperty = `headerName: ${translatePrettyString({
                  Severity: Major
                  Found in packages/inferencer/src/inferencers/mui/list.tsx - About 2 hrs to fix

                    Function useNavigationButton has 53 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    export function useNavigationButton(
                      props: NavigationButtonProps,
                    ): NavigationButtonValues {
                      const navigation = useNavigation();
                      const routerType = useRouterType();
                    Severity: Major
                    Found in packages/core/src/hooks/button/navigation-button/index.tsx - About 2 hrs to fix

                      Function getResourcePath has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
                      Open

                      export const getResourcePath = (
                        hookName: RefineHook,
                        legacyKey: boolean,
                      ): string | null => {
                        if (scopes[hookName] === "auth") {
                      Severity: Minor
                      Found in packages/devtools-internal/src/get-resource-path.ts - About 2 hrs to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function printImports has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
                      Open

                      export const printImports = (imports: Array<ImportElement>) => {
                        const byModule = imports.reduce(
                          (acc, [element, module, isDefault]) => {
                            if (!acc[module]) {
                              acc[module] = [] as Array<
                      Severity: Minor
                      Found in packages/inferencer/src/utilities/print-imports/index.ts - About 2 hrs to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function AddPackageDrawer has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
                      Open

                      export const AddPackageDrawer = ({
                        visible,
                        onClose,
                        installedPackages,
                        onInstall,
                      Severity: Minor
                      Found in packages/devtools-ui/src/components/add-package-drawer.tsx - About 2 hrs to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function useDeleteButton has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      export function useDeleteButton(props: DeleteButtonProps): DeleteButtonValues {
                        const translate = useTranslate();
                        const { mutate, isLoading, variables } = useDelete();
                        const { setWarnWhen } = useWarnAboutChange();
                        const { mutationMode } = useMutationMode(props.mutationMode);
                      Severity: Major
                      Found in packages/core/src/hooks/button/delete-button/index.tsx - About 2 hrs to fix

                        Function postTransform has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        export async function postTransform(files: any, flags: any) {
                          const config = new CodemodConfig(CONFIG_FILE_NAME);
                        
                          if (flags.dry) {
                            config.destroy();
                        Severity: Major
                        Found in packages/codemod/src/transformations/refine3-to-refine4.ts - About 2 hrs to fix

                          Function ReadyPage has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          export const ReadyPage: React.FC<RefineReadyPageProps> = () => {
                            return (
                              <BackgroundImage
                                sx={{
                                  display: "flex",
                          Severity: Major
                          Found in packages/mantine/src/components/pages/ready/index.tsx - About 2 hrs to fix

                            Function submissionPromise has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                >((resolve, reject) => {
                                  // Reject the mutation if the resource is not defined
                                  if (!resource) return reject(missingResourceError);
                                  // Reject the mutation if the `id` is not defined in edit action
                                  // This line is commented out because the `id` might not be set for some cases and edit is done on a resource.
                            Severity: Major
                            Found in packages/core/src/hooks/form/index.ts - About 2 hrs to fix

                              Function ErrorComponent has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                              export const ErrorComponent: React.FC<RefineErrorPageProps> = () => {
                                const [errorMessage, setErrorMessage] = useState<string>();
                                const { push } = useNavigation();
                                const go = useGo();
                                const routerType = useRouterType();
                              Severity: Major
                              Found in packages/mui/src/components/pages/error/index.tsx - About 2 hrs to fix

                                Function imageFields has 50 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                  const imageFields = (field: InferField) => {
                                    if (field.type === "image") {
                                      imports.push(
                                        ["Upload", "antd"],
                                        ["getValueFromEvent", "@refinedev/antd"],
                                Severity: Minor
                                Found in packages/inferencer/src/inferencers/antd/edit.tsx - About 2 hrs to fix

                                  Function imageFields has 50 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                    const imageFields = (field: InferField) => {
                                      if (field.type === "image") {
                                        imports.push(
                                          ["Upload", "antd"],
                                          ["getValueFromEvent", "@refinedev/antd"],
                                  Severity: Minor
                                  Found in packages/inferencer/src/inferencers/antd/create.tsx - About 2 hrs to fix
                                    Severity
                                    Category
                                    Status
                                    Source
                                    Language