@enterprisestandard/react 0.0.3-beta.2 → 0.0.3-beta.20251014.1

package/dist/index.d.ts

@@ -12,7 +12,6 @@ export type EnterpriseStandard = {
 type ESConfig = {
     ioniteUrl?: string;
     defaultInstance?: boolean;
-    ssoUserUrl?: string;
 };
 export declare function enterpriseStandard(appId: string, appKey?: string, initConfig?: ESConfig): Promise<EnterpriseStandard>;
 export type * from './enterprise-user';

package/dist/index.js

@@ -34,10 +34,10 @@ var jwksCache = new Map;
 function sso(config) {
   const configWithDefaults = {
     ...config,
-    secure: config.secure !== undefined ? config.secure : false,
-    sameSite: config.sameSite !== undefined ? config.sameSite : "Lax",
-    cookiePrefix: config.cookiePrefix ?? `es.sso.${config.client_id}`,
-    cookiePath: config.cookiePath ?? "/"
+    cookies_secure: config.cookies_secure !== undefined ? config.cookies_secure : true,
+    cookies_same_site: config.cookies_same_site !== undefined ? config.cookies_same_site : "Strict",
+    cookies_prefix: config.cookies_prefix ?? `es.sso.${config.client_id}`,
+    cookies_path: config.cookies_path ?? "/"
   };
   async function getUser(request) {
     if (!configWithDefaults) {
@@ -45,10 +45,10 @@ function sso(config) {
       return;
     }
     try {
-      const token = await getTokenFromCookies(request);
-      if (!token)
+      const { tokens } = await getTokenFromCookies(request);
+      if (!tokens)
         return;
-      return await parseUser(token);
+      return await parseUser(tokens);
     } catch (error) {
       console.error("Error parsing user from cookies:", error);
       return;
@@ -334,7 +334,7 @@ function sso(config) {
     const refresh_token = getCookie("refresh", req);
     const control = getCookie("control", req, true);
     if (!access_token || !id_token || !refresh_token || !control) {
-      return;
+      return { tokens: undefined, refreshHeaders: [] };
     }
     let tokenResponse = {
       access_token,
@@ -344,17 +344,20 @@ function sso(config) {
     };
     if (control.expires && refresh_token && Date.now() > new Date(control.expires).getTime()) {
       tokenResponse = await refreshToken(refresh_token);
+      const user = await parseUser(tokenResponse);
+      const refreshHeaders = createJwtCookies(tokenResponse, user.sso.expires);
+      return { tokens: tokenResponse, refreshHeaders };
     }
-    return tokenResponse;
+    return { tokens: tokenResponse, refreshHeaders: [] };
   }
   async function getJwt(request) {
-    const tokenResponse = await getTokenFromCookies(request);
-    if (!tokenResponse)
+    const { tokens } = await getTokenFromCookies(request);
+    if (!tokens)
       return;
-    return tokenResponse.access_token;
+    return tokens.access_token;
   }
   function createCookie(name, value, expires) {
-    name = `${configWithDefaults.cookiePrefix}.${name}`;
+    name = `${configWithDefaults.cookies_prefix}.${name}`;
     if (typeof value !== "string") {
       value = btoa(JSON.stringify(value));
     }
@@ -369,16 +372,16 @@ function sso(config) {
     if (value.length > 4000) {
       throw new Error(`Error setting cookie: ${name}. Cookie length is: ${value.length}`);
     }
-    return `${name}=${value}; ${exp}; Path=${configWithDefaults.cookiePath}; HttpOnly;${configWithDefaults.secure ? " Secure;" : ""} SameSite=${configWithDefaults.sameSite};`;
+    return `${name}=${value}; ${exp}; Path=${configWithDefaults.cookies_path}; HttpOnly;${configWithDefaults.cookies_secure ? " Secure;" : ""} SameSite=${configWithDefaults.cookies_same_site};`;
   }
   function clearCookie(name) {
-    return `${configWithDefaults.cookiePrefix}.${name}=; Max-Age=0; Path=${configWithDefaults.cookiePath}; HttpOnly;${configWithDefaults.secure ? " Secure;" : ""} SameSite=${configWithDefaults.sameSite};`;
+    return `${configWithDefaults.cookies_prefix}.${name}=; Max-Age=0; Path=${configWithDefaults.cookies_path}; HttpOnly;${configWithDefaults.cookies_secure ? " Secure;" : ""} SameSite=${configWithDefaults.cookies_same_site};`;
   }
   function getCookie(name, req, parse = false) {
     const header = req.headers.get("cookie");
     if (!header)
       return null;
-    const cookie = header.split(";").find((row) => row.trim().startsWith(`${configWithDefaults.cookiePrefix}.${name}=`));
+    const cookie = header.split(";").find((row) => row.trim().startsWith(`${configWithDefaults.cookies_prefix}.${name}=`));
     if (!cookie)
       return null;
     const val = cookie.split("=")[1].trim();
@@ -396,32 +399,39 @@ function sso(config) {
       return callbackHandler(request);
     }
     if (userUrl === path) {
-      const user = await getUser(request);
-      if (!user) {
+      const { tokens, refreshHeaders } = await getTokenFromCookies(request);
+      if (!tokens) {
         return new Response("User not logged in", { status: 401 });
       }
+      const user = await parseUser(tokens);
       return new Response(JSON.stringify(user), {
-        headers: [["Content-Type", "application/json"]]
+        headers: [["Content-Type", "application/json"], ...refreshHeaders]
       });
     }
     if (tokenUrl === path) {
-      const tokenResponse = await getTokenFromCookies(request);
-      if (!tokenResponse) {
+      const { tokens, refreshHeaders } = await getTokenFromCookies(request);
+      if (!tokens) {
         return new Response("User not logged in", { status: 401 });
       }
       return new Response(JSON.stringify({
-        token: tokenResponse.access_token,
-        expires: tokenResponse.expires
+        token: tokens.access_token,
+        expires: tokens.expires
       }), {
-        headers: [["Content-Type", "application/json"]]
+        headers: [["Content-Type", "application/json"], ...refreshHeaders]
       });
     }
     if (refreshUrl === path) {
-      const tokenResponse = await getTokenFromCookies(request);
-      if (!tokenResponse) {
+      const refresh_token = getCookie("refresh", request);
+      if (!refresh_token) {
         return new Response("User not logged in", { status: 401 });
       }
-      return new Response("Refresh Complete", { status: 200 });
+      const newTokenResponse = await refreshToken(refresh_token);
+      const user = await parseUser(newTokenResponse);
+      const refreshHeaders = createJwtCookies(newTokenResponse, user.sso.expires);
+      return new Response("Refresh Complete", {
+        status: 200,
+        headers: refreshHeaders
+      });
     }
     if (loginUrl === "*" || loginUrl === path) {
       return initiateLogin({
@@ -442,8 +452,8 @@ function sso(config) {
 }
 
 // src/vault.ts
-function vault(url, token) {
-  async function getFullSecret(path) {
+function vault(url) {
+  async function getFullSecret(path, token) {
     const resp = await fetch(`${url}/${path}`, { headers: { "X-Vault-Token": token } });
     if (resp.status !== 200) {
       throw new Error(`Vault returned invalid status, ${resp.status}: '${resp.statusText}' from URL: ${url}`);
@@ -458,8 +468,8 @@ function vault(url, token) {
   return {
     url,
     getFullSecret,
-    getSecret: async (path) => {
-      return (await getFullSecret(path)).data;
+    getSecret: async (path, token) => {
+      return (await getFullSecret(path, token)).data;
     }
   };
 }
@@ -632,8 +642,8 @@ function SignedIn({ children }) {
 // src/ui/signed-out.tsx
 import { jsxDEV as jsxDEV3, Fragment as Fragment3 } from "react/jsx-dev-runtime";
 function SignedOut({ children }) {
-  const { user } = useUser();
-  if (user)
+  const { user, isLoading } = useUser();
+  if (user || isLoading)
     return null;
   return /* @__PURE__ */ jsxDEV3(Fragment3, {
     children
@@ -870,29 +880,33 @@ function useToken() {
 async function enterpriseStandard(appId, appKey, initConfig) {
   let vaultUrl;
   let vaultToken;
-  let paths;
+  let secrets;
   const ioniteUrl = initConfig?.ioniteUrl ?? "https://ionite.com";
   if (appId === "IONITE_PUBLIC_DEMO") {
     vaultUrl = "https://vault-ionite.ionite.dev/v1/secret/data";
-    vaultToken = "hvs.NuiBSLuFk5Ju4JDOUwTOlSlP";
-    paths = { sso: "ionite/IONITE_PUBLIC_DEMO" };
+    secrets = {
+      sso: {
+        path: "public/IONITE_PUBLIC_DEMO_SSO",
+        token: "hvs.CAESIDGntTzqry6HOySoqAGUMQyfkF4RDj3xas23zhsJC6-uGh4KHGh2cy5mSzZXNHFQRWlZMG9VVnpWSlA1Zk1YeUE"
+      }
+    };
   } else if (appKey) {
     if (!vaultUrl || !vaultToken) {
       throw new Error("TODO something is wrong with the ionite config, handle this error");
     }
-    paths = {};
+    secrets = {};
   } else {
     throw new Error("TODO tell them how to connect to ionite");
   }
   const defaultInstance2 = getDefaultInstance();
-  const vaultClient = await vault(vaultUrl, vaultToken);
+  const vaultClient = await vault(vaultUrl);
   const result = {
     appId,
     ioniteUrl,
     defaultInstance: initConfig?.defaultInstance || initConfig?.defaultInstance !== false && !defaultInstance2,
     vault: vaultClient,
-    sso: paths.sso ? sso(await vaultClient.getSecret(paths.sso)) : undefined,
-    iam: paths.iam ? await iam(await vaultClient.getSecret(paths.iam)) : undefined
+    sso: secrets.sso ? sso(await vaultClient.getSecret(secrets.sso.path, secrets.sso.token)) : undefined,
+    iam: secrets.iam ? await iam(await vaultClient.getSecret(secrets.iam.path, secrets.iam.token)) : undefined
   };
   if (result.defaultInstance) {
     if (defaultInstance2) {

package/dist/sso.d.ts

@@ -10,10 +10,10 @@ export type SSOConfig = {
     post_logout_redirect_uri?: string;
     silent_redirect_uri?: string;
     jwks_uri?: string;
-    cookiePrefix?: string;
-    cookiePath?: string;
-    sameSite?: 'Strict' | 'Lax';
-    secure?: boolean;
+    cookies_prefix?: string;
+    cookies_path?: string;
+    cookies_secure?: boolean;
+    cookies_same_site?: 'Strict' | 'Lax';
 };
 export type ESConfig = {
     es?: EnterpriseStandard;

package/dist/vault.d.ts

@@ -10,8 +10,8 @@ type MetaData = {
 };
 export type Vault = {
     url: string;
-    getFullSecret: <T>(path: string) => Promise<Secret<T>>;
-    getSecret: <T>(path: string) => Promise<T>;
+    getFullSecret: <T>(path: string, token: string) => Promise<Secret<T>>;
+    getSecret: <T>(path: string, token: string) => Promise<T>;
 };
-export declare function vault(url: string, token: string): Vault;
+export declare function vault(url: string): Vault;
 export {};

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@enterprisestandard/react",
-  "version": "0.0.3-beta.2",
+  "version": "0.0.3-beta.20251014.1",
   "description": "Enterprise Standard React Components",
   "private": false,
   "main": "dist/index.js",
   "scripts": {
-    "build": "bun run build.ts",
-    "prepublishOnly": "bun run build"
+    "build": "bun run build.ts"
   },
   "types": "./dist/index.d.ts",
   "exports": {
@@ -30,6 +29,7 @@
     "access": "public"
   },
   "devDependencies": {
+    "@types/react": "^18.0.0",
     "typescript": "^5.0.0"
   },
   "author": "enterprisestandard",