dataiku-sdk 0.5.1 → 0.6.1

package/dist/src/resources/scenarios.js

@@ -1,7 +1,152 @@
+import { DataikuError, } from "../errors.js";
 import { ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, } from "../schemas.js";
 import { deepMerge, } from "../utils/deep-merge.js";
 import { BaseResource, } from "./base.js";
 import { computeNextPollDelayMs, } from "./jobs.js";
+export const SCENARIO_CANONICAL_EDITABLE_FIELDS = [
+    "params.steps",
+    "params.triggers",
+    "params.reporters",
+    "params.customScript",
+    "active",
+    "name",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function jsonValueEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        return left.every((value, index) => jsonValueEqual(value, right[index]));
+    }
+    if (!isRecord(left) || !isRecord(right))
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    return leftKeys.every((key) => Object.hasOwn(right, key) && jsonValueEqual(left[key], right[key]));
+}
+function jsonValueContains(actual, expected) {
+    if (jsonValueEqual(actual, expected))
+        return true;
+    if (Array.isArray(actual) || Array.isArray(expected)) {
+        if (!Array.isArray(actual) || !Array.isArray(expected) || actual.length !== expected.length) {
+            return false;
+        }
+        return expected.every((value, index) => jsonValueContains(actual[index], value));
+    }
+    if (!isRecord(actual) || !isRecord(expected))
+        return false;
+    return Object.entries(expected).every(([key, value,]) => Object.hasOwn(actual, key) && jsonValueContains(actual[key], value));
+}
+function collectPatchPaths(value, prefix = "", paths = []) {
+    if (!isRecord(value)) {
+        if (prefix)
+            paths.push(prefix);
+        return paths;
+    }
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+        if (prefix)
+            paths.push(prefix);
+        return paths;
+    }
+    for (const [key, child,] of entries) {
+        collectPatchPaths(child, prefix ? `${prefix}.${key}` : key, paths);
+    }
+    return paths;
+}
+function valueAtPath(value, path) {
+    let current = value;
+    for (const part of path.split(".")) {
+        if (!isRecord(current))
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function scenarioFieldChanges(before, after, patch) {
+    const changes = [];
+    const unchangedPaths = [];
+    for (const path of collectPatchPaths(patch)) {
+        const beforeValue = valueAtPath(before, path);
+        const afterValue = valueAtPath(after, path);
+        if (jsonValueEqual(beforeValue, afterValue)) {
+            unchangedPaths.push(path);
+            continue;
+        }
+        changes.push({ path, before: beforeValue, after: afterValue, });
+    }
+    return { changes, unchangedPaths, };
+}
+function scenarioFieldMismatches(actual, expected, patch) {
+    const mismatches = [];
+    for (const path of collectPatchPaths(patch)) {
+        const actualValue = valueAtPath(actual, path);
+        const expectedValue = valueAtPath(expected, path);
+        if (!jsonValueContains(actualValue, expectedValue)) {
+            mismatches.push({ path, expected: expectedValue, actual: actualValue, });
+        }
+    }
+    return mismatches;
+}
+export function normalizeScenarioUpdateData(data) {
+    const normalizedData = { ...data, };
+    const normalization = [];
+    const rawParams = data.rawParams;
+    if (!isRecord(rawParams) || !isRecord(rawParams.params)) {
+        return { normalizedData, normalization, };
+    }
+    const canonicalParams = isRecord(data.params) ? data.params : undefined;
+    const mergedParams = canonicalParams === undefined
+        ? rawParams.params
+        : deepMerge(rawParams.params, canonicalParams);
+    const promoted = canonicalParams === undefined || !jsonValueEqual(mergedParams, canonicalParams);
+    if (promoted)
+        normalizedData.params = mergedParams;
+    const rawParamsWithoutParams = { ...rawParams, };
+    delete rawParamsWithoutParams.params;
+    if (Object.keys(rawParamsWithoutParams).length === 0)
+        delete normalizedData.rawParams;
+    else
+        normalizedData.rawParams = rawParamsWithoutParams;
+    normalization.push({
+        from: "rawParams.params",
+        to: "params",
+        action: promoted ? "promoted" : "ignored",
+        message: promoted
+            ? "rawParams.params is a DSS echo; the editable scenario definition uses params."
+            : "rawParams.params was ignored because canonical params already supplied the same editable fields.",
+    });
+    return { normalizedData, normalization, };
+}
+export function scenarioUpdatePreview(current, data) {
+    const { normalizedData, normalization, } = normalizeScenarioUpdateData(data);
+    const next = deepMerge(current, normalizedData);
+    const { changes, unchangedPaths, } = scenarioFieldChanges(current, next, normalizedData);
+    return {
+        canonicalEditableFields: SCENARIO_CANONICAL_EDITABLE_FIELDS,
+        normalization,
+        normalizedData,
+        current,
+        next,
+        changes,
+        unchangedPaths,
+    };
+}
+function scenarioUpdateVerificationError(mismatches, normalization) {
+    const mismatchPaths = mismatches.map((mismatch) => mismatch.path).join(", ");
+    return new DataikuError(400, "Scenario Update Verification Failed", JSON.stringify({
+        message: `Scenario update did not persist requested fields after refetch: ${mismatchPaths}`,
+        mismatches,
+        canonicalEditableFields: SCENARIO_CANONICAL_EDITABLE_FIELDS,
+        ...(normalization.length > 0 ? { normalization, } : {}),
+    }));
+}
 export class ScenariosResource extends BaseResource {
     /** List all scenarios in a project. */
     async list(projectKey) {
@@ -42,13 +187,27 @@ export class ScenariosResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/scenarios/${scEnc}/light/`);
         return this.client.safeParse(ScenarioStatusSchema, raw, "scenarios.status");
     }
-    /** Merge-update a scenario's definition. */
+    /** Merge-update a scenario's definition, then refetch and verify requested fields persisted. */
     async update(scenarioId, data, projectKey) {
         const scEnc = encodeURIComponent(scenarioId);
         const pkEnc = this.enc(projectKey);
         const current = await this.client.get(`/public/api/projects/${pkEnc}/scenarios/${scEnc}/`);
-        const merged = deepMerge(current, data);
-        await this.client.put(`/public/api/projects/${pkEnc}/scenarios/${scEnc}/`, merged);
+        const preview = scenarioUpdatePreview(current, data);
+        await this.client.put(`/public/api/projects/${pkEnc}/scenarios/${scEnc}/`, preview.next);
+        const after = await this.client.get(`/public/api/projects/${pkEnc}/scenarios/${scEnc}/`);
+        const mismatches = scenarioFieldMismatches(after, preview.next, preview.normalizedData);
+        if (mismatches.length > 0) {
+            throw scenarioUpdateVerificationError(mismatches, preview.normalization);
+        }
+        const verified = scenarioFieldChanges(current, after, preview.normalizedData);
+        return {
+            ...preview,
+            after,
+            changes: verified.changes,
+            unchangedPaths: verified.unchangedPaths,
+            verified: true,
+            mismatches: [],
+        };
     }
     /** Delete a scenario. */
     async delete(scenarioId, projectKey) {

package/dist/src/resources/sql.js

@@ -24,6 +24,82 @@ function asString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
+function firstStringField(record, fields) {
+    for (const field of fields) {
+        const value = record[field];
+        if (typeof value === "string" && value.trim().length > 0)
+            return value.trim();
+    }
+    return undefined;
+}
+function isLikelySqlErrorDetail(detail) {
+    const lower = detail.toLowerCase();
+    return /\b[A-Z_]+(?:_ERROR|_NOT_FOUND|_MISMATCH|_DENIED|_EXCEEDED)\b/.test(detail)
+        || lower.includes("athena")
+        || lower.includes("sql")
+        || lower.includes("query")
+        || lower.includes("column")
+        || lower.includes("table")
+        || lower.includes("line ");
+}
+function sqlErrorDetailFromBody(body) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const record = parsed;
+            const nested = asRecord(record.details) ?? asRecord(record.error);
+            const nestedDetail = nested
+                ? firstStringField(nested, ["message", "errorMessage", "error", "reason", "cause",])
+                : undefined;
+            if (nestedDetail && isLikelySqlErrorDetail(nestedDetail))
+                return nestedDetail;
+            const direct = firstStringField(record, [
+                "message",
+                "detailedMessage",
+                "errorMessage",
+                "error",
+                "reason",
+                "cause",
+            ]);
+            if (direct && isLikelySqlErrorDetail(direct))
+                return direct;
+        }
+    }
+    catch {
+        // Fall back to regex extraction from raw DSS/Athena text below.
+    }
+    const match = trimmed.match(/\b[A-Z_]+(?:_ERROR|_NOT_FOUND|_MISMATCH|_DENIED|_EXCEEDED)\b[:\s-]+[^\n\r]+/);
+    return match?.[0] ?? (isLikelySqlErrorDetail(trimmed) ? trimmed.slice(0, 500) : undefined);
+}
+function withSqlErrorContext(error) {
+    if (error instanceof DataikuError) {
+        const detail = sqlErrorDetailFromBody(error.body);
+        if (detail) {
+            let body = error.body;
+            try {
+                const parsed = JSON.parse(error.body);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    body = JSON.stringify({
+                        ...parsed,
+                        message: `SQL query failed: ${detail}`,
+                        sqlError: detail,
+                    });
+                }
+                else {
+                    body = `SQL query failed: ${detail}\n${error.body}`;
+                }
+            }
+            catch {
+                body = `SQL query failed: ${detail}\n${error.body}`;
+            }
+            throw new DataikuError(error.status, error.statusText, body, error.retry);
+        }
+    }
+    throw error;
+}
 function splitDatasetIdentifier(datasetFullName, fallbackProjectKey) {
     const trimmed = datasetFullName.trim();
     const dotIndex = trimmed.indexOf(".");
@@ -79,7 +155,7 @@ export class SqlResource extends BaseResource {
         const { queryId, schema, } = await this.startQuery(opts);
         const rows = await this.streamResults(queryId);
         await this.finishStreaming(queryId);
-        return { queryId, schema, rows, };
+        return { queryId, schema, columns: schema, rows, };
     }
     async resolveDatasetQueryFallback(opts) {
         const datasetFullName = opts.datasetFullName;
@@ -119,14 +195,19 @@ export class SqlResource extends BaseResource {
         }
         catch (error) {
             if (!isUnsupportedSqlDatasetConnectionError(error))
-                throw error;
+                withSqlErrorContext(error);
             const retryOpts = await this.resolveDatasetQueryFallback(queryOpts);
             if (!retryOpts) {
                 throw new Error(buildUnsupportedSqlDatasetConnectionMessage(queryOpts.datasetFullName), {
                     cause: error,
                 });
             }
-            return this.executeQuery(retryOpts);
+            try {
+                return await this.executeQuery(retryOpts);
+            }
+            catch (retryError) {
+                withSqlErrorContext(retryError);
+            }
         }
     }
 }

package/dist/src/skill.d.ts

@@ -24,8 +24,8 @@ export interface DetectedAgent {
 }
 export declare function detectAgents(): DetectedAgent[];
 /**
- * Walk upward from startDir looking for common workspace markers.
- * Returns the first directory containing a marker, or startDir if none found.
+ * Walk upward from startDir looking for strong project markers.
+ * Agent config directories are install targets, not workspace roots.
  */
 export declare function findWorkspaceRoot(startDir: string): string;
 export interface InstallResult {

package/dist/src/skill.js

@@ -208,10 +208,10 @@ export function detectAgents() {
 // ---------------------------------------------------------------------------
 // Workspace root detection
 // ---------------------------------------------------------------------------
-const WORKSPACE_MARKERS = [".git", ".cursor", ".claude", ".codex", ".pi", ".omp", ".vscode",];
+const WORKSPACE_MARKERS = [".git",];
 /**
- * Walk upward from startDir looking for common workspace markers.
- * Returns the first directory containing a marker, or startDir if none found.
+ * Walk upward from startDir looking for strong project markers.
+ * Agent config directories are install targets, not workspace roots.
  */
 export function findWorkspaceRoot(startDir) {
     let dir = startDir;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dataiku-sdk",
-	"version": "0.5.1",
+	"version": "0.6.1",
 	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
 	"type": "module",
 	"workspaces": [

package/packages/types/dist/index.d.ts

@@ -611,6 +611,10 @@ export declare const SqlQueryResponseSchema: import("@sinclair/typebox").TObject
         name: import("@sinclair/typebox").TString;
         type: import("@sinclair/typebox").TString;
     }>>;
+    columns: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        type: import("@sinclair/typebox").TString;
+    }>>>;
     rows: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnknown>>;
 }>;
 export type SqlQueryResponse = Static<typeof SqlQueryResponseSchema>;

package/packages/types/dist/index.js

@@ -601,6 +601,7 @@ export const SqlQueryResultSchema = Type.Object({
 export const SqlQueryResponseSchema = Type.Object({
     queryId: Type.String(),
     schema: Type.Array(SqlQuerySchemaSchema),
+    columns: Type.Optional(Type.Array(SqlQuerySchemaSchema)),
     rows: Type.Array(Type.Array(Type.Unknown())),
 });
 // ---------------------------------------------------------------------------