taurusdb-core 0.1.0

package/dist/auth/sql-profile-loader/types.d.ts

@@ -0,0 +1,64 @@
+import type { Config } from "../../config/index.js";
+export type DatabaseEngine = "mysql" | "postgresql";
+export type CredentialRef = {
+    type: "plain";
+    value: string;
+} | {
+    type: "env";
+    key: string;
+} | {
+    type: "file";
+    path: string;
+} | {
+    type: "uri";
+    uri: string;
+};
+export interface UserCredential {
+    username: string;
+    password: CredentialRef;
+}
+export interface TlsOptions {
+    enabled?: boolean;
+    rejectUnauthorized?: boolean;
+    servername?: string;
+    ca?: CredentialRef;
+    cert?: CredentialRef;
+    key?: CredentialRef;
+}
+export interface DataSourceProfile {
+    name: string;
+    engine: DatabaseEngine;
+    host?: string;
+    port: number;
+    database?: string;
+    readonlyUser: UserCredential;
+    mutationUser?: UserCredential;
+    tls?: TlsOptions;
+    poolSize?: number;
+    toString(): string;
+}
+export interface ProfileLoader {
+    load(): Promise<Map<string, DataSourceProfile>>;
+    getDefault(): Promise<string | undefined>;
+    get(name: string): Promise<DataSourceProfile | undefined>;
+}
+export interface RuntimeDataSourceTarget {
+    host: string;
+    port?: number;
+    instanceId?: string;
+    nodeId?: string;
+}
+export interface RuntimeTargetProfileLoader extends ProfileLoader {
+    setRuntimeTarget(name: string, target: RuntimeDataSourceTarget): void;
+    clearRuntimeTarget(name: string): void;
+    clearAllRuntimeTargets(): void;
+    getRuntimeTarget(name: string): RuntimeDataSourceTarget | undefined;
+}
+export type SqlProfileLoaderOptions = {
+    config: Config;
+    env?: NodeJS.ProcessEnv;
+};
+export type LoadedProfiles = {
+    profiles: Map<string, DataSourceProfile>;
+    defaultDatasource?: string;
+};

package/dist/auth/sql-profile-loader/types.js

@@ -0,0 +1 @@
+export {};

package/dist/auth/sql-profile-loader.d.ts

@@ -0,0 +1,4 @@
+export type { CredentialRef, DataSourceProfile, DatabaseEngine, ProfileLoader, RuntimeDataSourceTarget, RuntimeTargetProfileLoader, SqlProfileLoaderOptions, TlsOptions, UserCredential, } from "./sql-profile-loader/types.js";
+export { redactDataSourceProfile } from "./sql-profile-loader/parsing.js";
+export { SqlProfileLoader, createSqlProfileLoader } from "./sql-profile-loader/loader.js";
+export { RuntimeOverrideProfileLoader } from "./sql-profile-loader/runtime-override.js";

package/dist/auth/sql-profile-loader.js

@@ -0,0 +1,3 @@
+export { redactDataSourceProfile } from "./sql-profile-loader/parsing.js";
+export { SqlProfileLoader, createSqlProfileLoader } from "./sql-profile-loader/loader.js";
+export { RuntimeOverrideProfileLoader } from "./sql-profile-loader/runtime-override.js";

package/dist/capability/feature-matrix.d.ts

@@ -0,0 +1,5 @@
+import type { FeatureMatrix, KernelInfo } from "./types.js";
+type ProbeVariables = Partial<Record<string, string>>;
+export declare function buildUnavailableFeatureMatrix(reason?: string): FeatureMatrix;
+export declare function buildFeatureMatrix(kernelInfo: KernelInfo, variables?: ProbeVariables): FeatureMatrix;
+export {};

package/dist/capability/feature-matrix.js

