shogun-core 0.0.1

package/dist/gun/auth.js

@@ -0,0 +1,523 @@
+/**
+ * Modulo di autenticazione OAuth per GunDB
+ *
+ * Implementa un sistema di autenticazione minimale ma completo
+ * compatibile con GunDB e il suo sistema SEA (Security, Encryption, Authorization).
+ *
+ * Fornisce funzionalità essenziali come:
+ * - Creazione di utenti
+ * - Login/Logout
+ * - Gestione delle sessioni
+ * - Recupero delle informazioni utente
+ * - Modifica delle credenziali
+ */
+import { logDebug, logWarning } from "../utils/logger";
+/**
+ * Errori specifici per l'autenticazione
+ */
+export class AuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AuthError";
+    }
+}
+export class InvalidCredentials extends AuthError {
+    constructor(message = "Credenziali non valide") {
+        super(message);
+        this.name = "InvalidCredentials";
+    }
+}
+export class UserExists extends AuthError {
+    constructor(message = "Utente già esistente") {
+        super(message);
+        this.name = "UserExists";
+    }
+}
+export class TimeoutError extends AuthError {
+    constructor(message = "Operazione scaduta") {
+        super(message);
+        this.name = "TimeoutError";
+    }
+}
+export class MultipleAuthError extends AuthError {
+    constructor(message = "Operazione di autenticazione già in corso") {
+        super(message);
+        this.name = "MultipleAuthError";
+    }
+}
+/**
+ * Utilità per verificare se si è in un ambiente web
+ */
+const isPlatformWeb = () => {
+    return typeof window !== "undefined";
+};
+/**
+ * Attende il completamento di una promessa con timeout
+ */
+async function timeoutAfter(promise, ms, error) {
+    if (ms <= 0)
+        return promise;
+    const timeout = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(error || new TimeoutError());
+        }, ms);
+    });
+    return Promise.race([promise, timeout]);
+}
+/**
+ * Core di autenticazione GUN
+ * Gestisce le operazioni di autenticazione a basso livello con GUN
+ */
+export class GunAuthCore {
+    /**
+     * @param gun - Istanza GUN di riferimento
+     */
+    constructor(gun) {
+        /** Flag per indicare se è iscritto agli eventi di autenticazione */
+        this._subscribed = false;
+        /** Callback di autenticazione */
+        this._authCallbacks = [];
+        this.gun = gun;
+    }
+    /**
+     * Ottiene l'istanza predefinita di GunAuthCore
+     * @param gun - Istanza GUN opzionale
+     * @returns Istanza predefinita di GunAuthCore
+     */
+    static default(gun) {
+        if (!GunAuthCore._default) {
+            if (!gun && !GunAuthCore.defaultGun) {
+                throw new Error("Nessuna istanza GUN disponibile");
+            }
+            GunAuthCore._default = new GunAuthCore(gun || GunAuthCore.defaultGun);
+        }
+        return GunAuthCore._default;
+    }
+    /**
+     * Reimposta l'istanza predefinita
+     */
+    static resetDefault() {
+        GunAuthCore._default = undefined;
+    }
+    /**
+     * Effettua il logout dell'utente corrente
+     */
+    logout() {
+        const user = this.gun.user();
+        if (user && typeof user.leave === "function") {
+            user.leave();
+        }
+        this._authPromise = undefined;
+        if (this.delegate && typeof this.delegate.onLogout === 'function') {
+            this.delegate.onLogout();
+        }
+        logDebug("Utente disconnesso con successo");
+    }
+    /**
+     * Ottiene l'utente correntemente autenticato
+     */
+    user() {
+        const user = this.gun.user();
+        // Accesso alla proprietà 'is' attraverso cast
+        const is = user.is;
+        if (!is)
+            return undefined;
+        return user;
+    }
+    /**
+     * Ottiene la chiave pubblica dell'utente corrente
+     */
+    pub() {
+        // Accesso alla proprietà '_' attraverso cast
+        return this.user()?._?.sea?.pub;
+    }
+    /**
+     * Ottiene la coppia di chiavi dell'utente corrente
+     */
+    pair() {
+        // Accesso alla proprietà '_' attraverso cast
+        return this.user()?._?.sea;
+    }
+    /**
+     * Crea un nuovo utente
+     * @param creds Credenziali utente
+     * @param options Opzioni aggiuntive
+     */
+    async create(creds, options = {}) {
+        return this._executeAuthOperation(() => this._createUser(creds, options));
+    }
+    /**
+     * Effettua il login di un utente
+     * @param creds Credenziali utente o coppia di chiavi
+     * @param options Opzioni aggiuntive
+     */
+    async login(creds, options = {}) {
+        return this._executeAuthOperation(() => this._loginUser(creds, options));
+    }
+    /**
+     * Verifica se un utente esiste
+     * @param alias Nome utente da verificare
+     * @param options Opzioni aggiuntive
+     */
+    async exists(alias, options = {}) {
+        const pub = await this.getPub(alias, options);
+        return !!pub;
+    }
+    /**
+     * Ottiene la chiave pubblica associata a un nome utente
+     * @param alias Nome utente
+     * @param options Opzioni aggiuntive
+     */
+    async getPub(alias, options = {}) {
+        const { timeout = GunAuthCore.defaultExistsTimeout } = options;
+        const user = this.gun.user();
+        return new Promise((resolve, reject) => {
+            let resolved = false;
+            let timer = null;
+            const callback = (at) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                try {
+                    if (!at) {
+                        if (timer) {
+                            clearTimeout(timer);
+                            timer = null;
+                        }
+                        return resolve(undefined);
+                    }
+                    const pubs = Object.values(at);
+                    if (!pubs.length) {
+                        return resolve(undefined);
+                    }
+                    if (timer) {
+                        clearTimeout(timer);
+                        timer = null;
+                    }
+                    resolve(pubs[0]);
+                }
+                catch (err) {
+                    reject(err instanceof Error ? err : new Error("Errore nel recupero della chiave pubblica"));
+                }
+            };
+            user.get("~@" + alias).once(callback);
+            if (timeout > 0) {
+                timer = setTimeout(() => {
+                    if (!resolved) {
+                        resolved = true;
+                        resolve(undefined);
+                    }
+                }, timeout);
+            }
+        });
+    }
+    /**
+     * Recupera un utente precedentemente autenticato dalla sessione
+     * @param options Opzioni aggiuntive
+     */
+    async recall(options = {}) {
+        return this._executeAuthOperation(() => this._recallSession(options));
+    }
+    /**
+     * Si sottoscrive agli eventi di autenticazione
+     * @param callback Funzione da chiamare quando l'utente viene autenticato
+     */
+    async on(callback) {
+        if (callback) {
+            this._addAuthCallback(callback);
+        }
+        if (this._authPromise) {
+            return this._authPromise;
+        }
+        return this._executeAuthOperation(() => this._handleAuthEvent());
+    }
+    /**
+     * Cambia la password di un utente
+     * @param creds Credenziali con la nuova password
+     * @param options Opzioni aggiuntive
+     */
+    async changePassword(creds, options = {}) {
+        return this._executeAuthOperation(() => this._createUser(creds, { ...options, changePass: true }));
+    }
+    /**
+     * Elimina un utente
+     * @param creds Credenziali dell'utente
+     * @param options Opzioni aggiuntive
+     */
+    async delete(creds, options = {}) {
+        return this._executeAuthOperation(() => this._deleteUser(creds, options));
+    }
+    /**
+     * Implementazione interna per la creazione di un utente
+     */
+    async _createUser({ alias, pass, newPass }, options) {
+        const { timeout = GunAuthCore.defaultTimeout, existsTimeout = GunAuthCore.defaultExistsTimeout } = options;
+        // Verifica se l'utente esiste già
+        if (alias) {
+            const exists = await this.exists(alias, { timeout: existsTimeout });
+            if (exists && !options.changePass) {
+                throw new UserExists();
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const createOp = (callback) => {
+                try {
+                    if (newPass && options.changePass) {
+                        // Cambio password: dobbiamo fare un cast a any per evitare errori di tipo
+                        const userRef = this.gun.user();
+                        userRef.auth(alias, pass, (ack) => {
+                            if (ack.err) {
+                                return callback({ err: ack.err });
+                            }
+                            // Una volta autenticati, cambiamo la password
+                            // Il secondo argomento è la nuova password, non è un callback
+                            userRef.auth(newPass, (ack) => {
+                                callback(ack);
+                            });
+                        });
+                    }
+                    else {
+                        // Creazione utente standard
+                        this.gun.user().create(alias, pass, callback);
+                    }
+                }
+                catch (err) {
+                    callback({ err: err instanceof Error ? err.message : String(err) });
+                }
+            };
+            try {
+                createOp((ack) => {
+                    if (ack.err) {
+                        return reject(this._parseGunError(ack.err));
+                    }
+                    // Utilizziamo un cast a any per accedere alla proprietà is
+                    const userRef = this.gun.user();
+                    const pub = ack.pub || (userRef.is?.pub);
+                    if (!pub) {
+                        return reject(new AuthError("Impossibile ottenere la chiave pubblica"));
+                    }
+                    // Se richiesto, memorizziamo la coppia di chiavi
+                    if (options.storePair && this.delegate?.storePair) {
+                        const pair = this.pair();
+                        if (pair) {
+                            this.delegate.storePair(this, pair).catch(err => {
+                                logWarning("Errore durante il salvataggio delle chiavi: " + err.message);
+                            });
+                        }
+                    }
+                    resolve(pub);
+                });
+            }
+            catch (err) {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    /**
+     * Implementazione interna per il login di un utente
+     */
+    async _loginUser(creds, options) {
+        const { timeout = GunAuthCore.defaultTimeout } = options;
+        const loginPromise = new Promise((resolve, reject) => {
+            try {
+                // Determina se stiamo usando credenziali o una coppia di chiavi
+                const isPair = 'pub' in creds && 'priv' in creds && !('alias' in creds);
+                const authCallback = (ack) => {
+                    if (ack.err) {
+                        reject(this._parseGunError(ack.err));
+                    }
+                    else {
+                        const pub = ack.sea?.pub || this.pub();
+                        if (!pub) {
+                            reject(new AuthError("Login riuscito ma impossibile ottenere la chiave pubblica"));
+                        }
+                        else {
+                            resolve(pub);
+                        }
+                    }
+                };
+                if (isPair) {
+                    this.gun.user().auth(creds, authCallback);
+                }
+                else {
+                    const { alias, pass } = creds;
+                    this.gun.user().auth(alias, pass, authCallback);
+                }
+            }
+            catch (err) {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+        return timeout > 0 ? timeoutAfter(loginPromise, timeout) : loginPromise;
+    }
+    /**
+     * Implementazione interna per l'eliminazione di un utente
+     */
+    async _deleteUser({ alias, pass }, options) {
+        const { timeout = GunAuthCore.defaultTimeout } = options;
+        return new Promise((resolve, reject) => {
+            try {
+                this.gun.user().delete(alias, pass, (ack) => {
+                    if (ack.err) {
+                        reject(this._parseGunError(ack.err));
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+            catch (err) {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    /**
+     * Implementazione interna per il recupero della sessione
+     */
+    async _recallSession(options) {
+        const { timeout = GunAuthCore.defaultTimeout } = options;
+        // Se il delegato può recuperare la coppia di chiavi
+        if (this.delegate?.recallPair) {
+            const pair = await this.delegate.recallPair(this, options);
+            if (pair) {
+                // Autentica con la coppia di chiavi
+                return await this.login(pair, options);
+            }
+        }
+        // Altrimenti prova a recuperare la sessione dal browser
+        if (isPlatformWeb()) {
+            const recallAction = new Promise((resolve, reject) => {
+                try {
+                    this.gun.user().recall({ sessionStorage: true }, (ack) => {
+                        if (ack.err) {
+                            reject(this._parseGunError(ack.err));
+                        }
+                        else if (ack.sea) {
+                            resolve(ack.sea.pub);
+                        }
+                        else {
+                            resolve(undefined);
+                        }
+                    });
+                }
+                catch (err) {
+                    reject(err instanceof Error ? err : new Error(String(err)));
+                }
+            });
+            return timeout > 0 ?
+                timeoutAfter(recallAction, timeout, new TimeoutError("Timeout durante il recupero della sessione")) :
+                recallAction;
+        }
+        return undefined;
+    }
+    /**
+     * Gestisce gli eventi di autenticazione
+     */
+    async _handleAuthEvent() {
+        if (!this._subscribed) {
+            this._subscribeToAuthEvents();
+        }
+        // Se siamo già autenticati, restituisci subito la chiave pubblica
+        const currentPub = this.pub();
+        if (currentPub) {
+            return Promise.resolve(currentPub);
+        }
+        // Altrimenti crea una nuova promise che verrà risolta quando l'autenticazione avviene
+        return new Promise((resolve) => {
+            this._beginAuthPromise(resolve);
+        });
+    }
+    /**
+     * Si sottoscrive agli eventi di autenticazione
+     */
+    _subscribeToAuthEvents() {
+        if (this._subscribed)
+            return;
+        // Callback interno che risolve la promise di autenticazione
+        const callback = () => this._completeAuthPromise();
+        // Sottoscrizione all'evento 'auth' di GUN
+        this.gun.on('auth', callback);
+        this._subscribed = true;
+    }
+    /**
+     * Aggiunge un callback agli eventi di autenticazione
+     */
+    _addAuthCallback(callback) {
+        this._authCallbacks.push(callback);
+        // Se siamo già autenticati, esegui subito il callback
+        if (this.pub()) {
+            setTimeout(callback, 0);
+        }
+    }
+    /**
+     * Inizializza la promise di autenticazione
+     */
+    _beginAuthPromise(resolver) {
+        this._authResolver = resolver;
+    }
+    /**
+     * Completa la promise di autenticazione
+     */
+    _completeAuthPromise(pub) {
+        if (this._authResolver) {
+            const actualPub = pub || this.pub();
+            if (actualPub) {
+                this._authResolver(actualPub);
+            }
+            else {
+                this._authResolver("");
+            }
+        }
+        this._authResolver = undefined;
+        this._authPromise = undefined;
+        // Se disponiamo di un delegato, salviamo la coppia di chiavi
+        if (pub) {
+            if (this.delegate && typeof this.delegate.storePair === "function") {
+                const pair = this.pair();
+                if (pair) {
+                    this.delegate.storePair(this, pair);
+                }
+            }
+        }
+        // Esegui tutti i callback di autenticazione
+        this._authCallbacks.forEach(cb => setTimeout(cb, 0));
+    }
+    /**
+     * Esegue un'operazione di autenticazione, impedendo operazioni simultanee
+     */
+    async _executeAuthOperation(operation) {
+        if (this._authOperation) {
+            throw new MultipleAuthError();
+        }
+        try {
+            const promise = operation();
+            this._authOperation = promise;
+            return await promise;
+        }
+        finally {
+            this._authOperation = undefined;
+            this._completeAuthPromise();
+        }
+    }
+    /**
+     * Converte gli errori di GUN in errori tipizzati
+     */
+    _parseGunError(error) {
+        switch (error) {
+            case "User already created!":
+                return new UserExists(error);
+            case "Wrong user or password.":
+                return new InvalidCredentials(error);
+            case "User is already being created or authenticated!":
+                return new MultipleAuthError(error);
+            default:
+                return new AuthError(error);
+        }
+    }
+}
+/** Timeout predefinito per le operazioni di autenticazione */
+GunAuthCore.defaultTimeout = 10000;
+/** Timeout predefinito per verificare l'esistenza di un utente */
+GunAuthCore.defaultExistsTimeout = 3000;
+// Per compatibilità retroattiva, manteniamo un alias
+export const Auth = GunAuthCore;

package/dist/gun/errors.js

@@ -0,0 +1,66 @@
+/**
+ * Classi di errore per Gun e Auth
+ */
+/**
+ * Errore di base per Gun
+ */
+export class GunError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GunError';
+    }
+}
+/**
+ * Errore di autenticazione generico
+ */
+export class AuthError extends GunError {
+    constructor(message) {
+        super(message);
+        this.name = 'AuthError';
+    }
+}
+/**
+ * Errore di credenziali non valide
+ */
+export class InvalidCredentials extends AuthError {
+    constructor(message = 'Credenziali non valide') {
+        super(message);
+        this.name = 'InvalidCredentials';
+    }
+}
+/**
+ * Errore di utente già esistente
+ */
+export class UserExists extends AuthError {
+    constructor(message = 'Utente già esistente') {
+        super(message);
+        this.name = 'UserExists';
+    }
+}
+/**
+ * Errore di timeout
+ */
+export class TimeoutError extends GunError {
+    constructor(message = 'Timeout durante l\'operazione') {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+/**
+ * Errore di multiple autenticazioni
+ */
+export class MultipleAuthError extends AuthError {
+    constructor(message = 'Autenticazione multipla in corso') {
+        super(message);
+        this.name = 'MultipleAuthError';
+    }
+}
+/** Base error related to the network. */
+export class NetworkError extends GunError {
+}
+const withDefaultMessage = (args, defaultMessage) => {
+    if (args.length === 0 || args.length === 1 && !args[0]) {
+        args = [defaultMessage];
+    }
+    return args;
+};