@bitblit/ratchet-graphql 6.0.146-alpha → 6.0.147-alpha

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@bitblit/ratchet-graphql",
-  "version": "6.0.146-alpha",
+  "version": "6.0.147-alpha",
   "description": "Ratchet tools to simplify use of graphql",
   "sideEffects": false,
   "type": "module",
   "files": [
+    "src/**",
     "lib/**",
     "bin/**"
   ],
@@ -46,12 +47,12 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@bitblit/ratchet-common": "6.0.146-alpha",
+    "@bitblit/ratchet-common": "6.0.147-alpha",
     "graphql": "16.12.0",
     "graphql-request": "7.3.1"
   },
   "peerDependencies": {
-    "@bitblit/ratchet-common": "6.0.146-alpha",
+    "@bitblit/ratchet-common": "6.0.147-alpha",
     "graphql": "^16.12.0",
     "graphql-request": "^7.2.0"
   }

package/src/build/ratchet-graphql-info.ts

@@ -0,0 +1,19 @@
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+
+export class RatchetGraphqlInfo {
+  // Empty constructor prevents instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static buildInformation(): BuildInformation {
+    const val: BuildInformation = {
+      version: 'LOCAL-SNAPSHOT',
+      hash: 'LOCAL-HASH',
+      branch: 'LOCAL-BRANCH',
+      tag: 'LOCAL-TAG',
+      timeBuiltISO: 'LOCAL-TIME-ISO',
+      notes: 'LOCAL-NOTES',
+    };
+    return val;
+  }
+}

package/src/graphql/authorization-style.ts

@@ -0,0 +1,5 @@
+export enum AuthorizationStyle {
+  TokenRequired = 'TokenRequired',
+  AlwaysAnonymous = 'AlwaysAnonymous',
+  AnonymousIfNoTokenAvailable = 'AnonymousIfNoTokenAvailable',
+}

package/src/graphql/graphql-ratchet.spec.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { GraphqlRatchet } from './graphql-ratchet';
+import { StringRecordQueryProvider } from './provider/string-record-query-provider';
+import { DefaultGraphqlRatchetEndpointProvider } from './provider/default-graphql-ratchet-endpoint-provider';
+
+describe('#runTest', function () {
+  test.skip('should pull defaults', async () => {
+    const doc: string =
+      '{\n' +
+      '\n' +
+      '   serverMeta {\n' +
+      '    version\n' +
+      '    launchTime\n' +
+      '    serverTime\n' +
+      '    status\n' +
+      '    buildInfo {\n' +
+      '      buildVersion\n' +
+      '      buildHash\n' +
+      '      buildBranch\n' +
+      '      buildTag\n' +
+      '    }\n' +
+      '    specBuildInfo {\n' +
+      '      buildVersion\n' +
+      '      buildHash\n' +
+      '      buildBranch\n' +
+      '      buildTag\n' +
+      '    }\n' +
+      '  }\n' +
+      '}';
+    const url: string = 'https://localhost:8888/graphql';
+    const gr: GraphqlRatchet = new GraphqlRatchet(
+      new StringRecordQueryProvider({ q: doc }),
+      new DefaultGraphqlRatchetEndpointProvider(url),
+      null,
+    );
+
+    // Since this'll be self-signed
+    process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
+    const out: any = await gr.executeQuery<any>('q', {}, true);
+    expect(out).toBeTruthy();
+  });
+});

package/src/graphql/graphql-ratchet.ts

