built our core code

Author: andrejpk

package.json

@@ -6,11 +6,37 @@
   "repository": "https://github.com/andrejpk/apollo-datasource-cosmosdb",
   "author": "Andrej Kyselica",
   "license": "MIT",
+  "keywords": [
+    "apollo",
+    "graphql",
+    "datasource",
+    "azure",
+    "cosmosdb",
+    "cosmos"
+  ],
   "scripts": {
     "build": "tsc",
     "watch": "tsc --watch"
   },
   "devDependencies": {
+    "@azure/cosmos": "^3.9.3",
+    "@types/node": "^14.14.10",
+    "graphql": "^15.4.0",
+    "jest": "^26.6.3",
+    "prettier": "^2.2.1",
     "typescript": "^4.1.2"
-  }
-}
+  },
+  "peerDependencies": {
+    "@azure/cosmos": "^3.9.3"
+  },
+  "dependencies": {
+    "apollo-datasource": "^0.7.2",
+    "apollo-server-caching": "^0.5.2",
+    "apollo-server-errors": "^2.4.2",
+    "bson": "^4.2.0",
+    "dataloader": "^2.0.0"
+  },
+  "files": [
+    "/dist"
+  ]
+}

src/cache.ts

@@ -0,0 +1,97 @@
+import { Container, Operation } from "@azure/cosmos";
+import { KeyValueCache } from "apollo-server-caching";
+import DataLoader from "dataloader";
+import { EJSON } from "bson";
+
+// https://github.com/graphql/dataloader#batch-function
+const orderDocs = <V>(ids: readonly string[]) => (
+  docs: (V | undefined)[],
+  keyFn?: (source: V) => string
+) => {
+  const keyFnDef =
+    keyFn ||
+    ((source: V & { id?: string }) => {
+      if (source.id) return source.id;
+      throw new Error(
+        "Could not find ID for object; if using an alternate key, pass in a key function"
+      );
+    });
+
+  const checkNotUndefined = (input: V | undefined): input is V => {
+    return Boolean(input);
+  };
+
+  const idMap: Record<string, V> = docs
+    .filter(checkNotUndefined)
+    .reduce((prev: Record<string, V>, cur: V) => {
+      prev[keyFnDef(cur)] = cur;
+      return prev;
+    }, {});
+  return ids.map((id) => idMap[id]);
+};
+
+export interface createCatchingMethodArgs {
+  container: Container;
+  cache: KeyValueCache;
+}
+
+export interface FindArgs {
+  ttl?: number;
+}
+
+export interface CachedMethods<DType> {
+  findOneById: (id: string, args: FindArgs) => Promise<DType | undefined>;
+  findManyByIds: (
+    ids: string[],
+    args: FindArgs
+  ) => Promise<(DType | undefined)[]>;
+  deleteFromCacheById: (id: string) => Promise<void>;
+}
+
+export const createCachingMethods = <DType>({
+  container,
+  cache,
+}: 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
+    );
+    return orderDocs<DType>(ids)(responseDocs);
+  });
+
+  const cachePrefix = `cosmos-${container.url}-`;
+
+  const methods: CachedMethods<DType> = {
+    findOneById: async (id, { ttl } = {}) => {
+      const key = cachePrefix + id;
+
+      const cacheDoc = await cache.get(key);
+      if (cacheDoc) {
+        return EJSON.parse(cacheDoc) as DType;
+      }
+
+      const doc = await loader.load(id);
+
+      if (Number.isInteger(ttl)) {
+        cache.set(key, EJSON.stringify(doc), { ttl });
+      }
+
+      return doc;
+    },
+
+    findManyByIds: (ids, args = {}) =>
+      Promise.all(ids.map((id) => methods.findOneById(id, args))),
+
+    deleteFromCacheById: async (id) => {
+      loader.clear(id);
+      await cache.delete(cachePrefix + id);
+    },
+  };
+
+  return methods;
+};

src/datasource.ts

@@ -0,0 +1,49 @@
+import { DataSource } from "apollo-datasource";
+import { ApolloError } from "apollo-server-errors";
+import { InMemoryLRUCache, KeyValueCache } from "apollo-server-caching";
+import { Container } from "@azure/cosmos";
+
+import { isCosmosDbContainer } from "./helpers";
+import { createCachingMethods, CachedMethods } from "./cache";
+
+export const placeholderHandler = () => {
+  throw new Error("DataSource not initialized");
+};
+
+export class CosmosDataSource<TData, TContext = any>
+  extends DataSource<TContext>
+  implements CachedMethods<TData> {
+  container: Container;
+  context?: TContext;
+  // 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;
+
+  constructor(container: Container) {
+    super();
+
+    if (!isCosmosDbContainer(container)) {
+      throw new ApolloError(
+        "CosmosDataSource must be created with a CosmosDb container (from @azure/cosmos)"
+      );
+    }
+
+    this.container = container;
+  }
+
+  initialize({
+    context,
+    cache,
+  }: { context?: TContext; cache?: KeyValueCache } = {}) {
+    this.context = context;
+
+    const methods = createCachingMethods<TData>({
+      container: this.container,
+      cache: cache || new InMemoryLRUCache(),
+    });
+
+    Object.assign(this, methods);
+  }
+}

src/helpers.ts

@@ -0,0 +1,13 @@
+import { Container } from "@azure/cosmos";
+
+export const isCosmosDbContainer = (
+  maybeContainer: any
+): maybeContainer is Container => {
+  // does the duck quack?
+  return (
+    maybeContainer.url &&
+    maybeContainer.items &&
+    maybeContainer.database &&
+    maybeContainer.getPartitionKeyDefinition
+  );
+};

src/index.ts

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

tsconfig.json

@@ -1,18 +1,18 @@
 {
   "compilerOptions": {
     /* Basic Options */
-    "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
+    "target": "es6" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */,
+    "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
     // "lib": [],                             /* Specify library files to be included in the compilation. */
     // "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. */
     // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
-    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    "sourceMap": true /* Generates corresponding '.map' file. */,
     // "outFile": "./",                       /* Concatenate and emit output to single file. */
-    "outDir": "./dist",                        /* Redirect output structure to the directory. */
-    "rootDir": "./src",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    "outDir": "./dist" /* Redirect output structure to the directory. */,
+    "rootDir": "./src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
     // "composite": true,                     /* Enable project compilation */
     // "removeComments": true,                /* Do not emit comments to output. */
     // "noEmit": true,                        /* Do not emit outputs. */
@@ -21,7 +21,7 @@
     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
 
     /* Strict Type-Checking Options */
-    "strict": true,                           /* Enable all strict type-checking options. */
+    "strict": true /* Enable all strict type-checking options. */,
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
     // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
@@ -36,14 +36,14 @@
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
 
     /* Module Resolution Options */
-    // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
     // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-    "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
 
     /* Source Map Options */
@@ -56,4 +56,4 @@
     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
   }
-}
+}