@liorian/sdk 0.28.0-alpha.56010ca

package/src/infrastructure/utilities/sso-auth.util.ts

@@ -0,0 +1,188 @@
+"use client"
+
+import {ApiService} from "./api-service";
+import {AppConfig} from "../../domain/config/app.config";
+import {AuthConfig} from "../../domain/config/auth.config";
+import {AuthUserService} from "../../application/service/auth-user.service";
+import {authUserConnectedStore} from "../stores/auth-user-connected.store";
+
+/**
+ * Client OAuth 2.0 (Authorization Code + PKCE) vers Liorian Auth.
+ *
+ * Utilisé par les applications consommatrices (ex. liorian-socle) pour
+ * s'authentifier via le SSO de `liorian-auth`. Deux modes de déclenchement :
+ *  - fenêtre popup (`startSsoLoginPopup`) — privilégié ;
+ *  - redirection complète (`startSsoLogin`) — solution de repli si le popup est bloqué.
+ *
+ * Les secrets PKCE (`code_verifier`/`state`) sont stockés en `localStorage`
+ * (et non en `sessionStorage`) afin d'être partagés entre l'onglet principal
+ * et le popup de la même origine.
+ */
+
+/** Identifiant OAuth de l'application consommatrice (configurable par application). */
+export const SSO_CLIENT_ID = AuthConfig.sso.clientId;
+export const SSO_SCOPE = 'openid profile email organizations';
+export const SSO_REDIRECT_PATH = AuthConfig.sso.redirectPath;
+
+const SSO_STORAGE = {
+    codeVerifier: 'sso.code_verifier',
+    state: 'sso.state',
+} as const;
+
+/** Type de message posté par le popup de callback vers l'onglet d'origine. */
+export const SSO_CALLBACK_MESSAGE = 'SSO_CALLBACK';
+
+function ssoOrigin(): string {
+    return (AppConfig.AUTH_HOST || 'https://localhost:5050').replace(/\/$/, '');
+}
+
+function randomBase64url(bytes: number): string {
+    const array = new Uint8Array(bytes);
+    crypto.getRandomValues(array);
+    return base64url(array);
+}
+
+function base64url(buffer: ArrayBuffer | Uint8Array): string {
+    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    let binary = '';
+    bytes.forEach((b) => (binary += String.fromCharCode(b)));
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+async function sha256Base64url(input: string): Promise<string> {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
+    return base64url(digest);
+}
+
+/** Construit l'URL d'autorisation vers Liorian Auth (PKCE S256). */
+export async function buildSsoLoginUrl(clientId: string = AuthConfig.sso.clientId): Promise<string> {
+    const codeVerifier = randomBase64url(64);
+    const state = randomBase64url(32);
+    const codeChallenge = await sha256Base64url(codeVerifier);
+    const redirectUri = `${window.location.origin}${SSO_REDIRECT_PATH}`;
+
+    localStorage.setItem(SSO_STORAGE.codeVerifier, codeVerifier);
+    localStorage.setItem(SSO_STORAGE.state, state);
+
+    const url = new URL(`${ssoOrigin()}/auth/sign-in`);
+    url.searchParams.set('response_type', 'code');
+    url.searchParams.set('client_id', clientId);
+    url.searchParams.set('redirect_uri', redirectUri);
+    url.searchParams.set('scope', SSO_SCOPE);
+    url.searchParams.set('state', state);
+    url.searchParams.set('code_challenge', codeChallenge);
+    url.searchParams.set('code_challenge_method', 'S256');
+    return url.toString();
+}
+
+/** Redirige toute la fenêtre vers Liorian Auth. */
+export async function startSsoLogin(clientId?: string): Promise<void> {
+    window.location.assign(await buildSsoLoginUrl(clientId));
+}
+
+/**
+ * Ouvre un popup Liorian Auth pour se connecter.
+ * Retourne la référence de la fenêtre, ou `null` si le popup a été bloqué
+ * (appelant doit alors basculer sur une redirection).
+ */
+export async function startSsoLoginPopup(clientId?: string): Promise<Window | null> {
+    const url = await buildSsoLoginUrl(clientId);
+
+    const width = 480;
+    const height = 720;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2;
+
+    return window.open(
+        url,
+        'liorian-auth',
+        `popup=yes,width=${width},height=${height},left=${left},top=${top},scrollbars=yes,resizable=yes`,
+    );
+}
+
+/** Vrai si la page de callback s'exécute dans un popup ouvert par `startSsoLoginPopup`. */
+export function isSsoCallbackInPopup(): boolean {
+    return typeof window !== 'undefined' && !!window.opener && window.location !== window.opener.location;
+}
+
+/**
+ * Échange le code d'autorisation (callback) contre une session et l'installe.
+ *
+ * En mode popup, le résultat est renvoyé à l'onglet d'origine via `postMessage`
+ * puis le popup est refermé (retourne `false` pour empêcher la navigation).
+ */
+export async function handleSsoCallback(): Promise<boolean> {
+    const params = new URLSearchParams(window.location.search);
+    const code = params.get('code');
+    const state = params.get('state');
+    const error = params.get('error');
+
+    const isPopup = isSsoCallbackInPopup();
+
+    if (error || !code) {
+        if (isPopup) {
+            postResult(window.opener, false);
+            window.close();
+        }
+        return false;
+    }
+
+    try {
+        const storedState = localStorage.getItem(SSO_STORAGE.state);
+        const codeVerifier = localStorage.getItem(SSO_STORAGE.codeVerifier);
+        if (state !== storedState || !codeVerifier) {
+            throw new Error('Le paramètre `state` est invalide (CSRF).');
+        }
+
+        const redirectUri = `${window.location.origin}${SSO_REDIRECT_PATH}`;
+        const response = await ApiService.post('/oauth/token', {
+            grant_type: 'authorization_code',
+            client_id: AuthConfig.sso.clientId,
+            code,
+            redirect_uri: redirectUri,
+            code_verifier: codeVerifier,
+        });
+
+        const authData = response.data?.data;
+        const token = authData?.access_token ?? authData?.token;
+        if (!token || !authData?.user) {
+            throw new Error('Réponse d’échange de jeton invalide.');
+        }
+
+        await AuthUserService.setSession({
+            user: authData.user,
+            token,
+            device: authData.device,
+            organizations: authData.organizations || [],
+        });
+        authUserConnectedStore.getState().setCurrentUser(authData.user);
+        authUserConnectedStore.getState().setOrganizations(authData.organizations || []);
+
+        localStorage.removeItem(SSO_STORAGE.codeVerifier);
+        localStorage.removeItem(SSO_STORAGE.state);
+
+        if (isPopup && window.opener) {
+            postResult(window.opener, true);
+            window.close();
+            return false;
+        }
+
+        return true;
+    } catch (e) {
+        // En mode popup : signaler l'échec à l'onglet d'origine et refermer le popup,
+        // sinon l'écran reste bloqué sur « Finalisation de la connexion… ».
+        if (isPopup && window.opener) {
+            postResult(window.opener, false);
+            window.close();
+            return false;
+        }
+        throw e;
+    }
+}
+
+function postResult(opener: Window, success: boolean): void {
+    opener.postMessage(
+        {source: 'liorian-auth', type: SSO_CALLBACK_MESSAGE, success},
+        window.location.origin,
+    );
+}

package/src/infrastructure/utilities/stringable.util.ts

@@ -0,0 +1,16 @@
+import {IStringablePartialExtended} from "../../domain/typing/values";
+
+
+export function stringableUtil(value: IStringablePartialExtended): string | null {
+    if (!value) return null;
+    switch (typeof value) {
+        case 'object':
+            return JSON.stringify(value);
+        default:
+            return value as string;
+    }
+}
+
+export function isStringable(value: IStringablePartialExtended) {
+    return !!stringableUtil(value)
+}

package/src/infrastructure/utilities/strings.util.ts

@@ -0,0 +1,18 @@
+export function kebabToPascalCase<T extends string>(str: string): T {
+    return str.toString()
+        .split("-")
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join("") as T;
+}
+
+export function camelCase(str: string) {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+
+export function unCamelCase(str: string) { return str.replace(/([A-Z])/g, ' $1').trim(); }
+
+export const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export const toTitleCase = (str: string) => str.replace(/\w\S*/g, txt => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+
+export const capitalizeFirstLetter = (str?: string) => str ? str.charAt(0).toUpperCase() + str.slice(1) : '';

package/src/infrastructure/utilities/tauri.util.ts

@@ -0,0 +1,15 @@
+/**
+ * Detects whether the current execution environment is within a Tauri application window.
+ */
+export function isTauri(): boolean {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return Boolean(
+    (window as any).__TAURI_INTERNALS__ ||
+    (window as any).__TAURI__ ||
+    (window as any).__TAURI_IPC__ ||
+    (window as any).__TAURI_METADATA__ ||
+    (window as any).__TAURI_PATTERN__
+  );
+}

package/src/infrastructure/utilities/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/src/infrastructure/utilities/values.ts

@@ -0,0 +1,5 @@
+export function getNestedValue(obj: Record<string, any>, path: string): any {
+    return path.split('.').reduce((current, key) => {
+        return current?.[key];
+    }, obj);
+}

package/src/presentation/8starlabs-ui/button.tsx

@@ -0,0 +1,94 @@
+import * as React from "react";
+import { Slot, Slottable } from "@radix-ui/react-slot";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "../../infrastructure/utilities/utils";
+
+const buttonVariants = cva(
+  "group/button inline-flex shrink-0 cursor-pointer items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium outline-none transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive:
+          "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+        outline:
+          "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
+        secondary:
+          "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost:
+          "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-9 px-4 py-2 has-[>svg]:px-3",
+        sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
+        lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+        icon: "size-9",
+        "icon-sm": "size-8",
+        "icon-lg": "size-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+
+function ButtonArrow({ className }: { className?: string }) {
+  return (
+    <svg
+      aria-hidden="true"
+      data-slot="button-arrow"
+      fill="none"
+      width="10"
+      height="10"
+      viewBox="0 0 10 10"
+      className={cn(
+        "ml-2 -mr-1 mt-0.5 size-2.5 overflow-visible stroke-current stroke-2",
+        className
+      )}
+    >
+      <path
+        className="opacity-0 transition-opacity group-hover/button:opacity-100 group-focus-visible/button:opacity-100"
+        d="M0 5h7"
+      />
+      <path
+        className="transition-transform group-hover/button:translate-x-[3px] group-focus-visible/button:translate-x-[3px]"
+        d="M1 1l4 4-4 4"
+      />
+    </svg>
+  );
+}
+
+function Button({
+  className,
+  variant,
+  size,
+  asChild = false,
+  withArrow = false,
+  arrowClassName,
+  children,
+  ...props
+}: React.ComponentProps<"button"> &
+  VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+    withArrow?: boolean;
+    arrowClassName?: string;
+  }) {
+  const Comp = asChild ? Slot : "button";
+
+  return (
+    <Comp
+      data-slot="button"
+      className={cn(buttonVariants({ variant, size, className }))}
+      {...props}
+    >
+      <Slottable>{children}</Slottable>
+      {withArrow && <ButtonArrow className={arrowClassName} />}
+    </Comp>
+  );
+}
+
+export { Button, ButtonArrow, buttonVariants };