@taruvi/sdk 1.3.0 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taruvi/sdk",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Taruvi SDK",
   "main": "src/index.ts",
   "type": "module",

package/src/index.ts

@@ -12,11 +12,24 @@ export { Secrets } from "./lib/Secrets/SecretsClient.js"
 export { Policy } from "./lib/Policy/PolicyClient.js"
 export { App } from "./lib/App/AppClient.js"
 export { Analytics } from "./lib/Analytics/AnalyticsClient.js"
+export { Graph } from "./lib/Graphs/GraphClient.js"
 
 // Export types
 export type { TaruviConfig, StorageFilters, DatabaseFilters } from "./types.js"
 export type { AuthTokens } from "./lib-internal/token/TokenClient.js"
-export type { UserCreateRequest, UserCreateResponse as UserResponse, UserDataResponse, UserUpdateRequest, UserUpdateResponse, UserGroup, UserPermission, UserRole, UserList, UserApp, UserAppsResponse } from "./lib/user/types.js"
+export type {
+  UserCreateRequest,
+  UserCreateResponse as UserResponse,
+  UserDataResponse as TaruviUser,
+  UserUpdateRequest,
+  UserUpdateResponse,
+  UserGroup,
+  UserPermission,
+  UserRole,
+  UserList,
+  UserApp,
+  UserAppsResponse
+} from "./lib/user/types.js"
 export type { Principal, Resource, Resources } from "./lib/Policy/types.js"
 export type { RoleResponse, SettingsResponse as AppSettingsResponse } from "./lib/App/types.js"
 export type { FunctionRequest, FunctionResponse, FunctionInvocation } from "./lib/Function/types.js"
@@ -24,4 +37,5 @@ export type { DatabaseRequest, DatabaseResponse, FilterOperator, SortOrder } fro
 export type { StorageRequest, StorageUpdateRequest, StorageResponse } from "./lib/Storage/types.js"
 export type { SettingsResponse } from "./lib/Settings/types.js"
 export type { SecretRequest, SecretResponse } from "./lib/Secrets/types.js"
-export type { AnalyticsRequest, AnalyticsResponse } from "./lib/Analytics/types.js"
+export type { AnalyticsRequest, AnalyticsResponse } from "./lib/Analytics/types.js"
+export type { GraphInclude, GraphFormat, GraphQueryParams, EdgeRequest, EdgeResponse } from "./lib/Graphs/types.js"

package/src/lib/Graphs/GraphClient.ts

