@thezelijah/majik-message 1.0.0 → 1.0.1

package/dist/core/database/chat/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/database/system/identity.d.ts

@@ -0,0 +1,61 @@
+import { MajikUser } from "./majik-user/majik-user";
+import { MajikContact } from "../../contacts/majik-contact";
+export interface MajikMessageIdentityJSON {
+    id: string;
+    user_id: string;
+    public_key: string;
+    phash: string;
+    label: string;
+    timestamp: string;
+    restricted: boolean;
+}
+/**
+ * MajikMessageIdentity
+ * Immutable identity container with integrity verification
+ */
+export declare class MajikMessageIdentity {
+    private readonly _id;
+    private readonly _userId;
+    private readonly _publicKey;
+    private readonly _phash;
+    private _label;
+    private readonly _timestamp;
+    private readonly _restricted;
+    /**
+     * Constructor is private to enforce controlled creation
+     */
+    private constructor();
+    /**
+     * Create a new immutable identity from MajikUser
+     */
+    static create(user: MajikUser, account: MajikContact, options?: {
+        label?: string;
+        restricted?: boolean;
+    }): MajikMessageIdentity;
+    get id(): string;
+    get userID(): string;
+    get publicKey(): string;
+    get phash(): string;
+    get label(): string;
+    get timestamp(): string;
+    get restricted(): boolean;
+    /**
+     * Only mutable field
+     */
+    set label(label: string);
+    /**
+     * Returns true if identity is restricted
+     */
+    isRestricted(): boolean;
+    /**
+     * Verify identity integrity
+     * Detects tampering of id/public_key
+     */
+    validateIntegrity(): boolean;
+    /**
+     * Explicit verification helper
+     */
+    matches(userId: string, publicKey: string): boolean;
+    toJSON(): MajikMessageIdentityJSON;
+    static fromJSON(json: string | MajikMessageIdentityJSON): MajikMessageIdentity;
+}

package/dist/core/database/system/identity.js

