data-primals-engine 1.3.4 → 1.4.1

package/src/modules/auth-google/index.js

@@ -0,0 +1,51 @@
+import { Strategy as GoogleStrategy } from 'passport-google-oauth20';
+import { Sso, SSOUserProvider } from '../../sso.js';
+import {Logger} from "../../gameObject.js";
+
+let logger;
+
+export async function onInit(engine) {
+    logger = engine.getComponent(Logger);
+
+    // Le SSOUserProvider est nécessaire pour l'initialisation et pour la stratégie.
+    // On le crée donc en premier.
+    const ssoUserProvider = new SSOUserProvider(engine);
+
+    // 1. Récupérer le composant PassportAuth central.
+    let passportAuth = engine.getComponent(Sso);
+    if (!passportAuth) {
+        passportAuth = engine.addComponent(Sso);
+        // C'EST ICI QUE L'INITIALISATION DOIT AVOIR LIEU, UNE SEULE FOIS.
+        passportAuth.initialize({ ssoUserProvider });
+        passportAuth.addLogoutRoute();
+        logger.info("[auth-google] Sso component was not found, created and initialized a new one.");
+    }
+
+    // 2. Vérifier que les variables d'environnement nécessaires sont présentes.
+    if (!process.env.GOOGLE_CLIENT_ID || !process.env.GOOGLE_CLIENT_SECRET) {
+        logger.warn("[auth-google] GOOGLE_CLIENT_ID or GOOGLE_CLIENT_SECRET are not set. Google SSO will be disabled.");
+        return;
+    }
+
+    // 3. Créer l'instance de la stratégie Google.
+    const googleStrategy = new GoogleStrategy({
+        clientID: process.env.GOOGLE_CLIENT_ID,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        callbackURL: "/api/auth/google/callback"
+    },
+    async (accessToken, refreshToken, profile, done) => {
+        try {
+            // On utilise le SSOUserProvider pour trouver ou créer l'utilisateur.
+            const user = await ssoUserProvider.findOrCreate(profile);
+            return done(null, user);
+        } catch (err) {
+            return done(err);
+        }
+    });
+
+    // 4. Enregistrer la stratégie auprès du composant PassportAuth.
+    passportAuth.addStrategy('google', googleStrategy,
+        { authPath: '/api/auth/google', callbackPath: '/api/auth/google/callback' },
+        { scope: ['profile', 'email'] }
+    );
+}

package/src/modules/auth-microsoft/index.js

