@taruvi/sdk 1.0.0

package/USAGE_EXAMPLE.md

@@ -0,0 +1,86 @@
+# Taruvi SDK - Usage Example
+
+## New Pattern: Dependency Injection (No Singleton)
+
+### Basic Usage
+
+```typescript
+import { Client, Auth, User, Database } from '@taruvi/sdk'
+
+// 1. Create the main client (can create multiple instances)
+const client = new Client({
+  apiKey: 'your-site-key',
+  appSlug: 'my-app',
+  baseUrl: 'https://api.taruvi.com',
+  token: 'optional-initial-token' // optional
+})
+
+// 2. Create only the clients you need (lazy initialization)
+const auth = new Auth(client)
+const user = new User(client)
+const database = new Database(client)
+
+// 3. Use the clients
+if (auth.isUserAuthenticated()) {
+  console.log('User is authenticated')
+}
+
+const token = auth.signInWithSSO()
+console.log('Token:', token)
+
+const userDetails = user.getUser()
+console.log('User:', userDetails)
+
+// Access token via User
+console.log('Current token:', user.token)
+```
+
+### Multiple Instances
+
+You can now create multiple instances for different environments or configs:
+
+```typescript
+const prodClient = new Client({
+  apiKey: 'prod-key',
+    appSlug: 'main-app',
+  baseUrl: 'https://api.taruvi.com'
+})
+
+const devClient = new Client({
+  apiKey: 'dev-key',
+    appSlug: 'dev-app',
+  baseUrl: 'https://dev-api.taruvi.com'
+})
+
+const prodAuth = new Auth(prodClient)
+const devAuth = new Auth(devClient)
+```
+
+### Benefits
+
+✅ **No singleton** - Multiple instances possible
+✅ **Lazy initialization** - Only create clients you need
+✅ **Better testability** - Easy to mock and test
+✅ **Explicit dependencies** - Clear what each client needs
+✅ **No global state** - No hidden global `taruvi` variable
+✅ **Tree-shakable** - Only bundle what you use
+
+### Internal Architecture
+
+The `taruvi` variable is no longer exported. Internal clients like `httpClient` and `tokenClient` are accessible only within the SDK through the `Client` instance passed to each client.
+
+```typescript
+// Inside Auth
+export class Auth {
+  private client: Client
+
+  constructor(client: Client) {
+    this.client = client
+  }
+
+  isUserAuthenticated(): boolean {
+    // Access internal tokenClient through the client instance
+    return !!this.client.tokenClient.getToken()
+  }
+}
+```

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@taruvi/sdk",
+  "version": "1.0.0",
+  "description": "Taruvi SDK",
+  "main": "src/index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "taruvi",
+    "sdk",
+    "EOX Vantage"
+  ],
+  "author": "Curran C Doddabele",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "@types/node": "^18.0.0 || ^20.0.0 || ^22.0.0",
+    "axios": "^1.0.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,81 @@
+import { HttpClient } from "./lib-internal/http/HttpClient.js";
+import { TokenClient } from "./lib-internal/token/TokenClient.js";
+import type { TaruviConfig } from "./types.js";
+
+export class Client {
+    private readonly config: TaruviConfig
+    private readonly _httpClient: HttpClient
+    private readonly _tokenClient: TokenClient
+
+    constructor(config: TaruviConfig) {
+        if (!config) {
+            throw new Error("Config is required")
+        }
+
+        if (!config.apiKey) {
+            throw new Error("API key is required")
+        }
+
+        if (!config.baseUrl) {
+            throw new Error("Base URL is required")
+        }
+
+        this.config = config
+
+        // Internal clients for SDK use only
+        // TokenClient must be created first, then passed to HttpClient
+
+        this._tokenClient = new TokenClient(config.token)
+        this._httpClient = new HttpClient(this.config, this._tokenClient)
+
+        // Check URL hash for tokens (OAuth callback)
+        this.extractTokensFromUrl()
+    }
+
+    /**
+     * Extracts access_token and refresh_token from URL hash and stores them in localStorage.
+     * This handles OAuth callback URLs like: #access_token=xxx&refresh_token=xxx
+     */
+    private extractTokensFromUrl(): void {
+        if (typeof window === "undefined" || typeof localStorage === "undefined") {
+            return
+        }
+
+        const hash = window.location.hash
+        if (!hash) {
+            return
+        }
+
+        const params = new URLSearchParams(hash.substring(1))
+        const accessToken = params.get("access_token")
+        const refreshToken = params.get("refresh_token")
+
+        if (accessToken) {
+            localStorage.setItem("jwt", accessToken)
+        }
+
+        if (refreshToken) {
+            localStorage.setItem("refresh_token", refreshToken)
+        }
+    }
+
+    /**
+     * @internal
+     * Internal use only - not part of public API
+     */
+    get httpClient(): HttpClient {
+        return this._httpClient
+    }
+
+    /**
+     * @internal
+     * Internal use only - not part of public API
+     */
+    get tokenClient(): TokenClient {
+        return this._tokenClient
+    }
+
+    getConfig(): Readonly<TaruviConfig> {
+        return { ...this.config }
+    }
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+// Export main client
+export { Client } from "./client.js"
+
+// Export public client classes
+export { Auth } from "./lib/auth/AuthClient.js"
+export { User } from "./lib/user/UserClient.js"
+export { Storage } from "./lib/Storage/StorageClient.js"
+export { Database } from "./lib/Database/DatabaseClient.js"
+export { Settings } from "./lib/Settings/SettingsClient.js"
+export { Functions } from "./lib/Function/FunctionsClient.js"
+export { Secrets } from "./lib/Secrets/SecretsClient.js"
+
+// Export types
+export type { TaruviConfig, StorageFilters, DatabaseFilters } from "./types.js"
+export type { UserCreateRequest, UserCreateResponse as UserResponse, UserDataResponse } from "./lib/user/types.js"
+export type { FunctionRequest, FunctionResponse, FunctionInvocation } from "./lib/Function/types.js"
+export type { DatabaseRequest, DatabaseResponse } from "./lib/Database/types.js"
+export type { StorageRequest, StorageUpdateRequest, StorageResponse } from "./lib/Storage/types.js"
+export type { SettingsRequest, SettingsResponse, SettingsMetadataResponse } from "./lib/Settings/types.js"
+export type { SecretRequest, SecretResponse } from "./lib/Secrets/types.js"

package/src/lib/Database/DatabaseClient.ts

@@ -0,0 +1,87 @@
+import type { Client } from "../../client.js";
+import { DatabaseRoutes } from "../../lib-internal/routes/DatabaseRoutes.js";
+import { HttpMethod } from "../../lib-internal/http/types.js";
+import type { TaruviConfig, DatabaseFilters } from "../../types.js";
+import type { UrlParams } from "./types.js";
+import { buildQueryString } from "../../utils/utils.js";
+
+// Used to access app data
+export class Database {
+    private client: Client
+    private urlParams: UrlParams
+    private config: TaruviConfig
+    private operation: HttpMethod | undefined
+    private body: object | undefined
+    private filters: DatabaseFilters | undefined
+
+    constructor(client: Client, urlParams: UrlParams, operation?: HttpMethod | undefined, body?: object | undefined, filters?: DatabaseFilters) {
+        this.client = client
+        this.urlParams = urlParams
+        this.operation = operation
+        this.body = body
+        this.config = this.client.getConfig()
+        this.filters = filters
+    }
+
+    from(dataTables: string): Database {
+        return new Database(this.client, { ...this.urlParams, dataTables }, undefined, undefined)
+    }
+
+    filter(filters: DatabaseFilters): Database {
+        return new Database(this.client, { ...this.urlParams }, undefined, undefined, filters)
+    }
+
+    get(recordId: string): Database {
+        return new Database(this.client, this.urlParams = { ...this.urlParams, recordId }, HttpMethod.GET)
+    }
+
+    update(body: any): Database {
+        return new Database(this.client, this.urlParams = { ...this.urlParams }, HttpMethod.POST, body)
+    }
+
+    delete(recordId?: any): Database {
+        return new Database(this.client, this.urlParams = { ...this.urlParams, recordId }, HttpMethod.DELETE)
+    }
+
+    private buildRoute(): string {
+        return DatabaseRoutes.baseUrl(this.config.appSlug) + Object.keys(this.urlParams).reduce((acc, key) => {
+            if (this.urlParams[key] && DatabaseRoutes[key]) {
+                acc += DatabaseRoutes[key](this.urlParams[key])
+            }
+            return acc
+        }, "") + "/" + buildQueryString(this.filters)
+    }
+
+    async execute() {
+        // Build the API URL
+        const url = this.buildRoute()
+        const fullUrl = `sites/eox_site/${url}` //remove for productions because baseurl is in the appscope, no need for site
+
+        const operation = this.operation || HttpMethod.GET
+
+        switch (operation) {
+            case HttpMethod.POST:
+                return await this.client.httpClient.post(fullUrl, this.body)
+
+            case HttpMethod.PUT:
+                if (!this.urlParams.recordId) {
+                    throw new Error('PUT operation requires a record ID. Use .get(recordId) before .update()')
+                }
+                return await this.client.httpClient.put(fullUrl, this.body)
+
+            case HttpMethod.DELETE:
+                return await this.client.httpClient.delete(fullUrl)
+
+            case HttpMethod.GET:
+            default:
+                return await this.client.httpClient.get(fullUrl)
+        }
+    }
+}
+
+
+// TODO: Implement storage operations
+// - upload files
+// - download files
+// - delete files
+// - list files

package/src/lib/Database/types.ts

@@ -0,0 +1,29 @@
+import type { Client } from "../../client.js"
+import { HttpMethod } from "../../lib-internal/http/types.js"
+
+export type DatabaseOperation = HttpMethod
+
+// Internal types
+export interface UrlParams {
+    appSlug?: string
+    dataTables?: string
+    recordId?: string
+}
+
+export interface DatabaseClientInterface {
+    client: Client
+    urlParams?: UrlParams
+}
+
+// Request types
+export interface DatabaseRequest {
+    [key: string]: unknown
+}
+
+// Response types
+export interface DatabaseResponse<T = unknown> {
+    id?: string | number
+    created_at?: string
+    updated_at?: string
+    [key: string]: T | string | number | undefined
+}

package/src/lib/Function/FunctionsClient.ts

@@ -0,0 +1,27 @@
+import type { Client } from "../../client.js";
+import type { TaruviConfig } from "../../types.js";
+import type { FunctionRequest, FunctionResponse } from "./types.js";
+import { FunctionRoutes } from "../../lib-internal/routes/FunctionRoutes.js";
+
+export class Functions {
+    private client: Client
+    private config: TaruviConfig
+
+    constructor(client: Client) {
+        this.client = client
+        this.config = this.client.getConfig()
+    }
+
+    async execute<T = unknown>(functionSlug: string, options: FunctionRequest = {}): Promise<FunctionResponse<T>> {
+        const url = `${FunctionRoutes.baseUrl(this.config.appSlug, functionSlug)}/execute/`
+
+        const body = {
+            async: options.async ?? false,
+            params: {   
+                ...options.params
+            }
+        }
+
+        return await this.client.httpClient.post<FunctionResponse<T>>(url, body)
+    }
+}

package/src/lib/Function/types.ts

@@ -0,0 +1,17 @@
+export interface FunctionRequest {
+    async?: boolean
+    params?: Record<string, unknown>
+}
+
+export interface FunctionInvocation {
+    invocation_id: number
+    celery_task_id: string
+    status: string
+    created_at: string
+    updated_at: string
+}
+
+export interface FunctionResponse<T = unknown> {
+    data: T | null
+    invocation: FunctionInvocation
+}

package/src/lib/Secrets/SecretsClient.ts

@@ -0,0 +1,44 @@
+import type { Client } from "../../client.js";
+import type { SecretsUrlParams } from "./types.js";
+import { HttpMethod } from "../../lib-internal/http/types.js";
+import { SecretsRoutes } from "../../lib-internal/routes/SecretsRoutes.js";
+
+export class Secrets {
+    private client: Client
+    private urlParams: SecretsUrlParams
+    private body: object | undefined
+    private method: HttpMethod
+
+    constructor(client: Client, urlParams: SecretsUrlParams = {}, body?: object, method: HttpMethod = HttpMethod.GET) {
+        this.client = client
+        this.urlParams = urlParams
+        this.body = body
+        this.method = method
+    }
+
+    list(): Secrets {
+        return new Secrets(this.client, { path: SecretsRoutes.baseUrl }, undefined, HttpMethod.GET)
+    }
+
+    get(key: string): Secrets {
+        const path = SecretsRoutes.get(key)
+        return new Secrets(this.client, { ...this.urlParams, path }, undefined, HttpMethod.GET)
+    }
+
+    update(key: string, body: object): Secrets {
+        const path = SecretsRoutes.update(key)
+        return new Secrets(this.client, { ...this.urlParams, path }, body, HttpMethod.PUT)
+    }
+
+    async execute<T = unknown>(): Promise<T> {
+        const url = this.urlParams.path ?? SecretsRoutes.baseUrl
+
+        switch (this.method) {
+            case HttpMethod.PUT:
+                return await this.client.httpClient.put<T>(url, this.body)
+            case HttpMethod.GET:
+            default:
+                return await this.client.httpClient.get<T>(url)
+        }
+    }
+}

package/src/lib/Secrets/types.ts

@@ -0,0 +1,17 @@
+// Internal types
+export interface SecretsUrlParams {
+    path?: string
+}
+
+// Request types
+export interface SecretRequest {
+    value: string
+}
+
+// Response types
+export interface SecretResponse {
+    key: string
+    value: string
+    created_at?: string
+    updated_at?: string
+}

package/src/lib/Settings/SettingsClient.ts

@@ -0,0 +1,14 @@
+import type { Client } from "../../client.js";
+import { SettingsRoutes } from "../../lib-internal/routes/SettingsRoutes.js";
+
+export class Settings {
+    private client: Client
+
+    constructor(client: Client) {
+        this.client = client
+    }
+
+    async get<T = unknown>(): Promise<T> {
+        return await this.client.httpClient.get<T>(SettingsRoutes.metadata)
+    }
+}

package/src/lib/Settings/types.ts

@@ -0,0 +1,4 @@
+// Response types
+export interface SettingsResponse {
+    [key: string]: unknown
+}

package/src/lib/Storage/StorageClient.ts

@@ -0,0 +1,88 @@
+import type { Client } from "../../client.js";
+import type { BucketFileUpload, BucketUrlParams } from "./types.js";
+import { StorageRoutes } from "../../lib-internal/routes/StorageRoutes.js";
+import type { TaruviConfig, StorageFilters } from "../../types.js";
+import { HttpMethod } from "../../lib-internal/http/types.js";
+import { buildQueryString } from "../../utils/utils.js";
+
+export class Storage {
+
+    private client: Client
+    private config: TaruviConfig
+    private urlParams: BucketUrlParams
+    private operation: HttpMethod | undefined
+    private body: object | undefined
+    private filters: StorageFilters | undefined
+
+
+    constructor(client: Client, urlParams: BucketUrlParams, operation?: HttpMethod | undefined, body?: object, filters?: StorageFilters) {
+        this.client = client
+        this.urlParams = urlParams
+        this.operation = operation
+        this.config = this.client.getConfig()
+        this.body = body
+        this.filters = filters
+    }
+
+
+    from(bucket: string): Storage {
+        return new Storage(this.client, { ...this.urlParams, bucket }, undefined, undefined)
+    }
+
+    filter(filters: StorageFilters) {
+        return new Storage(this.client, { ...this.urlParams }, undefined, undefined, filters)
+    }
+
+    delete(path: string): Storage {
+        return new Storage(this.client, { ...this.urlParams, path }, HttpMethod.DELETE)
+    }
+
+    update(path: string, body: object): Storage {
+        return new Storage(this.client, { ...this.urlParams, path }, HttpMethod.PUT, body)
+    }
+
+    download(path: string): Storage {
+        return new Storage(this.client, { ...this.urlParams, path }, HttpMethod.GET)
+    }
+
+    upload(filesData: { files: File[], metadatas: object[], paths: string[] }): Storage {
+        const formData = new FormData()
+        filesData.files.forEach(f => formData.append('files', f))
+        formData.append('paths', JSON.stringify(filesData.paths))
+        formData.append('metadata', JSON.stringify(filesData.metadatas))
+        return new Storage(this.client, {
+            ...this.urlParams, upload: "upload"
+        }, HttpMethod.POST, formData)
+    }
+
+
+    private buildRoute(): string {
+        return StorageRoutes.baseUrl(this.config.appSlug, this.urlParams.bucket) + Object.keys(this.urlParams).reduce((acc, key) => {
+            if (this.urlParams[key] && StorageRoutes[key]) {
+                acc += StorageRoutes[key](this.urlParams[key])
+            }
+            return acc
+        }, "") + "/" + buildQueryString(this.filters as Record<string, unknown>)
+    }
+
+    async execute(): Promise<T> {
+        const url = this.buildRoute()
+        const operation = this.operation || HttpMethod.GET
+
+
+        switch (operation) {
+            case HttpMethod.POST:
+                return await this.client.httpClient.post(url, this.body)
+
+            case HttpMethod.PUT:
+                return await this.client.httpClient.put(url, this.body)
+
+            case HttpMethod.DELETE:
+                return await this.client.httpClient.delete(url)
+
+            case HttpMethod.GET:
+            default:
+                return await this.client.httpClient.get(url)
+        }
+    }
+}

package/src/lib/Storage/types.ts

@@ -0,0 +1,40 @@
+// Internal types
+export interface BucketUrlParams {
+    appSlug: string
+    bucket: string
+    path?: string | undefined
+    upload: string,
+}
+
+export interface BucketFileUpload {
+    files: []
+    path: string
+    metadata?: Record<string, unknown>
+}
+
+// Request types
+export interface StorageRequest {
+    files: File[]
+    paths: string[]
+    metadatas: object[]
+}
+
+export interface StorageUpdateRequest {
+    metadata?: Record<string, unknown>
+    visibility?: 'public' | 'private'
+}
+
+// Response types
+export interface StorageResponse {
+    id: number
+    uuid: string
+    filename: string
+    file_path: string
+    file_url: string
+    size: number
+    mimetype: string
+    metadata?: Record<string, unknown>
+    visibility?: string
+    created_at: string
+    updated_at: string
+}

package/src/lib/auth/AuthClient.ts

@@ -0,0 +1,64 @@
+import type { Client } from "../../client.js";
+import { User } from "../user/UserClient.js";
+import { Settings } from "../Settings/SettingsClient.js";
+
+// handles user auth not dev auth
+export class Auth {
+    private client: Client
+
+    constructor(client: Client) {
+        this.client = client
+    }
+
+    async authenticateUser() {
+    //     const myHeaders = new Headers();
+    //     myHeaders.append("sec-ch-ua-platform", "\"Linux\"");
+    //     myHeaders.append("Referer", "http://localhost:5173/");
+    //     myHeaders.append("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36");
+    //     myHeaders.append("sec-ch-ua", "\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"");
+    //     myHeaders.append("Content-Type", "application/json");
+    //     myHeaders.append("sec-ch-ua-mobile", "?0");
+
+    //     const raw = JSON.stringify({
+    //         "password": "admin123",
+    //         "email": "admin@example.com"
+    //     });
+
+    //     const requestOptions: RequestInit = {
+    //         method: "POST",
+    //         headers: myHeaders,
+    //         body: raw,
+    //         redirect: "follow"
+    //     };
+
+    //     await fetch("https://test-api.taruvi.cloud/api/v1/auth/login", requestOptions)
+    //         .then((response) => response.json())
+    //         .then((result) => {
+    //             localStorage.setItem("jwt", result.meta.accesstoken)
+    //         })
+    //         .catch((error) => console.error(error));
+    }
+
+    async isUserAuthenticated(): Promise<boolean> {
+        const authValue = localStorage.getItem("jwt")
+        return authValue ? true : false
+    }
+
+    async redirectToLogin() {
+        const settings = new Settings(this.client)
+        // let { frontEndUrl } = await settings.get().execute()
+        let frontEndUrl
+        const currentUrl = window.location.href
+        
+        if (!frontEndUrl) frontEndUrl = this.client.getConfig().deskUrl
+        window.location.href = frontEndUrl + `?redirect=${currentUrl}`
+    }
+
+    // TODO: Implement authentication methods
+    // - signInWithSSO
+    // - signInWithPassword ?
+    // - signOut
+    // - isUserAuthenticated
+    // - refreshSession
+    // - redirectToLogin
+}

package/src/lib/auth/types.ts

@@ -0,0 +1,9 @@
+export interface SignInWithPassword {
+    username: string,
+    password: string
+}
+
+export interface AuthClientInterface {
+    baseUrl: string,
+    apiKey?: string
+}