@trackunit/irisx-proxy 0.0.14 → 0.0.15

package/index.cjs.js

@@ -1,9 +1,9 @@
 'use strict';
 
 var zod = require('zod');
+var react = require('react');
 var client = require('@apollo/client');
 var sharedUtils = require('@trackunit/shared-utils');
-var react = require('react');
 
 /**
  * Schema for HTTP headers
@@ -144,11 +144,7 @@ const useIrisAppProxy = (props) => {
     const createRequest = () => {
         const request = {
             ...requestOptions,
-            headers: [
-                { name: "Content-Type", value: "application/json" },
-                { name: "Accept-Profile", value: "default" },
-                ...requestOptions.headers,
-            ],
+            headers: [{ name: "Accept-Profile", value: "default" }, ...requestOptions.headers],
         };
         const result = irisAppProxySchema.safeParse(request);
         if (!result.success) {
@@ -310,6 +306,64 @@ const useIrisAppProxy = (props) => {
     return { data: proxyData, mutate: customMutate, loading, error, irisXProxyFetch };
 };
 
+const databricksTokenSchema = zod.z.object({
+    access_token: zod.z.string(),
+    authorization_details: zod.z.array(zod.z.object({
+        securable_type: zod.z.string(),
+        securable_object_name: zod.z.string(),
+        operation: zod.z.string(),
+        annotations: zod.z.object({
+            onlineViewName: zod.z.string(),
+            onlineViewId: zod.z.string(),
+            onlineViewMetastoreId: zod.z.string(),
+            onlineViewClusterId: zod.z.string(),
+        }),
+        type: zod.z.string(),
+    })),
+    scope: zod.z.string(),
+    token_type: zod.z.string(),
+    expires_in: zod.z.number(),
+});
+/**
+ * Hook for retrieving an access token to interact with Databricks.
+ * This hook fetches an authentication token needed to access specific tables within a Databricks workspace.
+ *
+ * @param {string} domainBase - The base domain URL of the Databricks workspace (e.g., 'mycompany.cloud.databricks.com').
+ * @param {string} encodedClientIdSecretVaultKey - A vault key pointing to a stored encoded base64 value in this format <clientId>:<clientSecret>.
+ *                                                 Example original value: `myClientId:myClientSecret`
+ *                                                 Stored encoded value: `bXlDbGllbnRJZDpteUNsaWVudFNlY3JldA==`
+ *                                                 This key must be set up and stored in advance to successfully authenticate.
+ * @param {string[]} tableNames - An array of table names that the token will grant access to.
+ */
+const useDatabricksToken = ({ domainBase, encodedClientIdSecretVaultKey, tableNames, }) => {
+    const encodedBody = react.useMemo(() => {
+        const authorization_details = JSON.stringify(tableNames.map(tableName => ({
+            type: "unity_catalog_permission",
+            securable_type: "table",
+            securable_object_name: tableName,
+            operation: "ReadOnlineView",
+        })));
+        const data = new URLSearchParams();
+        data.append("grant_type", "client_credentials");
+        data.append("scope", "all-apis");
+        data.append("authorization_details", authorization_details);
+        return btoa(data.toString());
+    }, [tableNames]);
+    return useIrisAppProxy({
+        requestOptions: {
+            url: `https://${domainBase}.cloud.databricks.com/oidc/v1/token`,
+            method: "POST",
+            headers: [
+                { name: "Authorization", value: `Basic {{${encodedClientIdSecretVaultKey}}}` },
+                { name: "Content-Type", value: "application/x-www-form-urlencoded" },
+            ],
+            body: encodedBody,
+        },
+        responseSchema: databricksTokenSchema,
+    });
+};
+
 exports.headerSchema = headerSchema;
 exports.irisAppProxySchema = irisAppProxySchema;
+exports.useDatabricksToken = useDatabricksToken;
 exports.useIrisAppProxy = useIrisAppProxy;

package/index.esm.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
+import { useState, useMemo } from 'react';
 import { useMutation } from '@apollo/client';
 import { objectEntries } from '@trackunit/shared-utils';
