@bitblit/ratchet-graphql 4.0.80-alpha

package/dist/cjs/build/ratchet-graphql-info.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatchetGraphqlInfo = void 0;
+class RatchetGraphqlInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '80',
+            hash: '10fcb761c2fa4186df89e527e948f5780a4e14ac',
+            branch: 'alpha-2023-03-12-2',
+            tag: 'alpha-2023-03-12-2',
+            timeBuiltISO: '2023-03-12T20:00:51-0700',
+            notes: '',
+        };
+        return val;
+    }
+}
+exports.RatchetGraphqlInfo = RatchetGraphqlInfo;

package/dist/cjs/graphql/graphql-ratchet.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlRatchet = void 0;
+const core_1 = require("@apollo/client/core");
+const default_graphql_ratchet_error_handler_1 = require("./provider/default-graphql-ratchet-error-handler");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class GraphqlRatchet {
+    constructor(queryProvider, endpointProvider, jwtTokenProvider, errorHandler = new default_graphql_ratchet_error_handler_1.DefaultGraphqlRatchetErrorHandler()) {
+        this.queryProvider = queryProvider;
+        this.endpointProvider = endpointProvider;
+        this.jwtTokenProvider = jwtTokenProvider;
+        this.errorHandler = errorHandler;
+        this.apolloCache = new Map();
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(queryProvider, 'queryProvider');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(endpointProvider, 'endpointProvider');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(jwtTokenProvider, 'jwtTokenProvider');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(errorHandler, 'errorHandler');
+        this.cachedEndpoint = this.endpointProvider.fetchGraphqlEndpoint();
+    }
+    async fetchQueryAsGql(qry) {
+        let rval = null;
+        const text = await this.queryProvider.fetchQueryText(qry);
+        if (text) {
+            rval = (0, core_1.gql)(text);
+        }
+        else {
+            ratchet_common_1.Logger.warn('Could not find requested query : %s', qry);
+        }
+        return rval;
+    }
+    createAnonymousApi() {
+        ratchet_common_1.Logger.info('Creating anonymous apollo client');
+        const httpLink = new core_1.HttpLink({ uri: this.cachedEndpoint });
+        const opts = {
+            link: httpLink,
+            cache: new core_1.InMemoryCache(),
+        };
+        const rval = new core_1.ApolloClient(opts);
+        return rval;
+    }
+    fetchApi(runAnonymous) {
+        let rval = null;
+        const jwtToken = this.jwtTokenProvider.fetchJwtToken();
+        this.checkIfEndpointChanged();
+        ratchet_common_1.Logger.info('Fetch auth apollo client %s', ratchet_common_1.StringRatchet.obscure(ratchet_common_1.StringRatchet.trimToEmpty(jwtToken), 2, 2));
+        if (ratchet_common_1.StringRatchet.trimToNull(jwtToken)) {
+            ratchet_common_1.Logger.debug('Fetching authd api');
+            if (!this.apolloCache.has(jwtToken)) {
+                const newValue = this.createAuthApi(jwtToken);
+                ratchet_common_1.Logger.debug('Setting apollo cache for this token to %s', newValue);
+                this.apolloCache.set(jwtToken, newValue);
+            }
+            else {
+                ratchet_common_1.Logger.debug('Fetching apollo client from cache');
+            }
+            rval = this.apolloCache.get(jwtToken);
+        }
+        else {
+            ratchet_common_1.Logger.debug('Fetching unauthd ap');
+            if (runAnonymous) {
+                if (!this.noAuthApollo) {
+                    this.noAuthApollo = this.createAnonymousApi();
+                }
+                else {
+                    ratchet_common_1.Logger.debug('Fetching anonymous client from cache');
+                }
+                rval = this.noAuthApollo;
+            }
+            else {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot fetch api - no token and runAnonymous is set to %s : -%s-', runAnonymous, jwtToken);
+            }
+        }
+        ratchet_common_1.Logger.debug('FetchApi returning %s', rval);
+        return rval;
+    }
+    createAuthApi(jwtToken) {
+        ratchet_common_1.Logger.info('Creating a new authenticated api for %s : %s', this.cachedEndpoint, ratchet_common_1.StringRatchet.obscure(jwtToken, 2, 2));
+        let rval = null;
+        ratchet_common_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(jwtToken, 'jwtToken');
+        ratchet_common_1.Logger.info('Creating auth apollo client %s', ratchet_common_1.StringRatchet.obscure(jwtToken, 2, 2));
+        const httpLink = new core_1.HttpLink({ uri: this.cachedEndpoint });
+        const authLink = new core_1.ApolloLink((operation, forward) => {
+            operation.setContext({
+                headers: {
+                    authorization: `Bearer ${jwtToken}`,
+                },
+            });
+            return forward(operation);
+        });
+        const opts = {
+            link: authLink.concat(httpLink),
+            cache: new core_1.InMemoryCache(),
+        };
+        rval = new core_1.ApolloClient(opts);
+        return rval;
+    }
+    checkIfEndpointChanged() {
+        const check = this.endpointProvider.fetchGraphqlEndpoint();
+        if (check !== this.cachedEndpoint) {
+            ratchet_common_1.Logger.info('Endpoint changed from %s to %s - clearing apollo caches');
+            this.apolloCache = new Map();
+            this.noAuthApollo = null;
+            this.cachedEndpoint = check;
+        }
+    }
+    async executeQuery(queryName, variables, runAnonymous = false) {
+        let rval = null;
+        try {
+            const api = this.fetchApi(runAnonymous);
+            if (api) {
+                ratchet_common_1.Logger.debug('API fetched for %s, fetching gql', queryName);
+                const GQL = await this.fetchQueryAsGql(queryName);
+                ratchet_common_1.Logger.debug('API and GQL fetched for %s - running %s %s', queryName, GQL, api);
+                const newValues = await api.query({
+                    query: GQL,
+                    variables: variables,
+                    fetchPolicy: 'no-cache',
+                });
+                ratchet_common_1.Logger.silly('Query returned: %j', newValues);
+                const keys = Object.keys(newValues.data);
+                if (keys.length !== 1) {
+                    ratchet_common_1.ErrorRatchet.throwFormattedErr('Unexpected number of keys : %s : %j', keys.length, keys);
+                }
+                rval = newValues.data[keys[0]];
+            }
+            else {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot run - no api fetched');
+            }
+        }
+        catch (err) {
+            ratchet_common_1.Logger.silly('Exception caught in executeQuery : %s %s %j %s', err, queryName, variables, runAnonymous, err);
+            this.errorHandler.handleError(err, queryName, variables, runAnonymous);
+        }
+        return rval;
+    }
+    async executeMutate(queryName, variables, runAnonymous = false) {
+        ratchet_common_1.Logger.info('Mutate : %s : %j', queryName, variables);
+        let rval = null;
+        const api = this.fetchApi(runAnonymous);
+        try {
+            if (api) {
+                const GQL = await this.fetchQueryAsGql(queryName);
+                const newValues = await api.mutate({
+                    mutation: GQL,
+                    variables: variables,
+                    fetchPolicy: 'no-cache',
+                });
+                const keys = Object.keys(newValues.data);
+                if (keys.length !== 1) {
+                    ratchet_common_1.ErrorRatchet.throwFormattedErr('Unexpected number of keys : %s : %j', keys.length, keys);
+                }
+                rval = newValues.data[keys[0]];
+            }
+            else {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot run - no api fetched');
+            }
+        }
+        catch (err) {
+            this.errorHandler.handleError(err, queryName, variables, runAnonymous);
+        }
+        return rval;
+    }
+}
+exports.GraphqlRatchet = GraphqlRatchet;

