feat: migrated index.js to index.ts to allow proper imports

Author: JonaszJestem

.eslintrc.js

@@ -4,57 +4,48 @@ module.exports = {
     es2020: true,
   },
   extends: [
-    'airbnb',
-    'plugin:react/recommended',
-    'plugin:@typescript-eslint/recommended',
+    "airbnb",
+    "plugin:react/recommended",
+    "plugin:@typescript-eslint/recommended",
   ],
-  ignorePatterns: [
-    '*/build/**/*',
-    '*.json',
-    '*.txt',
-    'yarn.lock',
-    '*.yaml',
-  ],
-  parser: '@typescript-eslint/parser',
+  ignorePatterns: ["*/build/**/*", "*.json", "*.txt", "yarn.lock", "*.yaml"],
+  parser: "@typescript-eslint/parser",
   parserOptions: {
     ecmaFeatures: {
       jsx: true,
     },
     ecmaVersion: 11,
-    sourceType: 'module',
+    sourceType: "module",
   },
-  plugins: [
-    'react',
-    '@typescript-eslint',
-  ],
+  plugins: ["react", "@typescript-eslint"],
   rules: {
-    semi: ['error', 'never'],
-    'no-unused-vars': 'off',
-    'import/extensions': 'off',
-    'import/no-unresolved': 'off',
-    'react/jsx-filename-extension': 'off',
-    indent: [
-      'error',
-      2,
-    ],
-    'linebreak-style': ['error', 'unix'],
-    'object-curly-newline': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
+    semi: ["error", "always"],
+    "no-unused-vars": "off",
+    "import/extensions": "off",
+    "import/no-unresolved": "off",
+    "react/jsx-filename-extension": "off",
+    indent: ["error", 2],
+    "linebreak-style": ["error", "unix"],
+    "object-curly-newline": "off",
+    "@typescript-eslint/no-explicit-any": "off",
   },
-  overrides: [{
-    files: ['*.tsx'],
-    rules: {
-      'react/prop-types': 'off',
-      'react/jsx-props-no-spreading': 'off',
-      'import/no-extraneous-dependencies': 'off',
+  overrides: [
+    {
+      files: ["*.tsx"],
+      rules: {
+        "react/prop-types": "off",
+        "react/jsx-props-no-spreading": "off",
+        "import/no-extraneous-dependencies": "off",
+      },
     },
-  }, {
-    files: ['./src/**/*.spec.ts', 'spec/*.ts'],
-    rules: {
-      'no-unused-expressions': 'off',
-      'prefer-arrow-callback': 'off',
-      'func-names': 'off',
-      'import/no-extraneous-dependencies': 'off',
+    {
+      files: ["./src/**/*.spec.ts", "spec/*.ts"],
+      rules: {
+        "no-unused-expressions": "off",
+        "prefer-arrow-callback": "off",
+        "func-names": "off",
+        "import/no-extraneous-dependencies": "off",
+      },
     },
-  }],
-}
+  ],
+};

index.d.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
 /**
  * @module @admin-bro/sequelize
  * @subcategory Adapters
@@ -79,7 +78,8 @@
  * @type {typeof BaseDatabase}
  * @static
  */
-const Database = require('./build/database').default
+import type { BaseDatabase, BaseResource } from 'admin-bro';
+import Database from './src/database';
 
 /**
  * Implementation of {@link BaseResource} for Sequelize Adapter
@@ -88,6 +88,10 @@ const Database = require('./build/database').default
  * @type {typeof BaseResource}
  * @static
  */
-const Resource = require('./build/resource').default
+import Resource from './src/resource';
 
-module.exports = { Database, Resource }
+module.exports = { Database, Resource };
+
+const SequelizeAdapter = { Database, Resource };
+
+export default SequelizeAdapter;

index.js renamed to index.ts

@@ -39,7 +39,7 @@
     "@types/sinon-chai": "^3.2.4",
     "@typescript-eslint/eslint-plugin": "^3.7.0",
     "@typescript-eslint/parser": "^3.7.0",
-    "admin-bro": "^3.2.3",
+    "admin-bro": "^3.4.0",
     "chai": "^4.2.0",
     "eslint": "^7.5.0",
     "eslint-config-airbnb": "^18.2.0",

package.json

@@ -1,27 +1,27 @@
-import { BaseDatabase, BaseResource } from 'admin-bro'
-import { Sequelize } from 'sequelize'
+import { BaseDatabase, BaseResource } from 'admin-bro';
+import { Sequelize } from 'sequelize';
 
