@gooddata/sdk-backend-tiger 11.64.0-alpha.1 → 11.64.0-alpha.3

package/esm/convertors/toBackend/DeclarativeModelConverter.js

@@ -0,0 +1,277 @@
+// (C) 2026 GoodData Corporation
+import { assertAllFieldsMapped, copyArray, mapArray, mapRecord, withoutUndefined, } from "../shared/declarativeFields.js";
+export function convertDeclarativeLdmToBackend(ldm) {
+    const { calendars, datasetExtensions, datasets, dateInstances, ...unmapped } = ldm;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        calendars: mapRecord(calendars, convertCalendar),
+        datasetExtensions: mapArray(datasetExtensions, convertDatasetExtension),
+        datasets: mapArray(datasets, convertDataset),
+        dateInstances: mapArray(dateInstances, convertDateDataset),
+    });
+}
+function convertCalendar(calendar) {
+    const { definition, description, enabledGranularities, name, ...unmapped } = calendar;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        definition: convertCalendarDefinition(definition),
+        description,
+        enabledGranularities: enabledGranularities.map(({ granularity, prefix, ...rest }) => {
+            assertAllFieldsMapped(rest);
+            return { granularity, prefix };
+        }),
+        name,
+    });
+}
+function convertCalendarDefinition(definition) {
+    if (definition.type === "fiscalYear") {
+        const { type, monthOffset, ...unmapped } = definition;
+        assertAllFieldsMapped(unmapped);
+        return { type, monthOffset };
+    }
+    const { type, dataSourceTables, ...unmapped } = definition;
+    assertAllFieldsMapped(unmapped);
+    return {
+        type,
+        dataSourceTables: mapRecord(dataSourceTables, ({ path, version, ...rest }) => {
+            assertAllFieldsMapped(rest);
+            return { path: [...path], version };
+        }) ?? {},
+    };
+}
+function convertDatasetExtension(extension) {
+    const { id, workspaceDataFilterReferences, ...unmapped } = extension;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        id,
+        workspaceDataFilterReferences: mapArray(workspaceDataFilterReferences, convertWorkspaceDataFilterReference),
+    });
+}
+function convertWorkspaceDataFilterReference(reference) {
+    const { filterColumn, filterColumnDataType, filterId, ...unmapped } = reference;
+    assertAllFieldsMapped(unmapped);
+    const { id, type, ...unmappedId } = filterId;
+    assertAllFieldsMapped(unmappedId);
+    return { filterColumn, filterColumnDataType, filterId: { id, type } };
+}
+function convertDataset(dataset) {
+    const { aggregatedFacts, attributes, dataSourceTableId, description, facts, grain, id, precedence, references, sql, tags, title, type, workspaceDataFilterColumns, workspaceDataFilterReferences, ...unmapped } = dataset;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        aggregatedFacts: mapArray(aggregatedFacts, convertAggregatedFact),
+        attributes: mapArray(attributes, convertAttribute),
+        dataSourceTableId: dataSourceTableId && convertDataSourceTableId(dataSourceTableId),
+        description,
+        facts: mapArray(facts, convertFact),
+        grain: mapArray(grain, convertGrainIdentifier),
+        id,
+        precedence,
+        references: mapArray(references, convertReference),
+        sql: sql && convertDatasetSql(sql),
+        tags: copyArray(tags),
+        title,
+        type,
+        workspaceDataFilterColumns: mapArray(workspaceDataFilterColumns, convertWorkspaceDataFilterColumn),
+        workspaceDataFilterReferences: mapArray(workspaceDataFilterReferences, convertWorkspaceDataFilterReference),
+    });
+}
+function convertAggregatedFact(fact) {
+    const { description, id, isNullable, nullValue, sourceColumn, sourceColumnDataType, sourceFactReference, tags, ...unmapped } = fact;
+    assertAllFieldsMapped(unmapped);
+    const { operation, reference, ...unmappedReference } = sourceFactReference;
+    assertAllFieldsMapped(unmappedReference);
+    const { id: referenceId, type: referenceType, ...unmappedIdentifier } = reference;
+    assertAllFieldsMapped(unmappedIdentifier);
+    return withoutUndefined({
+        description,
+        id,
+        isNullable,
+        nullValue,
+        sourceColumn,
+        sourceColumnDataType,
+        sourceFactReference: { operation, reference: { id: referenceId, type: referenceType } },
+        tags: copyArray(tags),
+    });
+}
+function convertAttribute(attribute) {
+    const { conditionalFormatting, defaultView, description, id, isHidden, isNullable, labels, locale, nullValue, sortColumn, sortDirection, sourceColumn, sourceColumnDataType, tags, title, ...unmapped } = attribute;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        conditionalFormatting: convertConditionalFormatting(conditionalFormatting),
+        defaultView: defaultView && convertLabelIdentifier(defaultView),
+        description,
+        id,
+        isHidden,
+        isNullable,
+        labels: mapArray(labels, convertLabel),
+        locale,
+        nullValue,
+        sortColumn,
+        sortDirection,
+        sourceColumn,
+        sourceColumnDataType,
+        tags: copyArray(tags),
+        title,
+    });
+}
+function convertLabel(label) {
+    const { conditionalFormatting, description, geoAreaConfig, id, isHidden, isNullable, locale, nullValue, sourceColumn, sourceColumnDataType, tags, title, translations, valueType, ...unmapped } = label;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        conditionalFormatting: convertConditionalFormatting(conditionalFormatting),
+        description,
+        geoAreaConfig: geoAreaConfig && convertGeoAreaConfig(geoAreaConfig),
+        id,
+        isHidden,
+        isNullable,
+        locale,
+        nullValue,
+        sourceColumn,
+        sourceColumnDataType,
+        tags: copyArray(tags),
+        title,
+        translations: mapArray(translations, ({ locale, sourceColumn, ...rest }) => {
+            assertAllFieldsMapped(rest);
+            return { locale, sourceColumn };
+        }),
+        valueType,
+    });
+}
+function convertConditionalFormatting(conditionalFormatting) {
+    if (!conditionalFormatting) {
+        return conditionalFormatting;
+    }
+    const { conditions, enabled, ...unmapped } = conditionalFormatting;
+    assertAllFieldsMapped(unmapped);
+    return { conditions: conditions.map(convertConditionalFormattingCondition), enabled };
+}
+function convertConditionalFormattingCondition(condition) {
+    const { format, id, operator, value, ...unmapped } = condition;
+    assertAllFieldsMapped(unmapped);
+    const { backgroundColor, color, scope, ...unmappedFormat } = format;
+    assertAllFieldsMapped(unmappedFormat);
+    return withoutUndefined({
+        format: withoutUndefined({ backgroundColor, color, scope }),
+        id,
+        operator,
+        value: convertConditionalFormattingValue(value),
+    });
+}
+function convertConditionalFormattingValue(value) {
+    switch (value.kind) {
+        case "none": {
+            const { kind, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { kind };
+        }
+        case "literal": {
+            const { kind, value: literal, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { kind, value: literal };
+        }
+        case "literalRange": {
+            const { kind, from, to, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { kind, from, to };
+        }
+        case "absoluteDate": {
+            const { from, to, kind, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { from, to, kind };
+        }
+        case "relativeDate": {
+            const { kind, granularity, from, to, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { kind, granularity, from, to };
+        }
+    }
+}
+function convertDataSourceTableId(tableId) {
+    const { dataSourceId, id, path, type, ...unmapped } = tableId;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({ dataSourceId, id, path: copyArray(path), type });
+}
+function convertFact(fact) {
+    const { description, id, isHidden, isNullable, nullValue, sourceColumn, sourceColumnDataType, tags, title, ...unmapped } = fact;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        description,
+        id,
+        isHidden,
+        isNullable,
+        nullValue,
+        sourceColumn,
+        sourceColumnDataType,
+        tags: copyArray(tags),
+        title,
+    });
+}
+function convertGrainIdentifier(grain) {
+    const { id, type, ...unmapped } = grain;
+    assertAllFieldsMapped(unmapped);
+    return { id, type };
+}
+function convertReference(reference) {
+    const { identifier, multivalue, sourceColumnDataTypes, sourceColumns, sources, ...unmapped } = reference;
+    assertAllFieldsMapped(unmapped);
+    const { id, type, ...unmappedIdentifier } = identifier;
+    assertAllFieldsMapped(unmappedIdentifier);
+    return withoutUndefined({
+        identifier: { id, type },
+        multivalue,
+        sourceColumnDataTypes: copyArray(sourceColumnDataTypes),
+        sourceColumns: copyArray(sourceColumns),
+        sources: mapArray(sources, convertReferenceSource),
+    });
+}
+function convertReferenceSource(source) {
+    const { column, dataType, isNullable, nullValue, target, ...unmapped } = source;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        column,
+        dataType,
+        isNullable,
+        nullValue,
+        target: convertGrainIdentifier(target),
+    });
+}
+function convertDatasetSql(sql) {
+    const { dataSourceId, statement, ...unmapped } = sql;
+    assertAllFieldsMapped(unmapped);
+    return { dataSourceId, statement };
+}
+function convertWorkspaceDataFilterColumn(column) {
+    const { dataType, name, ...unmapped } = column;
+    assertAllFieldsMapped(unmapped);
+    return { dataType, name };
+}
+function convertDateDataset(dateDataset) {
+    const { conditionalFormatting, description, granularities, granularitiesFormatting, id, tags, title, ...unmapped } = dateDataset;
+    assertAllFieldsMapped(unmapped);
+    const { titleBase, titlePattern, ...unmappedFormatting } = granularitiesFormatting;
+    assertAllFieldsMapped(unmappedFormatting);
+    return withoutUndefined({
+        conditionalFormatting: convertConditionalFormatting(conditionalFormatting),
+        description,
+        granularities: [...granularities],
+        granularitiesFormatting: { titleBase, titlePattern },
+        id,
+        tags: copyArray(tags),
+        title,
+    });
+}
+function convertLabelIdentifier(identifier) {
+    const { id, type, ...unmapped } = identifier;
+    assertAllFieldsMapped(unmapped);
+    return { id, type };
+}
+function convertGeoAreaConfig(config) {
+    const { collection, ...unmapped } = config;
+    assertAllFieldsMapped(unmapped);
+    return { collection: convertGeoCollectionIdentifier(collection) };
+}
+function convertGeoCollectionIdentifier(identifier) {
+    const { id, kind, ...unmapped } = identifier;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({ id, kind });
+}

package/esm/convertors/toBackend/PhysicalModelConverter.d.ts

@@ -0,0 +1,5 @@
+import { type GenerateLdmRequest, type ScanRequest } from "@gooddata/api-client-tiger";
+import { type IDataSourceScanRequest, type IGenerateLogicalModelRequest } from "@gooddata/sdk-model";
+export declare function convertScanRequest(request: IDataSourceScanRequest): ScanRequest;
+export declare function convertGenerateLogicalModelRequest(request: IGenerateLogicalModelRequest): GenerateLdmRequest;
+//# sourceMappingURL=PhysicalModelConverter.d.ts.map

package/esm/convertors/toBackend/PhysicalModelConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicalModelConverter.d.ts","sourceRoot":"","sources":["../../../src/convertors/toBackend/PhysicalModelConverter.ts"],"names":[],"mappings":"AAEA,OAAO,EAIH,KAAK,kBAAkB,EAGvB,KAAK,WAAW,EAEnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACH,KAAK,sBAAsB,EAG3B,KAAK,4BAA4B,EAKpC,MAAM,qBAAqB,CAAC;AAI7B,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,sBAAsB,GAAG,WAAW,CAW/E;AAED,wBAAgB,kCAAkC,CAC9C,OAAO,EAAE,4BAA4B,GACtC,kBAAkB,CA+CpB"}

package/esm/convertors/toBackend/PhysicalModelConverter.js

@@ -0,0 +1,97 @@
+// (C) 2026 GoodData Corporation
+import { assertAllFieldsMapped, copyArray, mapArray, withoutUndefined } from "../shared/declarativeFields.js";
+export function convertScanRequest(request) {
+    const { scanTables, scanViews, schemata, separator, tablePrefix, viewPrefix, ...unmapped } = request;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        scanTables,
+        scanViews,
+        schemata: copyArray(schemata),
+        separator,
+        tablePrefix,
+        viewPrefix,
+    });
+}
+export function convertGenerateLogicalModelRequest(request) {
+    const { aggregatedFactPrefix, dateGranularities, dateReferencePrefix, denormPrefix, factPrefix, generateLongIds, grainMultivalueReferencePrefix, grainPrefix, grainReferencePrefix, multivalueReferencePrefix, pdm, primaryLabelPrefix, referencePrefix, secondaryLabelPrefix, separator, tablePrefix, translationPrefix, viewPrefix, wdfPrefix, workspaceId, ...unmapped } = request;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        aggregatedFactPrefix,
+        dateGranularities,
+        dateReferencePrefix,
+        denormPrefix,
+        factPrefix,
+        generateLongIds,
+        grainMultivalueReferencePrefix,
+        grainPrefix,
+        grainReferencePrefix,
+        multivalueReferencePrefix,
+        pdm: pdm && convertPdm(pdm),
+        primaryLabelPrefix,
+        referencePrefix,
+        secondaryLabelPrefix,
+        separator,
+        tablePrefix,
+        translationPrefix,
+        viewPrefix,
+        wdfPrefix,
+        workspaceId,
+    });
+}
+function convertPdm(pdm) {
+    const { sqls, tableOverrides, tables, ...unmapped } = pdm;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        sqls: mapArray(sqls, convertSql),
+        tableOverrides: mapArray(tableOverrides, convertTableOverride),
+        tables: mapArray(tables, convertTable),
+    });
+}
+function convertSql(sql) {
+    const { columns, statement, title, ...unmapped } = sql;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        columns: mapArray(columns, ({ dataType, name, nullValue, ...rest }) => {
+            assertAllFieldsMapped(rest);
+            return withoutUndefined({ dataType, name, nullValue });
+        }),
+        statement,
+        title,
+    });
+}
+function convertTableOverride(override) {
+    const { columns, path, ...unmapped } = override;
+    assertAllFieldsMapped(unmapped);
+    return { columns: columns.map(convertColumnOverride), path: [...path] };
+}
+function convertColumnOverride(override) {
+    const { labelTargetColumn, labelType, ldmTypeOverride, name, ...unmapped } = override;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({ labelTargetColumn, labelType, ldmTypeOverride, name });
+}
+function convertTable(table) {
+    const { columns, id, namePrefix, path, type, ...unmapped } = table;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        columns: columns.map(convertColumn),
+        id,
+        namePrefix,
+        path: [...path],
+        type,
+    });
+}
+function convertColumn(column) {
+    const { dataType, defaultLabelOf, description, isNullable, isPrimaryKey, name, nullValue, referencedTableColumn, referencedTableId, ...unmapped } = column;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        dataType,
+        defaultLabelOf,
+        description,
+        isNullable,
+        isPrimaryKey,
+        name,
+        nullValue,
+        referencedTableColumn,
+        referencedTableId,
+    });
+}

