@redonvn/redai-backend-api-sdk 0.1.1

package/README.md

@@ -0,0 +1,69 @@
+# RedAI Dynamic Table SDK
+
+SDK axios cho API `dynamic-table` (backend NestJS).
+
+## Cài đặt
+
+```bash
+npm install
+```
+
+## Generate
+
+```bash
+npm run generate
+```
+
+Mặc định generator đọc OpenAPI từ:
+
+`F:\Redon\DuAn\project01\true\src\modules\dynamic-table\tests\curl\docs-json.json`
+
+Có thể override:
+
+```bash
+OPENAPI_PATH=path/to/openapi.json npm run generate
+```
+
+## Build
+
+```bash
+npm run type-check
+npm run build
+```
+
+## Sử dụng
+
+```ts
+import {
+  createDynamicTableSdk,
+  createFrontendAxiosTokenProvider,
+} from '@redonvn/redai-backend-api-sdk';
+
+const sdk = createDynamicTableSdk({
+  baseURL: 'https://api.example.com/v1',
+  tokenProvider: createFrontendAxiosTokenProvider({
+    authStorageKey: 'auth_data',
+    dtApiToken: 'dt-api-token',
+  }),
+});
+
+const res = await sdk.workspaces.getWorkspaceBySlug({ slug: 'my-workspace' });
+```
+
+## Auth runtime
+
+```ts
+sdk.auth.setBearerToken('new-jwt');
+sdk.auth.setDtApiToken('new-dt-token');
+sdk.auth.setAuth({ bearerToken: null, dtApiToken: null });
+
+// Tắt token provider nếu muốn quay về set token thủ công
+sdk.auth.setTokenProvider(null);
+```
+
+## Cấu trúc
+
+- `src/core/*`: runtime axios + auth
+- `src/generated/types.ts`: types sinh từ OpenAPI
+- `src/generated/services/*.service.ts`: service theo domain
+- `tools/generate-dynamic-table-sdk.ts`: tool generator

package/dist/core/auth.d.ts

@@ -0,0 +1,19 @@
+import { DynamicTableTokenProvider } from './types';
+export interface AuthState {
+    bearerToken: string | null;
+    dtApiToken: string | null;
+}
+export declare class DynamicTableAuth {
+    private state;
+    private tokenProvider;
+    constructor(initial?: Partial<AuthState>, tokenProvider?: DynamicTableTokenProvider);
+    getState(): Readonly<AuthState>;
+    setTokenProvider(provider: DynamicTableTokenProvider | null): void;
+    resolveState(): Promise<Readonly<AuthState>>;
+    setBearerToken(token: string | null): void;
+    setDtApiToken(token: string | null): void;
+    setAuth(input: {
+        bearerToken?: string | null;
+        dtApiToken?: string | null;
+    }): void;
+}

package/dist/core/auth.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicTableAuth = void 0;
+class DynamicTableAuth {
+    constructor(initial, tokenProvider) {
+        this.tokenProvider = null;
+        this.state = {
+            bearerToken: initial?.bearerToken ?? null,
+            dtApiToken: initial?.dtApiToken ?? null,
+        };
+        this.tokenProvider = tokenProvider ?? null;
+    }
+    getState() {
+        return this.state;
+    }
+    setTokenProvider(provider) {
+        this.tokenProvider = provider;
+    }
+    async resolveState() {
+        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) {
+        this.state.bearerToken = token;
+    }
+    setDtApiToken(token) {
+        this.state.dtApiToken = token;
+    }
+    setAuth(input) {
+        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;
+        }
+    }
+}
+exports.DynamicTableAuth = DynamicTableAuth;

package/dist/core/http-client.d.ts

@@ -0,0 +1,9 @@
+import { AxiosRequestConfig } from 'axios';
+import { DynamicTableAuth } from './auth';
+import { DynamicTableSdkConfig } from './types';
+export declare class HttpClient {
+    private readonly auth;
+    private readonly instance;
+    constructor(config: DynamicTableSdkConfig, auth: DynamicTableAuth);
+    request<T>(config: AxiosRequestConfig): Promise<T>;
+}

