shogun-core 2.0.3 → 3.0.0

package/dist/plugins/webauthn/webauthnPlugin.js

@@ -384,7 +384,7 @@ export class WebauthnPlugin extends BasePlugin {
                 throw new Error("Failed to generate SEA pair from WebAuthn credentials");
             }
             // Use pair-based authentication instead of password
-            return await core.signUp(username, "", "", pair);
+            return await core.signUp(username, undefined, pair);
         }
         catch (error) {
             console.error(`Error during WebAuthn registration: ${error}`);

package/dist/types/config/simplified-config.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Simplified configuration options to reduce complexity
+ * Provides sensible defaults and easy-to-use presets
+ */
+import { ShogunCoreConfig } from "../interfaces/shogun";
+/**
+ * Preset configurations for common use cases
+ */
+export declare const ShogunPresets: {
+    /**
+     * Minimal configuration for simple apps
+     */
+    minimal: () => ShogunCoreConfig;
+    /**
+     * Development configuration with local storage
+     */
+    development: () => ShogunCoreConfig;
+    /**
+     * Production configuration with multiple peers
+     */
+    production: (customPeers?: string[]) => ShogunCoreConfig;
+    /**
+     * Offline-first configuration
+     */
+    offline: () => ShogunCoreConfig;
+    /**
+     * Web3-enabled configuration
+     */
+    web3: () => ShogunCoreConfig;
+    /**
+     * WebAuthn-enabled configuration
+     */
+    webauthn: () => ShogunCoreConfig;
+};
+/**
+ * Configuration builder for custom setups
+ */
+export declare class ShogunConfigBuilder {
+    private config;
+    /**
+     * Set Gun options
+     */
+    gunOptions(options: any): this;
+    /**
+     * Add peers
+     */
+    peers(peerList: string[]): this;
+    /**
+     * Enable WebAuthn
+     */
+    enableWebAuthn(rpName?: string, rpId?: string): this;
+    /**
+     * Enable Web3
+     */
+    enableWeb3(): this;
+    /**
+     * Enable Nostr
+     */
+    enableNostr(): this;
+    /**
+     * Set timeouts
+     */
+    timeouts(timeouts: {
+        login?: number;
+        signup?: number;
+        operation?: number;
+    }): this;
+    /**
+     * Build the final configuration
+     */
+    build(): ShogunCoreConfig;
+}
+/**
+ * Helper functions for common configuration patterns
+ */
+export declare const ConfigHelpers: {
+    /**
+     * Create a configuration for a specific environment
+     */
+    forEnvironment(env: "development" | "production" | "test"): ShogunCoreConfig;
+    /**
+     * Create a configuration with custom peers
+     */
+    withPeers(peers: string[]): ShogunCoreConfig;
+    /**
+     * Create a configuration for a specific use case
+     */
+    forUseCase(useCase: "chat" | "social" | "gaming" | "finance"): ShogunCoreConfig;
+};
+/**
+ * Quick configuration functions
+ */
+export declare const QuickConfig: {
+    /**
+     * Minimal setup for quick testing
+     */
+    test: () => ShogunCoreConfig;
+    /**
+     * Standard setup for most apps
+     */
+    standard: () => ShogunCoreConfig;
+    /**
+     * Setup with WebAuthn for secure apps
+     */
+    secure: () => ShogunCoreConfig;
+    /**
+     * Setup with Web3 for crypto apps
+     */
+    crypto: () => ShogunCoreConfig;
+    /**
+     * Offline setup for local development
+     */
+    local: () => ShogunCoreConfig;
+};

package/dist/types/core.d.ts

@@ -1,11 +1,11 @@
-import { ShogunEventMap } from "./types/events";
+import { ShogunEventMap } from "./interfaces/events";
 import { ShogunError } from "./utils/errorHandler";
 import { ShogunStorage } from "./storage/storage";
-import { IShogunCore, ShogunCoreConfig, AuthResult, SignUpResult, PluginCategory, AuthMethod, Wallets } from "./types/shogun";
+import { IShogunCore, ShogunCoreConfig, AuthResult, SignUpResult, PluginCategory, AuthMethod, Wallets } from "./interfaces/shogun";
 import { ethers } from "ethers";
-import { ShogunPlugin } from "./types/plugin";
-import { IGunUserInstance, IGunInstance, DataBase, RxJS } from "./gundb";
+import { ShogunPlugin } from "./interfaces/plugin";
 import { ISEAPair } from "gun";
+import { DataBase, RxJS, GunInstance, GunUserInstance } from "./gundb";
 /**
  * Main ShogunCore class - implements the IShogunCore interface
  *
@@ -26,10 +26,11 @@ export declare class ShogunCore implements IShogunCore {
     rx: RxJS;
     private _gun;
     private _user;
-    private readonly eventEmitter;
-    private readonly plugins;
-    private currentAuthMethod?;
     wallets: Wallets | undefined;
+    private pluginManager;
+    private authManager;
+    private eventManager;
+    private coreInitializer;
     /**
      * Initialize the Shogun SDK
      * @param config - SDK Configuration object
@@ -38,21 +39,16 @@ export declare class ShogunCore implements IShogunCore {
      * and plugin system.
      */
     constructor(config: ShogunCoreConfig);
-    /**
-     * Initialize the Shogun SDK asynchronously
-     * This method handles initialization tasks that require async operations
-     */
-    initialize(): Promise<void>;
     /**
      * Access to the Gun instance
      * @returns The Gun instance
      */
-    get gun(): IGunInstance<any>;
+    get gun(): GunInstance;
     /**
      * Access to the current user
      * @returns The current Gun user instance
      */
-    get user(): IGunUserInstance<any> | null;
+    get user(): GunUserInstance | null;
     /**
      * Gets the current user information
      * @returns Current user object or null
@@ -61,16 +57,6 @@ export declare class ShogunCore implements IShogunCore {
         pub: string;
         user?: any;
     } | null;
-    /**
-     * Setup event forwarding from GunInstance to main event emitter
-     * @private
-     */
-    private setupGunEventForwarding;
-    /**
-     * Register built-in plugins based on configuration
-     * @private
-     */
-    private registerBuiltinPlugins;
     /**
      * Registers a plugin with the Shogun SDK
      * @param plugin Plugin instance to register
@@ -82,16 +68,6 @@ export declare class ShogunCore implements IShogunCore {
      * @param pluginName Name of the plugin to unregister
      */
     unregister(pluginName: string): void;
-    /**
-     * Internal method to register a plugin
-     * @param plugin Plugin instance to register
-     */
-    private registerPlugin;
-    /**
-     * Internal method to unregister a plugin
-     * @param name Name of the plugin to unregister
-     */
-    private unregisterPlugin;
     /**
      * Retrieve a registered plugin by name
      * @param name Name of the plugin
@@ -221,10 +197,7 @@ export declare class ShogunCore implements IShogunCore {
      * @returns The authentication plugin or undefined if not available
      * This is a more modern approach to accessing authentication methods
      */
-    getAuthenticationMethod(type: AuthMethod): ShogunPlugin | {
-        login: (username: string, password: string) => Promise<AuthResult>;
-        signUp: (username: string, password: string, confirm?: string) => Promise<SignUpResult>;
-    } | undefined;
+    getAuthenticationMethod(type: AuthMethod): unknown;
     /**
      * Retrieve recent errors logged by the system
      * @param count - Number of errors to retrieve (default: 10)
@@ -265,13 +238,13 @@ export declare class ShogunCore implements IShogunCore {
      * Register a new user with provided credentials
      * @param username - Username
      * @param password - Password
-     * @param passwordConfirmation - Password confirmation
+     * @param email - Email (optional)
      * @param pair - Pair of keys
      * @returns {Promise<SignUpResult>} Registration result
      * @description Creates a new user account with the provided credentials.
      * Validates password requirements and emits signup event on success.
      */
-    signUp(username: string, password?: string, email?: string, pair?: ISEAPair | null): Promise<SignUpResult>;
+    signUp(username: string, password?: string, pair?: ISEAPair | null): Promise<SignUpResult>;
     /**
      * Emits an event through the core's event emitter.
      * Plugins should use this method to emit events instead of accessing the private eventEmitter directly.
@@ -325,10 +298,4 @@ export declare class ShogunCore implements IShogunCore {
     saveCredentials(credentials: any): Promise<void>;
     getIsLoggedIn(): boolean;
 }
-declare global {
-    interface Window {
-        SHOGUN_CORE: (config: ShogunCoreConfig) => ShogunCore;
-        SHOGUN_CORE_CLASS: typeof ShogunCore;
-    }
-}
 export default ShogunCore;

package/dist/types/gundb/db.d.ts

@@ -5,7 +5,8 @@
  * - Direct authentication through Gun.user()
  */
 import type { GunUser, UserInfo, AuthCallback, GunData, EventData, EventListener, GunOperationResult } from "./types";
-import type { AuthResult, SignUpResult } from "../types/shogun";
+import type { GunInstance, GunUserInstance, GunChain } from "./improved-types";
+import type { AuthResult, SignUpResult } from "../interfaces/shogun";
 import Gun from "gun/gun";
 import SEA from "gun/sea";
 import "gun/lib/then";
@@ -14,25 +15,25 @@ import "gun/lib/radisk";
 import "gun/lib/store";
 import "gun/lib/rindexed";
 import "gun/lib/webrtc";
-import "gun/lib/evict";
-import "gun/lib/les";
+import "gun/lib/wire";
+import "gun/lib/axe";
 import { restrictedPut } from "./restricted-put";
 import derive, { DeriveOptions } from "./derive";
-import type { IGunUserInstance, IGunInstance, IGunChain, ISEAPair } from "gun/types";
-import { GunDataEventData, GunPeerEventData } from "../types/events";
+import type { IGunInstance, ISEAPair } from "gun/types";
+import { GunDataEventData, GunPeerEventData } from "../interfaces/events";
 import { RxJS } from "./rxjs";
 import * as GunErrors from "./errors";
 import * as crypto from "./crypto";
 declare class DataBase {
-    gun: IGunInstance<any>;
-    user: IGunUserInstance<any> | null;
+    gun: GunInstance;
+    user: GunUserInstance | null;
     crypto: typeof crypto;
     sea: typeof SEA;
-    node: IGunChain<any, IGunInstance<any>, IGunInstance<any>, string>;
+    node: GunChain;
     private readonly onAuthCallbacks;
     private readonly eventEmitter;
     private _rxjs?;
-    constructor(gun: IGunInstance<any>, appScope?: string);
+    constructor(gun: GunInstance, appScope?: string);
     /**
      * Initialize the GunInstance asynchronously
      * This method should be called after construction to perform async operations
@@ -97,7 +98,7 @@ declare class DataBase {
      * Gets the Gun instance
      * @returns Gun instance
      */
-    getGun(): IGunInstance<any>;
+    getGun(): GunInstance;
     /**
      * Gets the current user
      * @returns Current user object or null
@@ -168,10 +169,6 @@ declare class DataBase {
      * Validates signup credentials with enhanced security
      */
     private validateSignupCredentials;
-    /**
-     * Checks if user exists by attempting authentication
-     */
-    private checkUserExistence;
     /**
      * Creates a new user in Gun
      */
@@ -193,6 +190,87 @@ declare class DataBase {
      */
     private createNewUserWithPair;
     private runPostAuthOnAuthResult;
+    /**
+     * Sets up comprehensive user tracking system for agile user lookup
+     * Creates multiple indexes for efficient user discovery
+     */
+    private setupComprehensiveUserTracking;
+    /**
+     * Creates alias index following GunDB pattern: ~@alias -> userPub
+     */
+    private createAliasIndex;
+    /**
+     * Creates username mapping: usernames/alias -> userPub
+     */
+    private createUsernameMapping;
+    /**
+     * Creates user registry: users/userPub -> user data
+     */
+    private createUserRegistry;
+    /**
+     * Creates reverse lookup: userPub -> alias
+     */
+    private createReverseLookup;
+    /**
+     * Creates epub index: epubKeys/epub -> userPub
+     */
+    private createEpubIndex;
+    /**
+     * Creates user metadata in user's own node
+     */
+    private createUserMetadata;
+    /**
+     * Gets user information by alias using the comprehensive tracking system
+     * @param alias Username/alias to lookup
+     * @returns Promise resolving to user information or null if not found
+     */
+    getUserByAlias(alias: string): Promise<{
+        userPub: string;
+        epub: string | null;
+        username: string;
+        registeredAt: number;
+        lastSeen: number;
+    } | null>;
+    /**
+     * Gets user information by public key
+     * @param userPub User's public key
+     * @returns Promise resolving to user information or null if not found
+     */
+    getUserDataByPub(userPub: string): Promise<{
+        userPub: string;
+        epub: string | null;
+        username: string;
+        registeredAt: number;
+        lastSeen: number;
+    } | null>;
+    /**
+     * Gets user public key by encryption public key (epub)
+     * @param epub User's encryption public key
+     * @returns Promise resolving to user public key or null if not found
+     */
+    getUserPubByEpub(epub: string): Promise<string | null>;
+    /**
+     * Gets user alias by public key
+     * @param userPub User's public key
+     * @returns Promise resolving to user alias or null if not found
+     */
+    getUserAliasByPub(userPub: string): Promise<string | null>;
+    /**
+     * Gets all registered users (for admin purposes)
+     * @returns Promise resolving to array of user information
+     */
+    getAllRegisteredUsers(): Promise<Array<{
+        userPub: string;
+        epub: string | null;
+        username: string;
+        registeredAt: number;
+        lastSeen: number;
+    }>>;
+    /**
+     * Updates user's last seen timestamp
+     * @param userPub User's public key
+     */
+    updateUserLastSeen(userPub: string): Promise<void>;
     /**
      * Performs authentication with Gun
      */

package/dist/types/gundb/improved-types.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Improved type definitions to reduce 'any' usage while maintaining GunDB compatibility
+ */
+import type { IGunUserInstance, IGunInstance, IGunChain, ISEAPair } from "gun/types";
+export type GunInstance = IGunInstance<any>;
+export type GunUserInstance = IGunUserInstance<any>;
+export type GunChain = IGunChain<any, IGunInstance<any>, IGunInstance<any>, string>;
+export interface GunData {
+    [key: string]: unknown;
+}
+export interface GunNodeData {
+    [key: string]: unknown;
+    _?: {
+        "#": string;
+        ">": Record<string, number>;
+    };
+}
+export interface GunAckCallback {
+    (ack: {
+        err?: string;
+        ok?: number;
+        pub?: string;
+    }): void;
+}
+export interface GunDataCallback<T = unknown> {
+    (data: T, key: string): void;
+}
+export interface GunMapCallback<T = unknown> {
+    (data: T, key: string): void;
+}
+export interface TypedGunOperationResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    ack?: {
+        err?: string;
+        ok?: number;
+        pub?: string;
+    };
+}
+export interface TypedUserInfo {
+    pub: string;
+    alias?: string;
+    timestamp?: number;
+    user?: GunUserInstance;
+    metadata?: Record<string, unknown>;
+}
+export interface TypedAuthCallback {
+    (user: GunUserInstance): void;
+}
+export interface TypedAuthResult {
+    success: boolean;
+    userPub?: string;
+    username?: string;
+    error?: string;
+    ack?: {
+        err?: string;
+        ok?: number;
+        pub?: string;
+        sea?: ISEAPair;
+    };
+    sea?: ISEAPair;
+}
+export interface TypedGunConfig {
+    peers?: string[];
+    localStorage?: boolean;
+    radisk?: boolean;
+    file?: string;
+    uuid?: () => string;
+    [key: string]: unknown;
+}
+export interface TypedEventData {
+    type: string;
+    data: unknown;
+    timestamp: number;
+    source?: string;
+}
+export type GunPath = string | string[];
+export interface PathOperation<T = unknown> {
+    path: GunPath;
+    data?: T;
+    callback?: GunAckCallback;
+}
+export interface TypedRxJSObservable<T = unknown> {
+    subscribe: (observer: {
+        next: (value: T) => void;
+        error?: (error: Error) => void;
+        complete?: () => void;
+    }) => {
+        unsubscribe: () => void;
+    };
+}
+export interface TypedPluginConfig {
+    name: string;
+    version: string;
+    enabled: boolean;
+    config?: Record<string, unknown>;
+}
+export interface TypedStorageData {
+    key: string;
+    value: unknown;
+    timestamp: number;
+    ttl?: number;
+}
+export interface TypedGunError extends Error {
+    code?: string;
+    type: "GUN_ERROR" | "AUTH_ERROR" | "NETWORK_ERROR" | "VALIDATION_ERROR";
+    context?: Record<string, unknown>;
+}
+export type GunOperation = "get" | "put" | "set" | "remove" | "once" | "on" | "off";
+export type GunAuthMethod = "password" | "pair" | "webauthn" | "web3" | "nostr";
+export interface TypedGunWrapper<T = Record<string, unknown>> {
+    gun: GunInstance;
+    user: GunUserInstance | null;
+    get(path: GunPath): Promise<T>;
+    put(path: GunPath, data: T): Promise<TypedGunOperationResult<T>>;
+    set(path: GunPath, data: T): Promise<TypedGunOperationResult<T>>;
+    remove(path: GunPath): Promise<TypedGunOperationResult>;
+    getUserData(path: string): Promise<T>;
+    putUserData(path: string, data: T): Promise<void>;
+    login(username: string, password: string): Promise<TypedAuthResult>;
+    signUp(username: string, password: string): Promise<TypedAuthResult>;
+}

package/dist/types/gundb/index.d.ts

@@ -1 +1,3 @@
 export * from "./db";
+export * from "./improved-types";
+export * from "./simple-api";

package/dist/types/gundb/rxjs.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from "rxjs";
-import { IGunInstance, IGunUserInstance } from "gun";
+import { GunInstance, GunUserInstance } from "./improved-types";
 /**
  * RxJS Integration for GunDB
  * Provides reactive programming capabilities for GunDB data
@@ -11,12 +11,12 @@ export declare class RxJS {
      * Initialize GunRxJS with a GunDB instance
      * @param gun - GunDB instance
      */
-    constructor(gun: IGunInstance<any>);
+    constructor(gun: GunInstance);
     /**
      * Get the current user
      * @returns The current user
      */
-    getUser(): IGunUserInstance<any>;
+    getUser(): GunUserInstance;
     /**
      * Get the current user's public key
      * @returns The current user's public key

package/dist/types/gundb/simple-api.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Simplified API layer to reduce complexity for common use cases
+ * Provides quick-start methods that wrap the full DataBase functionality
+ */
+import { DataBase } from "./db";
+/**
+ * Simple API wrapper that provides common operations with minimal complexity
+ */
+export declare class SimpleGunAPI {
+    private db;
+    constructor(db: DataBase);
+    /**
+     * Quick data operations - simplified interface
+     */
+    get<T = unknown>(path: string): Promise<T | null>;
+    put<T = unknown>(path: string, data: T): Promise<boolean>;
+    set<T = unknown>(path: string, data: T): Promise<boolean>;
+    remove(path: string): Promise<boolean>;
+    /**
+     * Quick authentication - simplified interface
+     */
+    login(username: string, password: string): Promise<{
+        userPub: string;
+        username: string;
+    } | null>;
+    signup(username: string, password: string): Promise<{
+        userPub: string;
+        username: string;
+    } | null>;
+    logout(): void;
+    isLoggedIn(): boolean;
+    /**
+     * Quick user data operations - simplified interface
+     */
+    getUserData<T = unknown>(path: string): Promise<T | null>;
+    putUserData<T = unknown>(path: string, data: T): Promise<boolean>;
+    setUserData<T = unknown>(path: string, data: T): Promise<boolean>;
+    removeUserData(path: string): Promise<boolean>;
+    /**
+     * Quick utility methods
+     */
+    getCurrentUser(): {
+        pub: string;
+        username?: string;
+    } | null;
+    userExists(alias: string): Promise<boolean>;
+    getUser(alias: string): Promise<{
+        userPub: string;
+        username: string;
+    } | null>;
+    /**
+     * Advanced user space operations
+     */
+    getAllUserData(): Promise<Record<string, unknown> | null>;
+    updateProfile(profileData: {
+        name?: string;
+        email?: string;
+        bio?: string;
+        avatar?: string;
+        [key: string]: unknown;
+    }): Promise<boolean>;
+    getProfile(): Promise<Record<string, unknown> | null>;
+    saveSettings(settings: Record<string, unknown>): Promise<boolean>;
+    getSettings(): Promise<Record<string, unknown> | null>;
+    savePreferences(preferences: Record<string, unknown>): Promise<boolean>;
+    getPreferences(): Promise<Record<string, unknown> | null>;
+    createCollection<T = unknown>(collectionName: string, items: Record<string, T>): Promise<boolean>;
+    addToCollection<T = unknown>(collectionName: string, itemId: string, item: T): Promise<boolean>;
+    getCollection(collectionName: string): Promise<Record<string, unknown> | null>;
+    removeFromCollection(collectionName: string, itemId: string): Promise<boolean>;
+}
+/**
+ * Factory function to create a simple API instance
+ */
+export declare function createSimpleAPI(db: DataBase): SimpleGunAPI;
+/**
+ * Quick start helper - creates a simple API with minimal configuration
+ */
+export declare class QuickStart {
+    private db;
+    private simpleAPI;
+    constructor(gunInstance: any, appScope?: string);
+    init(): Promise<void>;
+    get api(): SimpleGunAPI;
+    get database(): DataBase;
+}
+/**
+ * Global helper for quick setup
+ */
+export declare function quickStart(gunInstance: any, appScope?: string): QuickStart;

package/dist/types/index.d.ts

@@ -1,12 +1,14 @@
 import { ShogunCore } from "./core";
 import { IGunUserInstance, IGunInstance, GunDataEventData, GunPeerEventData, DeriveOptions } from "./gundb/db";
 import { SEA, RxJS, crypto, derive, GunErrors, DataBase } from "./gundb/db";
+import { SimpleGunAPI, QuickStart, quickStart, createSimpleAPI, GunInstance, GunUserInstance, TypedGunOperationResult, TypedAuthResult } from "./gundb";
 import Gun from "./gundb/db";
 export * from "./utils/errorHandler";
 export * from "./plugins";
-export * from "./types/shogun";
-export type * from "./types/plugin";
-export type { IGunUserInstance, IGunInstance, GunDataEventData, GunPeerEventData, DeriveOptions, };
-export { SEA, RxJS, crypto, derive, GunErrors, DataBase };
+export * from "./interfaces/shogun";
+export type * from "./interfaces/plugin";
+export * from "./config/simplified-config";
+export type { IGunUserInstance, IGunInstance, GunDataEventData, GunPeerEventData, DeriveOptions, GunInstance, GunUserInstance, TypedGunOperationResult, TypedAuthResult, };
+export { SEA, RxJS, crypto, derive, GunErrors, DataBase, SimpleGunAPI, QuickStart, quickStart, createSimpleAPI, };
 export { Gun };
 export { ShogunCore };