@@ -0,0 +1,82 @@
+import { Sso, SSOUserProvider } from '../../sso.js';
+import { Logger } from "../../gameObject.js";
+
+let logger;
+
+export async function onInit(engine) {
+    logger = engine.getComponent(Logger);
+
+    try {
+        // 1. Tenter d'importer dynamiquement la stratégie Azure AD.
+        // L'utilisateur devra exécuter `npm install passport-azure-ad`.
+        const { OIDCStrategy } = await import('passport-azure-ad');
+
+        const ssoUserProvider = new SSOUserProvider(engine);
+
+        // 2. Récupérer ou créer le composant SSO central.
+        let ssoComponent = engine.getComponent(Sso);
+        if (!ssoComponent) {
+            ssoComponent = engine.addComponent(Sso);
+            ssoComponent.initialize({ ssoUserProvider });
+            ssoComponent.addLogoutRoute();
+            logger.info("[auth-microsoft] Sso component was not found, created and initialized a new one.");
+        }
+
+        // 3. Vérifier les variables d'environnement critiques pour Azure AD.
+        const { MICROSOFT_CLIENT_ID, MICROSOFT_CLIENT_SECRET, MICROSOFT_TENANT_ID } = process.env;
+        if (!MICROSOFT_CLIENT_ID || !MICROSOFT_CLIENT_SECRET || !MICROSOFT_TENANT_ID) {
+            logger.warn("[auth-microsoft] Microsoft environment variables are not fully set. Microsoft SSO will be disabled.");
+            return;
+        }
+
+        const callbackUrl = process.env.MICROSOFT_CALLBACK_URL || '/api/auth/microsoft/callback';
+
+        // 4. Créer l'instance de la stratégie OIDC pour Microsoft.
+        const microsoftStrategy = new OIDCStrategy({
+            identityMetadata: `https://login.microsoftonline.com/${MICROSOFT_TENANT_ID}/v2.0/.well-known/openid-configuration`,
+            clientID: MICROSOFT_CLIENT_ID,
+            responseType: 'code id_token',
+            responseMode: 'form_post',
+            redirectUrl: callbackUrl,
+            allowHttpForRedirectUrl: process.env.NODE_ENV !== 'production',
+            clientSecret: MICROSOFT_CLIENT_SECRET,
+            validateIssuer: false, // Important pour les tenants multiples
+            passReqToCallback: false,
+            scope: ['profile', 'email', 'openid']
+        },
+        async (iss, sub, profile, accessToken, refreshToken, done) => {
+            try {
+                // Le profil Azure AD est différent. On l'adapte à notre format standard.
+                const email = profile.upn || profile._json.email;
+                if (!email) {
+                    return done(new Error("Microsoft profile is missing an email (upn)."));
+                }
+
+                const adaptedProfile = {
+                    provider: 'azuread',
+                    id: profile.oid, // Object ID de l'utilisateur dans Azure
+                    displayName: profile.displayName,
+                    emails: [{ value: email }]
+                };
+
+                const user = await ssoUserProvider.findOrCreate(adaptedProfile);
+                return done(null, user);
+            } catch (err) {
+                return done(err);
+            }
+        });
+
+        // 5. Enregistrer la stratégie auprès du composant SSO.
+        ssoComponent.addStrategy('azuread-openidconnect', microsoftStrategy, {
+            authPath: '/api/auth/microsoft',
+            callbackPath: callbackUrl
+        });
+
+    } catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND') {
+            logger.info("[auth-microsoft] Module désactivé. Pour l'activer, exécutez 'npm install passport-azure-ad'");
+        } else {
+            logger.error("[auth-microsoft] Une erreur inattendue a empêché le chargement du module :", e);
+        }
+    }
+}

package/src/modules/auth-saml/index.js