package/dist/core/http-client.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class HttpClient {
+    constructor(config, auth) {
+        this.auth = auth;
+        this.instance = axios_1.default.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(config) {
+        const response = await this.instance.request(config);
+        return response.data;
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/core/types.d.ts

@@ -0,0 +1,19 @@
+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/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generated/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './services';

package/dist/generated/index.js

@@ -0,0 +1,19 @@
+"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 });
+/* eslint-disable */
+__exportStar(require("./types"), exports);
+__exportStar(require("./services"), exports);

package/dist/generated/services/auth.service.d.ts

@@ -0,0 +1,7 @@
+import { HttpClient } from '../../core/http-client';
+import { ExchangeTokenV1Params } from '../types';
+export declare class AuthService {
+    private readonly client;
+    constructor(client: HttpClient);
+    exchangeTokenV1(params?: ExchangeTokenV1Params): Promise<unknown>;
+}

package/dist/generated/services/auth.service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+class AuthService {
+    constructor(client) {
+        this.client = client;
+    }
+    async exchangeTokenV1(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/auth/exchange`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.AuthService = AuthService;

package/dist/generated/services/bases.service.d.ts

@@ -0,0 +1,11 @@
+import { HttpClient } from '../../core/http-client';
+import { DeleteBaseV1Params, GetBaseV1Params, UpdateBaseV1Params, ListSourcesV1Params, CreateSourceV1Params } from '../types';
+export declare class BasesService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteBaseV1(params: DeleteBaseV1Params): Promise<unknown>;
+    getBaseV1(params: GetBaseV1Params): Promise<unknown>;
+    updateBaseV1(params: UpdateBaseV1Params): Promise<unknown>;
+    listSourcesV1(params: ListSourcesV1Params): Promise<unknown>;
+    createSourceV1(params: CreateSourceV1Params): Promise<unknown>;
+}

package/dist/generated/services/bases.service.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasesService = void 0;
+class BasesService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteBaseV1(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getBaseV1(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateBaseV1(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async listSourcesV1(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/sources`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createSourceV1(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/sources`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.BasesService = BasesService;

package/dist/generated/services/calendars.service.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient } from '../../core/http-client';
+import { GetCalendarViewV1Params, UpdateCalendarViewV1Params } from '../types';
+export declare class CalendarsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    getCalendarViewV1(params: GetCalendarViewV1Params): Promise<unknown>;
+    updateCalendarViewV1(params: UpdateCalendarViewV1Params): Promise<unknown>;
+}

package/dist/generated/services/calendars.service.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarsService = void 0;
+class CalendarsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getCalendarViewV1(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/calendars/${encodeURIComponent(String(params.calendarViewId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateCalendarViewV1(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/calendars/${encodeURIComponent(String(params.calendarViewId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.CalendarsService = CalendarsService;

package/dist/generated/services/columns.service.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../core/http-client';
+import { DeleteColumnV1Params, GetColumnV1Params, UpdateColumnV1Params, SetPrimaryColumnV1Params } from '../types';
+export declare class ColumnsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteColumnV1(params: DeleteColumnV1Params): Promise<unknown>;
+    getColumnV1(params: GetColumnV1Params): Promise<unknown>;
+    updateColumnV1(params: UpdateColumnV1Params): Promise<unknown>;
+    setPrimaryColumnV1(params: SetPrimaryColumnV1Params): Promise<unknown>;
+}

package/dist/generated/services/columns.service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnsService = void 0;
+class ColumnsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteColumnV1(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/columns/${encodeURIComponent(String(params.columnId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getColumnV1(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/columns/${encodeURIComponent(String(params.columnId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateColumnV1(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/columns/${encodeURIComponent(String(params.columnId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async setPrimaryColumnV1(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/columns/${encodeURIComponent(String(params.columnId))}/primary`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.ColumnsService = ColumnsService;

package/dist/generated/services/filters.service.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../core/http-client';
+import { DeleteFilterV1Params, GetFilterV1Params, UpdateFilterV1Params, ListChildrenV1Params } from '../types';
+export declare class FiltersService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteFilterV1(params: DeleteFilterV1Params): Promise<unknown>;
+    getFilterV1(params: GetFilterV1Params): Promise<unknown>;
+    updateFilterV1(params: UpdateFilterV1Params): Promise<unknown>;
+    listChildrenV1(params: ListChildrenV1Params): Promise<unknown>;
+}

package/dist/generated/services/filters.service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FiltersService = void 0;
+class FiltersService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteFilterV1(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/filters/${encodeURIComponent(String(params.filterId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getFilterV1(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/filters/${encodeURIComponent(String(params.filterId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateFilterV1(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/filters/${encodeURIComponent(String(params.filterId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async listChildrenV1(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/filters/${encodeURIComponent(String(params.filterParentId))}/children`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.FiltersService = FiltersService;

package/dist/generated/services/form-columns.service.d.ts

@@ -0,0 +1,7 @@
+import { HttpClient } from '../../core/http-client';
+import { UpdateFormColumnV1Params } from '../types';
+export declare class FormColumnsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    updateFormColumnV1(params: UpdateFormColumnV1Params): Promise<unknown>;
+}

package/dist/generated/services/form-columns.service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormColumnsService = void 0;
+class FormColumnsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async updateFormColumnV1(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/form-columns/${encodeURIComponent(String(params.formViewColumnId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.FormColumnsService = FormColumnsService;

package/dist/generated/services/forms.service.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient } from '../../core/http-client';
+import { GetFormViewV1Params, UpdateFormViewV1Params } from '../types';
+export declare class FormsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    getFormViewV1(params: GetFormViewV1Params): Promise<unknown>;
+    updateFormViewV1(params: UpdateFormViewV1Params): Promise<unknown>;
+}

package/dist/generated/services/forms.service.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormsService = void 0;
+class FormsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getFormViewV1(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/forms/${encodeURIComponent(String(params.formViewId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateFormViewV1(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/forms/${encodeURIComponent(String(params.formViewId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.FormsService = FormsService;

package/dist/generated/services/galleries.service.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient } from '../../core/http-client';
+import { GetGalleryViewV1Params, UpdateGalleryViewV1Params } from '../types';
+export declare class GalleriesService {
+    private readonly client;
+    constructor(client: HttpClient);
+    getGalleryViewV1(params: GetGalleryViewV1Params): Promise<unknown>;
+    updateGalleryViewV1(params: UpdateGalleryViewV1Params): Promise<unknown>;
+}

package/dist/generated/services/galleries.service.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GalleriesService = void 0;
+class GalleriesService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getGalleryViewV1(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/galleries/${encodeURIComponent(String(params.galleryViewId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateGalleryViewV1(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/galleries/${encodeURIComponent(String(params.galleryViewId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.GalleriesService = GalleriesService;

package/dist/generated/services/grid-columns.service.d.ts

@@ -0,0 +1,7 @@
+import { HttpClient } from '../../core/http-client';
+import { UpdateGridColumnV1Params } from '../types';
+export declare class GridColumnsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    updateGridColumnV1(params: UpdateGridColumnV1Params): Promise<unknown>;
+}

package/dist/generated/services/grid-columns.service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridColumnsService = void 0;
+class GridColumnsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async updateGridColumnV1(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/grid-columns/${encodeURIComponent(String(params.gridViewColumnId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.GridColumnsService = GridColumnsService;

package/dist/generated/services/grids.service.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient } from '../../core/http-client';
+import { ListGridColumnsV1Params, UpdateGridViewV1Params } from '../types';
+export declare class GridsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    listGridColumnsV1(params: ListGridColumnsV1Params): Promise<unknown>;
+    updateGridViewV1(params: UpdateGridViewV1Params): Promise<unknown>;
+}

package/dist/generated/services/grids.service.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridsService = void 0;
+class GridsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async listGridColumnsV1(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/grids/${encodeURIComponent(String(params.gridViewId))}/grid-columns`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateGridViewV1(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/grids/${encodeURIComponent(String(params.viewId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.GridsService = GridsService;