@@ -0,0 +1,237 @@
+import { isKernelVersionAtLeast } from "./version.js";
+const FEATURE_MIN_VERSIONS = {
+    flashback_query: "2.0.69.250900",
+    recycle_bin: "2.0.57.240900",
+    statement_outline: "2.0.42.230600",
+    column_compression: "2.0.54.240600",
+    multi_tenant: "2.0.54.240600",
+    partition_mdl: "2.0.57.240900",
+    dynamic_masking: "2.0.69.250900",
+    nonblocking_ddl: "2.0.54.240600",
+    hot_row_update: "2.0.54.240600",
+};
+function normalizeBooleanVariable(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["on", "1", "true", "yes", "enabled"].includes(normalized)) {
+        return true;
+    }
+    if (["off", "0", "false", "no", "disabled"].includes(normalized)) {
+        return false;
+    }
+    return undefined;
+}
+function makeUnavailable(reason, minVersion) {
+    return {
+        available: false,
+        enabled: false,
+        minVersion,
+        reason,
+    };
+}
+function makeVersionGatedFeature(kernelInfo, feature, reasonWhenUnavailable) {
+    const minVersion = FEATURE_MIN_VERSIONS[feature];
+    if (!kernelInfo.isTaurusDB) {
+        return makeUnavailable("Instance is not TaurusDB.", minVersion);
+    }
+    if (!minVersion) {
+        return {
+            available: true,
+            minVersion,
+        };
+    }
+    if (!isKernelVersionAtLeast(kernelInfo.kernelVersion, minVersion)) {
+        return makeUnavailable(reasonWhenUnavailable ??
+            `Requires kernel version >= ${minVersion}, current: ${kernelInfo.kernelVersion ?? "unknown"}.`, minVersion);
+    }
+    return {
+        available: true,
+        minVersion,
+    };
+}
+function inferOffsetPushdown(optimizerSwitch) {
+    if (!optimizerSwitch) {
+        return undefined;
+    }
+    const match = optimizerSwitch.match(/(?:^|,)offset_pushdown=(on|off)(?:,|$)/i);
+    if (!match) {
+        return undefined;
+    }
+    return match[1].toLowerCase() === "on";
+}
+export function buildUnavailableFeatureMatrix(reason = "Instance is not TaurusDB.") {
+    return {
+        flashback_query: makeUnavailable(reason, FEATURE_MIN_VERSIONS.flashback_query),
+        parallel_query: makeUnavailable(reason),
+        ndp_pushdown: makeUnavailable(reason),
+        offset_pushdown: makeUnavailable(reason),
+        recycle_bin: makeUnavailable(reason, FEATURE_MIN_VERSIONS.recycle_bin),
+        statement_outline: makeUnavailable(reason, FEATURE_MIN_VERSIONS.statement_outline),
+        column_compression: makeUnavailable(reason, FEATURE_MIN_VERSIONS.column_compression),
+        multi_tenant: makeUnavailable(reason, FEATURE_MIN_VERSIONS.multi_tenant),
+        partition_mdl: makeUnavailable(reason, FEATURE_MIN_VERSIONS.partition_mdl),
+        dynamic_masking: makeUnavailable(reason, FEATURE_MIN_VERSIONS.dynamic_masking),
+        nonblocking_ddl: makeUnavailable(reason, FEATURE_MIN_VERSIONS.nonblocking_ddl),
+        hot_row_update: makeUnavailable(reason, FEATURE_MIN_VERSIONS.hot_row_update),
+    };
+}
+export function buildFeatureMatrix(kernelInfo, variables = {}) {
+    if (!kernelInfo.isTaurusDB) {
+        return buildUnavailableFeatureMatrix();
+    }
+    const flashbackEnabled = normalizeBooleanVariable(variables.innodb_rds_backquery_enable);
+    const recycleBinMode = normalizeBooleanVariable(variables.rds_recycle_bin_mode);
+    const parallelSetting = variables.force_parallel_execute;
+    const parallelEnabled = normalizeBooleanVariable(parallelSetting);
+    const offsetPushdownEnabled = inferOffsetPushdown(variables.optimizer_switch);
+    const ndpModeRaw = variables.ndp_mode ??
+        variables.rds_ndp_mode ??
+        variables.taurus_ndp_mode ??
+        variables.ndp_pushdown_mode ??
+        variables.ndp_pushdown;
+    const ndpParamName = variables.ndp_mode !== undefined
+        ? "ndp_mode"
+        : variables.rds_ndp_mode !== undefined
+            ? "rds_ndp_mode"
+            : variables.taurus_ndp_mode !== undefined
+                ? "taurus_ndp_mode"
+                : variables.ndp_pushdown_mode !== undefined
+                    ? "ndp_pushdown_mode"
+                    : variables.ndp_pushdown !== undefined
+                        ? "ndp_pushdown"
+                        : undefined;
+    const ndpMode = ndpModeRaw?.toUpperCase() === "REPLICA_ON" ||
+        ndpModeRaw?.toUpperCase() === "ON" ||
+        ndpModeRaw?.toUpperCase() === "OFF"
+        ? ndpModeRaw.toUpperCase()
+        : undefined;
+    const multiTenantActive = normalizeBooleanVariable(variables.rds_multi_tenant ?? variables.multi_tenant_mode);
+    const multiTenantParamName = variables.multi_tenant_mode !== undefined
+        ? "multi_tenant_mode"
+        : variables.rds_multi_tenant !== undefined
+            ? "rds_multi_tenant"
+            : "multi_tenant_mode";
+    const statementOutlineEnabled = normalizeBooleanVariable(variables.rds_opt_outline_enabled);
+    const partitionMdlEnabled = normalizeBooleanVariable(variables.rds_partition_level_mdl_enabled);
+    const dynamicMaskingEnabled = normalizeBooleanVariable(variables.rds_dynamic_masking_enabled);
+    const nonblockingDdlEnabled = normalizeBooleanVariable(variables.rds_nonblock_ddl_enable);
+    const hotRowUpdateEnabled = normalizeBooleanVariable(variables.rds_hotspot);
+    const flashback = makeVersionGatedFeature(kernelInfo, "flashback_query");
+    if (flashback.available) {
+        flashback.enabled = flashbackEnabled ?? true;
+        if (flashbackEnabled === false) {
+            flashback.param = "innodb_rds_backquery_enable=OFF";
+        }
+        else if (flashbackEnabled === true) {
+            flashback.param = "innodb_rds_backquery_enable=ON";
+        }
+    }
+    const recycleBin = makeVersionGatedFeature(kernelInfo, "recycle_bin");
+    if (recycleBin.available) {
+        recycleBin.enabled = recycleBinMode ?? true;
+        if (recycleBinMode === false) {
+            recycleBin.param = "rds_recycle_bin_mode=OFF";
+        }
+        else if (recycleBinMode === true) {
+            recycleBin.param = "rds_recycle_bin_mode=ON";
+        }
+    }
+    const statementOutline = makeVersionGatedFeature(kernelInfo, "statement_outline");
+    if (statementOutline.available) {
+        statementOutline.enabled = statementOutlineEnabled;
+        if (statementOutlineEnabled === false) {
+            statementOutline.param = "rds_opt_outline_enabled=OFF";
+        }
+        else if (statementOutlineEnabled === true) {
+            statementOutline.param = "rds_opt_outline_enabled=ON";
+        }
+    }
+    const columnCompression = makeVersionGatedFeature(kernelInfo, "column_compression");
+    const multiTenant = makeVersionGatedFeature(kernelInfo, "multi_tenant");
+    if (multiTenant.available) {
+        multiTenant.active = multiTenantActive ?? false;
+        multiTenant.enabled = multiTenantActive ?? false;
+        if (multiTenantActive === false) {
+            multiTenant.param = `${multiTenantParamName}=OFF`;
+        }
+        else if (multiTenantActive === true) {
+            multiTenant.param =
+                variables[multiTenantParamName] !== undefined
+                    ? `${multiTenantParamName}=${variables[multiTenantParamName]}`
+                    : `${multiTenantParamName}=ON`;
+        }
+    }
+    const partitionMdl = makeVersionGatedFeature(kernelInfo, "partition_mdl");
+    if (partitionMdl.available) {
+        partitionMdl.enabled = partitionMdlEnabled;
+        if (partitionMdlEnabled === false) {
+            partitionMdl.param = "rds_partition_level_mdl_enabled=OFF";
+        }
+        else if (partitionMdlEnabled === true) {
+            partitionMdl.param = "rds_partition_level_mdl_enabled=ON";
+        }
+    }
+    const dynamicMasking = makeVersionGatedFeature(kernelInfo, "dynamic_masking");
+    if (dynamicMasking.available) {
+        dynamicMasking.enabled = dynamicMaskingEnabled;
+        if (dynamicMaskingEnabled === false) {
+            dynamicMasking.param = "rds_dynamic_masking_enabled=OFF";
+        }
+        else if (dynamicMaskingEnabled === true) {
+            dynamicMasking.param = "rds_dynamic_masking_enabled=ON";
+        }
+    }
+    const nonblockingDdl = makeVersionGatedFeature(kernelInfo, "nonblocking_ddl");
+    if (nonblockingDdl.available) {
+        nonblockingDdl.enabled = nonblockingDdlEnabled;
+        if (nonblockingDdlEnabled === false) {
+            nonblockingDdl.param = "rds_nonblock_ddl_enable=OFF";
+        }
+        else if (nonblockingDdlEnabled === true) {
+            nonblockingDdl.param = "rds_nonblock_ddl_enable=ON";
+        }
+    }
+    const hotRowUpdate = makeVersionGatedFeature(kernelInfo, "hot_row_update");
+    if (hotRowUpdate.available) {
+        hotRowUpdate.enabled = hotRowUpdateEnabled;
+        if (hotRowUpdateEnabled === false) {
+            hotRowUpdate.param = "rds_hotspot=OFF";
+        }
+        else if (hotRowUpdateEnabled === true) {
+            hotRowUpdate.param = "rds_hotspot=ON";
+        }
+    }
+    return {
+        flashback_query: flashback,
+        parallel_query: {
+            available: true,
+            enabled: parallelEnabled ?? false,
+            param: parallelSetting ? `force_parallel_execute=${parallelSetting}` : undefined,
+        },
+        ndp_pushdown: {
+            available: true,
+            enabled: ndpMode ? ndpMode !== "OFF" : true,
+            mode: ndpMode,
+            param: ndpModeRaw && ndpParamName ? `${ndpParamName}=${ndpModeRaw}` : undefined,
+        },
+        offset_pushdown: {
+            available: true,
+            enabled: offsetPushdownEnabled ?? true,
+            param: offsetPushdownEnabled === false
+                ? "optimizer_switch: offset_pushdown=off"
+                : offsetPushdownEnabled === true
+                    ? "optimizer_switch: offset_pushdown=on"
+                    : undefined,
+        },
+        recycle_bin: recycleBin,
+        statement_outline: statementOutline,
+        column_compression: columnCompression,
+        multi_tenant: multiTenant,
+        partition_mdl: partitionMdl,
+        dynamic_masking: dynamicMasking,
+        nonblocking_ddl: nonblockingDdl,
+        hot_row_update: hotRowUpdate,
+    };
+}