package/dist/cjs/graphql/provider/default-graphql-ratchet-error-handler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultGraphqlRatchetErrorHandler = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class DefaultGraphqlRatchetErrorHandler {
+    constructor(logLevel = ratchet_common_1.LoggerLevelName.warn, rethrow = false) {
+        this.logLevel = logLevel;
+        this.rethrow = rethrow;
+    }
+    handleError(error, queryName, variables, anonymous) {
+        ratchet_common_1.Logger.logByLevel(this.logLevel, 'Graphql failed : %s : %s : Anon-%s : %j', error, queryName, anonymous, variables);
+        if (this.rethrow) {
+            throw error;
+        }
+    }
+}
+exports.DefaultGraphqlRatchetErrorHandler = DefaultGraphqlRatchetErrorHandler;

package/dist/cjs/graphql/provider/graphql-ratchet-endpoint-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/graphql/provider/graphql-ratchet-error-handler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/graphql/provider/graphql-ratchet-jwt-token-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/graphql/provider/graphql-ratchet-query-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/graphql/provider/local-fetch-query-provider.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFetchQueryProvider = void 0;
+const tslib_1 = require("tslib");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
+class LocalFetchQueryProvider {
+    constructor(pathTemplate = 'assets/gql/{{QUERY_NAME}}.gql', forcePathToLowerCase = false) {
+        this.pathTemplate = pathTemplate;
+        this.forcePathToLowerCase = forcePathToLowerCase;
+        this.cacheMap = new Map();
+    }
+    async fetchQueryText(qry) {
+        let rval = this.cacheMap.get(qry.toLowerCase());
+        if (!rval) {
+            const tgt = this.forcePathToLowerCase ? qry.toLowerCase() : qry;
+            const pathInput = this.pathTemplate.split('{{QUERY_NAME}}').join(tgt);
+            ratchet_common_1.Logger.info('Cache miss, loading %s from %s', qry, pathInput);
+            const qryResp = await (0, cross_fetch_1.default)(pathInput);
+            rval = ratchet_common_1.StringRatchet.trimToNull(await qryResp.text());
+            if (rval) {
+                this.cacheMap.set(qry.toLowerCase(), rval);
+            }
+        }
+        return rval;
+    }
+}
+exports.LocalFetchQueryProvider = LocalFetchQueryProvider;

