@qidcloud/sdk 1.2.0 → 1.2.1

package/src/modules/edge.ts

@@ -0,0 +1,98 @@
+import { QidCloud } from '../index';
+import { QidEdgeResponse } from '../types';
+
+export class EdgeModule {
+    private sdk: QidCloud;
+
+    constructor(sdk: QidCloud) {
+        this.sdk = sdk;
+    }
+
+    /**
+     * Invoke a serverless edge function
+     * @param name Name of the function to invoke
+     * @param params Arguments passed to the function
+     * @param userToken Optional session token for user-scoped access
+     */
+    async invoke(name: string, params: any = {}, userToken?: string): Promise<QidEdgeResponse> {
+        const headers: any = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+
+        const resp = await this.sdk.api.post('/api/edge/invoke', { name, params }, { headers });
+        return resp.data;
+    }
+
+    /**
+     * List all functions in the project enclave
+     */
+    async list(): Promise<any[]> {
+        const resp = await this.sdk.api.get('/api/edge/list');
+        return resp.data;
+    }
+
+    /**
+     * Get logs for a specific function
+     * @param name Function name
+     * @param userToken Optional session token
+     */
+    async getLogs(name: string, userToken?: string): Promise<any[]> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.get(`/api/edge/${name}/logs`, { headers });
+        return resp.data;
+    }
+
+    /**
+     * Get project-wide enclave logs
+     */
+    async getProjectLogs(userToken?: string): Promise<any[]> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.get('/api/edge/logs/project', { headers });
+        return resp.data;
+    }
+
+    /**
+     * Delete a function from the enclave
+     */
+    async delete(name: string, userToken?: string): Promise<{ success: boolean }> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.delete(`/api/edge/${name}`, { headers });
+        return resp.data;
+    }
+
+    /**
+     * Deploy a new function or update an existing one
+     * @param data Deployment data including name, code, and optional envVars
+     * @param userToken Optional session token
+     */
+    async deploy(data: { name: string; code: string; runtime?: string; envVars?: any; overwrite?: boolean }, userToken?: string): Promise<{ success: boolean; message: string }> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.post('/api/edge/deploy', data, { headers });
+        return resp.data;
+    }
+
+    /**
+     * Get available serverless runtimes
+     */
+    async getRuntimes(): Promise<string[]> {
+        const resp = await this.sdk.api.get('/api/edge/runtimes');
+        return resp.data;
+    }
+
+    /**
+     * Toggle centralized logging for the project's edge functions
+     * @param enabled Whether to enable or disable logging
+     * @param userToken Optional session token
+     */
+    async toggleLogging(enabled: boolean, userToken?: string): Promise<{ success: boolean; loggingEnabled: boolean }> {
+        const headers: any = {};
+        if (userToken) headers['Authorization'] = `Bearer ${userToken}`;
+        const resp = await this.sdk.api.post('/api/edge/logs/settings', { enabled }, { headers });
+        return resp.data;
+    }
+}

package/src/modules/logs.ts

@@ -0,0 +1,30 @@
+import { QidCloud } from '../index';
+
+export class LogsModule {
+    private sdk: QidCloud;
+
+    constructor(sdk: QidCloud) {
+        this.sdk = sdk;
+    }
+
+    /**
+     * Write a custom application log to the project enclave
+     * @param message The log message
+     * @param source The source of the log (e.g. 'auth-service', 'frontend')
+     * @param level Log level (info, warn, error)
+     * @param metadata Structured data for searching/filtering
+     */
+    async write(message: string, source: string = 'app', level: string = 'info', metadata: any = {}): Promise<{ success: boolean }> {
+        const resp = await this.sdk.api.post('/api/logs', { message, source, level, metadata });
+        return resp.data;
+    }
+
+    /**
+     * Retrieve application logs for the project
+     * @param query Filters (limit, level, etc.)
+     */
+    async fetch(query: any = {}): Promise<any[]> {
+        const resp = await this.sdk.api.get('/api/logs', { params: query });
+        return resp.data;
+    }
+}

package/src/modules/vault.ts

