@thezelijah/majik-message 1.0.0 → 1.0.2

package/dist/core/database/system/majik-user/majik-user.js

@@ -0,0 +1,812 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { arrayBufferToBase64, arrayToBase64, dateToYYYYMMDD, stripUndefined } from './utils';
+import { generateMnemonic, mnemonicToSeedSync } from '@scure/bip39';
+import * as ed25519 from '@stablelib/ed25519';
+import ed2curve from 'ed2curve';
+import { hash } from '@stablelib/sha256';
+import { wordlist } from '@scure/bip39/wordlists/english';
+/**
+ * Base user class for database persistence
+ * Designed to be extended by subclasses with additional metadata
+ */
+export class MajikUser {
+    id;
+    _email;
+    _displayName;
+    _hash;
+    _metadata;
+    _settings;
+    createdAt;
+    _lastUpdate;
+    constructor(data) {
+        this.id = data.id;
+        this._email = data.email;
+        this._displayName = data.displayName;
+        this._hash = data.hash;
+        this._metadata = { ...data.metadata };
+        this._settings = { ...data.settings };
+        this.createdAt = new Date(data.createdAt);
+        this._lastUpdate = new Date(data.lastUpdate);
+    }
+    // ==================== STATIC FACTORY METHODS ====================
+    /**
+     * Initialize a new user with email and display name
+     * Generates a UUID for the id if unset and sets timestamps
+     */
+    static initialize(email, displayName, id) {
+        if (!email) {
+            throw new Error('Email cannot be empty');
+        }
+        if (!displayName) {
+            throw new Error('Display name cannot be empty');
+        }
+        const userID = !id?.trim() ? MajikUser.generateID() : id;
+        const instance = new this({
+            id: userID,
+            email,
+            displayName,
+            hash: MajikUser.hashID(userID),
+            metadata: {
+                verification: {
+                    email_verified: false,
+                    phone_verified: false,
+                    identity_verified: false,
+                },
+            },
+            settings: {
+                notifications: true,
+                system: {
+                    isRestricted: false,
+                },
+            },
+            createdAt: new Date(),
+            lastUpdate: new Date(),
+        });
+        instance.validateEmail(email);
+        return instance;
+    }
+    /**
+     * Deserialize user from JSON object or JSON string
+     */
+    static fromJSON(json) {
+        // Parse string to object if needed
+        const data = typeof json === 'string' ? JSON.parse(json) : json;
+        if (!data.id || typeof data.id !== 'string') {
+            throw new Error('Invalid user data: missing or invalid id');
+        }
+        if (!data.email || typeof data.email !== 'string') {
+            throw new Error('Invalid user data: missing or invalid email');
+        }
+        if (!data.displayName || typeof data.displayName !== 'string') {
+            throw new Error('Invalid user data: missing or invalid displayName');
+        }
+        if (!data.hash || typeof data.hash !== 'string') {
+            throw new Error('Invalid user data: missing or invalid hash');
+        }
+        const userData = {
+            id: data.id,
+            email: data.email,
+            displayName: data.displayName,
+            hash: data.hash,
+            metadata: data.metadata || {},
+            settings: data.settings || {
+                notifications: true,
+                system: {
+                    isRestricted: false,
+                },
+            },
+            createdAt: data.createdAt ? new Date(data.createdAt) : new Date(),
+            lastUpdate: data.lastUpdate ? new Date(data.lastUpdate) : new Date(),
+        };
+        return new this(userData);
+    }
+    /**
+     * Create MajikUser from Supabase User object
+     * Maps Supabase user fields to MajikUser structure
+     */
+    static fromSupabase(supabaseUser) {
+        if (!supabaseUser.id) {
+            throw new Error('Invalid Supabase user: missing id');
+        }
+        if (!supabaseUser.email) {
+            throw new Error('Invalid Supabase user: missing email');
+        }
+        // Extract display name from user_metadata or email
+        const displayName = supabaseUser.user_metadata?.display_name ||
+            supabaseUser.user_metadata?.full_name ||
+            supabaseUser.user_metadata?.name ||
+            supabaseUser.email.split('@')[0];
+        // Map user_metadata to MajikUser metadata
+        const metadata = {
+            verification: {
+                email_verified: !!supabaseUser.email_confirmed_at,
+                phone_verified: !!supabaseUser.phone_confirmed_at,
+                identity_verified: false,
+            },
+        };
+        // Map optional fields from user_metadata if they exist
+        if (supabaseUser.user_metadata) {
+            const userMeta = supabaseUser.user_metadata;
+            // Name mapping
+            if (userMeta.first_name || userMeta.family_name) {
+                metadata.name = {
+                    first_name: userMeta.first_name || '',
+                    last_name: userMeta.family_name || '',
+                    middle_name: userMeta.middle_name,
+                    suffix: userMeta.suffix,
+                };
+            }
+            // Direct field mappings
+            if (userMeta.picture || userMeta.avatar_url) {
+                metadata.picture = userMeta.picture || userMeta.avatar_url;
+            }
+            if (userMeta.bio)
+                metadata.bio = userMeta.bio;
+            if (userMeta.phone)
+                metadata.phone = userMeta.phone;
+            if (userMeta.gender)
+                metadata.gender = userMeta.gender;
+            if (userMeta.birthdate)
+                metadata.birthdate = userMeta.birthdate;
+            if (userMeta.language)
+                metadata.language = userMeta.language;
+            if (userMeta.timezone)
+                metadata.timezone = userMeta.timezone;
+            if (userMeta.pronouns)
+                metadata.pronouns = userMeta.pronouns;
+            // Address mapping
+            if (userMeta.address) {
+                metadata.address = userMeta.address;
+            }
+            // Social links mapping
+            if (userMeta.social_links) {
+                metadata.social_links = userMeta.social_links;
+            }
+            // Company information
+            if (userMeta.company) {
+                metadata.company = userMeta.company;
+            }
+        }
+        // Map app_metadata to settings
+        const settings = {
+            notifications: supabaseUser.app_metadata?.notifications ?? true,
+            system: {
+                isRestricted: supabaseUser.app_metadata?.is_restricted ?? false,
+                restrictedUntil: supabaseUser.app_metadata?.restricted_until ? new Date(supabaseUser.app_metadata.restricted_until) : undefined,
+            },
+        };
+        // Add any additional app_metadata to settings
+        if (supabaseUser.app_metadata) {
+            Object.keys(supabaseUser.app_metadata).forEach((key) => {
+                if (!['notifications', 'is_restricted', 'restricted_until'].includes(key)) {
+                    settings[key] = supabaseUser.app_metadata[key];
+                }
+            });
+        }
+        const userData = {
+            id: supabaseUser.id,
+            email: supabaseUser.email,
+            displayName,
+            hash: MajikUser.hashID(supabaseUser.id),
+            metadata,
+            settings,
+            createdAt: new Date(supabaseUser.created_at),
+            lastUpdate: new Date(supabaseUser.updated_at || supabaseUser.created_at),
+        };
+        return new this(userData);
+    }
+    // ==================== GETTERS ====================
+    get email() {
+        return this._email;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    get hash() {
+        return this._hash;
+    }
+    get metadata() {
+        return { ...this._metadata };
+    }
+    get settings() {
+        return { ...this._settings };
+    }
+    get lastUpdate() {
+        return new Date(this._lastUpdate);
+    }
+    /**
+     * Get user's full name if available
+     */
+    get fullName() {
+        if (!this._metadata.name)
+            return null;
+        const { first_name, middle_name, last_name, suffix } = this._metadata.name;
+        const parts = [first_name, middle_name, last_name, suffix].filter(Boolean);
+        return parts.join(' ');
+    }
+    get fullNameObject() {
+        if (!this._metadata.name)
+            return null;
+        return this._metadata.name;
+    }
+    set fullNameObject(name) {
+        if (!name || !name?.first_name?.trim() || !name?.last_name?.trim()) {
+            throw new Error('Full name must contain first and last names');
+        }
+        this._metadata.name = name;
+        this.updateTimestamp();
+    }
+    /**
+     * Get user's formatted name (first + last)
+     */
+    get formattedName() {
+        if (!this._metadata.name)
+            return this._displayName;
+        const { first_name, last_name } = this._metadata.name;
+        if (first_name && last_name) {
+            return `${first_name} ${last_name}`;
+        }
+        return this._displayName;
+    }
+    /**
+     * Get user's first name if available
+     */
+    get firstName() {
+        if (!this._metadata?.name?.first_name?.trim())
+            return null;
+        return this._metadata.name.first_name;
+    }
+    /**
+     * Get user's last name if available
+     */
+    get lastName() {
+        if (!this._metadata?.name?.last_name?.trim())
+            return null;
+        return this._metadata.name.last_name;
+    }
+    /**
+     * Get user's gender
+     */
+    get gender() {
+        return this._metadata.gender || 'Unspecified';
+    }
+    /**
+     * Calculate user's age from birthdate
+     */
+    get age() {
+        const birthdate = this._metadata.birthdate;
+        if (!birthdate)
+            return null;
+        const today = new Date();
+        const birth = new Date(birthdate);
+        let age = today.getFullYear() - birth.getFullYear();
+        const monthDiff = today.getMonth() - birth.getMonth();
+        if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birth.getDate())) {
+            age--;
+        }
+        return age;
+    }
+    /**
+     * Get user's first name if available
+     */
+    get birthday() {
+        if (!this._metadata?.birthdate?.trim())
+            return null;
+        return this._metadata.birthdate;
+    }
+    /**
+     * Check if email is verified
+     */
+    get isEmailVerified() {
+        return this._metadata.verification?.email_verified ?? false;
+    }
+    /**
+     * Check if phone is verified
+     */
+    get isPhoneVerified() {
+        return this._metadata.verification?.phone_verified ?? false;
+    }
+    /**
+     * Check if identity is verified
+     */
+    get isIdentityVerified() {
+        return this._metadata.verification?.identity_verified ?? false;
+    }
+    /**
+     * Check if all verification steps are complete
+     */
+    get isFullyVerified() {
+        return this.isEmailVerified && this.isPhoneVerified && this.isIdentityVerified;
+    }
+    /**
+     * Get user's initials from name or display name
+     */
+    get initials() {
+        if (this._metadata.name) {
+            const { first_name, last_name } = this._metadata.name;
+            const firstInitial = first_name?.[0]?.toUpperCase() || '';
+            const lastInitial = last_name?.[0]?.toUpperCase() || '';
+            return `${firstInitial}${lastInitial}`.trim() || this._displayName[0].toUpperCase();
+        }
+        const names = this._displayName.split(' ');
+        if (names.length >= 2) {
+            return `${names[0][0]}${names[names.length - 1][0]}`.toUpperCase();
+        }
+        return this._displayName.slice(0, 2).toUpperCase();
+    }
+    // ==================== SETTERS ====================
+    set email(value) {
+        this.validateEmail(value);
+        this._email = value;
+        // Unverify email when changed
+        if (this._metadata.verification) {
+            this._metadata.verification.email_verified = false;
+        }
+        this.updateTimestamp();
+    }
+    set displayName(value) {
+        if (!value || value.trim().length === 0) {
+            throw new Error('Display name cannot be empty');
+        }
+        this._displayName = value;
+        this.updateTimestamp();
+    }
+    set hash(value) {
+        if (!value || value.length === 0) {
+            throw new Error('Hash cannot be empty');
+        }
+        this._hash = value;
+        this.updateTimestamp();
+    }
+    // ==================== METADATA METHODS ====================
+    /**
+     * Update user's full name
+     */
+    setName(name) {
+        this.updateMetadata({ name });
+    }
+    /**
+     * Update user's profile picture
+     */
+    setPicture(url) {
+        this.updateMetadata({ picture: url });
+    }
+    /**
+     * Update user's phone number
+     */
+    setPhone(phone) {
+        this.updateMetadata({ phone });
+        // Unverify phone when changed
+        if (this._metadata.verification) {
+            this._metadata.verification.phone_verified = false;
+        }
+    }
+    /**
+     * Update user's address
+     */
+    setAddress(address) {
+        this.updateMetadata({ address });
+    }
+    /**
+     * Update user's birthdate
+     * Accepts either YYYY-MM-DD string or Date object
+     */
+    setBirthdate(birthdate) {
+        let formatted;
+        if (birthdate instanceof Date) {
+            if (Number.isNaN(birthdate.getTime())) {
+                throw new Error('Invalid Date object');
+            }
+            // Format to YYYY-MM-DD (UTC-safe)
+            formatted = dateToYYYYMMDD(birthdate);
+        }
+        else {
+            // Validate ISO date format YYYY-MM-DD
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(birthdate)) {
+                throw new Error('Invalid birthdate format. Use YYYY-MM-DD');
+            }
+            formatted = birthdate;
+        }
+        this.updateMetadata({ birthdate: formatted });
+    }
+    /**
+     * Update user's address
+     */
+    setGender(gender) {
+        this.updateMetadata({ gender });
+    }
+    /**
+     * Update user's bio
+     */
+    setBio(bio) {
+        this.updateMetadata({ bio });
+    }
+    /**
+     * Update user's language preference
+     */
+    setLanguage(language) {
+        this.updateMetadata({ language });
+    }
+    /**
+     * Update user's timezone
+     */
+    setTimezone(timezone) {
+        this.updateMetadata({ timezone });
+    }
+    /**
+     * Add or update a social link
+     */
+    setSocialLink(platform, url) {
+        const socialLinks = { ...this._metadata.social_links, [platform]: url };
+        this.updateMetadata({ social_links: socialLinks });
+    }
+    /**
+     * Remove a social link
+     */
+    removeSocialLink(platform) {
+        if (!this._metadata.social_links)
+            return;
+        const socialLinks = { ...this._metadata.social_links };
+        delete socialLinks[platform];
+        this.updateMetadata({ social_links: socialLinks });
+    }
+    /**
+     * Update a specific metadata field
+     */
+    setMetadata(key, value) {
+        this._metadata[key] = value;
+        this.updateTimestamp();
+    }
+    /**
+     * Merge multiple metadata fields
+     */
+    updateMetadata(updates) {
+        this._metadata = { ...this._metadata, ...updates };
+        this._lastUpdate = new Date();
+    }
+    // ==================== VERIFICATION METHODS ====================
+    /**
+     * Mark email as verified
+     */
+    verifyEmail() {
+        const currentVerification = this._metadata.verification || {
+            email_verified: false,
+            phone_verified: false,
+            identity_verified: false,
+        };
+        this.updateMetadata({
+            verification: {
+                ...currentVerification,
+                email_verified: true,
+            },
+        });
+    }
+    /**
+     * Mark email as unverified
+     */
+    unverifyEmail() {
+        const currentVerification = this._metadata.verification || {
+            email_verified: false,
+            phone_verified: false,
+            identity_verified: false,
+        };
+        this.updateMetadata({
+            verification: {
+                ...currentVerification,
+                email_verified: false,
+            },
+        });
+    }
+    /**
+     * Mark phone as verified
+     */
+    verifyPhone() {
+        const currentVerification = this._metadata.verification || {
+            email_verified: false,
+            phone_verified: false,
+            identity_verified: false,
+        };
+        this.updateMetadata({
+            verification: {
+                ...currentVerification,
+                phone_verified: true,
+            },
+        });
+    }
+    /**
+     * Mark phone as unverified
+     */
+    unverifyPhone() {
+        const currentVerification = this._metadata.verification || {
+            email_verified: false,
+            phone_verified: false,
+            identity_verified: false,
+        };
+        this.updateMetadata({
+            verification: {
+                ...currentVerification,
+                phone_verified: false,
+            },
+        });
+    }
+    /**
+     * Mark identity as verified (KYC)
+     */
+    verifyIdentity() {
+        const currentVerification = this._metadata.verification || {
+            email_verified: false,
+            phone_verified: false,
+            identity_verified: false,
+        };
+        this.updateMetadata({
+            verification: {
+                ...currentVerification,
+                identity_verified: true,
+            },
+        });
+    }
+    /**
+     * Mark identity as unverified
+     */
+    unverifyIdentity() {
+        const currentVerification = this._metadata.verification || {
+            email_verified: false,
+            phone_verified: false,
+            identity_verified: false,
+        };
+        this.updateMetadata({
+            verification: {
+                ...currentVerification,
+                identity_verified: false,
+            },
+        });
+    }
+    // ==================== SETTINGS METHODS ====================
+    /**
+     * Update a specific setting
+     */
+    setSetting(key, value) {
+        this._settings[key] = value;
+        this.updateTimestamp();
+    }
+    /**
+     * Merge multiple settings
+     */
+    updateSettings(updates) {
+        this._settings = {
+            ...this._settings,
+            ...updates,
+            system: {
+                ...this._settings.system,
+                ...(updates.system || {}),
+            },
+        };
+        this.updateTimestamp();
+    }
+    /**
+     * Enable notifications
+     */
+    enableNotifications() {
+        this.updateSettings({ notifications: true });
+    }
+    /**
+     * Disable notifications
+     */
+    disableNotifications() {
+        this.updateSettings({ notifications: false });
+    }
+    // ==================== RESTRICTION METHODS ====================
+    /**
+     * Check if user is currently restricted
+     */
+    isCurrentlyRestricted() {
+        if (!this._settings.system.isRestricted)
+            return false;
+        if (!this._settings.system.restrictedUntil)
+            return true;
+        return new Date() < this._settings.system.restrictedUntil;
+    }
+    /**
+     * Restrict user until a specific date (or indefinitely)
+     */
+    restrict(until) {
+        this.updateSettings({
+            system: {
+                isRestricted: true,
+                restrictedUntil: until,
+            },
+        });
+    }
+    /**
+     * Remove restriction from user
+     */
+    unrestrict() {
+        this.updateSettings({
+            system: {
+                isRestricted: false,
+                restrictedUntil: undefined,
+            },
+        });
+    }
+    // ==================== COMPARISON & UTILITY METHODS ====================
+    /**
+     * Check if this user has the same ID as another user
+     */
+    equals(other) {
+        return this.id === other.id;
+    }
+    /**
+     * Check if user has complete profile information
+     */
+    hasCompleteProfile() {
+        return !!(this._metadata.name && this._metadata.phone && this._metadata.birthdate && this._metadata.address && this._metadata.gender);
+    }
+    /**
+     * Get profile completion percentage (0-100)
+     */
+    getProfileCompletionPercentage() {
+        const fields = ['name', 'picture', 'phone', 'gender', 'birthdate', 'address', 'bio'];
+        const completedFields = fields.filter((field) => {
+            const value = this._metadata[field];
+            if (typeof value === 'object' && value !== null) {
+                return Object.keys(value).length > 0;
+            }
+            return !!value;
+        }).length;
+        return Math.round((completedFields / fields.length) * 100);
+    }
+    // Add detailed validation with error collection
+    validate() {
+        const errors = [];
+        // Required fields
+        if (!this.id)
+            errors.push('ID is required');
+        if (!this._email)
+            errors.push('Email is required');
+        if (!this._displayName)
+            errors.push('Display name is required');
+        if (!this._hash)
+            errors.push('Hash is required');
+        // Format validation
+        try {
+            this.validateEmail(this._email);
+        }
+        catch (e) {
+            errors.push(`Invalid email format: ${e}`);
+        }
+        // Date validation
+        if (!(this.createdAt instanceof Date) || isNaN(this.createdAt.getTime())) {
+            errors.push('Invalid createdAt date');
+        }
+        if (!(this._lastUpdate instanceof Date) || isNaN(this._lastUpdate.getTime())) {
+            errors.push('Invalid lastUpdate date');
+        }
+        // Metadata validation
+        if (this._metadata.phone) {
+            if (!/^\+?[1-9]\d{1,14}$/.test(this._metadata.phone)) {
+                errors.push('Invalid phone number format');
+            }
+        }
+        if (this._metadata.birthdate) {
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(this._metadata.birthdate)) {
+                errors.push('Invalid birthdate format');
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Create a shallow clone of the user
+     */
+    clone() {
+        return new this.constructor({
+            id: this.id,
+            email: this._email,
+            displayName: this._displayName,
+            hash: this._hash,
+            metadata: { ...this._metadata },
+            settings: { ...this._settings },
+            createdAt: this.createdAt,
+            lastUpdate: this._lastUpdate,
+        });
+    }
+    /**
+     * Get a supabase ready version of user data (metadata)
+     */
+    toSupabaseJSON() {
+        return stripUndefined({
+            age: this.age,
+            name: this.fullName,
+            gender: this.metadata.gender,
+            address: this.metadata.address,
+            picture: this.metadata.picture,
+            birthdate: this.metadata.birthdate,
+            full_name: this.fullName,
+            bio: this.metadata.bio,
+            first_name: this.metadata.name?.first_name,
+            family_name: this.metadata.name?.last_name,
+            display_name: this.displayName,
+        });
+    }
+    /**
+     * Get a sanitized version of user data (removes sensitive info)
+     */
+    toPublicJSON() {
+        return {
+            id: this.id,
+            displayName: this._displayName,
+            picture: this._metadata.picture,
+            bio: this._metadata.bio,
+            createdAt: this.createdAt.toISOString(),
+        };
+    }
+    /**
+     * Serialize user to JSON-compatible object
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            email: this._email,
+            displayName: this._displayName,
+            hash: this._hash,
+            metadata: { ...this._metadata },
+            settings: { ...this._settings },
+            createdAt: this.createdAt.toISOString(),
+            lastUpdate: this._lastUpdate.toISOString(),
+        };
+    }
+    // ==================== PROTECTED HELPER METHODS ====================
+    /**
+     * Updates the lastUpdate timestamp
+     */
+    updateTimestamp() {
+        this._lastUpdate = new Date();
+    }
+    /**
+     * Validates email format
+     */
+    validateEmail(email) {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (!emailRegex.test(email)) {
+            throw new Error('Invalid email format');
+        }
+    }
+    // ==================== STATIC CRYPTOGRAPHIC METHODS ====================
+    /**
+     * Generate a cryptographically secure unique identifier
+     */
+    static generateID() {
+        try {
+            const mnemonic = generateMnemonic(wordlist, 128);
+            const seed = mnemonicToSeedSync(mnemonic);
+            const seed32 = new Uint8Array(seed.slice(0, 32));
+            const ed = ed25519.generateKeyPairFromSeed(seed32);
+            const skCurve = ed2curve.convertSecretKey(ed.secretKey);
+            const pkCurve = ed2curve.convertPublicKey(ed.publicKey);
+            if (!skCurve || !pkCurve) {
+                throw new Error('Failed to convert derived Ed25519 keys to Curve25519');
+            }
+            const pkCurveBytes = new Uint8Array(pkCurve);
+            const publicKey = arrayBufferToBase64(pkCurveBytes.buffer);
+            return publicKey;
+        }
+        catch (error) {
+            throw new Error(`Failed to generate user ID: ${error}`);
+        }
+    }
+    /**
+     * Validate ID format
+     */
+    static validateID(id) {
+        return /^[A-Za-z0-9+/]+=*$/.test(id) && id.length > 0;
+    }
+    /**
+     * Hash an ID using SHA-256
+     */
+    static hashID(id) {
+        const hashedID = hash(new TextEncoder().encode(id));
+        return arrayToBase64(hashedID);
+    }
+}