How to use the neo4j-driver.v1.driver function in neo4j-driver

require("dotenv").config();
import { v1 as NEO4J } from "neo4j-driver";
import knex from "knex";
import PQueue from "p-queue";
import { startOfHour } from "date-fns";

let count = 0;
const queue = new PQueue({ concurrency: 5 });

queue.on("active", () => (count % 1000 === 0 ? console.log(count++) : count++));

// 1. Connect to Neo4j database
const neo4j = NEO4J.driver(
  process.env.NEO4J_DB_URI,
  NEO4J.auth.basic(process.env.NEO4J_DB_USERNAME, process.env.NEO4J_DB_PASSWORD)
);

// 2. Connect to Postgres database
const postgres = knex({
  client: "postgres",
  connection: {
    host: process.env.DB_HOST,
    database: process.env.DB_NAME,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD
  }
});

(async function() {

require("dotenv").config();
import { v1 as NEO4J } from "neo4j-driver";
import knex from "knex";
import PQueue from "p-queue";

const queue = new PQueue({ concurrency: 1 });

// 1. Connect to Neo4j database
const neo4j = NEO4J.driver(
  process.env.NEO4J_DB_URI,
  NEO4J.auth.basic(process.env.NEO4J_DB_USERNAME, process.env.NEO4J_DB_PASSWORD)
);
// 2. Connect to Postgres database
const postgres = knex({
  client: "postgres",
  connection: {
    host: process.env.DB_HOST,
    database: process.env.DB_NAME,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD
  }
});

(async function() {
  const startTime = Date.now();

before(() => {
        const authToken = neo.auth.basic("neo4j", "h4ckM3");
        boltAdapter = new BoltAdapter(neo.driver("bolt://localhost", authToken));
    });

'use strict';
const path = require('path');
const execSync = require('child_process').execSync;

const neo4j = require('neo4j-driver').v1;
const async = require('async');
const LineByLine = require('n-readlines');

const config = require('./config.json');
const driver = neo4j.driver(config.neo4j.bolt, neo4j.auth.basic(config.neo4j.auth.user, config.neo4j.auth.pass));

console.log('Counting lines');
let lines = config.lines;
if (!lines) lines = execSync(`wc -l ${path.resolve(config.file)}`).toString().trim().split(' ')[0];

console.log('Found', lines, 'lines');

const lineReaderSetup = (lineReader) => {
    lineReader.total = lines;
    lineReader.skip = config.skip || 0;
    
    if (!config.skip) return lineReader;
    for (let i = 0; i < config.skip; i++) {
        if(i % config.bucket == 0) console.log('Skipping', i, '(', i / config.skip * 100, '%)');
        lineReader.next();
    }

import { makeAugmentedSchema, inferSchema } from '../../src/index';
import { ApolloServer } from 'apollo-server';
import { v1 as neo4j } from 'neo4j-driver';

const driver = neo4j.driver(
  process.env.NEO4J_URI || 'bolt://localhost:7687',
  neo4j.auth.basic(
    process.env.NEO4J_USER || 'neo4j',
    process.env.NEO4J_PASSWORD || 'letmein'
  )
);

const schemaInferenceOptions = {
  alwaysIncludeRelationships: false
};

const inferAugmentedSchema = driver => {
  return inferSchema(driver, schemaInferenceOptions).then(result => {
    console.log('TYPEDEFS:');
    console.log(result.typeDefs);

constructor(username, password, database, host, port) {
        this.driver = neo4j.driver(`bolt://${host}:${port}`, neo4j.auth.basic(username, password));
    }

constructor({boltUrl, user, password} = {}) {
        this.queries = {};

        this.driver = neo4j.driver(boltUrl, neo4j.auth.basic(user, password));
        const session = this.driver.session();
        this.initialized = session.run('RETURN "Neo4j instance successfully connected."')
            .then((result) => {
                logger.trace(chalk.green(parse(result)));
                session.close();
            })
            .catch(error => {
                logger.error(
                    chalk.red('Error connecting to the Neo4j instance, check connection options'));
                logger.error(error);
                throw error;
            });
    }

connect() {

        this.driver = db.driver(this.database.uri, db.auth.basic(this.database.user, this.database.password));
        
        return this.heartbeat().then(() => {
            this.logger.info(`Connected to ${this.database.uri}`);
            return Promise.resolve();
        });
        
    }

return new Promise((resolve, reject) => {
                try {
                    const connectionString = `${protocol}://${host}:${port}`;
                    const auth = username && password ? neo4j.auth.basic(username, password) : false;

                    if ( username && password && encrypted ) {
                        driver = new neo4j.driver(connectionString, auth, {encrypted});
                    }
                    else if ( username && password ) {
                        driver = new neo4j.driver(connectionString, auth);
                    }
                    else {
                        driver = new neo4j.driver(connectionString);
                    }

                    resolve(driver);
                }
                catch (e) {
                    reject(e);
                }
            });
        }