@qidcloud/sdk 1.2.2 → 1.2.4

package/dist/src/components/QidCloudLogin.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { QidCloud } from '../index';
+import { QidUser } from '../types';
+interface QidCloudLoginProps {
+    sdk: QidCloud;
+    onSuccess: (user: QidUser, token: string) => void;
+    onError?: (error: string) => void;
+    className?: string;
+}
+/**
+ * A comprehensive login component for QidCloud.
+ * STRICT SECURITY: ONLY supports QR Scanning (Mobile App) for Post-Quantum security.
+ * Conventional login is not available in the SDK to prevent password transmission in third-party apps.
+ */
+export declare const QidCloudLogin: React.FC<QidCloudLoginProps>;
+export {};

package/dist/{hooks → src/hooks}/useQidAuth.d.ts

@@ -7,9 +7,12 @@ export interface UseQidAuthReturn {
     error: string | null;
     session: QidAuthSession | null;
     initializing: boolean;
+    isExpired: boolean;
+    timeLeft: number;
     login: () => Promise<void>;
     logout: () => void;
     cancel: () => void;
+    setAuthenticated: (user: QidUser, token: string) => void;
 }
 /**
  * A React hook for managing QidCloud authentication lifecycle.

package/dist/{index.d.ts → src/index.d.ts}

@@ -5,6 +5,10 @@ import { DbModule } from './modules/db';
 import { EdgeModule } from './modules/edge';
 import { VaultModule } from './modules/vault';
 import { LogsModule } from './modules/logs';
+import { ProjectModule } from './modules/project';
+import { ResourceModule } from './modules/resource';
+import { SdkModule } from './modules/sdk';
+import { BillingModule } from './modules/billing';
 export declare class QidCloud {
     private config;
     api: AxiosInstance;
@@ -13,6 +17,10 @@ export declare class QidCloud {
     edge: EdgeModule;
     vault: VaultModule;
     logs: LogsModule;
+    projects: ProjectModule;
+    resources: ResourceModule;
+    sdk: SdkModule;
+    billing: BillingModule;
     constructor(config: QidConfig);
     /**
      * Get the current project configuration
@@ -22,4 +30,5 @@ export declare class QidCloud {
 export default QidCloud;
 export * from './types';
 export { QidSignInButton } from './components/QidSignInButton';
+export { QidCloudLogin } from './components/QidCloudLogin';
 export { useQidAuth } from './hooks/useQidAuth';

package/dist/src/modules/auth.d.ts

@@ -0,0 +1,155 @@
+import { QidCloud } from '../index';
+import { QidAuthSession, QidUser, QidSession } from '../types';
+export declare class AuthModule {
+    private sdk;
+    private socket;
+    constructor(sdk: QidCloud);
+    /**
+     * Initialize a new handshake session for QR login
+     */
+    createSession(): Promise<QidAuthSession>;
+    /**
+     * Listen for authorization events for a specific session
+     */
+    listen(sessionId: string, onAuthorized: (token: string) => void, onDenied?: (msg: string) => void): void;
+    /**
+     * Terminate the session on the server
+     */
+    logout(token: string): Promise<void>;
+    /**
+     * Stop listening and disconnect socket
+     */
+    disconnect(): void;
+    /**
+     * Fetch user profile using a session token
+     */
+    getProfile(token: string): Promise<QidUser>;
+    /**
+     * Login using username and password
+     */
+    login(credentials: {
+        username?: string;
+        email?: string;
+        password: string;
+    }): Promise<{
+        token: string;
+        user: QidUser;
+    }>;
+    /**
+     * Register a new user
+     */
+    register(data: {
+        username: string;
+        email: string;
+        password: string;
+        fullName?: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Initiate registration (OTP based if configured)
+     */
+    initiateRegistration(email: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Verify OTP or mobile verification
+     */
+    verify(data: {
+        email?: string;
+        otp?: string;
+        token?: string;
+    }): Promise<{
+        success: boolean;
+        token?: string;
+    }>;
+    /**
+     * Request a password reset link/OTP
+     */
+    requestPasswordReset(email: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Confirm password reset with OTP and new password
+     */
+    confirmPasswordReset(data: {
+        email: string;
+        otp: string;
+        newPassword: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Change current password (requires current token)
+     */
+    changePassword(token: string, data: {
+        currentPassword: string;
+        newPassword: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Delete user account
+     */
+    deleteAccount(token: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Toggle MFA status (Enable/Disable)
+     */
+    toggleMFA(token: string, data: {
+        enabled: boolean;
+        type: 'email' | 'totp' | 'mobile';
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Verify MFA toggle request
+     */
+    verifyMFA(token: string, otp: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Refresh the current active session
+     */
+    refreshSession(token: string): Promise<{
+        token: string;
+    }>;
+    /**
+     * List all active sessions for the user
+     */
+    getSessions(token: string): Promise<QidSession[]>;
+    /**
+     * Revoke a specific session
+     */
+    revokeSession(token: string, sessionToken: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Initiate account recovery (password reset)
+     */
+    initiateRecovery(email: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Verify recovery OTP and set new password
+     */
+    verifyRecovery(data: {
+        email: string;
+        otp: string;
+        newPassword: string;
+    }): Promise<{
+        success: boolean;
+        token: string;
+    }>;
+    /**
+     * Export all user data (GDPR requirement)
+     */
+    exportUserData(token: string): Promise<any>;
+}

package/dist/src/modules/billing.d.ts

@@ -0,0 +1,57 @@
+import { QidCloud } from '../index';
+import { QidBillingInfo, QidTransaction } from '../types';
+export declare class BillingModule {
+    private sdk;
+    constructor(sdk: QidCloud);
+    /**
+     * Retrieve all available plans and their pricing
+     */
+    getPlans(): Promise<any>;
+    /**
+     * Get detailed billing and usage info for a project
+     */
+    getProjectBillingInfo(userToken: string, tenantId: string): Promise<QidBillingInfo>;
+    /**
+     * Sync payment status after a successful Razorpay transaction
+     * @param paymentId The Razorpay payment ID
+     */
+    syncPaymentStatus(userToken: string, paymentId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Get transaction history for the current user
+     */
+    getTransactions(userToken: string): Promise<QidTransaction[]>;
+    /**
+     * Get usage analytics and history
+     */
+    getUsageAnalytics(userToken: string): Promise<any>;
+    /**
+     * Get billing alerts for a specific project
+     */
+    getBillingAlerts(userToken: string, tenantId: string): Promise<any[]>;
+    /**
+     * Create or update a billing alert
+     */
+    createBillingAlert(userToken: string, tenantId: string, data: {
+        resource: string;
+        threshold: number;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Delete a billing alert
+     */
+    deleteBillingAlert(userToken: string, alertId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Generate a consolidated financial report
+     */
+    getConsolidatedReport(userToken: string, query?: {
+        year?: number;
+        startDate?: string;
+        endDate?: string;
+    }): Promise<any>;
+}

package/dist/src/modules/db.d.ts

@@ -0,0 +1,49 @@
+import { QidCloud } from '../index';
+import { QidDbResponse, QidMigration, QidMigrateResult } from '../types';
+export declare class DbModule {
+    private sdk;
+    constructor(sdk: QidCloud);
+    /**
+     * Execute a SQL query against the project's enclave database
+     * @param sql The SQL query string
+     * @param params Parameterized values for the query
+     * @param userToken Optional session token for user-scoped access
+     */
+    query<T = any>(sql: string, params?: any[], userToken?: string): Promise<QidDbResponse<T>>;
+    /**
+     * Initialize the project's enclave database schema
+     * Useful for first-time project setup
+     */
+    setup(userToken?: string): Promise<{
+        success: boolean;
+        schemaName: string;
+    }>;
+    /**
+     * Run versioned migrations (Django-inspired).
+     * Only applies migrations that haven't been applied yet.
+     * Tracks applied migrations in a `_qid_migrations` table.
+     *
+     * @example
+     * ```ts
+     * await qid.db.migrate([
+     *   { version: '001', name: 'create_users', up: async () => { await qid.db.query('CREATE TABLE ...') } },
+     *   { version: '002', name: 'add_likes',    up: async () => { await qid.db.query('ALTER TABLE ...') } },
+     * ]);
+     * ```
+     *
+     * @param migrations Ordered array of migrations to apply
+     * @param userToken Optional session token
+     * @returns Result with applied/skipped counts
+     */
+    migrate(migrations: QidMigration[], userToken?: string): Promise<QidMigrateResult>;
+    /**
+     * Get the current migration status
+     * @param migrations The full list of registered migrations
+     * @param userToken Optional session token
+     */
+    migrateStatus(migrations: QidMigration[], userToken?: string): Promise<{
+        applied: string[];
+        pending: string[];
+        total: number;
+    }>;
+}

package/dist/src/modules/project.d.ts

@@ -0,0 +1,112 @@
+import { QidCloud } from '../index';
+import { QidProject, QidProjectSettings } from '../types';
+export declare class ProjectModule {
+    private sdk;
+    constructor(sdk: QidCloud);
+    /**
+     * Get all projects owned by the currently authenticated user
+     */
+    getMyProjects(userToken: string): Promise<QidProject[]>;
+    /**
+     * Create a new project
+     */
+    createProject(userToken: string, data: {
+        name: string;
+        tier?: string;
+    }): Promise<QidProject>;
+    /**
+     * Update project basic details (e.g. rename)
+     */
+    updateProject(userToken: string, tenantId: string, data: {
+        name: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Rotate the API key for a project
+     */
+    rotateApiKey(userToken: string, tenantId: string): Promise<{
+        success: boolean;
+        apiKey: string;
+    }>;
+    /**
+     * Get project specific settings
+     */
+    getSettings(userToken: string, tenantId: string): Promise<QidProjectSettings>;
+    /**
+     * Update project settings
+     */
+    updateSettings(userToken: string, tenantId: string, settings: QidProjectSettings): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Invite a new member to the project
+     */
+    inviteMember(userToken: string, tenantId: string, data: {
+        email: string;
+        role: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Remove a member from the project
+     */
+    removeMember(userToken: string, tenantId: string, userId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Get all users/members associated with a project
+     */
+    getProjectUsers(userToken: string, tenantId: string): Promise<any[]>;
+    /**
+     * Get all invitations for the currently authenticated user
+     */
+    getMyInvitations(userToken: string): Promise<any[]>;
+    /**
+     * Accept or reject a project invitation
+     */
+    handleInvitationAction(userToken: string, tenantId: string, action: 'accept' | 'reject'): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Update a member's permissions within a project
+     */
+    updateMemberPermissions(userToken: string, tenantId: string, userId: string, permissions: any): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Update a project user's status (active/suspended)
+     */
+    updateProjectUserStatus(userToken: string, tenantId: string, regUserId: string, status: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Unlink/Remove a user from the project identity enclave
+     */
+    unlinkProjectUser(userToken: string, tenantId: string, regUserId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Generate a new service key for the project
+     */
+    generateServiceKey(userToken: string, tenantId: string, data: {
+        name: string;
+        permissions: any;
+    }): Promise<any>;
+    /**
+     * Revoke an existing service key
+     */
+    revokeServiceKey(userToken: string, tenantId: string, keyId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Permanently wipe the project's identity enclave data
+     */
+    wipeProjectEnclave(userToken: string, tenantId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Retrieve security and audit logs for the project
+     */
+    getProjectSecurityLogs(userToken: string, tenantId: string): Promise<any[]>;
+}

package/dist/src/modules/resource.d.ts

@@ -0,0 +1,25 @@
+import { QidCloud } from '../index';
+import { QidResourceStatus } from '../types';
+export declare class ResourceModule {
+    private sdk;
+    constructor(sdk: QidCloud);
+    /**
+     * Get the status of all resources for a specific tenant
+     */
+    getStatus(userToken: string, tenantId: string): Promise<QidResourceStatus[]>;
+    /**
+     * Provision a new resource type for a project
+     * @param resourceType 'database' | 'storage' | 'edge'
+     */
+    provision(userToken: string, tenantId: string, resourceType: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Dissolve (delete) an existing resource from a project
+     */
+    dissolve(userToken: string, tenantId: string, resourceType: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}

package/dist/src/modules/sdk.d.ts

@@ -0,0 +1,29 @@
+import { QidCloud } from '../index';
+export declare class SdkModule {
+    private sdk;
+    constructor(sdk: QidCloud);
+    /**
+     * Get allowed origins for a project
+     */
+    getOrigins(userToken: string, tenantId: string): Promise<string[]>;
+    /**
+     * Add an allowed origin for SDK requests
+     */
+    addOrigin(userToken: string, tenantId: string, domain: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Remove an allowed origin
+     */
+    removeOrigin(userToken: string, tenantId: string, domain: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Test if an origin is allowed
+     */
+    testOrigin(userToken: string, tenantId: string, domain: string): Promise<{
+        allowed: boolean;
+    }>;
+}

package/dist/{modules → src/modules}/vault.d.ts

@@ -1,31 +1,48 @@
 import { QidCloud } from '../index';
-import { QidFile, QidUploadResponse } from '../types';
+import { QidFile, QidUploadResponse, QidUploadOptions } from '../types';
 export declare class VaultModule {
     private sdk;
     constructor(sdk: QidCloud);
     /**
-     * Upload a file to the project's secure enclave storage
-     * @param file The file data (Buffer or Blob)
+     * Upload a file to the project's secure enclave storage.
+     *
+     * Files < 10MB use single-shot upload.
+     * Files >= 10MB automatically use chunked upload with progress tracking.
+     *
+     * @param file The file data (Buffer, Blob, or File)
      * @param fileName Name of the file
      * @param metadata Optional E2EE metadata or custom tags
      * @param userToken Session token for user-scoped storage
+     * @param options Upload options (onProgress callback, custom chunk size)
      */
-    upload(file: any, fileName: string, metadata?: any, userToken?: string): Promise<QidUploadResponse>;
+    upload(file: any, fileName: string, metadata?: any, userToken?: string, options?: QidUploadOptions): Promise<QidUploadResponse>;
+    /**
+     * Single-shot upload for small files (< 10MB)
+     */
+    private _singleUpload;
+    /**
+     * Chunked upload for large files (>= 10MB)
+     * Flow: init → upload chunks → complete
+     */
+    private _chunkedUpload;
+    /**
+     * Get the status of a chunked upload (for resume support)
+     */
+    getUploadStatus(uploadId: string, userToken?: string): Promise<any>;
+    /**
+     * Resume a partially completed chunked upload
+     */
+    resumeUpload(uploadId: string, file: any, userToken?: string, options?: QidUploadOptions): Promise<QidUploadResponse>;
     /**
      * List files in the project enclave
-     * @param userToken Session token for user-scoped storage
      */
     list(userToken?: string): Promise<QidFile[]>;
     /**
      * Download a file from storage
-     * @param fileId Unique ID of the file
-     * @param userToken Session token for user-scoped storage
      */
     download(fileId: string, userToken?: string): Promise<ArrayBuffer>;
     /**
      * Delete a file from storage (Soft Delete)
-     * @param fileId Unique ID of the file
-     * @param userToken Session token for user-scoped storage
      */
     delete(fileId: string, userToken?: string): Promise<{
         success: boolean;
@@ -33,13 +50,10 @@ export declare class VaultModule {
     }>;
     /**
      * List deleted files in the project enclave (Recycle Bin)
-     * @param userToken Session token for user-scoped storage
      */
     listDeleted(userToken?: string): Promise<QidFile[]>;
     /**
      * Restore a deleted file from the recycle bin
-     * @param fileId Unique ID of the file
-     * @param userToken Session token for user-scoped storage
      */
     restore(fileId: string, userToken?: string): Promise<{
         success: boolean;
@@ -47,8 +61,6 @@ export declare class VaultModule {
     }>;
     /**
      * Permanently purge a deleted file
-     * @param fileId Unique ID of the file
-     * @param userToken Session token for user-scoped storage
      */
     purge(fileId: string, userToken?: string): Promise<{
         success: boolean;

package/dist/src/types.d.ts

@@ -0,0 +1,126 @@
+export interface QidConfig {
+    apiKey: string;
+    tenantId?: string;
+    baseUrl?: string;
+}
+export interface QidUser {
+    userId: string;
+    regUserId: string;
+    username: string;
+    email?: string;
+    role: string;
+    fullName?: string;
+    mfaEnabled?: boolean;
+    createdAt?: Date;
+}
+export interface QidSession {
+    token: string;
+    lastActive: Date;
+    ip?: string;
+    userAgent?: string;
+}
+export interface QidAuthSession {
+    sessionId: string;
+    qrData: string;
+    expiresAt: number;
+}
+export interface QidDbResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    count?: number;
+    meta?: any;
+}
+export interface QidEdgeResponse {
+    success: boolean;
+    result: any;
+    computeTime: string;
+    logs?: string[];
+}
+export interface QidFile {
+    fileId: string;
+    originalName: string;
+    mimeType: string;
+    size: number;
+    createdAt: string;
+    clientMetadata?: any;
+}
+export interface QidUploadResponse {
+    success: boolean;
+    message: string;
+    file: {
+        id: string;
+        name: string;
+        url: string;
+    };
+}
+export interface QidProject {
+    _id: string;
+    name: string;
+    tenantId: string;
+    apiKey: string;
+    owner: string;
+    tier: 'free' | 'pro' | 'elite' | 'enterprise';
+    status: 'active' | 'suspended' | 'pending';
+}
+export interface QidProjectSettings {
+    displayName?: string;
+    allowedOrigins?: string[];
+    enclaveConfig?: any;
+}
+export interface QidResourceStatus {
+    resourceType: string;
+    status: 'active' | 'provisioning' | 'failed' | 'dissolved';
+    endpoint?: string;
+    details?: any;
+}
+export interface QidBillingInfo {
+    plan: string;
+    profile: string;
+    estimatedMonthly: number;
+    estimatedHourly: string;
+    infraValueUSD: string;
+    currency: string;
+    activeEnclaves: string[];
+    billingNote?: string;
+}
+export interface QidTransaction {
+    transactionId: string;
+    amount: number;
+    date: string;
+    status: string;
+    planId: string;
+    currency?: string;
+}
+export interface QidBillingAlert {
+    _id: string;
+    resource: string;
+    threshold: number;
+    status: string;
+}
+export interface QidMigration {
+    version: string;
+    name: string;
+    up: () => Promise<void>;
+}
+export interface QidMigrateResult {
+    success: boolean;
+    applied: string[];
+    skipped: string[];
+    failed?: {
+        version: string;
+        error: string;
+    };
+    total: number;
+}
+export interface QidUploadProgress {
+    percent: number;
+    uploadedChunks: number;
+    totalChunks: number;
+    uploadedBytes: number;
+    totalBytes: number;
+}
+export interface QidUploadOptions {
+    onProgress?: (progress: QidUploadProgress) => void;
+    chunkSize?: number;
+}