@@ -0,0 +1,124 @@
+import { QidCloud } from '../index';
+import { QidFile, QidUploadResponse } from '../types';
+
+export class VaultModule {
+    private sdk: QidCloud;
+
+    constructor(sdk: QidCloud) {
+        this.sdk = sdk;
+    }
+
+    /**
+     * Upload a file to the project's secure enclave storage
+     * @param file The file data (Buffer or Blob)
+     * @param fileName Name of the file
+     * @param metadata Optional E2EE metadata or custom tags
+     * @param userToken Session token for user-scoped storage
+     */
+    async upload(file: any, fileName: string, metadata: any = {}, userToken?: string): Promise<QidUploadResponse> {
+        const formData = new FormData();
+        formData.append('file', file, fileName);
+        formData.append('metadata', JSON.stringify(metadata));
+
+        const headers: any = {
+            'Content-Type': 'multipart/form-data'
+        };
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+
+        const resp = await this.sdk.api.post('/api/storage/upload', formData, { headers });
+        return resp.data;
+    }
+
+    /**
+     * List files in the project enclave
+     * @param userToken Session token for user-scoped storage
+     */
+    async list(userToken?: string): Promise<QidFile[]> {
+        const headers: any = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+
+        const resp = await this.sdk.api.get('/api/storage/list', { headers });
+        return resp.data;
+    }
+
+    /**
+     * Download a file from storage
+     * @param fileId Unique ID of the file
+     * @param userToken Session token for user-scoped storage
+     */
+    async download(fileId: string, userToken?: string): Promise<ArrayBuffer> {
+        const headers: any = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+
+        const resp = await this.sdk.api.get(`/api/storage/${fileId}`, {
+            headers,
+            responseType: 'arraybuffer'
+        });
+        return resp.data;
+    }
+
+    /**
+     * Delete a file from storage (Soft Delete)
+     * @param fileId Unique ID of the file
+     * @param userToken Session token for user-scoped storage
+     */
+    async delete(fileId: string, userToken?: string): Promise<{ success: boolean; message: string }> {
+        const headers: any = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+
+        const resp = await this.sdk.api.delete(`/api/storage/${fileId}`, { headers });
+        return resp.data;
+    }
+
+    /**
+     * List deleted files in the project enclave (Recycle Bin)
+     * @param userToken Session token for user-scoped storage
+     */
+    async listDeleted(userToken?: string): Promise<QidFile[]> {
+        const headers: any = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+
+        const resp = await this.sdk.api.get('/api/storage/deleted', { headers });
+        return resp.data;
+    }
+
+    /**
+     * Restore a deleted file from the recycle bin
+     * @param fileId Unique ID of the file
+     * @param userToken Session token for user-scoped storage
+     */
+    async restore(fileId: string, userToken?: string): Promise<{ success: boolean; message: string }> {
+        const headers: any = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+
+        const resp = await this.sdk.api.post(`/api/storage/restore/${fileId}`, {}, { headers });
+        return resp.data;
+    }
+
+    /**
+     * Permanently purge a deleted file
+     * @param fileId Unique ID of the file
+     * @param userToken Session token for user-scoped storage
+     */
+    async purge(fileId: string, userToken?: string): Promise<{ success: boolean; message: string }> {
+        const headers: any = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+
+        const resp = await this.sdk.api.delete(`/api/storage/purge/${fileId}`, { headers });
+        return resp.data;
+    }
+}

package/src/types.ts

@@ -0,0 +1,52 @@
+export interface QidConfig {
+    apiKey: string;
+    tenantId: string;
+    baseUrl?: string;
+}
+
+export interface QidUser {
+    userId: string;
+    regUserId: string;
+    username: string;
+    email?: string;
+    role: string;
+}
+
+export interface QidAuthSession {
+    sessionId: string;
+    qrData: string;
+    expiresAt: number;
+}
+
+export interface QidDbResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    count?: number;
+}
+
+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;
+    };
+}

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "ESNext",
+        "moduleResolution": "node",
+        "declaration": true,
+        "outDir": "./dist",
+        "strict": true,
+        "jsx": "react",
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "lib": [
+            "DOM",
+            "ESNext"
+        ],
+        "baseUrl": ".",
+        "paths": {
+            "*": [
+                "src/*"
+            ]
+        }
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}