dataiku-sdk 0.6.0 → 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/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.6.0",
+	"version": "0.6.1",
 	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
 	"type": "module",
 	"workspaces": [