-import { useState } from 'react';
 
 /**
  * Schema for HTTP headers
@@ -142,11 +142,7 @@ const useIrisAppProxy = (props) => {
     const createRequest = () => {
         const request = {
             ...requestOptions,
-            headers: [
-                { name: "Content-Type", value: "application/json" },
-                { name: "Accept-Profile", value: "default" },
-                ...requestOptions.headers,
-            ],
+            headers: [{ name: "Accept-Profile", value: "default" }, ...requestOptions.headers],
         };
         const result = irisAppProxySchema.safeParse(request);
         if (!result.success) {
@@ -308,4 +304,61 @@ const useIrisAppProxy = (props) => {
     return { data: proxyData, mutate: customMutate, loading, error, irisXProxyFetch };
 };
 
-export { headerSchema, irisAppProxySchema, useIrisAppProxy };
+const databricksTokenSchema = z.object({
+    access_token: z.string(),
+    authorization_details: z.array(z.object({
+        securable_type: z.string(),
+        securable_object_name: z.string(),
+        operation: z.string(),
+        annotations: z.object({
+            onlineViewName: z.string(),
+            onlineViewId: z.string(),
+            onlineViewMetastoreId: z.string(),
+            onlineViewClusterId: z.string(),
+        }),
+        type: z.string(),
+    })),
+    scope: z.string(),
+    token_type: z.string(),
+    expires_in: z.number(),
+});
+/**
+ * Hook for retrieving an access token to interact with Databricks.
+ * This hook fetches an authentication token needed to access specific tables within a Databricks workspace.
+ *
+ * @param {string} domainBase - The base domain URL of the Databricks workspace (e.g., 'mycompany.cloud.databricks.com').
+ * @param {string} encodedClientIdSecretVaultKey - A vault key pointing to a stored encoded base64 value in this format <clientId>:<clientSecret>.
+ *                                                 Example original value: `myClientId:myClientSecret`
+ *                                                 Stored encoded value: `bXlDbGllbnRJZDpteUNsaWVudFNlY3JldA==`
+ *                                                 This key must be set up and stored in advance to successfully authenticate.
+ * @param {string[]} tableNames - An array of table names that the token will grant access to.
+ */
+const useDatabricksToken = ({ domainBase, encodedClientIdSecretVaultKey, tableNames, }) => {
+    const encodedBody = useMemo(() => {
+        const authorization_details = JSON.stringify(tableNames.map(tableName => ({
+            type: "unity_catalog_permission",
+            securable_type: "table",
+            securable_object_name: tableName,
+            operation: "ReadOnlineView",
+        })));
+        const data = new URLSearchParams();
+        data.append("grant_type", "client_credentials");
+        data.append("scope", "all-apis");
+        data.append("authorization_details", authorization_details);
+        return btoa(data.toString());
+    }, [tableNames]);
+    return useIrisAppProxy({
+        requestOptions: {
+            url: `https://${domainBase}.cloud.databricks.com/oidc/v1/token`,
+            method: "POST",
+            headers: [
+                { name: "Authorization", value: `Basic {{${encodedClientIdSecretVaultKey}}}` },
+                { name: "Content-Type", value: "application/x-www-form-urlencoded" },
+            ],
+            body: encodedBody,
+        },
+        responseSchema: databricksTokenSchema,
+    });
+};
+
+export { headerSchema, irisAppProxySchema, useDatabricksToken, useIrisAppProxy };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/irisx-proxy",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "engines": {

package/src/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./schema";
-export * from "./useProxy";
+export * from "./useDatabricksToken";
+export * from "./useIrisAppProxy";

package/src/useDatabricksToken.d.ts

@@ -0,0 +1,35 @@
+interface UseDatabricksTokenProps {
+    domainBase: string;
+    encodedClientIdSecretVaultKey: string;
+    tableNames: string[];
+}
+/**
+ * Hook for retrieving an access token to interact with Databricks.
+ * This hook fetches an authentication token needed to access specific tables within a Databricks workspace.
+ *
+ * @param {string} domainBase - The base domain URL of the Databricks workspace (e.g., 'mycompany.cloud.databricks.com').
+ * @param {string} encodedClientIdSecretVaultKey - A vault key pointing to a stored encoded base64 value in this format <clientId>:<clientSecret>.
+ *                                                 Example original value: `myClientId:myClientSecret`
+ *                                                 Stored encoded value: `bXlDbGllbnRJZDpteUNsaWVudFNlY3JldA==`
+ *                                                 This key must be set up and stored in advance to successfully authenticate.
+ * @param {string[]} tableNames - An array of table names that the token will grant access to.
+ */
+export declare const useDatabricksToken: ({ domainBase, encodedClientIdSecretVaultKey, tableNames, }: UseDatabricksTokenProps) => import("./useIrisAppProxy").UseIrisAppProxyReturn<{
+    access_token: string;
+    authorization_details: {
+        type: string;
+        securable_type: string;
+        securable_object_name: string;
+        operation: string;
+        annotations: {
+            onlineViewName: string;
+            onlineViewId: string;
+            onlineViewMetastoreId: string;
+            onlineViewClusterId: string;
+        };
+    }[];
+    scope: string;
+    token_type: string;
+    expires_in: number;
+}>;
+export {};

package/src/{useProxy.d.ts → useIrisAppProxy.d.ts}

@@ -13,19 +13,20 @@ export interface ProxyError {
     name: string;
     message: string;
 }
+export interface UseIrisAppProxyReturn<TResponse> {
+    data: TResponse | null;
+    error: ProxyError | null;
+    loading: boolean;
+    mutate: (request?: IrisAppProxyRequestOptions) => Promise<undefined | {
+        data?: TResponse;
+        error?: ProxyError;
+    }>;
+    irisXProxyFetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response | undefined>;
+}
 /**
  * Hook for managing proxy interactions.
  * This hook handles different layers of errors and responses from the provided endpoint through the IrisAppProxy.
  * For the auth token, we recommend saving it using the IrisAppProxyStoreSecrets mutation and including it in the requestOptions as one of the headers.
  * E.g. { name: "Authorization", value: `Bearer {{OAuthToken}}` }
  */
-export declare const useIrisAppProxy: <TResponse>(props: UseIrisAppProxyProps<TResponse>) => {
-    data: TResponse | null;
-    mutate: (request?: IrisAppProxyRequestOptions) => Promise<{
-        data?: TResponse | undefined;
-        error?: ProxyError;
-    } | undefined>;
-    loading: boolean;
-    error: ProxyError | null;
-    irisXProxyFetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response | undefined>;
-};
+export declare const useIrisAppProxy: <TResponse>(props: UseIrisAppProxyProps<TResponse>) => UseIrisAppProxyReturn<TResponse>;

package/src/utils.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ProxyError } from "./useProxy";
+import { ProxyError } from "./useIrisAppProxy";
 /**
  * Validates and parses the response body.
  *
@@ -12,11 +12,3 @@ export declare const validateAndParseResponse: <TResponse>(responseBody: string,
     data?: TResponse;
     error?: ProxyError;
 };
-/**
- * Encodes the given request body as a base64 string.
- *
- * @template TRequest - The type of the request body.
- * @param {TRequest} body - The request body to be encoded.
- * @returns {string} The base64-encoded string representation of the request body.
- */
-export declare const parseRequestBodyToBase64: <TRequest>(body: TRequest) => string;