@kweaver-ai/kweaver-sdk 0.4.10 → 0.4.12

package/dist/commands/ds.js

@@ -1,8 +1,13 @@
 import { createInterface } from "node:readline";
+import { statSync } from "node:fs";
+import { glob } from "node:fs/promises";
+import { resolve as resolvePath } from "node:path";
 import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
 import { testDatasource, createDatasource, listDatasources, getDatasource, deleteDatasource, listTablesWithColumns, } from "../api/datasources.js";
 import { formatCallOutput } from "./call.js";
 import { resolveBusinessDomain } from "../config/store.js";
+import { parseCsvFile, buildTableName, splitBatches, buildFieldMappings, buildDagBody, } from "./import-csv.js";
+import { executeDataflow } from "../api/dataflow.js";
 function confirmYes(prompt) {
     return new Promise((resolve) => {
         const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -32,7 +37,9 @@ Subcommands:
   delete <id> [-y]                  Delete a datasource
   tables <id> [--keyword X]         List tables with columns
   connect <db_type> <host> <port> <database> --account X --password Y [--schema Z] [--name N]
-    Test connectivity, register datasource, and discover tables.`);
+    Test connectivity, register datasource, and discover tables.
+  import-csv <ds-id> --files <glob_or_list> [--table-prefix X] [--batch-size N]
+    Import CSV files into datasource tables via dataflow API.`);
         return 0;
     }
     const dispatch = () => {
@@ -46,6 +53,8 @@ Subcommands:
             return runDsTablesCommand(rest);
         if (subcommand === "connect")
             return runDsConnectCommand(rest);
+        if (subcommand === "import-csv")
+            return runDsImportCsvCommand(rest);
         return Promise.resolve(-1);
     };
     try {
@@ -288,3 +297,197 @@ async function runDsConnectCommand(args) {
     console.log(JSON.stringify(output, null, 2));
     return 0;
 }
+// ── import-csv ────────────────────────────────────────────────────────────────
+const IMPORT_CSV_HELP = `kweaver ds import-csv <ds-id> --files <glob_or_list> [options]
+
+Import CSV files into datasource tables via dataflow API.
+
+Options:
+  --files <s>          CSV file paths (comma-separated or glob pattern, required)
+  --table-prefix <s>   Table name prefix (default: none)
+  --batch-size <n>     Rows per batch (default: 500, range: 1-10000)
+  -bd, --biz-domain    Business domain (default: bd_public)`;
+export function parseImportCsvArgs(args) {
+    let datasourceId = "";
+    let files = "";
+    let tablePrefix = "";
+    let batchSize = 500;
+    let businessDomain = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h")
+            throw new Error("help");
+        if (arg === "--files" && args[i + 1]) {
+            files = args[++i];
+            continue;
+        }
+        if (arg === "--table-prefix" && args[i + 1]) {
+            tablePrefix = args[++i];
+            continue;
+        }
+        if (arg === "--batch-size" && args[i + 1]) {
+            const n = parseInt(args[++i], 10);
+            if (Number.isNaN(n) || n < 1 || n > 10000) {
+                throw new Error("--batch-size must be between 1 and 10000");
+            }
+            batchSize = n;
+            continue;
+        }
+        if ((arg === "-bd" || arg === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (!arg.startsWith("-") && !datasourceId) {
+            datasourceId = arg;
+        }
+    }
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { datasourceId, files, tablePrefix, batchSize, businessDomain };
+}
+export async function resolveFiles(pattern) {
+    const parts = pattern.split(",").map((p) => p.trim()).filter(Boolean);
+    const result = [];
+    for (const part of parts) {
+        if (part.includes("*") || part.includes("?")) {
+            const matched = [];
+            for await (const entry of glob(part)) {
+                const p = String(entry);
+                if (/\.csv$/i.test(p)) {
+                    matched.push(resolvePath(p));
+                }
+            }
+            result.push(...matched);
+        }
+        else {
+            const abs = resolvePath(part);
+            statSync(abs); // throws if file does not exist
+            result.push(abs);
+        }
+    }
+    if (result.length === 0) {
+        throw new Error(`No CSV files matched: ${pattern}`);
+    }
+    return result;
+}
+export async function runDsImportCsv(args) {
+    let options;
+    try {
+        options = parseImportCsvArgs(args);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "help") {
+            console.log(IMPORT_CSV_HELP);
+            return { code: 0, tables: [], tableColumns: {}, sampleRows: {} };
+        }
+        throw error;
+    }
+    if (!options.datasourceId) {
+        console.error("Usage: kweaver ds import-csv <ds-id> --files <glob_or_list> [options]");
+        return { code: 1, tables: [], tableColumns: {}, sampleRows: {} };
+    }
+    if (!options.files) {
+        console.error("Error: --files is required");
+        return { code: 1, tables: [], tableColumns: {}, sampleRows: {} };
+    }
+    // 1. Get credentials
+    const token = await ensureValidToken();
+    const base = { baseUrl: token.baseUrl, accessToken: token.accessToken };
+    // 2. Resolve glob / file list
+    const filePaths = await resolveFiles(options.files);
+    // 3. Get datasource type
+    const dsBody = await getDatasource({ ...base, id: options.datasourceId, businessDomain: options.businessDomain });
+    const dsData = JSON.parse(dsBody);
+    const datasourceType = String(dsData.type ?? dsData.ds_type ?? dsData.data_type ?? "mysql");
+    const parsed = [];
+    for (const filePath of filePaths) {
+        const tableName = buildTableName(filePath, options.tablePrefix);
+        let csvData;
+        try {
+            csvData = await parseCsvFile(filePath);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[${tableName}] skipping — parse error: ${msg}`);
+            continue;
+        }
+        if (csvData.headers.length === 0) {
+            console.error(`[${tableName}] skipping — no headers`);
+            continue;
+        }
+        if (csvData.rows.length === 0) {
+            console.error(`[${tableName}] skipping — no rows`);
+            continue;
+        }
+        parsed.push({ filePath, tableName, headers: csvData.headers, rows: csvData.rows });
+    }
+    if (parsed.length === 0) {
+        console.error("All files were skipped — nothing to import");
+        return { code: 1, tables: [], tableColumns: {}, sampleRows: {} };
+    }
+    // Phase 2: Import each file in batches
+    const succeeded = [];
+    const failed = [];
+    const tableColumns = {};
+    const sampleRows = {};
+    for (const { tableName, headers, rows } of parsed) {
+        const batches = splitBatches(rows, options.batchSize);
+        const fieldMappings = buildFieldMappings(headers);
+        let batchFailed = false;
+        for (let bIdx = 0; bIdx < batches.length; bIdx += 1) {
+            const batch = batches[bIdx];
+            const tableExist = bIdx > 0;
+            const batchLabel = `${bIdx + 1}/${batches.length}`;
+            const rowCount = batch.length;
+            const dagBody = buildDagBody({
+                datasourceId: options.datasourceId,
+                datasourceType,
+                tableName,
+                tableExist,
+                data: batch,
+                fieldMappings,
+            });
+            const t0 = Date.now();
+            process.stderr.write(`[${tableName}] batch ${batchLabel} (${rowCount} rows)... `);
+            try {
+                await executeDataflow({
+                    ...base,
+                    businessDomain: options.businessDomain,
+                    body: dagBody,
+                });
+                const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+                process.stderr.write(`${elapsed}s\n`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`FAILED\n`);
+                console.error(`[${tableName}] batch ${batchLabel} error: ${msg}`);
+                batchFailed = true;
+                break;
+            }
+        }
+        if (batchFailed) {
+            failed.push(tableName);
+        }
+        else {
+            succeeded.push(tableName);
+            tableColumns[tableName] = headers;
+            sampleRows[tableName] = parsed.find((p) => p.tableName === tableName)?.rows.slice(0, 100) ?? [];
+        }
+    }
+    // Summary
+    console.error(`\nImport complete: ${succeeded.length} succeeded, ${failed.length} failed.`);
+    if (failed.length > 0) {
+        console.error(`Failed tables: ${failed.join(", ")}`);
+    }
+    console.log(JSON.stringify({
+        tables: succeeded,
+        failed,
+        summary: { succeeded: succeeded.length, failed: failed.length },
+    }, null, 2));
+    return { code: failed.length > 0 ? 1 : 0, tables: succeeded, tableColumns, sampleRows };
+}
+export async function runDsImportCsvCommand(args) {
+    const result = await runDsImportCsv(args);
+    return result.code;
+}

package/dist/commands/import-csv.d.ts

@@ -0,0 +1,47 @@
+import type { DataflowCreateBody } from "../api/dataflow.js";
+export interface CsvData {
+    headers: string[];
+    rows: Array<Record<string, string | null>>;
+}
+export interface FieldMapping {
+    source: {
+        name: string;
+    };
+    target: {
+        name: string;
+        data_type: string;
+    };
+}
+export interface DagBodyOptions {
+    datasourceId: string;
+    datasourceType: string;
+    tableName: string;
+    tableExist: boolean;
+    data: Array<Record<string, string | null>>;
+    fieldMappings: FieldMapping[];
+}
+/**
+ * Read a CSV file and return its headers and rows.
+ * - Strips UTF-8 BOM if present
+ * - Converts empty strings to null
+ * - Throws on column count mismatch
+ */
+export declare function parseCsvFile(filePath: string): Promise<CsvData>;
+/**
+ * Derive a table name from a file path: strip .csv (case-insensitive) and prepend prefix.
+ */
+export declare function buildTableName(filePath: string, prefix: string): string;
+/**
+ * Split an array into chunks of at most `batchSize` elements.
+ */
+export declare function splitBatches<T>(rows: T[], batchSize: number): T[][];
+/**
+ * Build field mapping descriptors from CSV headers.
+ * All target fields default to VARCHAR(512).
+ */
+export declare function buildFieldMappings(headers: string[]): FieldMapping[];
+/**
+ * Construct a DataflowCreateBody for a CSV → database write operation.
+ * The DAG has two steps: a manual trigger and the database write.
+ */
+export declare function buildDagBody(options: DagBodyOptions): DataflowCreateBody;

package/dist/commands/import-csv.js

@@ -0,0 +1,111 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { parse } from "csv-parse/sync";
+// ── parseCsvFile ──────────────────────────────────────────────────────────────
+/**
+ * Read a CSV file and return its headers and rows.
+ * - Strips UTF-8 BOM if present
+ * - Converts empty strings to null
+ * - Throws on column count mismatch
+ */
+export async function parseCsvFile(filePath) {
+    let content = await readFile(filePath, "utf8");
+    // Strip UTF-8 BOM
+    if (content.charCodeAt(0) === 0xfeff) {
+        content = content.slice(1);
+    }
+    // Parse with columns:true to get key/value rows
+    const records = parse(content, {
+        columns: true,
+        skip_empty_lines: true,
+        trim: true,
+        relax_column_count: false,
+    });
+    // If no records, parse just first row to extract headers
+    if (records.length === 0) {
+        const headerRows = parse(content, {
+            columns: false,
+            skip_empty_lines: false,
+            trim: true,
+            to: 1,
+        });
+        const headers = (headerRows[0] ?? []);
+        return { headers, rows: [] };
+    }
+    const headers = Object.keys(records[0]);
+    // Convert empty strings to null
+    const rows = records.map((record) => {
+        const row = {};
+        for (const key of headers) {
+            const val = record[key];
+            row[key] = val === "" ? null : (val ?? null);
+        }
+        return row;
+    });
+    return { headers, rows };
+}
+// ── buildTableName ────────────────────────────────────────────────────────────
+/**
+ * Derive a table name from a file path: strip .csv (case-insensitive) and prepend prefix.
+ */
+export function buildTableName(filePath, prefix) {
+    const base = basename(filePath).replace(/\.csv$/i, "");
+    return prefix + base;
+}
+// ── splitBatches ──────────────────────────────────────────────────────────────
+/**
+ * Split an array into chunks of at most `batchSize` elements.
+ */
+export function splitBatches(rows, batchSize) {
+    const batches = [];
+    for (let i = 0; i < rows.length; i += batchSize) {
+        batches.push(rows.slice(i, i + batchSize));
+    }
+    return batches;
+}
+// ── buildFieldMappings ────────────────────────────────────────────────────────
+/**
+ * Build field mapping descriptors from CSV headers.
+ * All target fields default to VARCHAR(512).
+ */
+export function buildFieldMappings(headers) {
+    return headers.map((name) => ({
+        source: { name },
+        target: { name, data_type: "VARCHAR(512)" },
+    }));
+}
+// ── buildDagBody ──────────────────────────────────────────────────────────────
+/**
+ * Construct a DataflowCreateBody for a CSV → database write operation.
+ * The DAG has two steps: a manual trigger and the database write.
+ */
+export function buildDagBody(options) {
+    const { datasourceId, datasourceType, tableName, tableExist, data, fieldMappings } = options;
+    const ts = Date.now();
+    const triggerStep = {
+        id: "step-trigger",
+        title: "Trigger",
+        operator: "@trigger/manual",
+        parameters: {},
+    };
+    const writeStep = {
+        id: "step-write",
+        title: "Write to Database",
+        operator: "@internal/database/write",
+        parameters: {
+            datasource_type: datasourceType,
+            datasource_id: datasourceId,
+            table_name: tableName,
+            table_exist: tableExist,
+            operate_type: "append",
+            data,
+            sync_model_fields: fieldMappings,
+        },
+    };
+    return {
+        title: `import-csv-${tableName}-${ts}`,
+        description: `CSV import into table ${tableName}`,
+        trigger_config: { operator: "@internal/trigger/manual" },
+        steps: [triggerStep, writeStep],
+    };
+}

package/dist/config/store.d.ts

@@ -8,6 +8,8 @@ export interface TokenConfig {
     refreshToken?: string;
     idToken?: string;
     obtainedAt: string;
+    /** When true, skip TLS certificate verification for this platform (saved by `kweaver auth --insecure`). */
+    tlsInsecure?: boolean;
 }
 /** OAuth2 client registration (per platform), used for refresh_token grant. */
 export interface ClientConfig {

package/dist/config/tls-env.d.ts

@@ -0,0 +1,8 @@
+/**
+ * When a platform was logged in with `--insecure`, the flag is stored on the token.
+ * Apply Node TLS verification skip for this process so all `fetch` calls to that
+ * platform succeed without per-request options.
+ *
+ * Also honors `KWEAVER_TLS_INSECURE=1` or `true` (development / scripting only).
+ */
+export declare function applyTlsEnvFromSavedTokens(): void;

package/dist/config/tls-env.js

@@ -0,0 +1,22 @@
+import { getCurrentPlatform, loadTokenConfig } from "./store.js";
+/**
+ * When a platform was logged in with `--insecure`, the flag is stored on the token.
+ * Apply Node TLS verification skip for this process so all `fetch` calls to that
+ * platform succeed without per-request options.
+ *
+ * Also honors `KWEAVER_TLS_INSECURE=1` or `true` (development / scripting only).
+ */
+export function applyTlsEnvFromSavedTokens() {
+    if (process.env.KWEAVER_TLS_INSECURE === "1" || process.env.KWEAVER_TLS_INSECURE === "true") {
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+        return;
+    }
+    const platform = getCurrentPlatform();
+    if (!platform) {
+        return;
+    }
+    const token = loadTokenConfig(platform);
+    if (token?.tlsInsecure) {
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+    }
+}

package/dist/index.d.ts

@@ -49,6 +49,9 @@ export type { AgentConfig, AgentInput, AgentInputField, AgentOutput, AgentLlmCon
 export { BknResource } from "./resources/bkn.js";
 export { ConversationsResource } from "./resources/conversations.js";
 export { ContextLoaderResource } from "./resources/context-loader.js";
+export type { ViewField, DataView, CreateDataViewOptions, GetDataViewOptions, ListDataViewsOptions, DeleteDataViewOptions, FindDataViewOptions, } from "./api/dataviews.js";
+export { parseDataView, createDataView, getDataView, listDataViews, deleteDataView, findDataView, } from "./api/dataviews.js";
+export { DataViewsResource } from "./resources/dataviews.js";
 export { HttpError, NetworkRequestError, fetchTextOrThrow } from "./utils/http.js";
 export type { TokenConfig, ContextLoaderEntry, ContextLoaderConfig, } from "./config/store.js";
 export { getConfigDir, getCurrentPlatform } from "./config/store.js";

package/dist/index.js

@@ -39,6 +39,8 @@ export { AgentsResource } from "./resources/agents.js";
 export { BknResource } from "./resources/bkn.js";
 export { ConversationsResource } from "./resources/conversations.js";
 export { ContextLoaderResource } from "./resources/context-loader.js";
+export { parseDataView, createDataView, getDataView, listDataViews, deleteDataView, findDataView, } from "./api/dataviews.js";
+export { DataViewsResource } from "./resources/dataviews.js";
 // ── HTTP utilities ────────────────────────────────────────────────────────────
 export { HttpError, NetworkRequestError, fetchTextOrThrow } from "./utils/http.js";
 export { getConfigDir, getCurrentPlatform } from "./config/store.js";

package/dist/resources/dataflows.d.ts

@@ -0,0 +1,17 @@
+import { type DataflowCreateBody, type DataflowResult } from "../api/dataflow.js";
+import type { ClientContext } from "../client.js";
+export declare class DataflowsResource {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    create(body: DataflowCreateBody): Promise<string>;
+    run(dagId: string): Promise<void>;
+    poll(dagId: string, opts?: {
+        interval?: number;
+        timeout?: number;
+    }): Promise<DataflowResult>;
+    delete(dagId: string): Promise<void>;
+    execute(body: DataflowCreateBody, opts?: {
+        interval?: number;
+        timeout?: number;
+    }): Promise<DataflowResult>;
+}

package/dist/resources/dataflows.js

@@ -0,0 +1,22 @@
+import { createDataflow, runDataflow, pollDataflowResults, deleteDataflow, executeDataflow, } from "../api/dataflow.js";
+export class DataflowsResource {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async create(body) {
+        return createDataflow({ ...this.ctx.base(), body });
+    }
+    async run(dagId) {
+        return runDataflow({ ...this.ctx.base(), dagId });
+    }
+    async poll(dagId, opts = {}) {
+        return pollDataflowResults({ ...this.ctx.base(), dagId, ...opts });
+    }
+    async delete(dagId) {
+        return deleteDataflow({ ...this.ctx.base(), dagId });
+    }
+    async execute(body, opts = {}) {
+        return executeDataflow({ ...this.ctx.base(), body, ...opts });
+    }
+}

package/dist/resources/datasources.d.ts

@@ -0,0 +1,52 @@
+import type { ClientContext } from "../client.js";
+export declare class DataSourcesResource {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    test(opts: {
+        type: string;
+        host: string;
+        port: number;
+        database: string;
+        account: string;
+        password: string;
+        schema?: string;
+    }): Promise<void>;
+    create(opts: {
+        name: string;
+        type: string;
+        host: string;
+        port: number;
+        database: string;
+        account: string;
+        password: string;
+        schema?: string;
+        comment?: string;
+    }): Promise<unknown>;
+    list(opts?: {
+        keyword?: string;
+        type?: string;
+    }): Promise<unknown[]>;
+    get(id: string): Promise<unknown>;
+    delete(id: string): Promise<void>;
+    listTables(id: string, opts?: {
+        keyword?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown[]>;
+    listTablesWithColumns(id: string, opts?: {
+        keyword?: string;
+        limit?: number;
+        offset?: number;
+        autoScan?: boolean;
+    }): Promise<Array<{
+        name: string;
+        columns: Array<{
+            name: string;
+            type: string;
+            comment?: string;
+        }>;
+    }>>;
+    scanMetadata(id: string, opts?: {
+        dsType?: string;
+    }): Promise<string>;
+}

package/dist/resources/datasources.js

@@ -0,0 +1,54 @@
+import { testDatasource, createDatasource, listDatasources, getDatasource, deleteDatasource, listTables, listTablesWithColumns, scanMetadata, } from "../api/datasources.js";
+export class DataSourcesResource {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async test(opts) {
+        await testDatasource({ ...this.ctx.base(), ...opts });
+    }
+    async create(opts) {
+        const raw = await createDatasource({ ...this.ctx.base(), ...opts });
+        return JSON.parse(raw);
+    }
+    async list(opts = {}) {
+        const raw = await listDatasources({ ...this.ctx.base(), ...opts });
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (parsed && typeof parsed === "object") {
+            const obj = parsed;
+            const items = obj.entries ?? obj.data ?? obj.records;
+            if (Array.isArray(items))
+                return items;
+        }
+        return [];
+    }
+    async get(id) {
+        const raw = await getDatasource({ ...this.ctx.base(), id });
+        return JSON.parse(raw);
+    }
+    async delete(id) {
+        await deleteDatasource({ ...this.ctx.base(), id });
+    }
+    async listTables(id, opts = {}) {
+        const raw = await listTables({ ...this.ctx.base(), id, ...opts });
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (parsed && typeof parsed === "object") {
+            const obj = parsed;
+            const items = obj.entries ?? obj.data;
+            if (Array.isArray(items))
+                return items;
+        }
+        return [];
+    }
+    async listTablesWithColumns(id, opts = {}) {
+        const raw = await listTablesWithColumns({ ...this.ctx.base(), id, ...opts });
+        return JSON.parse(raw);
+    }
+    async scanMetadata(id, opts = {}) {
+        return scanMetadata({ ...this.ctx.base(), id, ...opts });
+    }
+}

package/dist/resources/dataviews.d.ts

@@ -0,0 +1,28 @@
+import type { DataView } from "../api/dataviews.js";
+import type { ClientContext } from "../client.js";
+export declare class DataViewsResource {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    create(opts: {
+        name: string;
+        datasourceId: string;
+        table: string;
+        fields?: Array<{
+            name: string;
+            type: string;
+        }>;
+    }): Promise<string>;
+    get(id: string): Promise<DataView>;
+    list(opts?: {
+        datasourceId?: string;
+        type?: string;
+        limit?: number;
+    }): Promise<DataView[]>;
+    find(name: string, opts?: {
+        datasourceId?: string;
+        exact?: boolean;
+        wait?: boolean;
+        timeoutMs?: number;
+    }): Promise<DataView[]>;
+    delete(id: string): Promise<void>;
+}

package/dist/resources/dataviews.js

@@ -0,0 +1,34 @@
+import { createDataView, deleteDataView, findDataView, getDataView, listDataViews, } from "../api/dataviews.js";
+export class DataViewsResource {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async create(opts) {
+        return createDataView({ ...this.ctx.base(), ...opts });
+    }
+    async get(id) {
+        return getDataView({ ...this.ctx.base(), id });
+    }
+    async list(opts = {}) {
+        return listDataViews({
+            ...this.ctx.base(),
+            datasourceId: opts.datasourceId,
+            type: opts.type,
+            limit: opts.limit,
+        });
+    }
+    async find(name, opts) {
+        return findDataView({
+            ...this.ctx.base(),
+            name,
+            datasourceId: opts?.datasourceId,
+            exact: opts?.exact,
+            wait: opts?.wait,
+            timeoutMs: opts?.timeoutMs,
+        });
+    }
+    async delete(id) {
+        await deleteDataView({ ...this.ctx.base(), id });
+    }
+}