@thezelijah/majik-message 1.1.1 → 1.1.3

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

@@ -1,839 +0,0 @@
-/* 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;
-    }
-    /**
-     * Get user's full address if available
-     */
-    get address() {
-        if (!this._metadata.address)
-            return null;
-        const { building, street, area, city, region, zip, country } = this._metadata.address;
-        const parts = [building, street, area, city, region, zip, country].filter(Boolean);
-        return parts.join(", ");
-    }
-    /**
-     * 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);
-    }
-}