-import Resource from './resource'
+import Resource from './resource';
 
 class Database extends BaseDatabase {
   private sequelize: Sequelize
 
   static isAdapterFor(database: any): boolean {
     return (database.sequelize
             && database.sequelize.constructor.name === 'Sequelize')
-           || database.constructor.name === 'Sequelize'
+           || database.constructor.name === 'Sequelize';
   }
 
   constructor(database: any) {
-    super(database)
-    this.sequelize = database.sequelize || database
+    super(database);
+    this.sequelize = database.sequelize || database;
   }
 
   resources(): Array<BaseResource> {
     return Object.keys(this.sequelize.models).map((key) => (
       new Resource(this.sequelize.models[key])
-    ))
+    ));
   }
 }
 
-export default Database
+export default Database;

src/database.ts

@@ -1,101 +1,90 @@
-import escape from 'escape-regexp'
-import {
-  Op,
-} from 'sequelize'
+import escape from 'escape-regexp';
+import { Op } from 'sequelize';
 
 const convertFilter = (filter) => {
   if (!filter) {
-    return {}
+    return {};
   }
   return filter.reduce((memo, filterProperty) => {
-    const { property, value, path: filterPath } = filterProperty
+    const { property, value, path: filterPath } = filterProperty;
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_, index] = filterPath.split('.')
-    const isArray = typeof index !== 'undefined' && !Number.isNaN(Number(index))
-    const previousValue = memo[property.name()] || {}
+    const [_, index] = filterPath.split('.');
+    const isArray = typeof index !== 'undefined' && !Number.isNaN(Number(index));
+    const previousValue = memo[property.name()] || {};
     switch (property.type()) {
     case 'string': {
       if (property.sequelizePath.values) {
         return {
           [property.name()]: { [Op.eq]: `${escape(value)}` },
           ...memo,
-        }
+        };
       }
       if (isArray) {
         return {
           ...memo,
           [property.name()]: {
-            [Op.in]: [
-              ...(previousValue[Op.in] || []),
-              escape(value),
-            ],
+            [Op.in]: [...(previousValue[Op.in] || []), escape(value)],
           },
-        }
+        };
       }
       return {
         ...memo,
         [Op.and]: [
           ...(memo[Op.and] || []),
           {
             [property.name()]: {
-              [Op.iLike as unknown as string]: `%${escape(value)}%`,
+              [(Op.iLike as unknown) as string]: `%${escape(value)}%`,
             },
           },
         ],
-      }
+      };
     }
     case 'number': {
       if (!Number.isNaN(Number(value))) {
         if (isArray) {
           return {
             ...memo,
             [property.name()]: {
-              [Op.in]: [
-                ...(previousValue[Op.in] || []),
-                Number(value),
-              ],
+              [Op.in]: [...(previousValue[Op.in] || []), Number(value)],
             },
-          }
+          };
         }
         return {
           [property.name()]: Number(value),
           ...memo,
-        }
+        };
       }
-      return memo
+      return memo;
     }
     case 'date':
     case 'datetime': {
       if (value.from || value.to) {
         return {
           [property.name()]: {
-            ...value.from && { [Op.gte]: value.from },
-            ...value.to && { [Op.lte]: value.to },
+            ...(value.from && { [Op.gte]: value.from }),
+            ...(value.to && { [Op.lte]: value.to }),
           },
           ...memo,
-        }
+        };
       }
-      break
+      break;
     }
     default:
-      break
+      break;
     }
     if (isArray) {
       return {
         ...memo,
         [property.name()]: {
-          [Op.in]: [
-            ...(previousValue[Op.in] || []),
-            value,
-          ],
+          [Op.in]: [...(previousValue[Op.in] || []), value],
         },
-      }
+      };
     }
     return {
       [property.name()]: value,
       ...memo,
-    }
-  }, {})
-}
+    };
+  }, {});
+};
 
-export default convertFilter
+export default convertFilter;

src/utils/convert-filter.ts

@@ -1,12 +1,12 @@
-import { ValidationError } from 'admin-bro'
+import { ValidationError } from "admin-bro";
 
-const createValidationError = (originalError) => {
+const createValidationError = (originalError: any): ValidationError => {
   const errors = Object.keys(originalError.errors).reduce((memo, key) => {
-    const { path, message, validatorKey } = originalError.errors[key]
-    memo[path] = { message, kind: validatorKey } // eslint-disable-line no-param-reassign
-    return memo
-  }, {})
-  return new ValidationError(errors)
-}
+    const { path, message, validatorKey } = originalError.errors[key];
+    memo[path] = { message, kind: validatorKey }; // eslint-disable-line no-param-reassign
+    return memo;
+  }, {});
+  return new ValidationError(errors);
+};
 
-export default createValidationError
+export default createValidationError;