@@ -0,0 +1,105 @@
+import type { Client } from "../../client.js"
+import type { TaruviConfig } from "../../types.js"
+import type { GraphInclude, GraphFormat, GraphQueryParams, GraphUrlParams, EdgeRequest, EdgeResponse } from "./types.js"
+import { GraphRoutes, GraphEdgeRoutes, type GraphRouteKey } from "../../lib-internal/routes/GraphRoutes.js"
+import { buildQueryString } from "../../utils/utils.js"
+import { HttpMethod } from "../../lib-internal/http/types.js"
+
+export class Graph<T = Record<string, unknown>> {
+    private client: Client
+    private config: TaruviConfig
+    private urlParams: GraphUrlParams
+    private queryParams: GraphQueryParams
+    private operation: HttpMethod | undefined
+    private body: object | undefined
+    private edgeRoute: string | undefined
+
+    constructor(client: Client, urlParams: GraphUrlParams = {}, queryParams: GraphQueryParams = {}, operation?: HttpMethod, body?: object, edgeRoute?: string) {
+        this.client = client
+        this.config = this.client.getConfig()
+        this.urlParams = urlParams
+        this.queryParams = queryParams
+        this.operation = operation
+        this.body = body
+        this.edgeRoute = edgeRoute
+    }
+
+    from<U = Record<string, unknown>>(dataTables: string): Graph<U> {
+        return new Graph<U>(this.client, { ...this.urlParams, dataTables }, { ...this.queryParams })
+    }
+
+    get(recordId: string): Graph<T> {
+        return new Graph<T>(this.client, { ...this.urlParams, recordId }, { ...this.queryParams })
+    }
+
+    include(direction: GraphInclude): Graph<T> {
+        return new Graph<T>(this.client, { ...this.urlParams }, { ...this.queryParams, include: direction })
+    }
+
+    depth(n: number): Graph<T> {
+        return new Graph<T>(this.client, { ...this.urlParams }, { ...this.queryParams, depth: n })
+    }
+
+    format(fmt: GraphFormat): Graph<T> {
+        return new Graph<T>(this.client, { ...this.urlParams }, { ...this.queryParams, format: fmt })
+    }
+
+    types(types: string[]): Graph<T> {
+        return new Graph<T>(this.client, { ...this.urlParams }, { ...this.queryParams, graph_types: types.join(',') })
+    }
+
+    listEdges(): Graph<T> {
+        const route = GraphEdgeRoutes.baseUrl(this.config.appSlug) + GraphEdgeRoutes.edges(this.urlParams.dataTables!) + "/"
+        return new Graph<T>(this.client, { ...this.urlParams }, {}, HttpMethod.GET, undefined, route)
+    }
+
+    createEdge(edge: EdgeRequest): Graph<T> {
+        const route = GraphEdgeRoutes.baseUrl(this.config.appSlug) + GraphEdgeRoutes.edges(this.urlParams.dataTables!) + "/"
+        return new Graph<T>(this.client, { ...this.urlParams }, {}, HttpMethod.POST, edge, route)
+    }
+
+    updateEdge(edgeId: string, edge: EdgeRequest): Graph<T> {
+        const route = GraphEdgeRoutes.baseUrl(this.config.appSlug) + GraphEdgeRoutes.edges(this.urlParams.dataTables!) + GraphEdgeRoutes.edgeId(edgeId) + "/"
+        return new Graph<T>(this.client, { ...this.urlParams }, {}, HttpMethod.PATCH, edge, route)
+    }
+
+    deleteEdge(edgeIds: string[]): Graph<T> {
+        const route = GraphEdgeRoutes.baseUrl(this.config.appSlug) + GraphEdgeRoutes.edges(this.urlParams.dataTables!) + "/"
+        return new Graph<T>(this.client, { ...this.urlParams }, {}, HttpMethod.DELETE, edgeIds, route)
+    }
+
+    private buildRoute(): string {
+        if (this.edgeRoute) return this.edgeRoute
+
+        return (
+            GraphRoutes.baseUrl(this.config.appSlug) +
+            (Object.keys(this.urlParams) as GraphRouteKey[]).reduce((acc, key) => {
+                const value = this.urlParams[key]
+                const routeBuilder = GraphRoutes[key]
+                if (value && routeBuilder) {
+                    acc += routeBuilder(value)
+                }
+                return acc
+            }, "") +
+            "/" +
+            buildQueryString(this.queryParams as Record<string, unknown>)
+        )
+    }
+
+    async execute(): Promise<T | 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.PATCH:
+                return await this.client.httpClient.patch(url, this.body)
+            case HttpMethod.DELETE:
+                return await this.client.httpClient.delete(url, this.body)
+            case HttpMethod.GET:
+            default:
+                return await this.client.httpClient.get(url)
+        }
+    }
+}

package/src/lib/Graphs/types.ts

@@ -0,0 +1,26 @@
+export type GraphInclude = 'descendants' | 'ancestors' | 'both'
+export type GraphFormat = 'tree' | 'graph'
+
+export interface GraphQueryParams {
+    include?: GraphInclude
+    depth?: number
+    format?: GraphFormat
+    graph_types?: string
+}
+
+export interface GraphUrlParams {
+    dataTables?: string
+    recordId?: string
+}
+
+export interface EdgeRequest {
+    from_id: number
+    to_id: number
+    type: string
+    metadata?: Record<string, unknown>
+}
+
+export interface EdgeResponse extends EdgeRequest {
+    id: number
+    created_at?: string
+}

package/src/lib-internal/routes/GraphRoutes.ts

@@ -0,0 +1,14 @@
+export const GraphRoutes = {
+    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
+    dataTables: (tableName: string): string => `/datatables/${tableName}/data`,
+    recordId: (recordId: string): string => `/${recordId}`
+}
+
+export const GraphEdgeRoutes = {
+    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
+    edges: (tableName: string): string => `/datatables/${tableName}/edges`,
+    edgeId: (edgeId: string): string => `/${edgeId}`
+}
+
+type AllRouteKeys = keyof typeof GraphRoutes
+export type GraphRouteKey = Exclude<AllRouteKeys, 'baseUrl'>

package/src/utils/enums.ts

@@ -14,3 +14,11 @@ export const Visibility = {
 } as const
 
 export type Visibility = typeof Visibility[keyof typeof Visibility]
+
+
+export const QueryParams = {
+    include: "include",
+    depth: "depth",
+    format: "format",
+    graph_type: "graph_type",
+}