@@ -0,0 +1,90 @@
+import { Sso, SSOUserProvider } from '../../sso.js';
+import { Logger } from "../../gameObject.js";
+
+let logger;
+
+export async function onInit(engine) {
+    logger = engine.getComponent(Logger);
+
+    try {
+        // 1. Tenter d'importer dynamiquement la stratégie SAML.
+        // Cela ne fonctionnera que si l'utilisateur a exécuté `npm install passport-saml-encrypted`.
+        const { Strategy: SamlStrategy } = await import('passport-saml-encrypted');
+
+        const ssoUserProvider = new SSOUserProvider(engine);
+
+        // 2. Récupérer le composant SSO central.
+        let ssoComponent = engine.getComponent(Sso);
+        if (!ssoComponent) {
+            // S'il n'existe pas, on l'ajoute. C'est le premier module SSO à se charger.
+            ssoComponent = engine.addComponent(Sso);
+            ssoComponent.initialize({ ssoUserProvider });
+            ssoComponent.addLogoutRoute();
+            logger.info("[auth-saml] Sso component was not found, created and initialized a new one.");
+        }
+
+        // 3. Vérifier les variables d'environnement critiques pour SAML.
+        const { SAML_ENTRY_POINT, SAML_ISSUER, SAML_CERT, SAML_CALLBACK_URL, SAML_DECRYPTION_KEY } = process.env;
+        if (!SAML_ENTRY_POINT || !SAML_ISSUER || !SAML_CERT || !SAML_DECRYPTION_KEY) {
+            logger.warn("[auth-saml] SAML environment variables (SAML_ENTRY_POINT, SAML_ISSUER, SAML_CERT, SAML_DECRYPTION_KEY) are not fully set. SAML SSO will be disabled.");
+            return;
+        }
+
+        const callbackUrl = SAML_CALLBACK_URL || '/api/auth/saml/callback';
+
+        // 4. Créer l'instance de la stratégie SAML.
+        // La configuration SAML est plus complexe que OAuth2.
+        const samlStrategy = new SamlStrategy(
+            {
+                path: callbackUrl, // Le chemin où l'IdP (Identity Provider) enverra la réponse POST.
+                entryPoint: SAML_ENTRY_POINT, // L'URL de connexion de l'IdP.
+                issuer: SAML_ISSUER, // L'identifiant de votre application (Service Provider).
+                cert: SAML_CERT, // Le certificat public de l'IdP pour vérifier la signature.
+                decryptionPvk: SAML_DECRYPTION_KEY, // Clé privée pour déchiffrer les assertions.
+                encryptedSAML: true, // Indique que nous attendons des assertions chiffrées.
+                acceptedClockSkewMs: -1 // Optionnel mais recommandé: pour les problèmes de synchronisation d'horloge.
+            },
+            async (profile, done) => {
+                try {
+                    // Normaliser les clés du profil en minuscules pour une correspondance insensible à la casse.
+                    const normalizedProfile = Object.keys(profile).reduce((acc, key) => {
+                        acc[key.toLowerCase()] = profile[key];
+                        return acc;
+                    }, {});
+
+                    // Le profil SAML est différent du profil Google. Nous devons l'adapter.
+                    // `nameID` est souvent l'email. Les autres attributs dépendent de la configuration de l'IdP.
+                    const email = normalizedProfile.email || normalizedProfile.nameid;
+                    if (!email) {
+                        return done(new Error("SAML profile is missing an email or nameID."));
+                    }
+
+                    const adaptedProfile = {
+                        provider: 'saml',
+                        id: normalizedProfile.nameid,
+                        displayName: normalizedProfile.displayname || normalizedProfile.cn || `${normalizedProfile.firstname || ''} ${normalizedProfile.lastname || ''}`.trim() || email,
+                        emails: [{ value: email }]
+                    };
+
+                    const user = await ssoUserProvider.findOrCreate(adaptedProfile);
+                    return done(null, user);
+                } catch (err) {
+                    return done(err);
+                }
+            }
+        );
+
+        // 5. Enregistrer la stratégie auprès du composant SSO.
+        ssoComponent.addStrategy('saml', samlStrategy, {
+            authPath: '/api/auth/saml',
+            callbackPath: callbackUrl
+        });
+
+    } catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND') {
+            logger.info("[auth-saml] Module désactivé. Pour l'activer, exécutez 'npm install passport-saml-encrypted'");
+        } else {
+            logger.error("[auth-saml] Une erreur inattendue a empêché le chargement du module :", e);
+        }
+    }
+}

package/src/modules/data/data.core.js

@@ -1,8 +1,12 @@
 import NodeCache from "node-cache";
 import path from "node:path";
 import {Worker} from 'worker_threads';
+import {fileURLToPath} from "node:url";
 export const modelsCache = new NodeCache( { stdTTL: 100, checkperiod: 120 } );
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 export const mongoDBWhitelist = [
     "$$NOW", "$in", "$eq", "$gt", "$gte", "$in", "$lt", "$lte", "$ne", "$nin", "$type", "$size",
     "$and", "$not", "$nor", "$or", "$regexMatch", "$find", "$elemMatch", "$filter", "$toString", "$toObjectId",
@@ -60,7 +64,7 @@ export function runImportExportWorker(action, payload) {
  */
 export function runCryptoWorkerTask(action, payload) {
     return new Promise((resolve, reject) => {
-        const workerPath = path.resolve(process.cwd(), './src/workers/crypto-worker.js');
+        const workerPath = path.resolve(__dirname, '../../workers/crypto-worker.js');
         const worker = new Worker(workerPath);
 
         worker.postMessage({ action, payload });