package/dist/cjs/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./build/ratchet-graphql-info"), exports);
+tslib_1.__exportStar(require("./graphql/graphql-ratchet"), exports);
+tslib_1.__exportStar(require("./graphql/provider/default-graphql-ratchet-error-handler"), exports);
+tslib_1.__exportStar(require("./graphql/provider/graphql-ratchet-endpoint-provider"), exports);
+tslib_1.__exportStar(require("./graphql/provider/graphql-ratchet-error-handler"), exports);
+tslib_1.__exportStar(require("./graphql/provider/graphql-ratchet-jwt-token-provider"), exports);
+tslib_1.__exportStar(require("./graphql/provider/graphql-ratchet-query-provider"), exports);
+tslib_1.__exportStar(require("./graphql/provider/local-fetch-query-provider"), exports);

package/dist/es/build/ratchet-graphql-info.js

@@ -0,0 +1,14 @@
+export class RatchetGraphqlInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '80',
+            hash: '10fcb761c2fa4186df89e527e948f5780a4e14ac',
+            branch: 'alpha-2023-03-12-2',
+            tag: 'alpha-2023-03-12-2',
+            timeBuiltISO: '2023-03-12T20:00:51-0700',
+            notes: '',
+        };
+        return val;
+    }
+}

package/dist/es/graphql/graphql-ratchet.js

