How to use the sequelize function in sequelize

import Sequelize from 'sequelize';
import bodyParser from 'body-parser';
import chalk from 'chalk';
import * as response from './response';
import config from '../config';

// sequelize
const conf = config.webserver.sequelize;

export const sequelize = new Sequelize(conf.database, conf.username, conf.password, conf.options);
if (!sequelize) {
  console.log(chalk.red.bold('Could not connect sequelize'), err);
}

const connect = (models, force = true) => {
  Object.keys(models).map(model => {
    return models[model](sequelize);
  });

  sequelize.authenticate()
    .then(() => {
      console.log(chalk.bold.green('Sequelize connected'), sequelize.config);
    }, (err) => {
      console.log(chalk.red.bold('Unable to connect to the database:'), err);
    });

import uuid from 'uuid';
import { SequelizeModel } from '../../types';

const session = createNamespace('atlas-express-app');
Sequelize.useCLS(session);

/**
 * If the model has an id field, presume it's a uuid field and populate it
 */
export const beforeCreate = (instance: SequelizeModel, { fields }: { fields: [string] }) => {
  if (instance.constructor.name !== 'AddonSettings' && fields.includes('id')) {
    instance.id = uuid.v4(); // eslint-disable-line
  }
};

export default new Sequelize(process.env.DATABASE_URL, {
  dialect: process.env.DB_DIALECT,
  define: {
    underscored: true,
    paranoid: true,
    freezeTableName: false,
    charset: process.env.DB_CHARSET || 'utf8',
    dialectOptions: {
      collate: process.env.DB_DIALECT_OPTIONS_COLLATE || 'utf8_general_ci',
    },
    timestamps: true,
    hooks: {
      beforeCreate,
    },
  },
  // pool configuration used to pool database connections
  pool: {

import Sequelize from 'sequelize';
import { TEXT, INTEGER, REAL, NUMERIC, BLOB } from 'sequelize';

import {
  getPkFieldKey,
  makeCreateArgs,
  makeUpdateArgs,
  makeDeleteArgs,
  makePolyArgs,
} from '../builders/arguments';
import { GraphQLString, GraphQLNonNull, GraphQLInt } from 'graphql';

const db = new Sequelize({
  dialect: 'sqlite',
  storage: ':memory:',
  logging: false,
});

const model = db.define(
  'posts',
  {
    id: {
      type: INTEGER,
      primaryKey: true,
    },
    title: {
      type: TEXT,
      allowNull: true,
    },

init() {
    this.connection = new Sequelize(databaseConfig);

    models
      .map(model => model.init(this.connection))
      .map(model => model.associate && model.associate(this.connection.models));
  }

* port is mutually exclusive with instance name
             * see https://github.com/sequelize/sequelize/issues/3097
             */
            options = omit(['port'], options);
            options.dialectOptions.instanceName = trimmedInstanceName;
        }
        ['connectTimeout', 'requestTimeout'].forEach(timeoutSetting => {
            if (has(timeoutSetting, connection) &&
                !isNaN(parseInt(connection[timeoutSetting], 10))) {
                options.dialectOptions[timeoutSetting] =
                    connection[timeoutSetting];
            }
        });
    }

    return new Sequelize(
        database, username, password, options,
    );
}

import Sequelize from 'sequelize';
import config from '../config';

const connection = new Sequelize(process.env.DATABASE_URL || config.DATABASE_URL, {
  operatorsAliases: Sequelize.Op,
  host: 'localhost',
  dialect: 'postgres',
});

connection.authenticate()
  .then(() => {
    console.log('Database connection has been established successfully.');
  })
  .catch((err) => {
    console.error('Unable to connect to the database:', err);
  });

export default connection;

connect() {
    const { name, username, password, host, port } = this.settings.privateSettings.database

    const Conn = new Sequelize(
      name,
      username,
      password,
      {
        logging: false,
        dialect: 'mysql',
        host: host,
        port: port || 3306,
        define: {
          timestamps: false,
          freezeTableName: true,
        }
      }
    )

    return Conn

import Sequelize from 'sequelize';
import sequelizeConfig from '../sequelize_config';
import { ENV } from '../../../../config/env';
import tokenModel from './tokens';
import topicModel from './topics';
import userModel from './users';

const config = sequelizeConfig[ENV];

const db = {};
const dbUrl = process.env[config.use_env_variable];

const sequelize = dbUrl ? new Sequelize(dbUrl) : new Sequelize(config.database, config.username, config.password, config);

db.Token = sequelize.import('Token', tokenModel);
db.Topic = sequelize.import('Topic', topicModel);
db.User = sequelize.import('User', userModel);

Object.keys(db).forEach((key) => {
  const model = db[key];
  if (model.associate) {
    model.associate(db);
  }
});

export { db as Models, sequelize };

if (global[`dbconnection-${system.operationId}-${hashedParams}`]) {
        //@ts-ignore
        sequelize = global[`dbconnection-${system.operationId}-${hashedParams}`];
    } else {
        if (useStorage) {
            //@ts-ignore
            sequelize = new Sequelize({
                dialect: "sqlite",
                storage: useStorage,
                logging: false
            });
            //@ts-ignore
            global[`dbconnection-${system.operationId}-${hashedParams}`] = sequelize;
        } else if (params.connectionURI) {
            //@ts-ignore
            sequelize = new Sequelize(params.connectionURI, {
                pool: {
                    max: 1,
                    min: 1
                },
                logging: false
            });
            //@ts-ignore
            global[`dbconnection-${system.operationId}-${hashedParams}`] = sequelize;
        } else {
            //@ts-ignore
            sequelize = new Sequelize(params.database, params.username, params.password, {
                dialect: params.dialect,
                host: params.host || "localhost",
                port: params.port,
                pool: {
                    max: 1,