@agilant/toga-blox 1.0.317 → 1.0.318-beta.1

package/dist/api/apiFunctions.d.ts

@@ -1,6 +1,6 @@
-export declare const apiGet: <TData = unknown>(route: string, options?: Record<string, any>, params?: {}) => Promise<TData>;
-export declare const apiPost: <TData = unknown>(route: string, data: {
-    [key: string]: any;
-}, options?: Record<string, any>, params?: {}) => Promise<TData>;
-export declare const apiPut: <TData = unknown>(route: string, data?: {}, options?: Record<string, any>, params?: {}) => Promise<TData>;
-export declare const apiDelete: <TData = unknown>(route: string, data?: {}, options?: Record<string, any>, params?: {}) => Promise<TData>;
+import { AxiosInstance } from "axios";
+export declare const setAxiosInstance: (axiosInstance: AxiosInstance) => void;
+export declare const apiGet: <TData = unknown>(route: string, options?: {}, params?: {}) => Promise<TData>;
+export declare const apiPost: <TData = unknown>(route: string, data: Record<string, any>, options?: {}, params?: {}) => Promise<TData>;
+export declare const apiPut: <TData = unknown>(route: string, data?: {}, options?: {}, params?: {}) => Promise<TData>;
+export declare const apiDelete: <TData = unknown>(route: string, data?: {}, options?: {}, params?: {}) => Promise<TData>;

package/dist/api/apiFunctions.js

@@ -1,47 +1,32 @@
 import { assembleOptions } from "../reactQuery/queryHelpers";
