@nhost/nhost-js 0.3.5 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nhost/nhost-js",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Nhost JavaScript SDK",
   "keywords": [
     "nhost"
@@ -16,7 +16,8 @@
     "access": "public"
   },
   "files": [
-    "dist/"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "run-p build:esm build:cjs",
@@ -31,8 +32,8 @@
     "url": "git+https://github.com/nhost/nhost-js.git"
   },
   "dependencies": {
-    "@nhost/hasura-auth-js": "^0.1.9",
-    "@nhost/hasura-storage-js": "^0.0.5",
+    "@nhost/hasura-auth-js": "^0.1.10",
+    "@nhost/hasura-storage-js": "^0.0.6",
     "axios": "^0.23.0",
     "jwt-decode": "^3.1.2",
     "query-string": "^7.0.1"

package/src/clients/functions.ts

@@ -0,0 +1,68 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { FunctionCallResponse } from '../types';
+
+export type NhostFunctionsConstructorParams = {
+  url: string;
+};
+
+export class NhostFunctionsClient {
+  private instance: AxiosInstance;
+  private accessToken: string | null;
+
+  constructor(params: NhostFunctionsConstructorParams) {
+    const { url } = params;
+
+    this.accessToken = null;
+    this.instance = axios.create({
+      baseURL: url,
+    });
+  }
+
+  public async call(
+    url: string,
+    data: any,
+    config?: AxiosRequestConfig
+  ): Promise<FunctionCallResponse> {
+    const headers = {
+      ...this.generateAccessTokenHeaders(),
+      ...config?.headers,
+    };
+
+    let res;
+    try {
+      res = await this.instance.post(url, data, { ...config, headers });
+    } catch (error) {
+      if (error instanceof Error) {
+        return { res: null, error };
+      }
+    }
+
+    if (!res) {
+      return {
+        res: null,
+        error: Error('Unable to make post request to funtion'),
+      };
+    }
+
+    return { res, error: null };
+  }
+
+  public setAccessToken(accessToken: string | undefined) {
+    if (!accessToken) {
+      this.accessToken = null;
+      return;
+    }
+
+    this.accessToken = accessToken;
+  }
+
+  private generateAccessTokenHeaders() {
+    if (!this.accessToken) {
+      return;
+    }
+
+    return {
+      Authorization: `Bearer ${this.accessToken}`,
+    };
+  }
+}

package/src/clients/graphql.ts

@@ -0,0 +1,102 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { GraphqlRequestResponse, GraphqlResponse } from '../types';
+
+export type NhostGraphqlConstructorParams = {
+  url: string;
+};
+
+export class NhostGraphqlClient {
+  private url: string;
+  private instance: AxiosInstance;
+  private accessToken: string | null;
+
+  constructor(params: NhostGraphqlConstructorParams) {
+    const { url } = params;
+
+    this.url = url;
+    this.accessToken = null;
+    this.instance = axios.create({
+      baseURL: url,
+    });
+  }
+
+  public async request(
+    document: string,
+    variables?: any,
+    config?: AxiosRequestConfig
+  ): Promise<GraphqlRequestResponse> {
+    // add auth headers if any
+    const headers = {
+      ...config?.headers,
+      ...this.generateAccessTokenHeaders(),
+    };
+
+    const operationName = '';
+
+    let responseData;
+    try {
+      const res = await this.instance.post(
+        '',
+        {
+          operationName: operationName ? operationName : undefined,
+          query: document,
+          variables,
+        },
+        { ...config, headers }
+      );
+
+      responseData = res.data;
+    } catch (error) {
+      if (error instanceof Error) {
+        return { data: null, error };
+      }
+      console.error(error);
+      return { data: null, error: Error('Unable to get do GraphQL request') };
+    }
+
+    if (
+      typeof responseData !== 'object' ||
+      Array.isArray(responseData) ||
+      responseData === null
+    ) {
+      return {
+        data: null,
+        error: Error('incorrect response data from GraphQL server'),
+      };
+    }
+
+    responseData = responseData as GraphqlResponse;
+
+    if (responseData.errors) {
+      return {
+        data: null,
+        error: responseData.errors,
+      };
+    }
+
+    return { data: responseData.data, error: null };
+  }
+
+  public getUrl(): string {
+    return this.url;
+  }
+
+  public setAccessToken(accessToken: string | undefined) {
+    if (!accessToken) {
+      this.accessToken = null;
+      return;
+    }
+
+    this.accessToken = accessToken;
+  }
+
+  private generateAccessTokenHeaders() {
+    if (!this.accessToken) {
+      return;
+    }
+
+    return {
+      Authorization: `Bearer ${this.accessToken}`,
+    };
+  }
+}

package/src/core/index.ts

@@ -0,0 +1 @@
+export * from './nhost-client';

package/src/core/nhost-client.ts

@@ -0,0 +1,84 @@
+import { HasuraAuthClient } from '@nhost/hasura-auth-js';
+import { HasuraStorageClient } from '@nhost/hasura-storage-js';
+import { ClientStorage, ClientStorageType } from '@nhost/hasura-auth-js';
+
+import { NhostFunctionsClient } from '../clients/functions';
+import { NhostGraphqlClient } from '../clients/graphql';
+
+export type NhostClientConstructorParams = {
+  backendUrl: string;
+  refreshIntervalTime?: number;
+  clientStorage?: ClientStorage;
+  clientStorageType?: ClientStorageType;
+  autoRefreshToken?: boolean;
+  autoLogin?: boolean;
+};
+
+export class NhostClient {
+  auth: HasuraAuthClient;
+  storage: HasuraStorageClient;
+  functions: NhostFunctionsClient;
+  graphql: NhostGraphqlClient;
+
+  /**
+   * Nhost Client
+   *
+   * @example
+   * const nhost = new NhostClient({ url });
+   *
+   * @docs https://docs.nhost.io/TODO
+   */
+  constructor(params: NhostClientConstructorParams) {
+    if (!params.backendUrl)
+      throw 'Please specify a `backendUrl`. Docs: [todo]!';
+
+    const {
+      backendUrl,
+      refreshIntervalTime,
+      clientStorage,
+      clientStorageType,
+      autoRefreshToken,
+      autoLogin,
+    } = params;
+
+    this.auth = new HasuraAuthClient({
+      url: `${backendUrl}/v1/auth`,
+      refreshIntervalTime,
+      clientStorage,
+      clientStorageType,
+      autoRefreshToken,
+      autoLogin,
+    });
+
+    this.storage = new HasuraStorageClient({
+      url: `${backendUrl}/v1/storage`,
+    });
+
+    this.functions = new NhostFunctionsClient({
+      url: `${backendUrl}/v1/functions`,
+    });
+
+    this.graphql = new NhostGraphqlClient({
+      url: `${backendUrl}/v1/graphql`,
+    });
+
+    // set current token if token is already accessable
+    this.storage.setAccessToken(this.auth.getAccessToken());
+    this.functions.setAccessToken(this.auth.getAccessToken());
+    this.graphql.setAccessToken(this.auth.getAccessToken());
+
+    // update access token for clients
+    this.auth.onAuthStateChanged((_event, session) => {
+      this.storage.setAccessToken(session?.accessToken);
+      this.functions.setAccessToken(session?.accessToken);
+      this.graphql.setAccessToken(session?.accessToken);
+    });
+
+    // update access token for clients
+    this.auth.onTokenChanged((session) => {
+      this.storage.setAccessToken(session?.accessToken);
+      this.functions.setAccessToken(session?.accessToken);
+      this.graphql.setAccessToken(session?.accessToken);
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+import { NhostClient } from '.';
+import { NhostClientConstructorParams } from '.';
+
+const createClient = (config: NhostClientConstructorParams) => {
+    return new NhostClient(config);
+};  
+
+export * from './core';
+export {createClient};

package/src/types.ts

@@ -0,0 +1,26 @@
+import { AxiosResponse } from 'axios';
+
+export type GraphqlRequestResponse =
+  | {
+      data: unknown;
+      error: null;
+    }
+  | {
+      data: null;
+      error: Error | object;
+    };
+
+export type FunctionCallResponse =
+  | {
+      res: AxiosResponse;
+      error: null;
+    }
+  | {
+      res: null;
+      error: Error;
+    };
+
+export type GraphqlResponse = {
+  errors?: object[];
+  data?: object;
+};