@kweaver-ai/kweaver-sdk 0.4.0 → 0.4.2

package/dist/api/datasources.js

@@ -0,0 +1,218 @@
+import { HttpError } from "../utils/http.js";
+import { encryptPassword } from "../utils/crypto.js";
+const HTTPS_PROTOCOLS = new Set(["maxcompute", "anyshare7", "opensearch"]);
+function connectProtocol(dsType) {
+    return HTTPS_PROTOCOLS.has(dsType) ? "https" : "jdbc";
+}
+function makeBinData(type, host, port, database, account, password, schema) {
+    const d = {
+        host,
+        port,
+        database_name: database,
+        connect_protocol: connectProtocol(type),
+        account,
+        password: encryptPassword(password),
+    };
+    if (schema !== undefined && schema !== "") {
+        d.schema = schema;
+    }
+    return d;
+}
+function buildHeaders(accessToken, businessDomain) {
+    return {
+        accept: "application/json, text/plain, */*",
+        "accept-language": "zh-cn",
+        authorization: `Bearer ${accessToken}`,
+        token: accessToken,
+        "x-business-domain": businessDomain,
+        "x-language": "zh-cn",
+    };
+}
+export async function testDatasource(options) {
+    const { baseUrl, accessToken, type, host, port, database, account, password, schema, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/data-connection/v1/datasource/test`;
+    const body = JSON.stringify({
+        type,
+        bin_data: makeBinData(type, host, port, database, account, password, schema),
+    });
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    if (!response.ok) {
+        const responseBody = await response.text();
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+}
+export async function createDatasource(options) {
+    const { baseUrl, accessToken, name, type, host, port, database, account, password, schema, comment, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/data-connection/v1/datasource`;
+    const bodyObj = {
+        name,
+        type,
+        bin_data: makeBinData(type, host, port, database, account, password, schema),
+    };
+    if (comment) {
+        bodyObj.comment = comment;
+    }
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(bodyObj),
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function listDatasources(options) {
+    const { baseUrl, accessToken, keyword, type, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/data-connection/v1/datasource`);
+    if (keyword)
+        url.searchParams.set("keyword", keyword);
+    if (type)
+        url.searchParams.set("type", type);
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function getDatasource(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/data-connection/v1/datasource/${encodeURIComponent(id)}`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function deleteDatasource(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/data-connection/v1/datasource/${encodeURIComponent(id)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new HttpError(response.status, response.statusText, body);
+    }
+}
+export async function listTables(options) {
+    const { baseUrl, accessToken, id, keyword, limit = -1, offset, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/data-connection/v1/metadata/data-source/${encodeURIComponent(id)}`);
+    url.searchParams.set("limit", String(limit));
+    if (keyword)
+        url.searchParams.set("keyword", keyword);
+    if (offset !== undefined)
+        url.searchParams.set("offset", String(offset));
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+/** List tables with column details. Optionally triggers metadata scan if no tables found. */
+export async function listTablesWithColumns(options) {
+    const { id, autoScan = true, ...rest } = options;
+    let body = await listTables({ ...rest, id });
+    const parsed = JSON.parse(body);
+    let items = Array.isArray(parsed) ? parsed : (parsed.entries ?? parsed.data ?? []);
+    if (items.length === 0 && autoScan) {
+        await scanMetadata({
+            baseUrl: rest.baseUrl,
+            accessToken: rest.accessToken,
+            id,
+            businessDomain: rest.businessDomain,
+        });
+        body = await listTables({ ...rest, id });
+        const parsed2 = JSON.parse(body);
+        items = Array.isArray(parsed2) ? parsed2 : (parsed2.entries ?? parsed2.data ?? []);
+    }
+    const base = rest.baseUrl.replace(/\/+$/, "");
+    const tables = [];
+    for (const t of items) {
+        const tableId = String(t.id ?? "");
+        const tableName = String(t.name ?? "");
+        let columnsRaw = (t.columns ?? t.fields ?? []);
+        if (columnsRaw.length === 0 && tableId) {
+            const tableUrl = `${base}/api/data-connection/v1/metadata/table/${encodeURIComponent(tableId)}?limit=-1`;
+            const colResponse = await fetch(tableUrl, {
+                method: "GET",
+                headers: buildHeaders(rest.accessToken, rest.businessDomain ?? "bd_public"),
+            });
+            const colData = (await colResponse.json());
+            columnsRaw = Array.isArray(colData) ? colData : (colData.entries ?? colData.data ?? []);
+        }
+        const columns = columnsRaw.map((c) => ({
+            name: String(c.name ?? c.field_name ?? ""),
+            type: String(c.type ?? c.field_type ?? "varchar"),
+            comment: typeof c.comment === "string" ? c.comment : undefined,
+        }));
+        tables.push({ name: tableName, columns });
+    }
+    return JSON.stringify(tables);
+}
+export async function scanMetadata(options) {
+    const { baseUrl, accessToken, id, dsType = "mysql", businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const scanUrl = `${base}/api/data-connection/v1/metadata/scan`;
+    const statusUrl = (taskId) => `${base}/api/data-connection/v1/metadata/scan/${taskId}`;
+    const scanBody = JSON.stringify({
+        scan_name: `sdk_scan_${id.slice(0, 8)}`,
+        type: 0,
+        ds_info: { ds_id: id, ds_type: dsType },
+        use_default_template: true,
+        use_multi_threads: true,
+        status: "open",
+    });
+    const scanResponse = await fetch(scanUrl, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: scanBody,
+    });
+    const scanResult = await scanResponse.json();
+    const taskId = scanResult.id ?? "";
+    for (let i = 0; i < 30; i += 1) {
+        await new Promise((r) => setTimeout(r, 2000));
+        const statusResponse = await fetch(statusUrl(taskId), {
+            method: "GET",
+            headers: buildHeaders(accessToken, businessDomain),
+        });
+        const statusData = (await statusResponse.json());
+        if (statusData.status === "success" || statusData.status === "fail") {
+            break;
+        }
+    }
+    return taskId;
+}

package/dist/api/dataviews.d.ts

@@ -0,0 +1,20 @@
+export interface CreateDataViewOptions {
+    baseUrl: string;
+    accessToken: string;
+    name: string;
+    datasourceId: string;
+    table: string;
+    fields?: Array<{
+        name: string;
+        type: string;
+    }>;
+    businessDomain?: string;
+}
+export declare function createDataView(options: CreateDataViewOptions): Promise<string>;
+export interface GetDataViewOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    businessDomain?: string;
+}
+export declare function getDataView(options: GetDataViewOptions): Promise<string>;

package/dist/api/dataviews.js

@@ -0,0 +1,72 @@
+import { createHash } from "node:crypto";
+import { HttpError } from "../utils/http.js";
+function buildHeaders(accessToken, businessDomain) {
+    return {
+        accept: "application/json, text/plain, */*",
+        "accept-language": "zh-cn",
+        authorization: `Bearer ${accessToken}`,
+        token: accessToken,
+        "x-business-domain": businessDomain,
+        "x-language": "zh-cn",
+    };
+}
+function extractViewId(data) {
+    if (Array.isArray(data) && data.length > 0) {
+        const item = data[0];
+        if (typeof item === "string")
+            return item;
+        if (item && typeof item === "object" && "id" in item) {
+            return String(item.id ?? "");
+        }
+    }
+    if (data && typeof data === "object" && "id" in data) {
+        return String(data.id ?? "");
+    }
+    return null;
+}
+export async function createDataView(options) {
+    const { baseUrl, accessToken, name, datasourceId, table, fields = [], businessDomain = "bd_public", } = options;
+    const viewId = createHash("md5").update(`${datasourceId}:${table}`).digest("hex").slice(0, 35);
+    const body = JSON.stringify([
+        {
+            id: viewId,
+            name,
+            technical_name: table,
+            type: "atomic",
+            query_type: "SQL",
+            data_source_id: datasourceId,
+            group_id: datasourceId,
+            fields,
+        },
+    ]);
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/mdl-data-model/v1/data-views`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    const createdId = extractViewId(JSON.parse(responseBody));
+    return createdId ?? viewId;
+}
+export async function getDataView(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/mdl-data-model/v1/data-views/${encodeURIComponent(id)}`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}

package/dist/api/knowledge-networks.d.ts

@@ -55,3 +55,87 @@ export interface ListSchemaTypesOptions {
 export declare function listObjectTypes(options: ListSchemaTypesOptions): Promise<string>;
 export declare function listRelationTypes(options: ListSchemaTypesOptions): Promise<string>;
 export declare function listActionTypes(options: ListSchemaTypesOptions): Promise<string>;
+export interface GetObjectTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    otId: string;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function getObjectType(options: GetObjectTypeOptions): Promise<string>;
+export interface CreateObjectTypesOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    body: string;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function createObjectTypes(options: CreateObjectTypesOptions): Promise<string>;
+export interface UpdateObjectTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    otId: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function updateObjectType(options: UpdateObjectTypeOptions): Promise<string>;
+export interface DeleteObjectTypesOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    otIds: string;
+    businessDomain?: string;
+}
+export declare function deleteObjectTypes(options: DeleteObjectTypesOptions): Promise<void>;
+export interface GetRelationTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    rtId: string;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function getRelationType(options: GetRelationTypeOptions): Promise<string>;
+export interface CreateRelationTypesOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    body: string;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function createRelationTypes(options: CreateRelationTypesOptions): Promise<string>;
+export interface UpdateRelationTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    rtId: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function updateRelationType(options: UpdateRelationTypeOptions): Promise<string>;
+export interface DeleteRelationTypesOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    rtIds: string;
+    businessDomain?: string;
+}
+export declare function deleteRelationTypes(options: DeleteRelationTypesOptions): Promise<void>;
+export interface BuildKnowledgeNetworkOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    businessDomain?: string;
+}
+export declare function buildKnowledgeNetwork(options: BuildKnowledgeNetworkOptions): Promise<void>;
+export interface GetBuildStatusOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    businessDomain?: string;
+}
+export declare function getBuildStatus(options: GetBuildStatusOptions): Promise<string>;

package/dist/api/knowledge-networks.js

@@ -156,3 +156,170 @@ export async function listActionTypes(options) {
     }
     return body;
 }
+export async function getObjectType(options) {
+    const { baseUrl, accessToken, knId, otId, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otId)}`);
+    url.searchParams.set("branch", branch);
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function createObjectTypes(options) {
+    const { baseUrl, accessToken, knId, body, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types`);
+    url.searchParams.set("branch", branch);
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function updateObjectType(options) {
+    const { baseUrl, accessToken, knId, otId, body, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otId)}`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function deleteObjectTypes(options) {
+    const { baseUrl, accessToken, knId, otIds, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otIds)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new HttpError(response.status, response.statusText, body);
+    }
+}
+export async function getRelationType(options) {
+    const { baseUrl, accessToken, knId, rtId, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/relation-types/${encodeURIComponent(rtId)}`);
+    url.searchParams.set("branch", branch);
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function createRelationTypes(options) {
+    const { baseUrl, accessToken, knId, body, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/relation-types`);
+    url.searchParams.set("branch", branch);
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function updateRelationType(options) {
+    const { baseUrl, accessToken, knId, rtId, body, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/relation-types/${encodeURIComponent(rtId)}`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function deleteRelationTypes(options) {
+    const { baseUrl, accessToken, knId, rtIds, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/relation-types/${encodeURIComponent(rtIds)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new HttpError(response.status, response.statusText, body);
+    }
+}
+export async function buildKnowledgeNetwork(options) {
+    const { baseUrl, accessToken, knId, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/jobs`;
+    const body = JSON.stringify({
+        name: `sdk_build_${knId.slice(0, 8)}`,
+        job_type: "full",
+    });
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    if (!response.ok) {
+        const responseBody = await response.text();
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+}
+export async function getBuildStatus(options) {
+    const { baseUrl, accessToken, knId, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/jobs`);
+    url.searchParams.set("limit", "1");
+    url.searchParams.set("direction", "desc");
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}

package/dist/api/ontology-query.d.ts

@@ -20,7 +20,7 @@ export interface ObjectTypePropertiesOptions extends OntologyQueryBaseOptions {
     excludeSystemProperties?: string[];
 }
 export declare function objectTypeProperties(options: ObjectTypePropertiesOptions): Promise<string>;
-/** Subgraph: POST */
+/** Subgraph: POST with X-HTTP-Method-Override: GET */
 export interface SubgraphOptions extends OntologyQueryBaseOptions {
     body: string;
     includeLogicParams?: boolean;

package/dist/api/ontology-query.js

@@ -83,6 +83,7 @@ export async function subgraph(options) {
     const headers = {
         ...buildHeaders(accessToken, businessDomain),
         "content-type": "application/json",
+        "X-HTTP-Method-Override": "GET",
     };
     const response = await fetch(url.toString(), {
         method: "POST",