-import axiosInstance from "./axiosInstance";
-// Note: The transactionId is now added automatically via the axios interceptor.
-export const apiGet = async (route, options = {}, params = {}) => {
-    let url = route;
+let instance = null;
+export const setAxiosInstance = (axiosInstance) => {
+    instance = axiosInstance;
+};
+const getAxiosInstance = () => {
+    if (!instance)
+        throw new Error("[blox] No axios instance registered. Call setAxiosInstance before using API helpers.");
+    return instance;
+};
+const buildUrl = (route, options = {}) => {
     const optionsString = assembleOptions(options);
-    if (optionsString) {
-        url += route.includes("?") ? "&" : "?";
-        url += optionsString;
-    }
-    const response = await axiosInstance.get(url, { params });
+    if (!optionsString)
+        return route;
+    return route + (route.includes("?") ? "&" : "?") + optionsString;
+};
+export const apiGet = async (route, options = {}, params = {}) => {
+    const response = await getAxiosInstance().get(buildUrl(route, options), { params });
     return response.data;
 };
 export const apiPost = async (route, data, options = {}, params = {}) => {
-    let url = route;
-    const optionsString = assembleOptions(options);
-    if (optionsString) {
-        url += route.includes("?") ? "&" : "?";
-        url += optionsString;
-    }
-    const response = await axiosInstance.post(url, data, { params });
+    const response = await getAxiosInstance().post(buildUrl(route, options), data, { params });
     return response.data;
 };
 export const apiPut = async (route, data = {}, options = {}, params = {}) => {
-    let url = route;
-    const optionsString = assembleOptions(options);
-    if (optionsString) {
-        url += route.includes("?") ? "&" : "?";
-        url += optionsString;
-    }
-    const response = await axiosInstance.put(url, data, { params });
+    const response = await getAxiosInstance().put(buildUrl(route, options), data, { params });
     return response.data;
 };
 export const apiDelete = async (route, data = {}, options = {}, params = {}) => {
-    let url = route;
-    const optionsString = assembleOptions(options);
-    if (optionsString) {
-        url += route.includes("?") ? "&" : "?";
-        url += optionsString;
-    }
-    const response = await axiosInstance.delete(url, {
-        data,
-        params,
-        validateStatus: (status) => status < 500,
-    });
+    const response = await getAxiosInstance().delete(buildUrl(route, options), { data, params, validateStatus: (status) => status < 500 });
     return response.data;
 };

package/dist/api/auth.d.ts

@@ -1,3 +1,23 @@
+interface Tokens {
+    access: string;
+    refresh: string;
+}
+interface User {
+    firstName: string;
+    lastName: string;
+    uuid: string;
+}
+export interface AuthResponse {
+    data: {
+        tokens: Tokens;
+        user: User;
+    };
+    messages?: string[];
+}
 export declare const performLogout: () => void;
 export declare const fetchPublicToken: (baseURL: string) => Promise<string | null>;
 export declare const refreshAccessToken: (baseURL: string) => Promise<string | null>;
+export declare function validateEmailDomain(email: string): Promise<boolean>;
+export declare function submitLoginPassword<T = AuthResponse>(email: string, password: string, fields: string[]): Promise<T>;
+export declare function handleClientAuthentication(uuid: string): Promise<object | null>;
+export {};

package/dist/api/auth.js

@@ -1,4 +1,5 @@
 import axios from "axios";
+import { apiGet, apiPost } from "./apiFunctions";
 export const performLogout = () => {
     localStorage.removeItem("accessToken");
     localStorage.removeItem("user");
@@ -40,3 +41,76 @@ export const refreshAccessToken = async (baseURL) => {
     }
     return null;
 };
+export async function validateEmailDomain(email) {
+    const domain = email.split("@")[1];
+    const protocol = window.location.protocol;
+    const hostname = window.location.hostname;
+    const domainName = `${protocol}//${hostname}`;
+    let environment = import.meta.env.MODE;
+    if (environment === "development")
+        environment = "DEV";
+    else if (environment === "production")
+        environment = "PRODUCTION";
+    else if (environment === "alpha")
+        environment = "ALPHA";
+    const response = await apiGet("/domains", {
+        fields: ["domain"],
+        join: [
+            {
+                ClientEmailDomains: {
+                    "ClientEmailDomains.clientId": "Domains.clientId",
+                },
+            },
+            {
+                ["Domains@SelfDomains"]: {
+                    "SelfDomains.appId": "Domains.appId",
+                },
+            },
+            {
+                Environments: {
+                    "Domains.environmentId": "Environments.id",
+                },
+            },
+        ],
+        where: {
+            and: [
+                { "ClientEmailDomains.domain": { like: domain } },
+                { "Environments.slug": { like: environment } },
+                { "SelfDomains.domain": { like: domainName } },
+            ],
+        },
+    });
+    if (response?.data?.domains && response.data.domains.length > 0) {
+        return true;
+    }
+    console.error("Failed to fetch domain validation or domain not found.");
+    return false;
+}
+export async function submitLoginPassword(email, password, fields) {
+    const response = await apiPost("/auth/login", { email, password }, {
+        fields: [
+            {
+                user: fields,
+            },
+        ],
+    });
+    return response;
+}
+export async function handleClientAuthentication(uuid) {
+    const saml = {
+        auth: "encrypted-user-uuid",
+        payload: { client: "", user: "" },
+    };
+    const response = await apiPost(`/auth/${saml.auth}`, saml.payload);
+    if (!response) {
+        console.error("Authentication failed:", response?.messages);
+        return null;
+    }
+    const { access: accessToken, refresh: refreshToken } = response.data.tokens;
+    localStorage.setItem("accessToken", accessToken);
+    localStorage.setItem("refreshToken", refreshToken);
+    const userData = await apiGet("/users", {
+        where: { and: [{ "Users.uuid": { "=": uuid } }] },
+    });
+    return userData;
+}

package/dist/api/axiosInstance.d.ts

@@ -1,2 +1,5 @@
-declare const axiosInstance: import("axios").AxiosInstance;
-export default axiosInstance;
+export interface AxiosInstanceConfig {
+    baseURL: string;
+    onLogout?: () => void;
+}
+export declare const createAxiosInstance: ({ baseURL, onLogout, }: AxiosInstanceConfig) => import("axios").AxiosInstance;

package/dist/api/axiosInstance.js

@@ -1,58 +1,44 @@
 import axios from "axios";
 import { v4 as uuidv4 } from "uuid";
 import { performLogout, fetchPublicToken, refreshAccessToken } from "./auth";
-// Build base URL from environment
-const fullHostName = window.location.hostname.toUpperCase();
-const hostName = fullHostName.split(".");
-const host = "VITE_API_" + hostName[0];
-const baseURL = import.meta.env[host] || import.meta.env.VITE_API;
-const axiosInstance = axios.create({
-    baseURL,
-    headers: { "Content-Type": "application/json" },
-    timeout: 180000,
-});
-// Add transactionId to requests
-axiosInstance.interceptors.request.use((config) => {
-    config.params = config.params || {};
-    config.params.transactionId = uuidv4();
-    return config;
-});
-// Add Authorization header
-axiosInstance.interceptors.request.use(async (config) => {
-    let token;
-    const userString = localStorage.getItem("user");
-    if (userString) {
-        token = localStorage.getItem("accessToken");
-    }
-    else {
-        token = await fetchPublicToken(baseURL);
-    }
-    if (token) {
-        config.headers["Authorization"] = `Bearer ${token}`;
-    }
-    return config;
-});
-// Delay (optional)
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-axiosInstance.interceptors.request.use(async (config) => {
-    await delay(1);
-    return config;
-});
-// Handle 401
-axiosInstance.interceptors.response.use((response) => response, async (error) => {
-    const originalRequest = error.config;
-    if (error.response?.status === 401 && !originalRequest._retry) {
-        originalRequest._retry = true;
-        const newToken = await refreshAccessToken(baseURL);
-        if (newToken) {
-            originalRequest.headers["Authorization"] = `Bearer ${newToken}`;
-            return axiosInstance(originalRequest);
+export const createAxiosInstance = ({ baseURL, onLogout, }) => {
+    const instance = axios.create({
+        baseURL,
+        headers: { "Content-Type": "application/json" },
+        timeout: 180000,
+    });
+    instance.interceptors.request.use((config) => {
+        config.params = config.params || {};
+        config.params.transactionId = uuidv4();
+        return config;
+    });
+    instance.interceptors.request.use(async (config) => {
+        const userString = localStorage.getItem("user");
+        const token = userString
+            ? localStorage.getItem("accessToken")
+            : await fetchPublicToken(baseURL);
+        if (token)
+            config.headers["Authorization"] = `Bearer ${token}`;
+        return config;
+    });
+    instance.interceptors.response.use((response) => response, async (error) => {
+        const originalRequest = error.config;
+        if (originalRequest &&
+            error.response?.status === 401 &&
+            !originalRequest._retry) {
+            originalRequest._retry = true;
+            const newToken = await refreshAccessToken(baseURL);
+            if (newToken) {
+                originalRequest.headers["Authorization"] = `Bearer ${newToken}`;
+                return instance(originalRequest);
+            }
+            else {
+                const handleLogout = onLogout ?? performLogout;
+                if (localStorage.getItem("user"))
+                    handleLogout();
+            }
         }
-        else {
-            if (localStorage.getItem("user"))
-                performLogout();
-        }
-    }
-    return Promise.reject(error);
-});
-export default axiosInstance;
+        return Promise.reject(error);
+    });
+    return instance;
+};

package/dist/api/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./axiosInstance";
+export * from "./apiFunctions";
+export { getDataTableData } from "./tableData/getDataTableData";
+export { getDataTableMeta } from "./tableData/getDataTableMeta";
+export { getColumnFieldFilterOptions } from "./tableData/getColumnFieldFilterOptions";
+export { apiGet, apiPost, apiPut, apiDelete } from "./apiFunctions";
+export { performLogout, fetchPublicToken, validateEmailDomain, submitLoginPassword, handleClientAuthentication, AuthResponse, } from "./auth";

package/dist/api/index.js

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./axiosInstance";
+export * from "./apiFunctions";
+export { getDataTableData } from "./tableData/getDataTableData";
+export { getDataTableMeta } from "./tableData/getDataTableMeta";
+export { getColumnFieldFilterOptions } from "./tableData/getColumnFieldFilterOptions";
+export { apiGet, apiPost, apiPut, apiDelete } from "./apiFunctions";
+export { performLogout, fetchPublicToken, validateEmailDomain, submitLoginPassword, handleClientAuthentication, } from "./auth";

package/dist/api/tableData/getColumnFieldFilterOptions.d.ts

@@ -0,0 +1,2 @@
+import type { DataTableMetaFormatted } from "../types";
+export declare const getColumnFieldFilterOptions: (recordRoute: string, options?: {}, params?: {}) => Promise<DataTableMetaFormatted>;

package/dist/api/tableData/getColumnFieldFilterOptions.js

@@ -0,0 +1,12 @@
+import { apiGet } from "../apiFunctions";
+export const getColumnFieldFilterOptions = async (recordRoute, options = {}, params = {}) => {
+    const response = (await apiGet(`/${recordRoute}`, options, params));
+    if (!response.isSuccess) {
+        return {
+            table: null,
+            nestedTable: null,
+        };
+    }
+    const optionsResponse = response?.data;
+    return optionsResponse;
+};

package/dist/api/tableData/getDataTableData.d.ts

@@ -0,0 +1,13 @@
+import type { DataTableMetaProp } from "../types";
+export declare const getDataTableData: (tableViewMeta: DataTableMetaProp, additionalData?: {
+    page?: number;
+    hasInfiniteScroll?: boolean;
+    extraWhereConditions?: any[];
+    [key: string]: any;
+}, extraFields?: string[], searchParams?: URLSearchParams, options?: {
+    onError?: (message: string, extra?: any) => void;
+}) => Promise<any>;
+export declare const getPageMeta: (page: string, app: string, // ← no longer hardcoded to "supply"
+options?: {
+    onError?: (message: string, extra?: any) => void;
+}) => Promise<any>;