@trackunit/irisx-proxy 0.0.1

package/README.md

@@ -0,0 +1,21 @@
+# Trackunit proxy
+
+The `@trackunit/irisx-proxy` package is the home of Trackunit's public hook used for calling IrisX Proxy.
+
+This library is exposed publicly for use in the the Trackunit [Iris App SDK](https://www.npmjs.com/package/@trackunit/iris-app).
+
+To browse all avaliable components visit our [Public Storybook](https://apps.iris.trackunit.com/storybook/).
+
+For more info and a full guide on Iris App SDK Development, please visit our [Developer Hub](https://developers.trackunit.com/).
+
+## Development
+
+At this point this library is only developed by Trackunit Employees.
+For development related information see the [development readme](https://github.com/Trackunit/manager/blob/master/libs/react/components/DEVELOPMENT.md).
+
+## Trackunit
+
+This package was developed by Trackunit ApS.
+Trackunit is the leading SaaS-based IoT solution for the construction industry, offering an ecosystem of hardware, fleet management software & telematics.
+
+![The Trackunit logo](https://trackunit.com/wp-content/uploads/2022/03/top-logo.svg)

package/codegen.d.ts

@@ -0,0 +1,3 @@
+import { type CodegenConfig } from "@graphql-codegen/cli";
+declare const config: CodegenConfig;
+export default config;

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,317 @@
+'use strict';
+
+var zod = require('zod');
+var client = require('@apollo/client');
+var react = require('react');
+
+/**
+ * Schema for HTTP headers
+ *
+ * @property {string} name - The name of the header
+ * @property {string} value - The value of the header
+ */
+const headerSchema = zod.z.object({
+    name: zod.z.string(),
+    value: zod.z.string(),
+});
+/**
+ * Schema for API call parameters
+ *
+ * @property {string} url - The URL for the API call (must be a valid URL)
+ * @property {('GET'|'POST'|'PUT'|'PATCH'|'DELETE')} method - The HTTP method for the API call
+ * @property {HeaderSchema[]} headers - An array of headers for the API call
+ * @property {string} [body] - Optional body content for the API call
+ */
+const irisAppProxySchema = zod.z.object({
+    url: zod.z.string().url(),
+    method: zod.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+    headers: zod.z.array(headerSchema),
+    body: zod.z.string().optional(),
+});
+
+const IrisAppProxyFetchDocument = {
+    kind: "Document",
+    definitions: [
+        {
+            kind: "OperationDefinition",
+            operation: "mutation",
+            name: { kind: "Name", value: "IrisAppProxyFetch" },
+            variableDefinitions: [
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "url" } },
+                    type: { kind: "NonNullType", type: { kind: "NamedType", name: { kind: "Name", value: "String" } } },
+                },
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "method" } },
+                    type: { kind: "NonNullType", type: { kind: "NamedType", name: { kind: "Name", value: "HttpMethod" } } },
+                },
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "headers" } },
+                    type: {
+                        kind: "NonNullType",
+                        type: {
+                            kind: "ListType",
+                            type: {
+                                kind: "NonNullType",
+                                type: { kind: "NamedType", name: { kind: "Name", value: "IrisAppProxyHeader" } },
+                            },
+                        },
+                    },
+                },
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "body" } },
+                    type: { kind: "NamedType", name: { kind: "Name", value: "String" } },
+                },
+            ],
+            selectionSet: {
+                kind: "SelectionSet",
+                selections: [
+                    {
+                        kind: "Field",
+                        name: { kind: "Name", value: "irisAppProxyFetch" },
+                        arguments: [
+                            {
+                                kind: "Argument",
+                                name: { kind: "Name", value: "url" },
+                                value: { kind: "Variable", name: { kind: "Name", value: "url" } },
+                            },
+                            {
+                                kind: "Argument",
+                                name: { kind: "Name", value: "method" },
+                                value: { kind: "Variable", name: { kind: "Name", value: "method" } },
+                            },
+                            {
+                                kind: "Argument",
+                                name: { kind: "Name", value: "headers" },
+                                value: { kind: "Variable", name: { kind: "Name", value: "headers" } },
+                            },
+                            {
+                                kind: "Argument",
+                                name: { kind: "Name", value: "body" },
+                                value: { kind: "Variable", name: { kind: "Name", value: "body" } },
+                            },
+                        ],
+                        selectionSet: {
+                            kind: "SelectionSet",
+                            selections: [
+                                { kind: "Field", name: { kind: "Name", value: "success" } },
+                                { kind: "Field", name: { kind: "Name", value: "body" } },
+                                { kind: "Field", name: { kind: "Name", value: "status" } },
+                                { kind: "Field", name: { kind: "Name", value: "errorMessage" } },
+                            ],
+                        },
+                    },
+                ],
+            },
+        },
+    ],
+};
+
+/**
+ * Validates and parses the response body.
+ *
+ * @template T - The type inferred from the response schema.
+ * @param {string} responseBody - The base64-encoded response body from the API.
+ * @param {z.ZodType<T>} responseSchema - The Zod schema used to validate and parse the response data.
+ * @returns {T | null} The parsed and validated response data of type `T`, or `null` if validation fails.
+ */
+const validateAndParseResponse = (responseBody, responseSchema) => {
+    const decodedBody = atob(responseBody);
+    const parsedBody = JSON.parse(decodedBody);
+    const validationResult = responseSchema.safeParse(parsedBody);
+    if (!validationResult.success) {
+        return { error: validationResult.error };
+    }
+    return { data: validationResult.data };
+};
+
+/**
+ * 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}}` }
+ *
+ * @param props - The properties for useIrisAppProxy hook.
+ * @returns An object containing chatbot state and functions.
+ */
+const useIrisAppProxy = (props) => {
+    const { requestOptions, responseSchema, onSuccess, onError } = props;
+    const [error, setError] = react.useState(null);
+    const [proxyData, setProxyData] = react.useState(null);
+    const [mutate, { loading }] = client.useMutation(IrisAppProxyFetchDocument);
+    const createRequest = () => {
+        const request = {
+            ...requestOptions,
+            headers: [
+                { name: "Content-Type", value: "application/json" },
+                { name: "Accept-Profile", value: "default" },
+                ...requestOptions.headers,
+            ],
+        };
+        const result = irisAppProxySchema.safeParse(request);
+        if (!result.success) {
+            const localError = {
+                name: "Failed to parse request",
+                message: JSON.stringify(result.error, null, 2),
+            };
+            setError(localError);
+            onError && onError(localError);
+            return null;
+        }
+        return result.data;
+    };
+    const customMutate = async (request) => {
+        var _a, _b;
+        try {
+            const proxyRequest = request !== null && request !== void 0 ? request : createRequest();
+            if (!proxyRequest) {
+                return;
+            }
+            const { data, errors: gqlErrors } = await mutate({
+                variables: { ...proxyRequest, body: proxyRequest.body },
+            });
+            // Handle GraphQL errors
+            if (gqlErrors) {
+                const localError = {
+                    name: "GraphQL Error",
+                    message: JSON.stringify(gqlErrors, null, 2),
+                };
+                setError(localError);
+                onError && onError(localError);
+                return;
+            }
+            // Handle errors from Proxy (These does not fail the GraphQL query)
+            if (data && !data.irisAppProxyFetch.success) {
+                const localError = {
+                    name: "Error from Proxy Fetch",
+                    message: JSON.stringify(JSON.parse((_a = data.irisAppProxyFetch.errorMessage) !== null && _a !== void 0 ? _a : ""), null, 2),
+                };
+                setError(localError);
+                onError && onError(localError);
+                return;
+            }
+            // Handle errors from external service (These does not fail the GraphQL query)
+            if (data && data.irisAppProxyFetch.success && data.irisAppProxyFetch.status !== 200) {
+                const decodedBody = atob((_b = data.irisAppProxyFetch.body) !== null && _b !== void 0 ? _b : "");
+                const localError = {
+                    name: `Error from external service (${data.irisAppProxyFetch.status})`,
+                    message: decodedBody,
+                };
+                setError(localError);
+                onError && onError(localError);
+                return;
+            }
+            // Handle successful response
+            if (data === null || data === void 0 ? void 0 : data.irisAppProxyFetch.body) {
+                const parsedBody = validateAndParseResponse(data.irisAppProxyFetch.body, responseSchema);
+                if (parsedBody.error) {
+                    setError(parsedBody.error);
+                    onError && onError(parsedBody.error);
+                    return;
+                }
+                if (parsedBody.data) {
+                    setProxyData(parsedBody.data);
+                    onSuccess && onSuccess(parsedBody.data);
+                    return parsedBody;
+                }
+                else {
+                    return;
+                }
+            }
+            else {
+                return;
+            }
+        }
+        catch (error) {
+            const localError = {
+                name: "Error",
+                message: JSON.stringify(error, null, 2),
+            };
+            setError(localError);
+            onError && onError(localError);
+            return;
+        }
+    };
+    const convertHeadersToIrisAppProxySchema = (headers) => {
+        if (!headers) {
+            return [];
+        }
+        if (headers instanceof Headers) {
+            const headersArray = [];
+            headers.forEach((value, name) => {
+                headersArray.push({ name, value });
+            });
+            return headersArray;
+        }
+        if (Array.isArray(headers)) {
+            return headers.map(([name, value]) => ({ name, value: value.toString() }));
+        }
+        if (typeof headers === "object") {
+            return Object.entries(headers).map(([name, value]) => ({ name, value: value.toString() }));
+        }
+        return [];
+    };
+    const mapToIrisAppProxySchema = (input, init) => {
+        var _a;
+        const headersArray = convertHeadersToIrisAppProxySchema(init === null || init === void 0 ? void 0 : init.headers);
+        const result = irisAppProxySchema.safeParse({
+            url: input,
+            method: (_a = init === null || init === void 0 ? void 0 : init.method) !== null && _a !== void 0 ? _a : "GET",
+            headers: headersArray,
+            body: (init === null || init === void 0 ? void 0 : init.body) ? String(init.body) : undefined,
+        });
+        if (!result.success) {
+            const localError = {
+                name: "Failed to map request",
+                message: JSON.stringify(result.error, null, 2),
+            };
+            setError(localError);
+            onError && onError(localError);
+            return null;
+        }
+        return result.data;
+    };
+    /**
+     * Performs a proxy fetch operation using the IrisX API.
+     * Use this function when you need to have a function that mimics the browser fetch API.
+     * This could be when using an external library that requires a fetch function.   *
+     *
+     * @async
+     * @function irisXProxyFetch
+     * @param {RequestInfo | URL} input - The resource that you want to fetch, which can be a URL string or a Request object.
+     * @param {RequestInit} [init] - Optional configuration options for the request, similar to the standard fetch API.
+     * @returns {Promise<Response | undefined>} A promise that resolves to a Response object or undefined if the request mapping fails.
+     * @description
+     * This function maps the provided request to the IrisApp proxy schema. If the mapping is successful, it initiates a custom mutation with the mapped request.
+     * If the mapping fails, the function returns without performing the fetch operation. The function handles errors and returns appropriate responses based on the mutation outcome.
+     */
+    const irisXProxyFetch = async (input, init) => {
+        const proxyRequest = mapToIrisAppProxySchema(input, init);
+        if (!proxyRequest) {
+            return;
+        }
+        const response = await customMutate(proxyRequest);
+        if (response === null || response === void 0 ? void 0 : response.error) {
+            return new Response(JSON.stringify(response.error), {
+                status: 500,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        if (response === null || response === void 0 ? void 0 : response.data) {
+            return new Response(JSON.stringify(response.data), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        return new Response(null, { status: 204 });
+    };
+    return { data: proxyData, mutate: customMutate, loading, error, irisXProxyFetch };
+};
+
+exports.headerSchema = headerSchema;
+exports.irisAppProxySchema = irisAppProxySchema;
+exports.useIrisAppProxy = useIrisAppProxy;

package/index.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.esm.js

@@ -0,0 +1,313 @@
+import { z } from 'zod';
+import { useMutation } from '@apollo/client';
+import { useState } from 'react';
+
+/**
+ * Schema for HTTP headers
+ *
+ * @property {string} name - The name of the header
+ * @property {string} value - The value of the header
+ */
+const headerSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/**
+ * Schema for API call parameters
+ *
+ * @property {string} url - The URL for the API call (must be a valid URL)
+ * @property {('GET'|'POST'|'PUT'|'PATCH'|'DELETE')} method - The HTTP method for the API call
+ * @property {HeaderSchema[]} headers - An array of headers for the API call
+ * @property {string} [body] - Optional body content for the API call
+ */
+const irisAppProxySchema = z.object({
+    url: z.string().url(),
+    method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+    headers: z.array(headerSchema),
+    body: z.string().optional(),
+});
+
+const IrisAppProxyFetchDocument = {
+    kind: "Document",
+    definitions: [
+        {
+            kind: "OperationDefinition",
+            operation: "mutation",
+            name: { kind: "Name", value: "IrisAppProxyFetch" },
+            variableDefinitions: [
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "url" } },
+                    type: { kind: "NonNullType", type: { kind: "NamedType", name: { kind: "Name", value: "String" } } },
+                },
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "method" } },
+                    type: { kind: "NonNullType", type: { kind: "NamedType", name: { kind: "Name", value: "HttpMethod" } } },
+                },
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "headers" } },
+                    type: {
+                        kind: "NonNullType",
+                        type: {
+                            kind: "ListType",
+                            type: {
+                                kind: "NonNullType",
+                                type: { kind: "NamedType", name: { kind: "Name", value: "IrisAppProxyHeader" } },
+                            },
+                        },
+                    },
+                },
+                {
+                    kind: "VariableDefinition",
+                    variable: { kind: "Variable", name: { kind: "Name", value: "body" } },
+                    type: { kind: "NamedType", name: { kind: "Name", value: "String" } },
+                },
+            ],
+            selectionSet: {
+                kind: "SelectionSet",
+                selections: [
+                    {
+                        kind: "Field",
+                        name: { kind: "Name", value: "irisAppProxyFetch" },
+                        arguments: [
+                            {
+                                kind: "Argument",
+                                name: { kind: "Name", value: "url" },
+                                value: { kind: "Variable", name: { kind: "Name", value: "url" } },
+                            },
+                            {
+                                kind: "Argument",
+                                name: { kind: "Name", value: "method" },
+                                value: { kind: "Variable", name: { kind: "Name", value: "method" } },
+                            },
+                            {
+                                kind: "Argument",
+                                name: { kind: "Name", value: "headers" },
+                                value: { kind: "Variable", name: { kind: "Name", value: "headers" } },
+                            },
+                            {
+                                kind: "Argument",
+                                name: { kind: "Name", value: "body" },
+                                value: { kind: "Variable", name: { kind: "Name", value: "body" } },
+                            },
+                        ],
+                        selectionSet: {
+                            kind: "SelectionSet",
+                            selections: [
+                                { kind: "Field", name: { kind: "Name", value: "success" } },
+                                { kind: "Field", name: { kind: "Name", value: "body" } },
+                                { kind: "Field", name: { kind: "Name", value: "status" } },
+                                { kind: "Field", name: { kind: "Name", value: "errorMessage" } },
+                            ],
+                        },
+                    },
+                ],
+            },
+        },
+    ],
+};
+
+/**
+ * Validates and parses the response body.
+ *
+ * @template T - The type inferred from the response schema.
+ * @param {string} responseBody - The base64-encoded response body from the API.
+ * @param {z.ZodType<T>} responseSchema - The Zod schema used to validate and parse the response data.
+ * @returns {T | null} The parsed and validated response data of type `T`, or `null` if validation fails.
+ */
+const validateAndParseResponse = (responseBody, responseSchema) => {
+    const decodedBody = atob(responseBody);
+    const parsedBody = JSON.parse(decodedBody);
+    const validationResult = responseSchema.safeParse(parsedBody);
+    if (!validationResult.success) {
+        return { error: validationResult.error };
+    }
+    return { data: validationResult.data };
+};
+
+/**
+ * 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}}` }
+ *
+ * @param props - The properties for useIrisAppProxy hook.
+ * @returns An object containing chatbot state and functions.
+ */
+const useIrisAppProxy = (props) => {
+    const { requestOptions, responseSchema, onSuccess, onError } = props;
+    const [error, setError] = useState(null);
+    const [proxyData, setProxyData] = useState(null);
+    const [mutate, { loading }] = useMutation(IrisAppProxyFetchDocument);
+    const createRequest = () => {
+        const request = {
+            ...requestOptions,
+            headers: [
+                { name: "Content-Type", value: "application/json" },
+                { name: "Accept-Profile", value: "default" },
+                ...requestOptions.headers,
+            ],
+        };
+        const result = irisAppProxySchema.safeParse(request);
+        if (!result.success) {
+            const localError = {
+                name: "Failed to parse request",
+                message: JSON.stringify(result.error, null, 2),
+            };
+            setError(localError);
+            onError && onError(localError);
+            return null;
+        }
+        return result.data;
+    };
+    const customMutate = async (request) => {
+        var _a, _b;
+        try {
+            const proxyRequest = request !== null && request !== void 0 ? request : createRequest();
+            if (!proxyRequest) {
+                return;
+            }
+            const { data, errors: gqlErrors } = await mutate({
+                variables: { ...proxyRequest, body: proxyRequest.body },
+            });
+            // Handle GraphQL errors
+            if (gqlErrors) {
+                const localError = {
+                    name: "GraphQL Error",
+                    message: JSON.stringify(gqlErrors, null, 2),
+                };
+                setError(localError);
+                onError && onError(localError);
+                return;
+            }
+            // Handle errors from Proxy (These does not fail the GraphQL query)
+            if (data && !data.irisAppProxyFetch.success) {
+                const localError = {
+                    name: "Error from Proxy Fetch",
+                    message: JSON.stringify(JSON.parse((_a = data.irisAppProxyFetch.errorMessage) !== null && _a !== void 0 ? _a : ""), null, 2),
+                };
+                setError(localError);
+                onError && onError(localError);
+                return;
+            }
+            // Handle errors from external service (These does not fail the GraphQL query)
+            if (data && data.irisAppProxyFetch.success && data.irisAppProxyFetch.status !== 200) {
+                const decodedBody = atob((_b = data.irisAppProxyFetch.body) !== null && _b !== void 0 ? _b : "");
+                const localError = {
+                    name: `Error from external service (${data.irisAppProxyFetch.status})`,
+                    message: decodedBody,
+                };
+                setError(localError);
+                onError && onError(localError);
+                return;
+            }
+            // Handle successful response
+            if (data === null || data === void 0 ? void 0 : data.irisAppProxyFetch.body) {
+                const parsedBody = validateAndParseResponse(data.irisAppProxyFetch.body, responseSchema);
+                if (parsedBody.error) {
+                    setError(parsedBody.error);
+                    onError && onError(parsedBody.error);
+                    return;
+                }
+                if (parsedBody.data) {
+                    setProxyData(parsedBody.data);
+                    onSuccess && onSuccess(parsedBody.data);
+                    return parsedBody;
+                }
+                else {
+                    return;
+                }
+            }
+            else {
+                return;
+            }
+        }
+        catch (error) {
+            const localError = {
+                name: "Error",
+                message: JSON.stringify(error, null, 2),
+            };
+            setError(localError);
+            onError && onError(localError);
+            return;
+        }
+    };
+    const convertHeadersToIrisAppProxySchema = (headers) => {
+        if (!headers) {
+            return [];
+        }
+        if (headers instanceof Headers) {
+            const headersArray = [];
+            headers.forEach((value, name) => {
+                headersArray.push({ name, value });
+            });
+            return headersArray;
+        }
+        if (Array.isArray(headers)) {
+            return headers.map(([name, value]) => ({ name, value: value.toString() }));
+        }
+        if (typeof headers === "object") {
+            return Object.entries(headers).map(([name, value]) => ({ name, value: value.toString() }));
+        }
+        return [];
+    };
+    const mapToIrisAppProxySchema = (input, init) => {
+        var _a;
+        const headersArray = convertHeadersToIrisAppProxySchema(init === null || init === void 0 ? void 0 : init.headers);
+        const result = irisAppProxySchema.safeParse({
+            url: input,
+            method: (_a = init === null || init === void 0 ? void 0 : init.method) !== null && _a !== void 0 ? _a : "GET",
+            headers: headersArray,
+            body: (init === null || init === void 0 ? void 0 : init.body) ? String(init.body) : undefined,
+        });
+        if (!result.success) {
+            const localError = {
+                name: "Failed to map request",
+                message: JSON.stringify(result.error, null, 2),
+            };
+            setError(localError);
+            onError && onError(localError);
+            return null;
+        }
+        return result.data;
+    };
+    /**
+     * Performs a proxy fetch operation using the IrisX API.
+     * Use this function when you need to have a function that mimics the browser fetch API.
+     * This could be when using an external library that requires a fetch function.   *
+     *
+     * @async
+     * @function irisXProxyFetch
+     * @param {RequestInfo | URL} input - The resource that you want to fetch, which can be a URL string or a Request object.
+     * @param {RequestInit} [init] - Optional configuration options for the request, similar to the standard fetch API.
+     * @returns {Promise<Response | undefined>} A promise that resolves to a Response object or undefined if the request mapping fails.
+     * @description
+     * This function maps the provided request to the IrisApp proxy schema. If the mapping is successful, it initiates a custom mutation with the mapped request.
+     * If the mapping fails, the function returns without performing the fetch operation. The function handles errors and returns appropriate responses based on the mutation outcome.
+     */
+    const irisXProxyFetch = async (input, init) => {
+        const proxyRequest = mapToIrisAppProxySchema(input, init);
+        if (!proxyRequest) {
+            return;
+        }
+        const response = await customMutate(proxyRequest);
+        if (response === null || response === void 0 ? void 0 : response.error) {
+            return new Response(JSON.stringify(response.error), {
+                status: 500,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        if (response === null || response === void 0 ? void 0 : response.data) {
+            return new Response(JSON.stringify(response.data), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        return new Response(null, { status: 204 });
+    };
+    return { data: proxyData, mutate: customMutate, loading, error, irisXProxyFetch };
+};
+
+export { headerSchema, irisAppProxySchema, useIrisAppProxy };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@trackunit/irisx-proxy",
+  "version": "0.0.1",
+  "repository": "https://github.com/Trackunit/manager",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "engines": {
+    "node": ">=20.x"
+  },
+  "dependencies": {
+    "react": "18.3.1",
+    "@apollo/client": "3.10.4",
+    "graphql": "^15.8.0",
+    "@graphql-codegen/cli": "^5.0.0",
+    "@graphql-typed-document-node/core": "^3.2.0",
+    "@trackunit/iris-app-api": "*",
+    "@trackunit/iris-app-build-utilities": "*",
+    "@trackunit/react-core-contexts-test": "*",
+    "zod": "3.22.4",
+    "jest-fetch-mock": "^3.0.3"
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.esm.d.ts"
+}

package/src/generated/graphql-api/fragment-masking.d.ts

@@ -0,0 +1,15 @@
+import { ResultOf, DocumentTypeDecoration, TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { Incremental } from './graphql';
+export type FragmentType<TDocumentType extends DocumentTypeDecoration<any, any>> = TDocumentType extends DocumentTypeDecoration<infer TType, any> ? [TType] extends [{
+    ' $fragmentName'?: infer TKey;
+}] ? TKey extends string ? {
+    ' $fragmentRefs'?: {
+        [key in TKey]: TType;
+    };
+} : never : never : never;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>>): TType;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null | undefined): TType | null | undefined;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>>): ReadonlyArray<TType>;
+export declare function getFragmentData<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined): ReadonlyArray<TType> | null | undefined;
+export declare function makeFragmentData<F extends DocumentTypeDecoration<any, any>, FT extends ResultOf<F>>(data: FT, _fragment: F): FragmentType<F>;
+export declare function isFragmentReady<TQuery, TFrag>(queryNode: DocumentTypeDecoration<TQuery, any>, fragmentNode: TypedDocumentNode<TFrag>, data: FragmentType<TypedDocumentNode<Incremental<TFrag>, any>> | null | undefined): data is FragmentType<typeof fragmentNode>;

package/src/generated/graphql-api/gql.d.ts

@@ -0,0 +1,39 @@
+import * as types from './graphql';
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+/**
+ * Map of all GraphQL operations in the project.
+ *
+ * This map has several performance disadvantages:
+ * 1. It is not tree-shakeable, so it will include all operations in the project.
+ * 2. It is not minifiable, so the string of a GraphQL query will be multiple times inside the bundle.
+ * 3. It does not support dead code elimination, so it will add unused operations.
+ *
+ * Therefore it is highly recommended to use the babel or swc plugin for production.
+ */
+declare const documents: {
+    "mutation IrisAppProxyFetch($url: String!, $method: HttpMethod!, $headers: [IrisAppProxyHeader!]!, $body: String) {\n  irisAppProxyFetch(url: $url, method: $method, headers: $headers, body: $body) {\n    success\n    body\n    status\n    errorMessage\n  }\n}": DocumentNode<types.IrisAppProxyFetchMutation, types.Exact<{
+        url: types.Scalars["String"]["input"];
+        method: types.HttpMethod;
+        headers: Array<types.IrisAppProxyHeader> | types.IrisAppProxyHeader;
+        body: types.InputMaybe<types.Scalars["String"]["input"]>;
+    }>>;
+};
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ *
+ *
+ * @example
+ * ```ts
+ * const query = graphql(`query GetUser($id: ID!) { user(id: $id) { name } }`);
+ * ```
+ *
+ * The query argument is unknown!
+ * Please regenerate the types.
+ */
+export declare function graphql(source: string): unknown;
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function graphql(source: "mutation IrisAppProxyFetch($url: String!, $method: HttpMethod!, $headers: [IrisAppProxyHeader!]!, $body: String) {\n  irisAppProxyFetch(url: $url, method: $method, headers: $headers, body: $body) {\n    success\n    body\n    status\n    errorMessage\n  }\n}"): (typeof documents)["mutation IrisAppProxyFetch($url: String!, $method: HttpMethod!, $headers: [IrisAppProxyHeader!]!, $body: String) {\n  irisAppProxyFetch(url: $url, method: $method, headers: $headers, body: $body) {\n    success\n    body\n    status\n    errorMessage\n  }\n}"];
+export type DocumentType<TDocumentNode extends DocumentNode<any, any>> = TDocumentNode extends DocumentNode<infer TType, any> ? TType : never;
+export {};

package/src/generated/graphql-api/graphql.d.ts

@@ -0,0 +1,162 @@
+import { TypedDocumentNode as DocumentNode } from "@graphql-typed-document-node/core";
+import type { PublicIrisAppManifest } from "@trackunit/iris-app-api";
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T> | undefined;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
+};
+export type DateTimeISOString = string;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    /** The ISO 4217 currency code of the monetary field definition. */
+    Currency: {
+        input: string;
+        output: string;
+    };
+    /** Cursor scalar. */
+    Cursor: {
+        input: string;
+        output: string;
+    };
+    /** Date without time, Eg. 2019-01-01 */
+    Date: {
+        input: DateTimeISOString;
+        output: DateTimeISOString;
+    };
+    /** DateTime represents a “date-time” as specified in section 5.6 of RFC 3339 */
+    DateTime: {
+        input: DateTimeISOString;
+        output: DateTimeISOString;
+    };
+    /** Duration represents an ISO 8601 duration */
+    Duration: {
+        input: any;
+        output: any;
+    };
+    /** Valid email address according to https://owasp.org/www-community/OWASP_Validation_Regex_Repository */
+    EmailAddress: {
+        input: string;
+        output: string;
+    };
+    /** A (possiblely multidimensional) set of coordinates following x, y, z order. */
+    GeoJSONCoordinates: {
+        input: number[] | number[][];
+        output: number[] | number[][];
+    };
+    Integer: {
+        input: any;
+        output: any;
+    };
+    /** Raw JSON object structure, not serialized to string */
+    JSON: {
+        input: any;
+        output: any;
+    };
+    /** The `JSONObject` scalar type represents JSON values as a string */
+    JSONObject: {
+        input: any;
+        output: any;
+    };
+    /** LocalDate scalar */
+    LocalDate: {
+        input: any;
+        output: any;
+    };
+    /** Javascript `Long`. Type represents a 64 bit integer. */
+    Long: {
+        input: any;
+        output: any;
+    };
+    /** Phone number in E.164 format */
+    PhoneNumber: {
+        input: string;
+        output: string;
+    };
+    /** The `PublicIrisAppManifest` scalar type represents an Iris App Manifest as JSON */
+    PublicIrisAppManifest: {
+        input: PublicIrisAppManifest;
+        output: PublicIrisAppManifest;
+    };
+    /** The `Upload` scalar type represents a file upload. */
+    Upload: {
+        input: any;
+        output: any;
+    };
+    /** Uniform resource locator */
+    Url: {
+        input: string;
+        output: string;
+    };
+    /** YearMonth scalar */
+    YearMonth: {
+        input: any;
+        output: any;
+    };
+};
+export declare const httpMethod: {
+    readonly DELETE: "DELETE";
+    readonly GET: "GET";
+    readonly PATCH: "PATCH";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+};
+export type HttpMethod = (typeof httpMethod)[keyof typeof httpMethod];
+export type IrisAppProxyHeader = {
+    /** The name/key of the header */
+    name: Scalars["String"]["input"];
+    /** Use mustache template to insert secrets. Like `Bearer {{TOKEN}}` assuming the app has a stored secret containing `TOKEN` */
+    value: Scalars["String"]["input"];
+};
+export type IrisAppProxyFetchMutationVariables = Exact<{
+    url: Scalars["String"]["input"];
+    method: HttpMethod;
+    headers: Array<IrisAppProxyHeader> | IrisAppProxyHeader;
+    body: InputMaybe<Scalars["String"]["input"]>;
+}>;
+export type IrisAppProxyFetchMutation = {
+    __typename?: "Mutation";
+    irisAppProxyFetch: {
+        __typename?: "IrisAppProxyFetchResponse";
+        success: boolean;
+        body: string | null;
+        status: number | null;
+        errorMessage: string | null;
+    };
+};
+export declare const IrisAppProxyFetchDocument: DocumentNode<IrisAppProxyFetchMutation, IrisAppProxyFetchMutationVariables>;