@@ -0,0 +1,180 @@
+import { GraphqlRatchetEndpointProvider } from './provider/graphql-ratchet-endpoint-provider.js';
+import { GraphqlRatchetJwtTokenProvider } from './provider/graphql-ratchet-jwt-token-provider.js';
+import { GraphqlRatchetQueryProvider } from './provider/graphql-ratchet-query-provider.js';
+import { GraphqlRatchetErrorHandler } from './provider/graphql-ratchet-error-handler.js';
+import { DefaultGraphqlRatchetErrorHandler } from './provider/default-graphql-ratchet-error-handler.js';
+
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { GraphQLClient } from 'graphql-request';
+import { AuthorizationStyle } from './authorization-style.js';
+
+/**
+ * This is a very simplistic client for non-cache use cases, etc.  For more
+ * powerful clients, use a library like Apollo-client
+ */
+export class GraphqlRatchet {
+  private clientCache: Map<string, GraphQLClient> = new Map<string, GraphQLClient>();
+  private noAuthClient: GraphQLClient;
+
+  private cachedEndpoint: string;
+
+  constructor(
+    private queryProvider: GraphqlRatchetQueryProvider,
+    private endpointProvider: GraphqlRatchetEndpointProvider,
+    private jwtTokenProvider?: GraphqlRatchetJwtTokenProvider,
+    private errorHandler: GraphqlRatchetErrorHandler = new DefaultGraphqlRatchetErrorHandler(),
+  ) {
+    RequireRatchet.notNullOrUndefined(queryProvider, 'queryProvider');
+    RequireRatchet.notNullOrUndefined(endpointProvider, 'endpointProvider');
+    //RequireRatchet.notNullOrUndefined(jwtTokenProvider, 'jwtTokenProvider');
+    RequireRatchet.notNullOrUndefined(errorHandler, 'errorHandler');
+    this.cachedEndpoint = this.endpointProvider.fetchGraphqlEndpoint();
+  }
+
+  public currentAuthToken(): string {
+    return this?.jwtTokenProvider?.fetchJwtToken();
+  }
+
+  public async fetchQueryText(qry: string): Promise<string> {
+    const text: string = await this.queryProvider.fetchQueryText(qry);
+    if (!text) {
+      Logger.warn('Could not find requested query : %s', qry);
+    }
+    return text;
+  }
+
+  private createAnonymousApi(): GraphQLClient {
+    Logger.info('Creating anonymous GraphQLClient');
+    const rval: GraphQLClient = new GraphQLClient(this.cachedEndpoint, { errorPolicy: 'none' });
+    return rval;
+  }
+
+  private fetchApi(authStyle: AuthorizationStyle): GraphQLClient {
+    let rval: GraphQLClient = null;
+    const jwtToken: string =
+      authStyle === AuthorizationStyle.AlwaysAnonymous ? null : StringRatchet.trimToNull(this?.jwtTokenProvider?.fetchJwtToken());
+    if (authStyle === AuthorizationStyle.TokenRequired && !jwtToken) {
+      throw ErrorRatchet.fErr('No token provided, auth style is TokenRequired');
+    }
+
+    this.checkIfEndpointChanged(); // Always check for cache invalidation first...
+    Logger.info('Fetch auth client %s', StringRatchet.obscure(StringRatchet.trimToEmpty(jwtToken), 2, 2));
+
+    if (jwtToken) {
+      Logger.debug('Fetching authd api');
+      if (!this.clientCache.has(jwtToken)) {
+        const newValue: GraphQLClient = this.createAuthApi(jwtToken);
+        Logger.debug('Setting cache for this token to %s', newValue);
+        this.clientCache.set(jwtToken, newValue);
+      } else {
+        Logger.debug('Fetching apollo client from cache');
+      }
+      rval = this.clientCache.get(jwtToken);
+    } else {
+      Logger.debug('Fetching unauthd ap');
+      if (!this.noAuthClient) {
+        this.noAuthClient = this.createAnonymousApi();
+      } else {
+        Logger.debug('Fetching anonymous client from cache');
+      }
+      rval = this.noAuthClient;
+    }
+    Logger.debug('FetchApi returning %s', rval);
+    return rval;
+  }
+
+  private createAuthApi(jwtToken: string): GraphQLClient {
+    Logger.info('Creating a new authenticated api for %s : %s', this.cachedEndpoint, StringRatchet.obscure(jwtToken, 2, 2));
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(jwtToken, 'jwtToken');
+    Logger.info('Creating auth apollo client %s', StringRatchet.obscure(jwtToken, 2, 2));
+    const rval: GraphQLClient = new GraphQLClient(this.cachedEndpoint, {
+      errorPolicy: 'none',
+      headers: { authorization: `Bearer ${jwtToken}` },
+    });
+    return rval;
+  }
+
+  private checkIfEndpointChanged(): void {
+    const check: string = this.endpointProvider.fetchGraphqlEndpoint();
+    if (check !== this.cachedEndpoint) {
+      Logger.info('Endpoint changed from %s to %s - clearing apollo caches');
+      this.clientCache = new Map<string, GraphQLClient>();
+      this.noAuthClient = null;
+      this.cachedEndpoint = check;
+    }
+  }
+
+  public clearCaches(): void {
+    Logger.info('Clearing cached apollo');
+    this.clientCache = new Map<string, GraphQLClient>();
+    this.noAuthClient = null;
+    this.cachedEndpoint = null;
+  }
+
+  public static extractSingleValueFromResponse<T>(data: any): T {
+    if (!data) {
+      throw ErrorRatchet.fErr('Could not find response in : %j', data);
+    } else if (data.errors) {
+      throw ErrorRatchet.fErr('Errors: %j', data.errors);
+    }
+    const keys: string[] = Object.keys(data);
+    if (keys.length !== 1) {
+      ErrorRatchet.throwFormattedErr('Unexpected number of keys : %s : %j', keys.length, keys);
+    }
+    const rval: T = data[keys[0]];
+    return rval;
+  }
+
+  public async executeQuery<T>(
+    queryName: string,
+    variables: Record<string, any>,
+    authStyle: AuthorizationStyle = AuthorizationStyle.TokenRequired,
+  ): Promise<T> {
+    let rval: T = null;
+    try {
+      const api: GraphQLClient = this.fetchApi(authStyle);
+      if (api) {
+        Logger.debug('API fetched for %s, fetching gql', queryName);
+        const gql: string = await this.fetchQueryText(queryName);
+        Logger.debug('API and GQL fetched for %s - running %s %s', queryName, gql, api);
+        const newValues: any = await api.request(gql, variables);
+        rval = GraphqlRatchet.extractSingleValueFromResponse(newValues);
+        Logger.silly('Query returned: %j', rval);
+      } else {
+        ErrorRatchet.throwFormattedErr('Cannot run - no api fetched');
+      }
+    } catch (err) {
+      Logger.silly('Exception caught in executeQuery : %s %s %j %s', err, queryName, variables, authStyle, err);
+      this.errorHandler.handleError(err, queryName, variables, authStyle);
+    }
+    return rval;
+  }
+
+  public async executeMutate<T>(
+    queryName: string,
+    variables: any,
+    authStyle: AuthorizationStyle = AuthorizationStyle.TokenRequired,
+  ): Promise<T> {
+    Logger.info('Mutate : %s : %j', queryName, variables);
+    let rval: T = null;
+    const api: GraphQLClient = this.fetchApi(authStyle);
+    try {
+      if (api) {
+        const gql: string = await this.fetchQueryText(queryName);
+        Logger.debug('API and GQL fetched for %s - running %s %s', queryName, gql, api);
+        const newValues: any = await api.request(gql, variables);
+        rval = GraphqlRatchet.extractSingleValueFromResponse(newValues);
+        Logger.silly('Mutate returned: %j', rval);
+      } else {
+        ErrorRatchet.throwFormattedErr('Cannot run - no api fetched');
+      }
+    } catch (err) {
+      this.errorHandler.handleError(err, queryName, variables, authStyle);
+    }
+
+    return rval;
+  }
+}