@@ -0,0 +1,160 @@
+import { ApolloClient, ApolloLink, gql, HttpLink, InMemoryCache } from '@apollo/client/core';
+import { DefaultGraphqlRatchetErrorHandler } from './provider/default-graphql-ratchet-error-handler';
+import { RequireRatchet, Logger, StringRatchet, ErrorRatchet } from '@bitblit/ratchet-common';
+export class GraphqlRatchet {
+    constructor(queryProvider, endpointProvider, jwtTokenProvider, errorHandler = new DefaultGraphqlRatchetErrorHandler()) {
+        this.queryProvider = queryProvider;
+        this.endpointProvider = endpointProvider;
+        this.jwtTokenProvider = jwtTokenProvider;
+        this.errorHandler = errorHandler;
+        this.apolloCache = new Map();
+        RequireRatchet.notNullOrUndefined(queryProvider, 'queryProvider');
+        RequireRatchet.notNullOrUndefined(endpointProvider, 'endpointProvider');
+        RequireRatchet.notNullOrUndefined(jwtTokenProvider, 'jwtTokenProvider');
+        RequireRatchet.notNullOrUndefined(errorHandler, 'errorHandler');
+        this.cachedEndpoint = this.endpointProvider.fetchGraphqlEndpoint();
+    }
+    async fetchQueryAsGql(qry) {
+        let rval = null;
+        const text = await this.queryProvider.fetchQueryText(qry);
+        if (text) {
+            rval = gql(text);
+        }
+        else {
+            Logger.warn('Could not find requested query : %s', qry);
+        }
+        return rval;
+    }
+    createAnonymousApi() {
+        Logger.info('Creating anonymous apollo client');
+        const httpLink = new HttpLink({ uri: this.cachedEndpoint });
+        const opts = {
+            link: httpLink,
+            cache: new InMemoryCache(),
+        };
+        const rval = new ApolloClient(opts);
+        return rval;
+    }
+    fetchApi(runAnonymous) {
+        let rval = null;
+        const jwtToken = this.jwtTokenProvider.fetchJwtToken();
+        this.checkIfEndpointChanged();
+        Logger.info('Fetch auth apollo client %s', StringRatchet.obscure(StringRatchet.trimToEmpty(jwtToken), 2, 2));
+        if (StringRatchet.trimToNull(jwtToken)) {
+            Logger.debug('Fetching authd api');
+            if (!this.apolloCache.has(jwtToken)) {
+                const newValue = this.createAuthApi(jwtToken);
+                Logger.debug('Setting apollo cache for this token to %s', newValue);
+                this.apolloCache.set(jwtToken, newValue);
+            }
+            else {
+                Logger.debug('Fetching apollo client from cache');
+            }
+            rval = this.apolloCache.get(jwtToken);
+        }
+        else {
+            Logger.debug('Fetching unauthd ap');
+            if (runAnonymous) {
+                if (!this.noAuthApollo) {
+                    this.noAuthApollo = this.createAnonymousApi();
+                }
+                else {
+                    Logger.debug('Fetching anonymous client from cache');
+                }
+                rval = this.noAuthApollo;
+            }
+            else {
+                ErrorRatchet.throwFormattedErr('Cannot fetch api - no token and runAnonymous is set to %s : -%s-', runAnonymous, jwtToken);
+            }
+        }
+        Logger.debug('FetchApi returning %s', rval);
+        return rval;
+    }
+    createAuthApi(jwtToken) {
+        Logger.info('Creating a new authenticated api for %s : %s', this.cachedEndpoint, StringRatchet.obscure(jwtToken, 2, 2));
+        let rval = null;
+        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(jwtToken, 'jwtToken');
+        Logger.info('Creating auth apollo client %s', StringRatchet.obscure(jwtToken, 2, 2));
+        const httpLink = new HttpLink({ uri: this.cachedEndpoint });
+        const authLink = new ApolloLink((operation, forward) => {
+            operation.setContext({
+                headers: {
+                    authorization: `Bearer ${jwtToken}`,
+                },
+            });
+            return forward(operation);
+        });
+        const opts = {
+            link: authLink.concat(httpLink),
+            cache: new InMemoryCache(),
+        };
+        rval = new ApolloClient(opts);
+        return rval;
+    }
+    checkIfEndpointChanged() {
+        const check = this.endpointProvider.fetchGraphqlEndpoint();
+        if (check !== this.cachedEndpoint) {
+            Logger.info('Endpoint changed from %s to %s - clearing apollo caches');
+            this.apolloCache = new Map();
+            this.noAuthApollo = null;
+            this.cachedEndpoint = check;
+        }
+    }
+    async executeQuery(queryName, variables, runAnonymous = false) {
+        let rval = null;
+        try {
+            const api = this.fetchApi(runAnonymous);
+            if (api) {
+                Logger.debug('API fetched for %s, fetching gql', queryName);
+                const GQL = await this.fetchQueryAsGql(queryName);
+                Logger.debug('API and GQL fetched for %s - running %s %s', queryName, GQL, api);
+                const newValues = await api.query({
+                    query: GQL,
+                    variables: variables,
+                    fetchPolicy: 'no-cache',
+                });
+                Logger.silly('Query returned: %j', newValues);
+                const keys = Object.keys(newValues.data);
+                if (keys.length !== 1) {
+                    ErrorRatchet.throwFormattedErr('Unexpected number of keys : %s : %j', keys.length, keys);
+                }
+                rval = newValues.data[keys[0]];
+            }
+            else {
+                ErrorRatchet.throwFormattedErr('Cannot run - no api fetched');
+            }
+        }
+        catch (err) {
+            Logger.silly('Exception caught in executeQuery : %s %s %j %s', err, queryName, variables, runAnonymous, err);
+            this.errorHandler.handleError(err, queryName, variables, runAnonymous);
+        }
+        return rval;
+    }
+    async executeMutate(queryName, variables, runAnonymous = false) {
+        Logger.info('Mutate : %s : %j', queryName, variables);
+        let rval = null;
+        const api = this.fetchApi(runAnonymous);
+        try {
+            if (api) {
+                const GQL = await this.fetchQueryAsGql(queryName);
+                const newValues = await api.mutate({
+                    mutation: GQL,
+                    variables: variables,
+                    fetchPolicy: 'no-cache',
+                });
+                const keys = Object.keys(newValues.data);
+                if (keys.length !== 1) {
+                    ErrorRatchet.throwFormattedErr('Unexpected number of keys : %s : %j', keys.length, keys);
+                }
+                rval = newValues.data[keys[0]];
+            }
+            else {
+                ErrorRatchet.throwFormattedErr('Cannot run - no api fetched');
+            }
+        }
+        catch (err) {
+            this.errorHandler.handleError(err, queryName, variables, runAnonymous);
+        }
+        return rval;
+    }
+}

