@redonvn/redai-backend-api-sdk 0.1.10 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redonvn/redai-backend-api-sdk",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Axios SDK for RedAI Dynamic Table APIs",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -27,9 +27,6 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "clean": "node -e \"require('fs').rmSync('dist',{ recursive: true, force: true })\"",
     "generate": "cross-env GEN_MODE=hybrid OUTPUT_REPORT=true tsx tools/generate-dynamic-table-sdk.ts",

package/src/core/auth.ts

@@ -0,0 +1,62 @@
+import { DynamicTableTokenProvider } from './types';
+
+export interface AuthState {
+  bearerToken: string | null;
+  dtApiToken: string | null;
+}
+
+export class DynamicTableAuth {
+  private state: AuthState;
+  private tokenProvider: DynamicTableTokenProvider | null = null;
+
+  constructor(initial?: Partial<AuthState>, tokenProvider?: DynamicTableTokenProvider) {
+    this.state = {
+      bearerToken: initial?.bearerToken ?? null,
+      dtApiToken: initial?.dtApiToken ?? null,
+    };
+    this.tokenProvider = tokenProvider ?? null;
+  }
+
+  getState(): Readonly<AuthState> {
+    return this.state;
+  }
+
+  setTokenProvider(provider: DynamicTableTokenProvider | null): void {
+    this.tokenProvider = provider;
+  }
+
+  async resolveState(): Promise<Readonly<AuthState>> {
+    if (!this.tokenProvider) {
+      return this.state;
+    }
+
+    const [providerBearer, providerDtApiToken] = await Promise.all([
+      this.tokenProvider.getBearerToken?.(),
+      this.tokenProvider.getDtApiToken?.(),
+    ]);
+
+    return {
+      bearerToken:
+        providerBearer === undefined ? this.state.bearerToken : (providerBearer ?? null),
+      dtApiToken:
+        providerDtApiToken === undefined ? this.state.dtApiToken : (providerDtApiToken ?? null),
+    };
+  }
+
+  setBearerToken(token: string | null): void {
+    this.state.bearerToken = token;
+  }
+
+  setDtApiToken(token: string | null): void {
+    this.state.dtApiToken = token;
+  }
+
+  setAuth(input: { bearerToken?: string | null; dtApiToken?: string | null }): void {
+    if (Object.prototype.hasOwnProperty.call(input, 'bearerToken')) {
+      this.state.bearerToken = input.bearerToken ?? null;
+    }
+    if (Object.prototype.hasOwnProperty.call(input, 'dtApiToken')) {
+      this.state.dtApiToken = input.dtApiToken ?? null;
+    }
+  }
+}

package/src/core/http-client.ts