package/src/graphql/provider/default-graphql-ratchet-endpoint-provider.ts

@@ -0,0 +1,6 @@
+export class DefaultGraphqlRatchetEndpointProvider {
+  constructor(private value: string) {}
+  public fetchGraphqlEndpoint(): string {
+    return this.value;
+  }
+}

package/src/graphql/provider/default-graphql-ratchet-error-handler.ts

@@ -0,0 +1,18 @@
+import { GraphqlRatchetErrorHandler } from './graphql-ratchet-error-handler.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
+import { AuthorizationStyle } from '../authorization-style';
+
+export class DefaultGraphqlRatchetErrorHandler implements GraphqlRatchetErrorHandler {
+  constructor(
+    private logLevel: LoggerLevelName = LoggerLevelName.warn,
+    private rethrow: boolean = false,
+  ) {}
+
+  public handleError(error: any, queryName: string, variables: Record<string, any>, authStyle: AuthorizationStyle): void {
+    Logger.logByLevel(this.logLevel, 'Graphql failed : %s : %s : Anon-%s : %j', error, queryName, authStyle, variables);
+    if (this.rethrow) {
+      throw error;
+    }
+  }
+}

package/src/graphql/provider/graphql-ratchet-endpoint-provider.ts

@@ -0,0 +1,3 @@
+export interface GraphqlRatchetEndpointProvider {
+  fetchGraphqlEndpoint(): string;
+}