package/dist/es/graphql/provider/default-graphql-ratchet-error-handler.js

@@ -0,0 +1,13 @@
+import { LoggerLevelName, Logger } from '@bitblit/ratchet-common';
+export class DefaultGraphqlRatchetErrorHandler {
+    constructor(logLevel = LoggerLevelName.warn, rethrow = false) {
+        this.logLevel = logLevel;
+        this.rethrow = rethrow;
+    }
+    handleError(error, queryName, variables, anonymous) {
+        Logger.logByLevel(this.logLevel, 'Graphql failed : %s : %s : Anon-%s : %j', error, queryName, anonymous, variables);
+        if (this.rethrow) {
+            throw error;
+        }
+    }
+}

package/dist/es/graphql/provider/graphql-ratchet-endpoint-provider.js

@@ -0,0 +1 @@
+export {};

package/dist/es/graphql/provider/graphql-ratchet-error-handler.js

@@ -0,0 +1 @@
+export {};

package/dist/es/graphql/provider/graphql-ratchet-jwt-token-provider.js

@@ -0,0 +1 @@
+export {};

package/dist/es/graphql/provider/graphql-ratchet-query-provider.js

@@ -0,0 +1 @@
+export {};

package/dist/es/graphql/provider/local-fetch-query-provider.js

@@ -0,0 +1,23 @@
+import { StringRatchet, Logger } from '@bitblit/ratchet-common';
+import fetch from 'cross-fetch';
+export class LocalFetchQueryProvider {
+    constructor(pathTemplate = 'assets/gql/{{QUERY_NAME}}.gql', forcePathToLowerCase = false) {
+        this.pathTemplate = pathTemplate;
+        this.forcePathToLowerCase = forcePathToLowerCase;
+        this.cacheMap = new Map();
+    }
+    async fetchQueryText(qry) {
+        let rval = this.cacheMap.get(qry.toLowerCase());
+        if (!rval) {
+            const tgt = this.forcePathToLowerCase ? qry.toLowerCase() : qry;
+            const pathInput = this.pathTemplate.split('{{QUERY_NAME}}').join(tgt);
+            Logger.info('Cache miss, loading %s from %s', qry, pathInput);
+            const qryResp = await fetch(pathInput);
+            rval = StringRatchet.trimToNull(await qryResp.text());
+            if (rval) {
+                this.cacheMap.set(qry.toLowerCase(), rval);
+            }
+        }
+        return rval;
+    }
+}

package/dist/es/index.js

@@ -0,0 +1,8 @@
+export * from './build/ratchet-graphql-info';
+export * from './graphql/graphql-ratchet';
+export * from './graphql/provider/default-graphql-ratchet-error-handler';
+export * from './graphql/provider/graphql-ratchet-endpoint-provider';
+export * from './graphql/provider/graphql-ratchet-error-handler';
+export * from './graphql/provider/graphql-ratchet-jwt-token-provider';
+export * from './graphql/provider/graphql-ratchet-query-provider';
+export * from './graphql/provider/local-fetch-query-provider';