@kweaver-ai/kweaver-sdk 0.4.10 → 0.4.11

package/dist/commands/bkn.js

@@ -8,11 +8,12 @@ import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/
 import { listKnowledgeNetworks, getKnowledgeNetwork, createKnowledgeNetwork, updateKnowledgeNetwork, deleteKnowledgeNetwork, listObjectTypes, listRelationTypes, listActionTypes, getObjectType, createObjectTypes, updateObjectType, deleteObjectTypes, getRelationType, createRelationTypes, updateRelationType, deleteRelationTypes, buildKnowledgeNetwork, getBuildStatus, } from "../api/knowledge-networks.js";
 import { objectTypeQuery, objectTypeProperties, subgraph, actionTypeQuery, actionTypeExecute, actionExecutionGet, actionLogsList, actionLogGet, actionLogCancel, } from "../api/ontology-query.js";
 import { semanticSearch } from "../api/semantic-search.js";
-import { listTablesWithColumns } from "../api/datasources.js";
-import { createDataView } from "../api/dataviews.js";
+import { listTablesWithColumns, scanMetadata, getDatasource } from "../api/datasources.js";
+import { createDataView } from "../api/dataviews.js"; // used by runKnCreateFromDsCommand
 import { downloadBkn, uploadBkn } from "../api/bkn-backend.js";
 import { formatCallOutput } from "./call.js";
 import { resolveBusinessDomain } from "../config/store.js";