package/esm/utils/apiProblemDetail.d.ts

@@ -0,0 +1,3 @@
+export declare const getApiProblemDetail: (error: unknown) => string | undefined;
+export declare const getDataSourceErrorMessage: (error: unknown) => string;
+//# sourceMappingURL=apiProblemDetail.d.ts.map

package/esm/utils/apiProblemDetail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiProblemDetail.d.ts","sourceRoot":"","sources":["../../src/utils/apiProblemDetail.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,mBAAmB,UAAW,OAAO,KAAG,MAAM,GAAG,SAK7D,CAAC;AAEF,eAAO,MAAM,yBAAyB,UAAW,OAAO,KAAG,MAS1D,CAAC"}

package/esm/utils/apiProblemDetail.js

@@ -0,0 +1,19 @@
+// (C) 2026 GoodData Corporation
+// An API rejection carries the actionable reason in the problem `detail` field, while the
+// surrounding AxiosError message only names the status code. The authenticated call converts
+// the AxiosError to a backend error and keeps the original as its cause.
+export const getApiProblemDetail = (error) => {
+    const problemError = error;
+    const detail = problemError?.response?.data?.detail ?? problemError?.cause?.response?.data?.detail;
+    return typeof detail === "string" && detail.trim() !== "" ? detail : undefined;
+};
+export const getDataSourceErrorMessage = (error) => {
+    const detail = getApiProblemDetail(error);
+    if (detail !== undefined) {
+        return detail;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-backend-tiger",
-  "version": "11.64.0-alpha.1",
+  "version": "11.64.0-alpha.3",
   "description": "GoodData Backend SPI implementation for GoodData Cloud and GoodData.CN",
   "license": "MIT",
   "author": "GoodData",
@@ -34,12 +34,12 @@
     "ts-invariant": "0.10.3",
     "tslib": "2.8.1",
     "uuid": "11.1.1",
-    "@gooddata/api-client-tiger": "11.64.0-alpha.1",
-    "@gooddata/sdk-code-convertors": "11.64.0-alpha.1",
-    "@gooddata/sdk-backend-spi": "11.64.0-alpha.1",
-    "@gooddata/sdk-model": "11.64.0-alpha.1",
-    "@gooddata/sdk-backend-base": "11.64.0-alpha.1",
-    "@gooddata/util": "11.64.0-alpha.1"
+    "@gooddata/api-client-tiger": "11.64.0-alpha.3",
+    "@gooddata/sdk-backend-spi": "11.64.0-alpha.3",
+    "@gooddata/sdk-code-convertors": "11.64.0-alpha.3",
+    "@gooddata/sdk-backend-base": "11.64.0-alpha.3",
+    "@gooddata/sdk-model": "11.64.0-alpha.3",
+    "@gooddata/util": "11.64.0-alpha.3"
   },
   "devDependencies": {
     "@gooddata/fixtures": "3.7.0",
@@ -64,10 +64,10 @@
     "oxlint-tsgolint": "7.0.2001",
     "typescript": "7.0.2",
     "vitest": "5.0.4",
-    "@gooddata/eslint-config": "11.64.0-alpha.1",
-    "@gooddata/oxlint-config": "11.64.0-alpha.1",
-    "@gooddata/reference-workspace": "11.64.0-alpha.1",
-    "@gooddata/catalog-export": "11.64.0-alpha.1"
+    "@gooddata/catalog-export": "11.64.0-alpha.3",
+    "@gooddata/oxlint-config": "11.64.0-alpha.3",
+    "@gooddata/reference-workspace": "11.64.0-alpha.3",
+    "@gooddata/eslint-config": "11.64.0-alpha.3"
   },
   "scripts": {
     "_phase:build": "npm run build",