package/dist/capability/probe.d.ts

@@ -0,0 +1,19 @@
+import type { SessionContext } from "../context/session-context.js";
+import type { ConnectionPool } from "../executor/connection-pool.js";
+import type { CapabilitySnapshot, FeatureMatrix, KernelInfo } from "./types.js";
+export interface CapabilityProbe {
+    probe(ctx: SessionContext): Promise<CapabilitySnapshot>;
+    getKernelInfo(ctx: SessionContext): Promise<KernelInfo>;
+    listFeatures(ctx: SessionContext): Promise<FeatureMatrix>;
+}
+export interface CapabilityProbeOptions {
+    connectionPool: ConnectionPool;
+}
+export declare class CapabilityProbeImpl implements CapabilityProbe {
+    private readonly connectionPool;
+    constructor(options: CapabilityProbeOptions);
+    probe(ctx: SessionContext): Promise<CapabilitySnapshot>;
+    getKernelInfo(ctx: SessionContext): Promise<KernelInfo>;
+    listFeatures(ctx: SessionContext): Promise<FeatureMatrix>;
+}
+export declare function createCapabilityProbe(options: CapabilityProbeOptions): CapabilityProbe;

package/dist/capability/probe.js

@@ -0,0 +1,139 @@
+import { buildFeatureMatrix } from "./feature-matrix.js";
+import { extractKernelVersion } from "./version.js";
+const TAURUS_VARIABLE_NAMES = [
+    "innodb_rds_backquery_enable",
+    "rds_recycle_bin_mode",
+    "force_parallel_execute",
+    "ndp_mode",
+    "rds_ndp_mode",
+    "taurus_ndp_mode",
+    "ndp_pushdown_mode",
+    "ndp_pushdown",
+    "rds_multi_tenant",
+    "multi_tenant_mode",
+    "rds_opt_outline_enabled",
+    "rds_partition_level_mdl_enabled",
+    "rds_dynamic_masking_enabled",
+    "rds_nonblock_ddl_enable",
+    "rds_hotspot",
+];
+function mysqlCompatFromVersion(rawVersion) {
+    if (/8\.0/i.test(rawVersion)) {
+        return "8.0";
+    }
+    if (/5\.7/i.test(rawVersion)) {
+        return "5.7";
+    }
+    return "unknown";
+}
+function rowValueOf(row) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+        return undefined;
+    }
+    const record = row;
+    const preferredKeys = ["Value", "value", "VARIABLE_VALUE", "version", "VERSION()"];
+    for (const key of preferredKeys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    for (const value of Object.values(record)) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function firstRow(result) {
+    return Array.isArray(result.rows) ? result.rows[0] : undefined;
+}
+function inferInstanceSpecHint(variables) {
+    const parallelSetting = (variables.force_parallel_execute ?? "").toUpperCase();
+    const ndpMode = (variables.ndp_mode ??
+        variables.rds_ndp_mode ??
+        variables.taurus_ndp_mode ??
+        variables.ndp_pushdown_mode ??
+        "").toUpperCase();
+    if (parallelSetting === "ON" || ndpMode === "REPLICA_ON") {
+        return "large";
+    }
+    if (parallelSetting === "OFF" || ndpMode === "ON") {
+        return "medium";
+    }
+    return undefined;
+}
+async function executeSingleValueQuery(session, sql) {
+    try {
+        const result = await session.execute(sql);
+        return rowValueOf(firstRow(result));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readVariable(session, name) {
+    return executeSingleValueQuery(session, `SHOW VARIABLES LIKE '${name}'`);
+}
+async function collectVariables(session) {
+    const names = [
+        "version_comment",
+        ...TAURUS_VARIABLE_NAMES,
+        "optimizer_switch",
+    ];
+    const entries = await Promise.all(names.map(async (name) => [name, await readVariable(session, name)]));
+    return Object.fromEntries(entries.filter(([, value]) => value !== undefined));
+}
+function hasTaurusSpecificVariables(variables) {
+    return TAURUS_VARIABLE_NAMES.some((name) => Object.prototype.hasOwnProperty.call(variables, name));
+}
+async function detectKernelInfo(session, variables) {
+    const rawVersion = (await executeSingleValueQuery(session, "SELECT VERSION() AS version")) ?? "unknown";
+    const versionComment = variables.version_comment;
+    const combined = [rawVersion, versionComment].filter(Boolean).join(" ");
+    const kernelVersion = extractKernelVersion(combined);
+    const taurusSignals = [combined, variables.force_parallel_execute, variables.innodb_rds_backquery_enable]
+        .filter((value) => typeof value === "string")
+        .join(" ");
+    const hasTaurusSignals = /taurus|huawei|gaussdb/i.test(taurusSignals) ||
+        hasTaurusSpecificVariables(variables);
+    return {
+        isTaurusDB: hasTaurusSignals,
+        kernelVersion,
+        mysqlCompat: mysqlCompatFromVersion(rawVersion),
+        instanceSpecHint: inferInstanceSpecHint(variables),
+        rawVersion,
+    };
+}
+export class CapabilityProbeImpl {
+    connectionPool;
+    constructor(options) {
+        this.connectionPool = options.connectionPool;
+    }
+    async probe(ctx) {
+        const session = await this.connectionPool.acquire(ctx.datasource, "ro");
+        try {
+            const variables = await collectVariables(session);
+            const kernelInfo = await detectKernelInfo(session, variables);
+            return {
+                kernelInfo,
+                features: buildFeatureMatrix(kernelInfo, variables),
+                checkedAt: Date.now(),
+            };
+        }
+        finally {
+            await this.connectionPool.release(session);
+        }
+    }
+    async getKernelInfo(ctx) {
+        const snapshot = await this.probe(ctx);
+        return snapshot.kernelInfo;
+    }
+    async listFeatures(ctx) {
+        const snapshot = await this.probe(ctx);
+        return snapshot.features;
+    }
+}
+export function createCapabilityProbe(options) {
+    return new CapabilityProbeImpl(options);
+}

package/dist/capability/types.d.ts

@@ -0,0 +1,49 @@
+export interface KernelInfo {
+    isTaurusDB: boolean;
+    kernelVersion?: string;
+    mysqlCompat: "5.7" | "8.0" | "unknown";
+    instanceSpecHint?: "small" | "medium" | "large";
+    rawVersion: string;
+}
+export type FeatureStatus = {
+    available: boolean;
+    enabled?: boolean;
+    minVersion?: string;
+    reason?: string;
+    param?: string;
+};
+export interface FeatureMatrix {
+    flashback_query: FeatureStatus;
+    parallel_query: FeatureStatus;
+    ndp_pushdown: FeatureStatus & {
+        mode?: "OFF" | "ON" | "REPLICA_ON";
+    };
+    offset_pushdown: FeatureStatus;
+    recycle_bin: FeatureStatus;
+    statement_outline: FeatureStatus;
+    column_compression: FeatureStatus;
+    multi_tenant: FeatureStatus & {
+        active?: boolean;
+    };
+    partition_mdl: FeatureStatus;
+    dynamic_masking: FeatureStatus;
+    nonblocking_ddl: FeatureStatus;
+    hot_row_update: FeatureStatus;
+}
+export type TaurusFeatureName = keyof FeatureMatrix;
+export interface CapabilitySnapshot {
+    kernelInfo: KernelInfo;
+    features: FeatureMatrix;
+    checkedAt: number;
+}
+export declare class UnsupportedFeatureError extends Error {
+    readonly code = "UNSUPPORTED_FEATURE";
+    readonly feature: TaurusFeatureName;
+    readonly requiredVersion?: string;
+    readonly currentVersion?: string;
+    constructor(feature: TaurusFeatureName, message: string, options?: {
+        requiredVersion?: string;
+        currentVersion?: string;
+        cause?: unknown;
+    });
+}

package/dist/capability/types.js

@@ -0,0 +1,16 @@
+export class UnsupportedFeatureError extends Error {
+    code = "UNSUPPORTED_FEATURE";
+    feature;
+    requiredVersion;
+    currentVersion;
+    constructor(feature, message, options = {}) {
+        super(message);
+        this.name = "UnsupportedFeatureError";
+        this.feature = feature;
+        this.requiredVersion = options.requiredVersion;
+        this.currentVersion = options.currentVersion;
+        if (options.cause !== undefined) {
+            this.cause = options.cause;
+        }
+    }
+}

package/dist/capability/version.d.ts

@@ -0,0 +1,3 @@
+export declare function compareKernelVersions(left: string | undefined, right: string | undefined): number;
+export declare function isKernelVersionAtLeast(currentVersion: string | undefined, minimumVersion: string | undefined): boolean;
+export declare function extractKernelVersion(input: string | undefined): string | undefined;

package/dist/capability/version.js

@@ -0,0 +1,47 @@
+function parseVersion(version) {
+    if (!version) {
+        return [];
+    }
+    const match = version.match(/\d+(?:\.\d+)+/);
+    if (!match) {
+        return [];
+    }
+    return match[0]
+        .split(".")
+        .map((segment) => Number.parseInt(segment, 10))
+        .filter((segment) => Number.isFinite(segment));
+}
+export function compareKernelVersions(left, right) {
+    const leftParts = parseVersion(left);
+    const rightParts = parseVersion(right);
+    const size = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < size; index += 1) {
+        const a = leftParts[index] ?? 0;
+        const b = rightParts[index] ?? 0;
+        if (a === b) {
+            continue;
+        }
+        return a > b ? 1 : -1;
+    }
+    return 0;
+}
+export function isKernelVersionAtLeast(currentVersion, minimumVersion) {
+    if (!minimumVersion) {
+        return true;
+    }
+    if (!currentVersion) {
+        return false;
+    }
+    return compareKernelVersions(currentVersion, minimumVersion) >= 0;
+}
+export function extractKernelVersion(input) {
+    if (!input) {
+        return undefined;
+    }
+    const exact = input.match(/\b\d+\.\d+\.\d+\.\d+\b/);
+    if (exact) {
+        return exact[0];
+    }
+    const fallback = input.match(/\b\d+\.\d+\.\d+\b/);
+    return fallback?.[0];
+}

package/dist/cloud/auth.d.ts

@@ -0,0 +1,26 @@
+import type { Config } from "../config/index.js";
+export interface HuaweiCloudAuthOptions {
+    region?: string;
+    projectId?: string;
+    authToken?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    securityToken?: string;
+    domainSuffix?: string;
+    iamEndpoint?: string;
+    language?: "en-us" | "zh-cn";
+}
+export interface FetchHuaweiCloudOptions {
+    url: string;
+    method?: string;
+    headers?: HeadersInit;
+    body?: string;
+    auth: HuaweiCloudAuthOptions;
+    fetchImpl?: typeof fetch;
+}
+export declare function canAuthenticateHuaweiCloudRequests(auth: HuaweiCloudAuthOptions): boolean;
+export declare function fetchHuaweiCloud(options: FetchHuaweiCloudOptions): Promise<Response>;
+export declare function resolveHuaweiCloudProjectId(auth: HuaweiCloudAuthOptions, fetchImpl?: typeof fetch): Promise<string | undefined>;
+export declare function getHuaweiCloudAuthFromConfig(config: Config): HuaweiCloudAuthOptions;
+export declare function hasHuaweiCloudCredentialAuth(config: Config): boolean;
+export declare function inferHuaweiCloudRegionFromEndpoint(endpoint: string | undefined): string | undefined;