@@ -0,0 +1,41 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { DynamicTableAuth } from './auth';
+import { DynamicTableSdkConfig } from './types';
+
+export class HttpClient {
+  private readonly instance: AxiosInstance;
+
+  constructor(config: DynamicTableSdkConfig, private readonly auth: DynamicTableAuth) {
+    this.instance = axios.create({
+      baseURL: config.baseURL,
+      timeout: config.timeout ?? 30000,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(config.defaultHeaders ?? {}),
+      },
+    });
+
+    this.instance.interceptors.request.use(async (requestConfig) => {
+      const state = await this.auth.resolveState();
+
+      if (state.bearerToken) {
+        requestConfig.headers.Authorization = `Bearer ${state.bearerToken}`;
+      } else if (requestConfig.headers.Authorization) {
+        delete requestConfig.headers.Authorization;
+      }
+
+      if (state.dtApiToken) {
+        requestConfig.headers['x-dt-api-token'] = state.dtApiToken;
+      } else if (requestConfig.headers['x-dt-api-token']) {
+        delete requestConfig.headers['x-dt-api-token'];
+      }
+
+      return requestConfig;
+    });
+  }
+
+  async request<T>(config: AxiosRequestConfig): Promise<T> {
+    const response = await this.instance.request<T>(config);
+    return response.data;
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,23 @@
+export type Nullable<T> = T | null;
+
+export interface ApiResponseDto<T> {
+  code: number;
+  message: string;
+  result: T;
+}
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export interface DynamicTableTokenProvider {
+  getBearerToken?: () => MaybePromise<string | null | undefined>;
+  getDtApiToken?: () => MaybePromise<string | null | undefined>;
+}
+
+export interface DynamicTableSdkConfig {
+  baseURL: string;
+  timeout?: number;
+  defaultHeaders?: Record<string, string>;
+  bearerToken?: string | null;
+  dtApiToken?: string | null;
+  tokenProvider?: DynamicTableTokenProvider;
+}

package/src/generated/dynamic-table/index.ts

@@ -0,0 +1,3 @@
+/* eslint-disable */
+export * from './types';
+export * from './services';

package/src/generated/dynamic-table/services/api-docs.service.ts

@@ -0,0 +1,42 @@
+/* eslint-disable */
+import { HttpClient } from '../../../core/http-client';
+import type {
+  ApiResponseDto,
+  OpenApiJsonParams,
+  RedocParams,
+  SwaggerParams,
+} from '../types';
+
+export class ApiDocsService {
+  constructor(private readonly client: HttpClient) {}
+
+  async openApiJson(params?: OpenApiJsonParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/api-docs/openapi.json`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async redoc(params?: RedocParams): Promise<ApiResponseDto<string>> {
+    return this.client.request<ApiResponseDto<string>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/api-docs/redoc`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async swagger(params?: SwaggerParams): Promise<ApiResponseDto<string>> {
+    return this.client.request<ApiResponseDto<string>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/api-docs/swagger`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+}

package/src/generated/dynamic-table/services/api-tokens.service.ts

@@ -0,0 +1,53 @@
+/* eslint-disable */
+import { HttpClient } from '../../../core/http-client';
+import type {
+  ApiResponseDto,
+  CreateApiTokenParams,
+  DeleteApiTokenParams,
+  ListApiTokensParams,
+  UpdateApiTokenParams,
+} from '../types';
+
+export class ApiTokensService {
+  constructor(private readonly client: HttpClient) {}
+
+  async listApiTokens(params?: ListApiTokensParams): Promise<ApiResponseDto<Record<string, unknown>[]>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>[]>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/db/meta/api-tokens`,
+      params: params?.query,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async createApiToken(params: CreateApiTokenParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'POST',
+      url: `/v1/dynamic-table/db/meta/api-tokens`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+
+  async deleteApiToken(params: DeleteApiTokenParams): Promise<ApiResponseDto<null>> {
+    return this.client.request<ApiResponseDto<null>>({
+      method: 'DELETE',
+      url: `/v1/dynamic-table/db/meta/api-tokens/${encodeURIComponent(String(params.tokenId))}`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async updateApiToken(params: UpdateApiTokenParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'PATCH',
+      url: `/v1/dynamic-table/db/meta/api-tokens/${encodeURIComponent(String(params.tokenId))}`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+}

package/src/generated/dynamic-table/services/attachments-secure.service.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import { HttpClient } from '../../../core/http-client';
+import type {
+  ApiResponseDto,
+  CreateSecureTokenParams,
+  GetSecureAttachmentParams,
+} from '../types';
+
+export class AttachmentsSecureService {
+  constructor(private readonly client: HttpClient) {}
+
+  async getSecureAttachment(params: GetSecureAttachmentParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/storage/secure/${encodeURIComponent(String(params.attachmentId))}`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async createSecureToken(params: CreateSecureTokenParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'POST',
+      url: `/v1/dynamic-table/storage/secure/${encodeURIComponent(String(params.attachmentId))}/token`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+}

package/src/generated/dynamic-table/services/attachments.service.ts

@@ -0,0 +1,53 @@
+/* eslint-disable */
+import { HttpClient } from '../../../core/http-client';
+import type {
+  ApiResponseDto,
+  CreatePresignedUrlParams,
+  DeleteAttachmentParams,
+  GetAttachmentParams,
+  UploadParams,
+} from '../types';
+
+export class AttachmentsService {
+  constructor(private readonly client: HttpClient) {}
+
+  async deleteAttachment(params: DeleteAttachmentParams): Promise<ApiResponseDto<null>> {
+    return this.client.request<ApiResponseDto<null>>({
+      method: 'DELETE',
+      url: `/v1/dynamic-table/storage/${encodeURIComponent(String(params.attachmentId))}`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async getAttachment(params: GetAttachmentParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/storage/${encodeURIComponent(String(params.attachmentId))}`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async createPresignedUrl(params: CreatePresignedUrlParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'POST',
+      url: `/v1/dynamic-table/storage/presigned-url`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+
+  async upload(params: UploadParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'POST',
+      url: `/v1/dynamic-table/storage/upload`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+}

package/src/generated/dynamic-table/services/base-members.service.ts

@@ -0,0 +1,55 @@
+/* eslint-disable */
+import { HttpClient } from '../../../core/http-client';
+import type {
+  AddBaseMemberParams,
+  ApiResponseDto,
+  BaseMemberListResponseDto,
+  BaseMemberResponseDto,
+  ListBaseMembersParams,
+  RemoveBaseMemberParams,
+  UpdateBaseMemberParams,
+} from '../types';
+
+export class BaseMembersService {
+  constructor(private readonly client: HttpClient) {}
+
+  async listBaseMembers(params: ListBaseMembersParams): Promise<ApiResponseDto<BaseMemberListResponseDto>> {
+    return this.client.request<ApiResponseDto<BaseMemberListResponseDto>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/members`,
+      params: params?.query,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async addBaseMember(params: AddBaseMemberParams): Promise<ApiResponseDto<BaseMemberResponseDto>> {
+    return this.client.request<ApiResponseDto<BaseMemberResponseDto>>({
+      method: 'POST',
+      url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/members`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+
+  async removeBaseMember(params: RemoveBaseMemberParams): Promise<ApiResponseDto<BaseMemberResponseDto>> {
+    return this.client.request<ApiResponseDto<BaseMemberResponseDto>>({
+      method: 'DELETE',
+      url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/members/${encodeURIComponent(String(params.baseMemberId))}`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async updateBaseMember(params: UpdateBaseMemberParams): Promise<ApiResponseDto<BaseMemberResponseDto>> {
+    return this.client.request<ApiResponseDto<BaseMemberResponseDto>>({
+      method: 'PATCH',
+      url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/members/${encodeURIComponent(String(params.baseMemberId))}`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+}

package/src/generated/dynamic-table/services/bases.service.ts

@@ -0,0 +1,66 @@
+/* eslint-disable */
+import { HttpClient } from '../../../core/http-client';
+import type {
+  ApiResponseDto,
+  BaseResponseDto,
+  CreateBaseParams,
+  DeleteBaseParams,
+  GetBaseParams,
+  ListBasesParams,
+  PagedResponse,
+  UpdateBaseParams,
+} from '../types';
+
+export class BasesService {
+  constructor(private readonly client: HttpClient) {}
+
+  async deleteBase(params: DeleteBaseParams): Promise<ApiResponseDto<BaseResponseDto>> {
+    return this.client.request<ApiResponseDto<BaseResponseDto>>({
+      method: 'DELETE',
+      url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async getBase(params: GetBaseParams): Promise<ApiResponseDto<BaseResponseDto>> {
+    return this.client.request<ApiResponseDto<BaseResponseDto>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async updateBase(params: UpdateBaseParams): Promise<ApiResponseDto<BaseResponseDto>> {
+    return this.client.request<ApiResponseDto<BaseResponseDto>>({
+      method: 'PATCH',
+      url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+
+  async listBases(params: ListBasesParams): Promise<ApiResponseDto<PagedResponse<BaseResponseDto>>> {
+    return this.client.request<ApiResponseDto<PagedResponse<BaseResponseDto>>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/db/meta/workspaces/${encodeURIComponent(String(params.workspaceId))}/bases`,
+      params: params?.query,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async createBase(params: CreateBaseParams): Promise<ApiResponseDto<BaseResponseDto>> {
+    return this.client.request<ApiResponseDto<BaseResponseDto>>({
+      method: 'POST',
+      url: `/v1/dynamic-table/db/meta/workspaces/${encodeURIComponent(String(params.workspaceId))}/bases`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+}

package/src/generated/dynamic-table/services/caches.service.ts

@@ -0,0 +1,42 @@
+/* eslint-disable */
+import { HttpClient } from '../../../core/http-client';
+import type {
+  ApiResponseDto,
+  InvalidateParams,
+  StatsParams,
+  WarmupParams,
+} from '../types';
+
+export class CachesService {
+  constructor(private readonly client: HttpClient) {}
+
+  async invalidate(params: InvalidateParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'POST',
+      url: `/v1/dynamic-table/db/meta/cache/invalidate`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+
+  async stats(params?: StatsParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/db/meta/cache/stats`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async warmup(params: WarmupParams): Promise<ApiResponseDto<Record<string, unknown>>> {
+    return this.client.request<ApiResponseDto<Record<string, unknown>>>({
+      method: 'POST',
+      url: `/v1/dynamic-table/db/meta/cache/warmup`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+}

package/src/generated/dynamic-table/services/calendar-data.service.ts

@@ -0,0 +1,44 @@
+/* eslint-disable */
+import { HttpClient } from '../../../core/http-client';
+import type {
+  ApiResponseDto,
+  CountByDateParams,
+  CountRangeParams,
+  ListCalendarRecordsParams,
+  PagedResponse,
+  TableRecord,
+} from '../types';
+
+export class CalendarDataService {
+  constructor(private readonly client: HttpClient) {}
+
+  async listCalendarRecords(params: ListCalendarRecordsParams): Promise<ApiResponseDto<PagedResponse<TableRecord>>> {
+    return this.client.request<ApiResponseDto<PagedResponse<TableRecord>>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/calendars/${encodeURIComponent(String(params.viewId))}/records`,
+      params: params?.query,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async countByDate(params: CountByDateParams): Promise<ApiResponseDto<{ count: number; dates: string[]; }>> {
+    return this.client.request<ApiResponseDto<{ count: number; dates: string[]; }>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/calendars/${encodeURIComponent(String(params.viewId))}/records/count-by-date`,
+      params: params?.query,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async countRange(params: CountRangeParams): Promise<ApiResponseDto<{ count: number; }>> {
+    return this.client.request<ApiResponseDto<{ count: number; }>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/calendars/${encodeURIComponent(String(params.viewId))}/records/count-range`,
+      params: params?.query,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+}

package/src/generated/dynamic-table/services/calendars.service.ts

@@ -0,0 +1,45 @@
+/* eslint-disable */
+import { HttpClient } from '../../../core/http-client';
+import type {
+  ApiResponseDto,
+  CalendarViewDetailResponseDto,
+  CalendarViewResponseDto,
+  CreateCalendarViewParams,
+  GetCalendarViewParams,
+  UpdateCalendarViewParams,
+  ViewResponseDto,
+} from '../types';
+
+export class CalendarsService {
+  constructor(private readonly client: HttpClient) {}
+
+  async getCalendarView(params: GetCalendarViewParams): Promise<ApiResponseDto<CalendarViewDetailResponseDto>> {
+    return this.client.request<ApiResponseDto<CalendarViewDetailResponseDto>>({
+      method: 'GET',
+      url: `/v1/dynamic-table/db/meta/calendars/${encodeURIComponent(String(params.calendarViewId))}`,
+      params: undefined,
+      data: undefined,
+      headers: undefined,
+    });
+  }
+
+  async updateCalendarView(params: UpdateCalendarViewParams): Promise<ApiResponseDto<CalendarViewResponseDto>> {
+    return this.client.request<ApiResponseDto<CalendarViewResponseDto>>({
+      method: 'PATCH',
+      url: `/v1/dynamic-table/db/meta/calendars/${encodeURIComponent(String(params.calendarViewId))}`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+
+  async createCalendarView(params: CreateCalendarViewParams): Promise<ApiResponseDto<ViewResponseDto>> {
+    return this.client.request<ApiResponseDto<ViewResponseDto>>({
+      method: 'POST',
+      url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}/calendars`,
+      params: undefined,
+      data: params?.body,
+      headers: undefined,
+    });
+  }
+}