SQLite support

[tab00]

After adding extends SQLDataSource to the datasource class I get the above error and the component doesn't render.

It happens even if I don't call any of the functions (getBatched(), getCached(), getBatchedAndCached())

If I remove just those two words (extends SQLDataSource) then the app works fine.

Is this a bug?

[cvburgess]

can you post a more complete snippet? I have never encountered this issue.

[tab00]

import knex from "knex"
import { SQLDataSource } from "datasource-sql"

const knex1 = knex({
  client: "sqlite3",
  connection: { filename: "./sqlite.db" },
  useNullAsDefault: true
})

const MINUTE = 60 * 1000

export class DSBooks extends SQLDataSource {
  constructor() {
    super()
    this.knex = knex1
  }

  async getBooks({ idOfOwner }) {
    console.log(`In data source function getBooks. idOfOwner: ${JSON.stringify(idOfOwner)}`)

    const query = knex1.select().from("books")
      // return await this.getBatchedAndCached(query, MINUTE)
      .then((books) => {
        console.log(`books: ${JSON.stringify(books)}`)
        return books
      })
    return await query
  }

  async bookAdd({ book }) {
    console.log(`In data source function bookAdd. book: ${JSON.stringify(book)}`)

    return await knex1("books").insert(book)
      .then(idArray => Object.assign(book, { id: idArray[0] }))
  }
}

[cvburgess]

that looks fine, but how are you calling and using the DataSource?

[cvburgess]

FYI: typically that error is not stemming from a DataSource, it is caused by a GraphQL type referencing itself in your schema. See apollographql/apollo-server#1557

[tab00]

This is my schema:

export const typeDefs = `
type Book {
  id: String
  title: String
  author: String
  idOfOwner: String
}

type Query {
  books: [Book]
}

type Mutation {
  bookAdd(title: String!, author: String!): Book
}

type Subscription {
  latestBook(idOfOwner: String!): Book
}
`

There is no type referencing itself .

[tab00]

that looks fine, but how are you calling and using the DataSource?

The error occurs even if the DataSource is not used.

[tab00]

Here is the DataSource class being passed into ApolloServer instantiation:

  const server = new ApolloServer({
    typeDefs,
    resolvers,
    dataSources: () => ({
      dsBooks: new DSBooks()
    }),
    context: async ({ req, connection }) => {
      if (connection) { // check connection for metadata
        const token = req.headers.authorization || ""
        return { token }
      }

      return { user: await getUser(req.headers.authorization) }
    },
    uploads: false,
  })

[tab00]

resolvers:

export const resolvers = {
  Query: {
    books: async (root, args, context) => {
      console.log(`Query context: ${JSON.stringify(context)}`)
      // if (!context.user) throw new Error("Please log in.")

      const books = await context.dataSources.dsBooks.getBooks(context.user ? { idOfOwner: context.user._id } : {}) //Meteor user available because of https://github.com/apollographql/meteor-integration
      return books
    }
  },

  Mutation: {
    bookAdd: async (root, { title, author }, { dataSources, user }) => { //{ title, author } is args, { dataSources, user } is context. Called "destructuring assignment"
      console.log(`In bookAdd mutation. user: ${JSON.stringify(user)}`)

      if (user === undefined) throw new Error("Please log in.")

      const latestBook = await dataSources.dsBooks.bookAdd({ book: { title, author, idOfOwner: user._id } })
      pubSub.publish(subChannelBookAdded, { latestBook })
      return latestBook
    }
  },

  Subscription: {
    latestBook: {
      subscribe: withFilter(() => pubSub.asyncIterator(subChannelBookAdded),
        (payload, variables, context) => {
          return payload.latestBook.idOfOwner === variables.idOfOwner && payload.latestBook.idOfOwner === context.user._id //only update books added by current logged in user. return true (or don't use withFilter()) if you want everyone to see. user is added to context via SubscriptionServer onConnect.
        }
      ),
    }
  },
}

[tab00]

I've added getBooks() and bookAdd() functions to DSBooks class in the code in #9 (comment)

[cvburgess]

can you verify that it is in fact the SQL Data Source that is causing the issue?

you are currently not even using the methods from the class so im not sure what would be causing this error. Try replacing this with a placeholder class and see if the issue persists

[tab00]

I wrote a simple SQLDataSource class

import { DataSource } from "apollo-datasource"
class SQLDataSource extends DataSource {
  initialize(config) {
    this.context = config.context
    this.db = this.knex
  }
}

export class DSBooks extends SQLDataSource {

I have found that this.context = config.context causes the error, as when I remove that the app runs fine.

[tab00]

If I replace this.context = config.context with this.context = Object.assign({}, config.context) (and add all the other SQLDataSource and SQLCache code) then the app runs.

Only getCached() works. Is this the right way to use getBatched()?:

  async getBooks({ idOfOwner }) {
    const query = knex1.select().from("books")

    return this.getBatched(query)
  }

[cvburgess]

what version of apollo server are you using?

[tab00]

Node package dependencies:

"dependencies": {
    "@babel/runtime": "^7.2.0",
    "apollo-cache-inmemory": "^1.3.12",
    "apollo-client": "^2.4.8",
    "apollo-link": "^1.2.6",
    "apollo-link-error": "^1.1.5",
    "apollo-link-http": "^1.5.9",
    "apollo-link-ws": "^1.0.12",
    "apollo-server-express": "^2.3.1",
    "datasource-sql": "^0.1.4",
    "graphql": "^14.1.1",
    "knex": "^0.16.3",
    "meteor-node-stubs": "^0.4.1",
    "node-fetch": "^2.3.0",
    "prop-types": "^15.6.2",
    "react": "^16.7.0",
    "react-apollo": "^2.3.3",
    "react-dom": "^16.7.0",
    "sequelize": "^4.42.0",
    "sqlite3": "^4.0.6",
    "subscriptions-transport-ws": "^0.9.15"
  },

[tab00]

If I replace:

SQLDataSource/SQLCache.js

Line 14 in 221011c

return this.loader.load(queryString).then(result => result && result.rows);

with

    return await this.loader.load(queryString)

Then getBatched() works as result.rows is undefined.