@@ -0,0 +1,170 @@
+import crypto from "crypto";
+import { autogenerateID } from "./utils";
+/**
+ * Utility assertions
+ */
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function assertString(value, field) {
+    assert(typeof value === "string" && value.trim().length > 0, `${field} must be a non-empty string`);
+}
+function assertISODate(value, field) {
+    const date = new Date(value);
+    assert(!isNaN(date.getTime()), `${field} must be a valid ISO timestamp`);
+}
+function sha256(input) {
+    return crypto.createHash("sha256").update(input).digest("hex");
+}
+/**
+ * MajikMessageIdentity
+ * Immutable identity container with integrity verification
+ */
+export class MajikMessageIdentity {
+    // 🔒 Private backing fields
+    _id;
+    _userId;
+    _publicKey;
+    _phash;
+    _label;
+    _timestamp;
+    _restricted;
+    /**
+     * Constructor is private to enforce controlled creation
+     */
+    constructor(params) {
+        assertString(params.id, "id");
+        assertString(params.userId, "user_id");
+        assertString(params.publicKey, "public_key");
+        assertString(params.phash, "phash");
+        assertString(params.label, "label");
+        assertISODate(params.timestamp, "timestamp");
+        assert(typeof params.restricted === "boolean", "restricted must be boolean");
+        this._id = params.id;
+        this._userId = params.userId;
+        this._publicKey = params.publicKey;
+        this._phash = params.phash;
+        this._label = params.label;
+        this._timestamp = params.timestamp;
+        this._restricted = params.restricted;
+        // Final integrity check at construction
+        assert(this.validateIntegrity(), "Identity integrity validation failed");
+    }
+    // ─────────────────────────────
+    // Static factory
+    // ─────────────────────────────
+    /**
+     * Create a new immutable identity from MajikUser
+     */
+    static create(user, account, options) {
+        assert(user, "MajikUser is required");
+        const userValidResult = user.validate();
+        if (!userValidResult.isValid) {
+            throw new Error(`Invalid MajikUser: ${userValidResult.errors.join(", ")}`);
+        }
+        const label = options?.label || account?.meta?.label || user.displayName;
+        assertString(label, "label");
+        const generatedID = autogenerateID();
+        const timestamp = new Date().toISOString();
+        const phash = sha256(`${user.id}:${account.id}:${generatedID}`);
+        return new MajikMessageIdentity({
+            id: generatedID,
+            userId: user.id,
+            publicKey: account.id,
+            phash,
+            label,
+            timestamp,
+            restricted: options?.restricted ?? false,
+        });
+    }
+    // ─────────────────────────────
+    // Getters (safe, read-only)
+    // ─────────────────────────────
+    get id() {
+        return this._id;
+    }
+    get userID() {
+        return this._userId;
+    }
+    get publicKey() {
+        return this._publicKey;
+    }
+    get phash() {
+        return this._phash;
+    }
+    get label() {
+        return this._label;
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    get restricted() {
+        return this._restricted;
+    }
+    // ─────────────────────────────
+    // Mutators (restricted)
+    // ─────────────────────────────
+    /**
+     * Only mutable field
+     */
+    set label(label) {
+        assertString(label, "label");
+        this._label = label;
+    }
+    // ─────────────────────────────
+    // Identity checks
+    // ─────────────────────────────
+    /**
+     * Returns true if identity is restricted
+     */
+    isRestricted() {
+        return this._restricted === true;
+    }
+    /**
+     * Verify identity integrity
+     * Detects tampering of id/public_key
+     */
+    validateIntegrity() {
+        const expected = sha256(`${this._userId}:${this._publicKey}:${this._id}`);
+        return expected === this._phash;
+    }
+    /**
+     * Explicit verification helper
+     */
+    matches(userId, publicKey) {
+        assertString(userId, "userId");
+        assertString(publicKey, "publicKey");
+        const hash = sha256(`${userId}:${publicKey}:${this._id}`);
+        return hash === this._phash;
+    }
+    // ─────────────────────────────
+    // Serialization
+    // ─────────────────────────────
+    toJSON() {
+        return {
+            id: this._id,
+            user_id: this._userId,
+            public_key: this._publicKey,
+            phash: this._phash,
+            label: this._label,
+            timestamp: this._timestamp,
+            restricted: this._restricted,
+        };
+    }
+    static fromJSON(json) {
+        const obj = typeof json === "string" ? JSON.parse(json) : json;
+        assert(typeof obj === "object" && obj !== null, "Invalid JSON object");
+        const identity = new MajikMessageIdentity({
+            id: obj.id,
+            userId: obj.user_id,
+            publicKey: obj.public_key,
+            phash: obj.phash,
+            label: obj.label,
+            timestamp: obj.timestamp,
+            restricted: obj.restricted,
+        });
+        assert(identity.validateIntegrity(), "Invalid phash in JSON");
+        return identity;
+    }
+}

package/dist/core/database/system/majik-user/enums.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Target gender brackets for the audience.
+ */
+export declare const UserGenderOptions: {
+    readonly MALE: "Male";
+    readonly FEMALE: "Female";
+    readonly OTHER: "Other";
+};
+export type UserGenderOptions = (typeof UserGenderOptions)[keyof typeof UserGenderOptions];
+/**
+ * Enum representing different types of social media platforms.
+ */
+export declare const SocialLinkType: {
+    readonly FACEBOOK: "Facebook";
+    readonly X: "X";
+    readonly TIKTOK: "Tik-Tok";
+    readonly THREADS: "Threads";
+    readonly INSTAGRAM: "Instagram";
+    readonly YOUTUBE: "Youtube";
+    readonly SPOTIFY: "Spotify";
+    readonly APPLE_MUSIC: "Apple Music";
+    readonly LINKEDIN: "LinkedIn";
+    readonly WEBSITE: "Website URL";
+};
+export type SocialLinkType = (typeof SocialLinkType)[keyof typeof SocialLinkType];
+/** Payment methods accepted for the invoice */
+export declare const PaymentMethod: {
+    /** Payment is made in cash */
+    readonly CASH: "Cash";
+    /** Payment is made via bank transfer or deposit */
+    readonly BANK: "Bank";
+    /** Payment is made via e-wallet transfer */
+    readonly EWALLET: "E-Wallet";
+    /** Payment is made using a check */
+    readonly CHECK: "Check";
+};
+export type PaymentMethod = (typeof PaymentMethod)[keyof typeof PaymentMethod];
+export declare const Visibility: {
+    readonly PRIVATE: "Private";
+    readonly PUBLIC: "Public";
+    readonly LIMITED: "Limited";
+    readonly UNLISTED: "Unlisted";
+};
+export type Visibility = (typeof Visibility)[keyof typeof Visibility];

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

@@ -0,0 +1,40 @@
+/**
+ * Target gender brackets for the audience.
+ */
+export const UserGenderOptions = {
+    MALE: 'Male',
+    FEMALE: 'Female',
+    OTHER: 'Other'
+};
+/**
+ * Enum representing different types of social media platforms.
+ */
+export const SocialLinkType = {
+    FACEBOOK: 'Facebook',
+    X: 'X',
+    TIKTOK: 'Tik-Tok',
+    THREADS: 'Threads',
+    INSTAGRAM: 'Instagram',
+    YOUTUBE: 'Youtube',
+    SPOTIFY: 'Spotify',
+    APPLE_MUSIC: 'Apple Music',
+    LINKEDIN: 'LinkedIn',
+    WEBSITE: 'Website URL'
+};
+/** Payment methods accepted for the invoice */
+export const PaymentMethod = {
+    /** Payment is made in cash */
+    CASH: 'Cash',
+    /** Payment is made via bank transfer or deposit */
+    BANK: 'Bank',
+    /** Payment is made via e-wallet transfer */
+    EWALLET: 'E-Wallet',
+    /** Payment is made using a check */
+    CHECK: 'Check'
+};
+export const Visibility = {
+    PRIVATE: 'Private',
+    PUBLIC: 'Public',
+    LIMITED: 'Limited',
+    UNLISTED: 'Unlisted'
+};

package/dist/core/database/system/majik-user/majik-user.d.ts

@@ -0,0 +1,257 @@
+import type { UserBasicInformation, FullName, Address, UserSettings, MajikUserJSON, SupabaseUser, YYYYMMDD } from './types';
+import type { UserGenderOptions } from './enums';
+export interface MajikUserData<TMetadata extends UserBasicInformation = UserBasicInformation> {
+    id: string;
+    email: string;
+    displayName: string;
+    hash: string;
+    metadata: TMetadata;
+    settings: UserSettings;
+    createdAt: Date;
+    lastUpdate: Date;
+}
+/**
+ * Base user class for database persistence
+ * Designed to be extended by subclasses with additional metadata
+ */
+export declare class MajikUser<TMetadata extends UserBasicInformation = UserBasicInformation> {
+    readonly id: string;
+    protected _email: string;
+    protected _displayName: string;
+    protected _hash: string;
+    protected _metadata: TMetadata;
+    protected _settings: UserSettings;
+    readonly createdAt: Date;
+    protected _lastUpdate: Date;
+    constructor(data: MajikUserData<TMetadata>);
+    /**
+     * Initialize a new user with email and display name
+     * Generates a UUID for the id if unset and sets timestamps
+     */
+    static initialize<T extends MajikUser>(this: new (data: MajikUserData<any>) => T, email: string, displayName: string, id?: string): T;
+    /**
+     * Deserialize user from JSON object or JSON string
+     */
+    static fromJSON<T extends MajikUser>(this: new (data: MajikUserData<any>) => T, json: MajikUserJSON<any> | string): T;
+    /**
+     * Create MajikUser from Supabase User object
+     * Maps Supabase user fields to MajikUser structure
+     */
+    static fromSupabase<T extends MajikUser>(this: new (data: MajikUserData<any>) => T, supabaseUser: SupabaseUser): T;
+    get email(): string;
+    get displayName(): string;
+    get hash(): string;
+    get metadata(): Readonly<TMetadata>;
+    get settings(): Readonly<UserSettings>;
+    get lastUpdate(): Date;
+    /**
+     * Get user's full name if available
+     */
+    get fullName(): string | null;
+    get fullNameObject(): FullName | null;
+    set fullNameObject(name: FullName);
+    /**
+     * Get user's formatted name (first + last)
+     */
+    get formattedName(): string;
+    /**
+     * Get user's first name if available
+     */
+    get firstName(): string | null;
+    /**
+     * Get user's last name if available
+     */
+    get lastName(): string | null;
+    /**
+     * Get user's gender
+     */
+    get gender(): string;
+    /**
+     * Calculate user's age from birthdate
+     */
+    get age(): number | null;
+    /**
+     * Get user's first name if available
+     */
+    get birthday(): YYYYMMDD | null;
+    /**
+     * Check if email is verified
+     */
+    get isEmailVerified(): boolean;
+    /**
+     * Check if phone is verified
+     */
+    get isPhoneVerified(): boolean;
+    /**
+     * Check if identity is verified
+     */
+    get isIdentityVerified(): boolean;
+    /**
+     * Check if all verification steps are complete
+     */
+    get isFullyVerified(): boolean;
+    /**
+     * Get user's initials from name or display name
+     */
+    get initials(): string;
+    set email(value: string);
+    set displayName(value: string);
+    set hash(value: string);
+    /**
+     * Update user's full name
+     */
+    setName(name: FullName): void;
+    /**
+     * Update user's profile picture
+     */
+    setPicture(url: string): void;
+    /**
+     * Update user's phone number
+     */
+    setPhone(phone: string): void;
+    /**
+     * Update user's address
+     */
+    setAddress(address: Address): void;
+    /**
+     * Update user's birthdate
+     * Accepts either YYYY-MM-DD string or Date object
+     */
+    setBirthdate(birthdate: YYYYMMDD | Date): void;
+    /**
+     * Update user's address
+     */
+    setGender(gender: UserGenderOptions): void;
+    /**
+     * Update user's bio
+     */
+    setBio(bio: string): void;
+    /**
+     * Update user's language preference
+     */
+    setLanguage(language: string): void;
+    /**
+     * Update user's timezone
+     */
+    setTimezone(timezone: string): void;
+    /**
+     * Add or update a social link
+     */
+    setSocialLink(platform: string, url: string): void;
+    /**
+     * Remove a social link
+     */
+    removeSocialLink(platform: string): void;
+    /**
+     * Update a specific metadata field
+     */
+    setMetadata(key: keyof TMetadata, value: TMetadata[typeof key]): void;
+    /**
+     * Merge multiple metadata fields
+     */
+    updateMetadata(updates: Partial<TMetadata>): void;
+    /**
+     * Mark email as verified
+     */
+    verifyEmail(): void;
+    /**
+     * Mark email as unverified
+     */
+    unverifyEmail(): void;
+    /**
+     * Mark phone as verified
+     */
+    verifyPhone(): void;
+    /**
+     * Mark phone as unverified
+     */
+    unverifyPhone(): void;
+    /**
+     * Mark identity as verified (KYC)
+     */
+    verifyIdentity(): void;
+    /**
+     * Mark identity as unverified
+     */
+    unverifyIdentity(): void;
+    /**
+     * Update a specific setting
+     */
+    setSetting(key: string, value: unknown): void;
+    /**
+     * Merge multiple settings
+     */
+    updateSettings(updates: Partial<UserSettings>): void;
+    /**
+     * Enable notifications
+     */
+    enableNotifications(): void;
+    /**
+     * Disable notifications
+     */
+    disableNotifications(): void;
+    /**
+     * Check if user is currently restricted
+     */
+    isCurrentlyRestricted(): boolean;
+    /**
+     * Restrict user until a specific date (or indefinitely)
+     */
+    restrict(until?: Date): void;
+    /**
+     * Remove restriction from user
+     */
+    unrestrict(): void;
+    /**
+     * Check if this user has the same ID as another user
+     */
+    equals(other: MajikUser): boolean;
+    /**
+     * Check if user has complete profile information
+     */
+    hasCompleteProfile(): boolean;
+    /**
+     * Get profile completion percentage (0-100)
+     */
+    getProfileCompletionPercentage(): number;
+    validate(): {
+        isValid: boolean;
+        errors: string[];
+    };
+    /**
+     * Create a shallow clone of the user
+     */
+    clone(): MajikUser<TMetadata>;
+    /**
+     * Get a supabase ready version of user data (metadata)
+     */
+    toSupabaseJSON(): Record<string, unknown>;
+    /**
+     * Get a sanitized version of user data (removes sensitive info)
+     */
+    toPublicJSON(): Record<string, unknown>;
+    /**
+     * Serialize user to JSON-compatible object
+     */
+    toJSON(): MajikUserJSON<TMetadata>;
+    /**
+     * Updates the lastUpdate timestamp
+     */
+    protected updateTimestamp(): void;
+    /**
+     * Validates email format
+     */
+    protected validateEmail(email: string): void;
+    /**
+     * Generate a cryptographically secure unique identifier
+     */
+    protected static generateID(): string;
+    /**
+     * Validate ID format
+     */
+    protected static validateID(id: string): boolean;
+    /**
+     * Hash an ID using SHA-256
+     */
+    protected static hashID(id: string): string;
+}