package/src/generated/graphql-api/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./fragment-masking";
+export * from "./gql";

package/src/generated/graphql-api/mock.d.ts

@@ -0,0 +1,5 @@
+import { DeepPartialNullable } from "@trackunit/react-core-contexts-test";
+import * as gql from "./graphql";
+export declare const mockForIrisAppProxyFetchMutation: (variables: gql.IrisAppProxyFetchMutationVariables, data?: DeepPartialNullable<gql.IrisAppProxyFetchMutation>) => import("@apollo/client/testing").MockedResponse<gql.IrisAppProxyFetchMutation, Record<string, any>> & {
+    data: gql.IrisAppProxyFetchMutation;
+};

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./schema";
+export * from "./useProxy";

package/src/schema.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+/**
+ * Schema for HTTP headers
+ *
+ * @property {string} name - The name of the header
+ * @property {string} value - The value of the header
+ */
+export declare const headerSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    value: string;
+}, {
+    name: string;
+    value: string;
+}>;
+export type HeaderSchema = z.infer<typeof headerSchema>;
+/**
+ * Schema for API call parameters
+ *
+ * @property {string} url - The URL for the API call (must be a valid URL)
+ * @property {('GET'|'POST'|'PUT'|'PATCH'|'DELETE')} method - The HTTP method for the API call
+ * @property {HeaderSchema[]} headers - An array of headers for the API call
+ * @property {string} [body] - Optional body content for the API call
+ */
+export declare const irisAppProxySchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
+    headers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        value: string;
+    }, {
+        name: string;
+        value: string;
+    }>, "many">;
+    body: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers: {
+        name: string;
+        value: string;
+    }[];
+    body?: string | undefined;
+}, {
+    url: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers: {
+        name: string;
+        value: string;
+    }[];
+    body?: string | undefined;
+}>;
+export type IrisAppProxyRequestOptions = z.infer<typeof irisAppProxySchema>;
+export type IrisAppProxyMethod = IrisAppProxyRequestOptions["method"];