package/src/graphql/provider/graphql-ratchet-error-handler.ts

@@ -0,0 +1,5 @@
+import { AuthorizationStyle } from '../authorization-style';
+
+export interface GraphqlRatchetErrorHandler {
+  handleError(error: any, queryName: string, variables: Record<string, any>, authStyle: AuthorizationStyle): void;
+}

package/src/graphql/provider/graphql-ratchet-jwt-token-provider.ts

@@ -0,0 +1,3 @@
+export interface GraphqlRatchetJwtTokenProvider {
+  fetchJwtToken(): string;
+}

package/src/graphql/provider/graphql-ratchet-query-provider.ts

@@ -0,0 +1,3 @@
+export interface GraphqlRatchetQueryProvider {
+  fetchQueryText(name: string): Promise<string>;
+}

package/src/graphql/provider/local-fetch-query-provider.ts

@@ -0,0 +1,28 @@
+import { GraphqlRatchetQueryProvider } from './graphql-ratchet-query-provider.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import fetch from 'cross-fetch';
+
+export class LocalFetchQueryProvider implements GraphqlRatchetQueryProvider {
+  private cacheMap: Map<string, string> = new Map<string, string>();
+
+  constructor(
+    private pathTemplate: string = 'assets/gql/${QUERY_NAME}.gql',
+    private forcePathToLowerCase: boolean = false,
+  ) {}
+
+  public async fetchQueryText(qry: string): Promise<string> {
+    let rval: string = this.cacheMap.get(qry.toLowerCase());
+    if (!rval) {
+      const tgt: string = this.forcePathToLowerCase ? qry.toLowerCase() : qry;
+      const pathInput: string = StringRatchet.simpleTemplateFill(this.pathTemplate, { QUERY_NAME: tgt }, true);
+      Logger.info('Cache miss, loading %s from %s', qry, pathInput);
+      const qryResp: Response = await fetch(pathInput);
+      rval = StringRatchet.trimToNull(await qryResp.text());
+      if (rval) {
+        this.cacheMap.set(qry.toLowerCase(), rval);
+      }
+    }
+    return rval;
+  }
+}

package/src/graphql/provider/string-record-query-provider.ts

@@ -0,0 +1,36 @@
+import { GraphqlRatchetQueryProvider } from './graphql-ratchet-query-provider.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+export class StringRecordQueryProvider implements GraphqlRatchetQueryProvider {
+  private files: Record<string, string> = {};
+  constructor(
+    inFiles: Record<string, string>,
+    private autoPrefix: string = '',
+    private autoSuffix: string = '',
+    private caseSensitive?: boolean,
+  ) {
+    if (inFiles) {
+      if (caseSensitive) {
+        this.files = Object.assign({}, inFiles);
+      } else {
+        Object.keys(inFiles).forEach((k) => {
+          this.files[k.toLowerCase()] = inFiles[k];
+        });
+      }
+    }
+  }
+
+  public async fetchQueryText(qry: string): Promise<string> {
+    let lookupKey: string = '';
+    lookupKey += this.caseSensitive ? StringRatchet.trimToEmpty(this.autoPrefix) : StringRatchet.trimToEmpty(this.autoPrefix).toLowerCase();
+    lookupKey += this.caseSensitive ? StringRatchet.trimToEmpty(qry) : StringRatchet.trimToEmpty(qry).toLowerCase();
+    lookupKey += this.caseSensitive ? StringRatchet.trimToEmpty(this.autoSuffix) : StringRatchet.trimToEmpty(this.autoSuffix).toLowerCase();
+
+    const rval: string = this.files[lookupKey];
+    if (!rval) {
+      Logger.warn('Could not find %s in %j', lookupKey, Object.keys(this.files));
+    }
+    return rval;
+  }
+}