queries running

Author: andrejpk

package.json

@@ -1,8 +1,9 @@
 {
   "name": "apollo-datasource-cosmosdb",
-  "version": "1.0.0",
+  "version": "0.0.1",
   "description": "An Apollo data source for Azure CosmosDB",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "repository": "https://github.com/andrejpk/apollo-datasource-cosmosdb",
   "author": "Andrej Kyselica",
   "license": "MIT",
@@ -39,4 +40,4 @@
   "files": [
     "/dist"
   ]
-}
+}

src/cache.ts

@@ -2,6 +2,7 @@ import { Container, Operation } from "@azure/cosmos";
 import { KeyValueCache } from "apollo-server-caching";
 import DataLoader from "dataloader";
 import { EJSON } from "bson";
+import { CosmosDataSourceOptions } from "./datasource";
 
 // https://github.com/graphql/dataloader#batch-function
 const orderDocs = <V>(ids: readonly string[]) => (
@@ -33,33 +34,53 @@ const orderDocs = <V>(ids: readonly string[]) => (
 export interface createCatchingMethodArgs {
   container: Container;
   cache: KeyValueCache;
+  options: CosmosDataSourceOptions;
 }
 
 export interface FindArgs {
   ttl?: number;
 }
 
 export interface CachedMethods<DType> {
-  findOneById: (id: string, args: FindArgs) => Promise<DType | undefined>;
+  findOneById: (id: string, args?: FindArgs) => Promise<DType | undefined>;
   findManyByIds: (
     ids: string[],
-    args: FindArgs
+    args?: FindArgs
   ) => Promise<(DType | undefined)[]>;
   deleteFromCacheById: (id: string) => Promise<void>;
 }
 
 export const createCachingMethods = <DType>({
   container,
   cache,
+  options,
 }: createCatchingMethodArgs): CachedMethods<DType> => {
   const loader = new DataLoader<string, DType>(async (ids) => {
-    const operations = ids.map<Operation>((id) => ({
-      operationType: "Read",
-      id,
-    }));
-    const response = await container.items.bulk(operations);
-    const responseDocs = response.map((r) =>
-      r.resourceBody ? ((r.resourceBody as unknown) as DType) : undefined
+    options?.logger?.debug(
+      `CosmosDataSource/DataLoader: loading for IDs: ${ids}`
+    );
+    // const operations = ids.map<Operation>((id) => ({
+    //   operationType: "Read",
+    //   id,
+    // }));
+    // const response = await container.items.bulk(operations);
+    const querySpec = {
+      query: `select * from c where c.id in (${ids
+        .map((id) => `'${id}'`)
+        .join(",")})`,
+      //   query: "select * from c where c.id in (@ids)",
+      //   parameters: [{ name: "@ids", value: ids }],
+    };
+    const response = await container.items.query(querySpec).fetchAll();
+
+    options?.logger?.debug(
+      `CosmosDataSource/DataLoader: response count: ${response.resources.length}`
+    );
+    options?.logger?.debug(
+      `data: ${JSON.stringify(response.resources[0], null, " ")}`
+    );
+    const responseDocs = response.resources.map((r) =>
+      r ? ((r as unknown) as DType) : undefined
     );
     return orderDocs<DType>(ids)(responseDocs);
   });
@@ -68,6 +89,7 @@ export const createCachingMethods = <DType>({
 
   const methods: CachedMethods<DType> = {
     findOneById: async (id, { ttl } = {}) => {
+      options?.logger?.debug(`CosmosDataSource: Running query for ID ${id}`);
       const key = cachePrefix + id;
 
       const cacheDoc = await cache.get(key);
@@ -84,8 +106,10 @@ export const createCachingMethods = <DType>({
       return doc;
     },
 
-    findManyByIds: (ids, args = {}) =>
-      Promise.all(ids.map((id) => methods.findOneById(id, args))),
+    findManyByIds: (ids, args = {}) => {
+      options?.logger?.debug(`CosmosDataSource: Running query for IDs ${ids}`);
+      return Promise.all(ids.map((id) => methods.findOneById(id, args)));
+    },
 
     deleteFromCacheById: async (id) => {
       loader.clear(id);

src/datasource.ts

@@ -2,11 +2,16 @@ import { DataSource } from "apollo-datasource";
 import { ApolloError } from "apollo-server-errors";
 import { InMemoryLRUCache, KeyValueCache } from "apollo-server-caching";
 import { Container } from "@azure/cosmos";
+import { Logger } from "./helpers";
 
 import { isCosmosDbContainer } from "./helpers";
 import { createCachingMethods, CachedMethods } from "./cache";
 
-export const placeholderHandler = () => {
+export interface CosmosDataSourceOptions {
+  logger?: Logger;
+}
+
+const placeholderHandler = () => {
   throw new Error("DataSource not initialized");
 };
 
@@ -15,21 +20,25 @@ export class CosmosDataSource<TData, TContext = any>
   implements CachedMethods<TData> {
   container: Container;
   context?: TContext;
+  private options: CosmosDataSourceOptions;
   // these get set by the initializer but they must be defined or nullable after the constructor
   // runs, so we guard against using them before init
-  findOneById = placeholderHandler;
-  findManyByIds = placeholderHandler;
-  deleteFromCacheById = placeholderHandler;
+  findOneById: CachedMethods<TData>["findOneById"] = placeholderHandler;
+  findManyByIds: CachedMethods<TData>["findManyByIds"] = placeholderHandler;
+  deleteFromCacheById: CachedMethods<TData>["deleteFromCacheById"] = placeholderHandler;
 
-  constructor(container: Container) {
+  constructor(container: Container, options: CosmosDataSourceOptions = {}) {
     super();
+    console.log(`options: ${options.logger}`);
+    options?.logger?.info(`CosmosDataSource started`);
 
     if (!isCosmosDbContainer(container)) {
       throw new ApolloError(
         "CosmosDataSource must be created with a CosmosDb container (from @azure/cosmos)"
       );
     }
 
+    this.options = options;
     this.container = container;
   }
 
@@ -42,6 +51,7 @@ export class CosmosDataSource<TData, TContext = any>
     const methods = createCachingMethods<TData>({
       container: this.container,
       cache: cache || new InMemoryLRUCache(),
+      options: this.options,
     });
 
     Object.assign(this, methods);

src/helpers.ts

@@ -11,3 +11,11 @@ export const isCosmosDbContainer = (
     maybeContainer.getPartitionKeyDefinition
   );
 };
+
+export type Logger = {
+  // Ordered from least-severe to most-severe.
+  debug(message?: any): void;
+  info(message?: any): void;
+  warn(message?: any): void;
+  error(message?: any): void;
+}

src/index.ts

@@ -1,3 +1 @@
-import { CosmosDataSource } from "./datasource";
-
-export default { CosmosDataSource };
+export { CosmosDataSource } from "./datasource";

tsconfig.json

@@ -7,7 +7,7 @@
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
     // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
-    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    "declaration": true /* Generates corresponding '.d.ts' file. */,
     // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
     "sourceMap": true /* Generates corresponding '.map' file. */,
     // "outFile": "./",                       /* Concatenate and emit output to single file. */