+import { runDsImportCsv } from "./ds.js";
 export function formatSimpleKnList(text, pretty, includeDetail = false) {
     const parsed = JSON.parse(text);
     const entries = Array.isArray(parsed.entries) ? parsed.entries : [];
@@ -600,6 +601,8 @@ Subcommands:
   get <kn-id> [options]   Get knowledge network detail (use --stats or --export)
   create [options]     Create a knowledge network (empty or from --body-file)
   create-from-ds <ds-id> --name X [--tables a,b] [--build]   Create KN from datasource
+  create-from-csv <ds-id> --files <glob> --name X [--table-prefix P] [--build]
+    Import CSVs then create knowledge network
   update <kn-id> [options]  Update a knowledge network
   delete <kn-id>       Delete a knowledge network
   build <kn-id> [--wait|--no-wait] [--timeout n]   Trigger full build
@@ -646,6 +649,8 @@ export async function runKnCommand(args) {
             return runKnCreateCommand(rest);
         if (subcommand === "create-from-ds")
             return runKnCreateFromDsCommand(rest);
+        if (subcommand === "create-from-csv")
+            return runKnCreateFromCsvCommand(rest);
         if (subcommand === "update")
             return runKnUpdateCommand(rest);
         if (subcommand === "delete")
@@ -1074,20 +1079,18 @@ export function parseKnActionTypeExecuteArgs(args) {
         timeout,
     };
 }
-const PK_CANDIDATES = new Set(["id", "pk", "key"]);
-const PK_TYPES = new Set(["integer", "unsigned integer", "string", "varchar", "bigint", "int"]);
 const DISPLAY_HINTS = ["name", "title", "label", "display_name", "description"];
-function detectPrimaryKey(table) {
-    for (const col of table.columns) {
-        if (PK_CANDIDATES.has(col.name.toLowerCase()) && PK_TYPES.has(col.type.toLowerCase())) {
-            return col.name;
-        }
-    }
-    for (const col of table.columns) {
-        if (PK_TYPES.has(col.type.toLowerCase())) {
-            return col.name;
+/** Detect primary key: first column (left-to-right) with all unique values in the sample. */
+function detectPrimaryKey(table, rows) {
+    if (rows && rows.length > 0) {
+        for (const col of table.columns) {
+            const values = rows.map((r) => r[col.name]);
+            const unique = new Set(values);
+            if (unique.size === rows.length)
+                return col.name;
         }
     }
+    // Fallback: first column
     return table.columns[0]?.name ?? "id";
 }
 function detectDisplayKey(table, primaryKey) {
@@ -2141,7 +2144,25 @@ function parseKnCreateFromDsArgs(args) {
         businessDomain = resolveBusinessDomain();
     return { dsId, name, tables, build, timeout, businessDomain, pretty };
 }
-async function runKnCreateFromDsCommand(args) {
+/** Sanitize a table name into a BKN-safe ID (alphanumeric + underscore). */
+function sanitizeBknId(name) {
+    return name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+}
+/** Generate a BKN ObjectType YAML markdown file for a table. */
+function generateObjectTypeBkn(tableName, dvId, pk, dk, columns) {
+    const safeId = sanitizeBknId(tableName);
+    const header = `## ObjectType: ${safeId}\n\n**${tableName}**\n`;
+    const dsTable = `### Data Source\n\n| Type | ID | Name |\n|------|-----|------|\n| data_view | ${dvId} | ${tableName} |\n`;
+    const dpHeader = `### Data Properties\n\n| Property | Display Name | Type | Primary Key | Display Key |\n|----------|-------------|------|-------------|-------------|\n`;
+    const dpRows = columns.map((c) => {
+        const isPk = c.name === pk ? "yes" : "no";
+        const isDk = c.name === dk ? "yes" : "no";
+        return `| ${c.name} | ${c.name} | string | ${isPk} | ${isDk} |`;
+    }).join("\n");
+    const frontmatter = `---\ntype: object_type\nid: ${safeId}\nname: ${tableName}\n---\n\n`;
+    return `${frontmatter}${header}\n${dsTable}\n${dpHeader}${dpRows}\n`;
+}
+async function runKnCreateFromDsCommand(args, sampleRows) {
     let options;
     try {
         options = parseKnCreateFromDsArgs(args);
@@ -2170,6 +2191,8 @@ async function runKnCreateFromDsCommand(args) {
             console.error("No tables available");
             return 1;
         }
+        // Phase 1: Create DataViews for each table
+        console.error(`Creating data views for ${targetTables.length} table(s) ...`);
         const viewMap = {};
         for (const t of targetTables) {
             const dvId = await createDataView({
@@ -2181,6 +2204,7 @@ async function runKnCreateFromDsCommand(args) {
             });
             viewMap[t.name] = dvId;
         }
+        // Phase 2: Create the KN record
         const knBody = JSON.stringify({
             name: options.name,
             branch: "main",
@@ -2193,20 +2217,25 @@ async function runKnCreateFromDsCommand(args) {
         const knParsed = JSON.parse(knResponse);
         const knItem = Array.isArray(knParsed) ? knParsed[0] : knParsed;
         const knId = String(knItem?.id ?? "");
+        console.error(`Knowledge network created: ${knId}`);
+        // Phase 3: Create object types via REST API
+        console.error(`Creating ${targetTables.length} object type(s) ...`);
         const otResults = [];
         for (const t of targetTables) {
-            const pk = detectPrimaryKey(t);
+            const pk = detectPrimaryKey(t, sampleRows?.[t.name]);
             const dk = detectDisplayKey(t, pk);
+            const uniqueProps = [pk, dk].filter((x, i, a) => a.indexOf(x) === i);
             const entry = {
                 branch: "main",
                 name: t.name,
                 data_source: { type: "data_view", id: viewMap[t.name] },
                 primary_keys: [pk],
                 display_key: dk,
-                data_properties: [pk, dk].filter((x, i, a) => a.indexOf(x) === i).map((n) => ({
-                    name: n,
-                    display_name: n,
+                data_properties: t.columns.map((c) => ({
+                    name: c.name,
+                    display_name: c.name,
                     type: "string",
+                    mapped_field: { name: c.name, type: c.type || "varchar" },
                 })),
             };
             const otBody = JSON.stringify({ entries: [entry] });
@@ -2222,6 +2251,16 @@ async function runKnCreateFromDsCommand(args) {
                 id: otItem?.id ?? "",
                 field_count: t.columns.length,
             });
+            console.error(`  Created: ${t.name} (${t.columns.length} fields, pk=${pk}, dk=${dk})`);
+        }
+        if (otResults.length === 0) {
+            const errorOutput = {
+                kn_id: knId,
+                kn_name: options.name,
+                error: "No object types were created",
+            };
+            console.log(JSON.stringify(errorOutput, null, options.pretty ? 2 : 0));
+            return 1;
         }
         let statusStr = "skipped";
         if (options.build) {
@@ -2749,3 +2788,149 @@ async function runKnSearchCommand(args) {
         return 1;
     }
 }
+const KN_CREATE_FROM_CSV_HELP = `kweaver bkn create-from-csv <ds-id> --files <glob> --name X [options]
+
+Import CSV files into datasource, then create a knowledge network.
+
+Options:
+  --files <s>          CSV file paths (comma-separated or glob, required)
+  --name <s>           Knowledge network name (required)
+  --table-prefix <s>   Table name prefix (default: none)
+  --batch-size <n>     Rows per batch (default: 500)
+  --tables <a,b>       Tables to include in KN (default: all imported)
+  --build (default)    Build after creation
+  --no-build           Skip build
+  --timeout <n>        Build timeout in seconds (default: 300)
+  -bd, --biz-domain    Business domain (default: bd_public)`;
+function parseKnCreateFromCsvArgs(args) {
+    let dsId = "";
+    let files = "";
+    let name = "";
+    let tablePrefix = "";
+    let batchSize = 500;
+    let tablesStr = "";
+    let build = true;
+    let timeout = 300;
+    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 === "--name" && args[i + 1]) {
+            name = args[++i];
+            continue;
+        }
+        if (arg === "--table-prefix" && args[i + 1]) {
+            tablePrefix = args[++i];
+            continue;
+        }
+        if (arg === "--batch-size" && args[i + 1]) {
+            batchSize = parseInt(args[++i], 10);
+            if (Number.isNaN(batchSize) || batchSize < 1)
+                batchSize = 500;
+            continue;
+        }
+        if (arg === "--tables" && args[i + 1]) {
+            tablesStr = args[++i];
+            continue;
+        }
+        if (arg === "--build") {
+            build = true;
+            continue;
+        }
+        if (arg === "--no-build") {
+            build = false;
+            continue;
+        }
+        if (arg === "--timeout" && args[i + 1]) {
+            timeout = parseInt(args[++i], 10);
+            if (Number.isNaN(timeout) || timeout < 1)
+                timeout = 300;
+            continue;
+        }
+        if ((arg === "-bd" || arg === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (!arg.startsWith("-") && !dsId) {
+            dsId = arg;
+        }
+    }
+    const tables = tablesStr ? tablesStr.split(",").map((s) => s.trim()).filter(Boolean) : [];
+    if (!dsId || !files || !name) {
+        throw new Error("Usage: kweaver bkn create-from-csv <ds-id> --files <glob> --name X [options]");
+    }
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { dsId, files, name, tablePrefix, batchSize, tables, build, timeout, businessDomain };
+}
+async function runKnCreateFromCsvCommand(args) {
+    let options;
+    try {
+        options = parseKnCreateFromCsvArgs(args);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "help") {
+            console.log(KN_CREATE_FROM_CSV_HELP);
+            return 0;
+        }
+        console.error(formatHttpError(error));
+        return 1;
+    }
+    // Phase 1: Import CSVs
+    console.error("Phase 1: Importing CSVs ...");
+    const importArgs = [
+        options.dsId,
+        "--files", options.files,
+        "--table-prefix", options.tablePrefix,
+        "--batch-size", String(options.batchSize),
+        "-bd", options.businessDomain,
+    ];
+    const importResult = await runDsImportCsv(importArgs);
+    if (importResult.code !== 0) {
+        console.error("CSV import failed — aborting KN creation");
+        return importResult.code;
+    }
+    // Phase 1.5: Scan datasource metadata so platform discovers newly imported tables
+    console.error("Scanning datasource metadata ...");
+    try {
+        const token = await ensureValidToken();
+        const dsBody = await getDatasource({
+            baseUrl: token.baseUrl,
+            accessToken: token.accessToken,
+            id: options.dsId,
+            businessDomain: options.businessDomain,
+        });
+        const dsParsed = JSON.parse(dsBody);
+        await scanMetadata({
+            baseUrl: token.baseUrl,
+            accessToken: token.accessToken,
+            id: options.dsId,
+            dsType: dsParsed.type ?? "mysql",
+            businessDomain: options.businessDomain,
+        });
+    }
+    catch (err) {
+        console.error(`Scan warning (continuing): ${String(err)}`);
+    }
+    // Phase 2: Create KN from datasource
+    console.error("Phase 2: Creating knowledge network ...");
+    const tableNames = options.tables.length > 0 ? options.tables : importResult.tables;
+    if (tableNames.length === 0) {
+        console.error("No tables available for KN creation — aborting");
+        return 1;
+    }
+    const knArgs = [
+        options.dsId,
+        "--name", options.name,
+        "--tables", tableNames.join(","),
+        options.build ? "--build" : "--no-build",
+        "--timeout", String(options.timeout),
+        "-bd", options.businessDomain,
+    ];
+    return runKnCreateFromDsCommand(knArgs, importResult.sampleRows);
+}

package/dist/commands/ds.d.ts

@@ -5,3 +5,19 @@ export declare function parseDsListArgs(args: string[]): {
     businessDomain: string;
     pretty: boolean;
 };
+export declare function parseImportCsvArgs(args: string[]): {
+    datasourceId: string;
+    files: string;
+    tablePrefix: string;
+    batchSize: number;
+    businessDomain: string;
+};
+export declare function resolveFiles(pattern: string): Promise<string[]>;
+export interface ImportCsvResult {
+    code: number;
+    tables: string[];
+    tableColumns: Record<string, string[]>;
+    sampleRows: Record<string, Array<Record<string, string | null>>>;
+}
+export declare function runDsImportCsv(args: string[]): Promise<ImportCsvResult>;
+export declare function runDsImportCsvCommand(args: string[]): Promise<number>;

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;