hotgazpacho / apollo-server-cache-dynamodb Goto Github PK

const DynamoDB = require("aws-sdk/clients/dynamodb");
const { DynamoDBCache } = require("apollo-server-cache-dynamodb");

const dynamoDBClient = new DynamoDB.DocumentClient();

const cacheOptions = {
  tableName: "Test-Apollo-Cache",
  partitionKeyName: "Query",
  valueAttribute: "Response",
  ttlAttribute: "TTL",
  defaultTTL: 300
};

const app = new ApolloServer({
  schema,
  playground: true,
  context: async ({ context }) => {
    context.callbackWaitsForEmptyEventLoop = false;
    var dataloaderFactory = new MongooseDataloaderFactory();
    return { ...context, dataloaderFactory };
  },
  cache: new DynamoDBCache(dynamoDBClient, cacheOptions),
  dataSources: () => ({
    productPages: new data.ProductPagesAPI(),
    products: new data.ProductAPI()
  })
});

const { Types } = require("mongoose");

class BaseAPI {
  constructor(model) {
    this.model = model;
  }
  getOneById(id, ctx) {
    if (!id || !Types.ObjectId.isValid(_id)) {
      return null;
    }
    return this.getOneByField("_id", id, ctx);
  }

  getManyById(ids, ctx) {
    if (!ids) {
      return null;
    }
    return this.getManyByField(
      "_id",
      ids.filter(_id => Types.ObjectId.isValid(_id)),
      ctx
    );
  }

  getOneByField(field, value, ctx) {
    return ctx.dataloaderFactory
      .mongooseLoader(this.model)
      .dataloader(field)
      .load(value);
  }

  getManyByField(field, values, ctx) {
    return ctx.dataloaderFactory
      .mongooseLoader(this.model)
      .dataloader(field)
      .loadMany(values);
  }

  async get(args, ctx, isArray) {
    let filter = args.filter;
    if (filter && Object.keys(filter).length === 1) {
      let indexes = await this.model.collection.getIndexes({ full: true });
      indexes = indexes
        .map(_index => _index.key)
        .map(_index => Object.keys(_index)[0]);
      let key = Object.keys(filter)[0];
      let value = Object.values(filter)[0];
      if (indexes.includes(key)) {
        return isArray
          ? this.getManyByField(key, [value], ctx)
          : this.getOneByField(key, value, ctx);
      }
    }
    return isArray
      ? this.model
          .find(filter)
          .limit(args.limit)
          .skip(args.skip)
          .sort(args.sort)
          .lean()
      : this.model.findOne(filter).lean();
  }
}

module.exports = BaseAPI;