@redonvn/redai-backend-api-sdk 0.1.17 → 0.1.20

package/dist/index.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDynamicTableSdk = exports.createFrontendAxiosTokenProvider = void 0;
+const auth_1 = require("./core/auth");
+const http_client_1 = require("./core/http-client");
+const services_1 = require("./generated/services");
+__exportStar(require("./generated"), exports);
+const createFrontendAxiosTokenProvider = (options) => {
+    const authStorageKey = options?.authStorageKey ?? 'auth_data';
+    return {
+        getBearerToken: () => {
+            const storage = globalThis.localStorage;
+            if (!storage)
+                return null;
+            try {
+                const raw = storage.getItem(authStorageKey);
+                if (!raw)
+                    return null;
+                const parsed = JSON.parse(raw);
+                if (!parsed?.accessToken)
+                    return null;
+                if (typeof parsed.expiresAt === 'number' && parsed.expiresAt <= Date.now())
+                    return null;
+                return parsed.accessToken;
+            }
+            catch {
+                return null;
+            }
+        },
+        getDtApiToken: () => options?.getDtApiToken?.() ?? options?.dtApiToken ?? null,
+    };
+};
+exports.createFrontendAxiosTokenProvider = createFrontendAxiosTokenProvider;
+const createDynamicTableSdk = (config) => {
+    const auth = new auth_1.DynamicTableAuth({ bearerToken: config.bearerToken ?? null, dtApiToken: config.dtApiToken ?? null }, config.tokenProvider);
+    const client = new http_client_1.HttpClient(config, auth);
+    const viewColumns = new services_1.ViewColumnsService(client);
+    return {
+        auth,
+        apiDocs: new services_1.ApiDocsService(client),
+        apiTokens: new services_1.ApiTokensService(client),
+        attachmentsSecure: new services_1.AttachmentsSecureService(client),
+        attachments: new services_1.AttachmentsService(client),
+        baseMembers: new services_1.BaseMembersService(client),
+        bases: new services_1.BasesService(client),
+        caches: new services_1.CachesService(client),
+        calendarData: new services_1.CalendarDataService(client),
+        calendars: new services_1.CalendarsService(client),
+        columns: new services_1.ColumnsService(client),
+        commandPalette: new services_1.CommandPaletteService(client),
+        comments: new services_1.CommentsService(client),
+        dataImports: new services_1.DataImportsService(client),
+        dataTable: new services_1.DataTableService(client),
+        authService: new services_1.DynamicTableAuthService(client),
+        filters: new services_1.FiltersService(client),
+        forms: new services_1.FormsService(client),
+        galleries: new services_1.GalleriesService(client),
+        grids: new services_1.GridsService(client),
+        hooks: new services_1.HooksService(client),
+        internal: new services_1.InternalService(client),
+        jobsMeta: new services_1.JobsMetaService(client),
+        jobs: new services_1.JobsService(client),
+        kanbanData: new services_1.KanbanDataService(client),
+        kanbans: new services_1.KanbansService(client),
+        maps: new services_1.MapsService(client),
+        rowColor: new services_1.RowColorService(client),
+        sorts: new services_1.SortsService(client),
+        sources: new services_1.SourcesService(client),
+        tables: new services_1.TablesService(client),
+        userUiPreferences: new services_1.UserUiPreferencesService(client),
+        utils: new services_1.UtilsService(client),
+        views: new services_1.ViewsService(client),
+        workspaceInviteLinkSettings: new services_1.WorkspaceInviteLinkSettingsService(client),
+        workspaceInviteLinks: new services_1.WorkspaceInviteLinksService(client),
+        workspaceInvites: new services_1.WorkspaceInvitesService(client),
+        workspaceJoinRequests: new services_1.WorkspaceJoinRequestsService(client),
+        workspaceMembers: new services_1.WorkspaceMembersService(client),
+        workspaces: new services_1.WorkspacesService(client),
+        formColumns: viewColumns,
+        gridColumns: viewColumns,
+        viewColumns,
+    };
+};
+exports.createDynamicTableSdk = createDynamicTableSdk;

package/package.json

@@ -1,28 +1,33 @@
 {
   "name": "@redonvn/redai-backend-api-sdk",
-  "version": "0.1.17",
+  "version": "0.1.20",
   "description": "Axios SDK for RedAI Dynamic Table APIs",
   "license": "UNLICENSED",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "require": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./generated": {
-      "types": "./src/generated/index.ts",
-      "require": "./src/generated/index.ts",
-      "default": "./src/generated/index.ts"
+      "types": "./dist/generated/index.d.ts",
+      "require": "./dist/generated/index.js",
+      "default": "./dist/generated/index.js"
     },
     "./generated/*": {
-      "types": "./src/generated/*.ts",
-      "require": "./src/generated/*.ts",
-      "default": "./src/generated/*.ts"
+      "types": "./dist/generated/*.d.ts",
+      "require": "./dist/generated/*.js",
+      "default": "./dist/generated/*.js"
     },
     "./package.json": "./package.json"
   },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "package.json"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -36,7 +41,8 @@
     "generate:report": "cross-env GEN_MODE=hybrid OUTPUT_REPORT=true tsx tools/generate-dynamic-table-sdk.ts",
     "verify:generated": "tsx tools/verify-generated.ts --module=dynamic-table --pathPrefix=/v1/dynamic-table --backendRoot=F:\\Redon\\DuAn\\project01\\true --controllersDir=src/modules/dynamic-table/controllers",
     "type-check": "tsc --noEmit",
-    "build": "npm run clean && tsc -p tsconfig.json"
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "axios": "^1.9.0"

package/src/core/auth.ts

@@ -1,62 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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/services/api-docs.service.ts

@@ -1,42 +0,0 @@
-/* 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

@@ -1,53 +0,0 @@
-/* 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

@@ -1,31 +0,0 @@
-/* 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

@@ -1,53 +0,0 @@
-/* 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

@@ -1,55 +0,0 @@
-/* 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

@@ -1,66 +0,0 @@
-/* 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

@@ -1,42 +0,0 @@
-/* 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,
-    });
-  }
-}