package/src/useProxy.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { IrisAppProxyRequestOptions } from "./schema";
+export interface UseIrisAppProxyProps<R> {
+    requestOptions: IrisAppProxyRequestOptions;
+    responseSchema: z.ZodType<R>;
+    onSuccess?: (data: R) => void;
+    onError?: (error: {
+        name: string;
+        message: string;
+    }) => void;
+}
+export interface ProxyError {
+    name: string;
+    message: string;
+}
+/**
+ * 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}}` }
+ *
+ * @param props - The properties for useIrisAppProxy hook.
+ * @returns An object containing chatbot state and functions.
+ */
+export declare const useIrisAppProxy: <R>(props: UseIrisAppProxyProps<R>) => {
+    data: R | null;
+    mutate: (request?: IrisAppProxyRequestOptions) => Promise<{
+        data?: R | undefined;
+        error?: ProxyError;
+    } | undefined>;
+    loading: boolean;
+    error: ProxyError | null;
+    irisXProxyFetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response | undefined>;
+};

package/src/utils.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { ProxyError } from "./useProxy";
+/**
+ * Validates and parses the response body.
+ *
+ * @template T - The type inferred from the response schema.
+ * @param {string} responseBody - The base64-encoded response body from the API.
+ * @param {z.ZodType<T>} responseSchema - The Zod schema used to validate and parse the response data.
+ * @returns {T | null} The parsed and validated response data of type `T`, or `null` if validation fails.
+ */
+export declare const validateAndParseResponse: <T>(responseBody: string, responseSchema: z.ZodType<T>) => {
+    data?: T;
+    error?: ProxyError;
+};
+/**
+ * Encodes the given request body as a base64 string.
+ *
+ * @template R - The type of the request body.
+ * @param {R} body - The request body to be encoded.
+ * @returns {string} The base64-encoded string representation of the request body.
+ */
+export declare const parseRequestBodyToBase64: <R>(body: R) => string;