dataiku-sdk 0.12.7 → 1.0.0

package/dist/src/resources/connections.js

@@ -9,27 +9,89 @@ function normalizeConnectionNames(value) {
         .filter((v) => typeof v === "string" && v.length > 0)
         .sort();
 }
-async function inferRichConnectionsFromDatasets(client, projectEnc) {
-    const datasets = await client.get(`/public/api/projects/${projectEnc}/datasets/`);
+export async function resolveAdminManagedStorageConnection(client, capability, preferredName) {
+    try {
+        const raw = await client.get("/public/api/admin/connections/");
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const candidates = [];
+        for (const [name, value,] of Object.entries(raw)) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            const details = value;
+            if (details["allowWrite"] === true && details[capability] === true) {
+                candidates.push(name);
+            }
+        }
+        candidates.sort();
+        return preferredName && candidates.includes(preferredName) ? preferredName : candidates[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+async function inferRichConnections(client, projectEnc) {
+    const datasetsRaw = await client.get(`/public/api/projects/${projectEnc}/datasets/`);
+    const datasets = Array.isArray(datasetsRaw) ? datasetsRaw : [];
     const map = new Map();
-    for (const ds of datasets) {
-        const d = ds;
-        const params = d["params"];
-        const connection = params?.["connection"];
+    const recordConnection = (connection, type, managed, schema) => {
         if (typeof connection !== "string" || connection.length === 0)
-            continue;
-        if (!map.has(connection)) {
-            map.set(connection, { types: new Set(), managed: false, dbSchemas: new Set(), });
+            return;
+        let entry = map.get(connection);
+        if (!entry) {
+            entry = { types: new Set(), managed: false, dbSchemas: new Set(), };
+            map.set(connection, entry);
         }
-        const entry = map.get(connection);
-        const dsType = d["type"];
-        if (typeof dsType === "string" && dsType.length > 0)
-            entry.types.add(dsType);
-        if (d["managed"] === true)
+        if (typeof type === "string" && type.length > 0)
+            entry.types.add(type);
+        if (managed)
             entry.managed = true;
-        const schema = params?.["schema"];
         if (typeof schema === "string" && schema.length > 0)
             entry.dbSchemas.add(schema);
+    };
+    for (const dataset of datasets) {
+        if (!dataset || typeof dataset !== "object" || Array.isArray(dataset))
+            continue;
+        const details = dataset;
+        const params = details["params"];
+        if (!params || typeof params !== "object" || Array.isArray(params))
+            continue;
+        const datasetParams = params;
+        recordConnection(datasetParams["connection"], details["type"], details["managed"] === true, datasetParams["schema"]);
+        recordConnection(datasetParams["uploadConnection"], details["type"], false);
+    }
+    try {
+        const foldersRaw = await client.get(`/public/api/projects/${projectEnc}/managedfolders/`);
+        const folders = Array.isArray(foldersRaw) ? foldersRaw : [];
+        const folderDetails = await Promise.all(folders.map(async (folder) => {
+            if (!folder || typeof folder !== "object" || Array.isArray(folder))
+                return folder;
+            const summary = folder;
+            const params = summary["params"];
+            if (params && typeof params === "object" && !Array.isArray(params))
+                return summary;
+            const id = summary["id"];
+            if (typeof id !== "string" || id.length === 0)
+                return summary;
+            try {
+                return await client.get(`/public/api/projects/${projectEnc}/managedfolders/${encodeURIComponent(id)}`);
+            }
+            catch {
+                return summary;
+            }
+        }));
+        for (const folder of folderDetails) {
+            if (!folder || typeof folder !== "object" || Array.isArray(folder))
+                continue;
+            const details = folder;
+            const params = details["params"];
+            if (!params || typeof params !== "object" || Array.isArray(params))
+                continue;
+            recordConnection(params["connection"], details["type"], true);
+        }
+    }
+    catch {
+        // Dataset-derived inference remains useful when managed folders are inaccessible.
     }
     return [...map.entries(),]
         .sort(([a,], [b,]) => a.localeCompare(b))
@@ -48,9 +110,8 @@ export class ConnectionsResource extends BaseResource {
      * Returns sorted list of all connection names visible to the current user.
      */
     async list(opts) {
-        const type = opts?.type?.trim();
-        const query = type ? `?type=${encodeURIComponent(type)}` : "";
-        const raw = await this.client.get(`/public/api/connections/get-names/${query}`);
+        const type = opts?.type?.trim() || "all";
+        const raw = await this.client.get(`/public/api/connections/get-names/?type=${encodeURIComponent(type)}`);
         return normalizeConnectionNames(raw);
     }
     /**
@@ -58,14 +119,14 @@ export class ConnectionsResource extends BaseResource {
      *
      * - fast (default): fetches the connection name list and maps to ConnectionSummary.
      *   Falls back to rich mode on any failure or empty result set.
-     * - rich: inspects project datasets to derive connection metadata
+     * - rich: inspects project datasets and managed folders to derive connection metadata
      *   (types, managed flag, db schemas).
      */
     async infer(opts) {
         const mode = opts?.mode ?? "fast";
         const projectEnc = this.enc(opts?.projectKey);
         if (mode === "rich") {
-            return inferRichConnectionsFromDatasets(this.client, projectEnc);
+            return inferRichConnections(this.client, projectEnc);
         }
         // fast — attempt name list, fall back to rich on any error or empty result
         try {
@@ -77,7 +138,7 @@ export class ConnectionsResource extends BaseResource {
         catch {
             // Fall through to rich inference.
         }
-        return inferRichConnectionsFromDatasets(this.client, projectEnc);
+        return inferRichConnections(this.client, projectEnc);
     }
     async schemas(opts) {
         const pk = this.resolveProjectKey(opts.projectKey);

package/dist/src/resources/datasets.js

@@ -3,11 +3,12 @@ import * as nodePath from "node:path";
 import { Readable, Transform, } from "node:stream";
 import { pipeline, } from "node:stream/promises";
 import { createGzip, } from "node:zlib";
-import { DataikuError, } from "../errors.js";
+import { ClientValidationError, DataikuError, } from "../errors.js";
 import { DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, } from "../schemas.js";
 import { deepMerge, } from "../utils/deep-merge.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
 import { BaseResource, } from "./base.js";
+import { resolveAdminManagedStorageConnection, } from "./connections.js";
 // ---------------------------------------------------------------------------
 // Helpers: TSV → CSV streaming conversion
 // ---------------------------------------------------------------------------
@@ -253,15 +254,25 @@ function shouldRetryWithConnectionInferredType(error) {
         || detail.includes("invalid type")
         || detail.includes("illegal argument"));
 }
+function isMissingUploadedFilesTargetConnection(error) {
+    if (!(error instanceof DataikuError))
+        return false;
+    const detail = error.body.toLowerCase();
+    return (detail.includes("without a target connection")
+        || detail.includes("target connection is required"));
+}
 function buildDatasetCreateBody(opts) {
     if (opts.dsType.toLowerCase() === "uploadedfiles") {
         return {
             projectKey: opts.projectKey,
             name: opts.datasetName,
             type: opts.dsType,
-            params: { uploadConnection: opts.connection, },
+            params: opts.connection ? { uploadConnection: opts.connection, } : {},
         };
     }
+    if (!opts.connection) {
+        throw new ClientValidationError("connection is required unless dsType is UploadedFiles.");
+    }
     if (opts.table) {
         const params = {
             connection: opts.connection,
@@ -481,6 +492,35 @@ export class DatasetsResource extends BaseResource {
             return await this.client.post(`/public/api/projects/${enc}/datasets/`, body);
         }
         catch (error) {
+            if (explicitType?.toLowerCase() === "uploadedfiles"
+                && !opts.connection
+                && isMissingUploadedFilesTargetConnection(error)) {
+                let uploadConnection = await resolveAdminManagedStorageConnection(this.client, "allowManagedDatasets", "filesystem_managed");
+                if (!uploadConnection) {
+                    const existing = await this.list(pk);
+                    uploadConnection = [
+                        ...new Set(existing
+                            .filter((dataset) => dataset.managed === true)
+                            .map((dataset) => dataset.params?.connection)
+                            .filter((connection) => typeof connection === "string" && connection.length > 0)),
+                    ].sort()[0];
+                }
+                if (!uploadConnection)
+                    throw error;
+                body = buildDatasetCreateBody({
+                    projectKey: pk,
+                    datasetName: opts.datasetName,
+                    connection: uploadConnection,
+                    dsType,
+                    table: opts.table,
+                    dbSchema: opts.dbSchema,
+                    catalog: opts.catalog,
+                    formatType: opts.formatType,
+                    formatParams: opts.formatParams,
+                    managed: opts.managed,
+                });
+                return this.client.post(`/public/api/projects/${enc}/datasets/`, body);
+            }
             if (explicitType || !shouldRetryWithConnectionInferredType(error)) {
                 throw error;
             }

package/dist/src/resources/folders.js

@@ -6,6 +6,7 @@ import { FolderDetailsSchema, FolderItemArraySchema, FolderSummaryArraySchema, }
 import { deepMerge, } from "../utils/deep-merge.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
 import { BaseResource, } from "./base.js";
+import { resolveAdminManagedStorageConnection, } from "./connections.js";
 function normalizeRemotePath(path) {
     return path.replace(/\\/g, "/");
 }
@@ -20,14 +21,17 @@ function inferDownloadFileName(remotePath) {
 export class FoldersResource extends BaseResource {
     async create(opts) {
         const pk = this.resolveProjectKey(opts.projectKey);
-        const path = opts.path?.trim() || `/dataiku/${pk}/${opts.name}`;
+        const path = opts.path?.trim() || "/${projectKey}/${odbId}";
+        const connection = opts.connection
+            ?? await resolveAdminManagedStorageConnection(this.client, "allowManagedFolders", "filesystem_folders")
+            ?? "filesystem_folders";
         const raw = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/managedfolders/`, {
             name: opts.name,
             projectKey: pk,
-            type: opts.type,
+            type: opts.type ?? null,
             params: {
                 ...opts.params,
-                connection: opts.connection,
+                connection: connection,
                 path,
             },
         });

package/dist/src/resources/project-git.d.ts

@@ -0,0 +1,154 @@
+import type { ProjectGitActionResult, ProjectGitDiffResult, ProjectGitFutureResponse, ProjectGitFutureState, ProjectGitLibraries, ProjectGitLogResult, ProjectGitRemote, ProjectGitStatus, ProjectGitTags } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export interface ProjectGitSetRemoteOptions {
+    url: string;
+    name?: string;
+}
+export interface ProjectGitCreateBranchOptions {
+    commit?: string;
+    duplicateProject?: boolean;
+    targetProjectKey?: string;
+    targetProjectFolderId?: string;
+}
+export interface ProjectGitDeleteBranchOptions {
+    remote?: boolean;
+    deleteRemotely?: boolean;
+    forceDelete?: boolean;
+}
+export interface ProjectGitCreateTagOptions {
+    reference?: string;
+    message?: string;
+}
+export interface ProjectGitPullOptions {
+    branchName?: string;
+}
+export interface ProjectGitPushOptions {
+    branchName?: string;
+}
+export interface ProjectGitLogOptions {
+    path?: string;
+    startCommit?: string;
+    count?: number;
+}
+export interface ProjectGitDiffOptions {
+    commitFrom?: string;
+    commitTo?: string;
+}
+export interface ProjectGitCommitOptions {
+    message: string;
+}
+/**
+ * `dropAndRebuild` permanently destroys the project's Git history, so the
+ * caller must acknowledge it explicitly before the request is issued.
+ */
+export interface ProjectGitDropAndRebuildOptions {
+    confirmed?: boolean;
+}
+export interface ProjectGitAddLibraryOptions {
+    repository: string;
+    localTargetPath: string;
+    checkout: string;
+    pathInGitRepository?: string;
+    addToPythonPath?: boolean;
+    login?: string;
+    password?: string;
+}
+export interface ProjectGitSetLibraryOptions {
+    repository: string;
+    pathInGitRepository?: string;
+    checkout: string;
+    login?: string;
+    password?: string;
+}
+export interface ProjectGitFutureStateOptions {
+    peek?: boolean;
+}
+export interface ProjectGitFutureWaitOptions {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+}
+export declare class ProjectGitResource extends BaseResource {
+    /** Working-copy status: current branch, remotes, tracking counts, changes. */
+    status(projectKey: string): Promise<ProjectGitStatus>;
+    /**
+     * Read a Git remote. DSS answers `{}` when the remote is not configured.
+     * The remote name defaults to `origin` like the Python client.
+     */
+    getRemote(projectKey: string, name?: string): Promise<ProjectGitRemote>;
+    /** Create or replace a Git remote. */
+    setRemote(projectKey: string, options: ProjectGitSetRemoteOptions): Promise<ProjectGitActionResult>;
+    /** Delete a Git remote. */
+    removeRemote(projectKey: string, name?: string): Promise<void>;
+    /** Plain list of branch names, local by default. */
+    listBranches(projectKey: string, remote?: boolean): Promise<string[]>;
+    /**
+     * Create a branch and switch to it. With `duplicateProject`, DSS creates a
+     * duplicate project for the branch instead of moving this one.
+     */
+    createBranch(projectKey: string, name: string, options?: ProjectGitCreateBranchOptions): Promise<ProjectGitActionResult>;
+    /** Delete a branch locally and, with `deleteRemotely`, on the remote too. */
+    deleteBranch(projectKey: string, name: string, options?: ProjectGitDeleteBranchOptions): Promise<ProjectGitActionResult>;
+    /** Current branch name, or null when DSS reports none. */
+    currentBranch(projectKey: string): Promise<string | null>;
+    /** Switch the project to another branch. */
+    switchBranch(projectKey: string, branchName: string): Promise<ProjectGitActionResult>;
+    listTags(projectKey: string): Promise<ProjectGitTags>;
+    createTag(projectKey: string, name: string, options?: ProjectGitCreateTagOptions): Promise<ProjectGitActionResult>;
+    deleteTag(projectKey: string, name: string): Promise<ProjectGitActionResult>;
+    /** Fetch from the remote. Failures arrive as `{success: false}` with HTTP 200. */
+    fetch(projectKey: string): Promise<ProjectGitActionResult>;
+    /** Pull. DSS only ever exposes a rebase pull; there is no merge variant. */
+    pull(projectKey: string, options?: ProjectGitPullOptions): Promise<ProjectGitActionResult>;
+    push(projectKey: string, options?: ProjectGitPushOptions): Promise<ProjectGitActionResult>;
+    /** Commit log page. Paginate by passing the previous `nextCommit` as `startCommit`. */
+    log(projectKey: string, options?: ProjectGitLogOptions): Promise<ProjectGitLogResult>;
+    diff(projectKey: string, options?: ProjectGitDiffOptions): Promise<ProjectGitDiffResult>;
+    /** Commit the project. DSS stages untracked files before committing. */
+    commit(projectKey: string, options: ProjectGitCommitOptions): Promise<ProjectGitActionResult>;
+    /** Restore the project to the state of a past commit. */
+    revertToRevision(projectKey: string, commit: string): Promise<ProjectGitActionResult>;
+    /** Revert one commit, keeping later history. */
+    revertCommit(projectKey: string, commit: string): Promise<ProjectGitActionResult>;
+    /** Hard reset to local HEAD, dropping uncommitted changes. */
+    resetToHead(projectKey: string): Promise<ProjectGitActionResult>;
+    /** Hard reset to the tracked upstream branch, dropping local commits. */
+    resetToUpstream(projectKey: string): Promise<ProjectGitActionResult>;
+    /**
+     * Wipe the project's entire Git history and rebuild a fresh repository.
+     * Irreversible, so nothing is sent unless the caller acknowledges it.
+     */
+    dropAndRebuild(projectKey: string, options?: ProjectGitDropAndRebuildOptions): Promise<ProjectGitActionResult>;
+    listLibraries(projectKey: string): Promise<ProjectGitLibraries>;
+    /** Attach an external Git library. Runs as a DSS future. */
+    addLibrary(projectKey: string, options: ProjectGitAddLibraryOptions): Promise<ProjectGitFutureResponse>;
+    /** Update an attached library's repository, sub-path, or checkout. */
+    setLibrary(projectKey: string, gitReferencePath: string, options: ProjectGitSetLibraryOptions): Promise<string>;
+    /** Detach a library, optionally deleting its local directory. */
+    removeLibrary(projectKey: string, gitReferencePath: string, deleteDirectory?: boolean): Promise<void>;
+    /** Reset one library to its remote state. Runs as a DSS future. */
+    resetLibrary(projectKey: string, gitReferencePath: string): Promise<ProjectGitFutureResponse>;
+    /** Commit and push one library. Runs as a DSS future. */
+    pushLibrary(projectKey: string, gitReferencePath: string, commitMessage: string): Promise<ProjectGitFutureResponse>;
+    /** Commit and push every attached library. Runs as a DSS future. */
+    pushAllLibraries(projectKey: string, commitMessage: string): Promise<ProjectGitFutureResponse>;
+    /** Reset every attached library to its remote state. Runs as a DSS future. */
+    resetAllLibraries(projectKey: string): Promise<ProjectGitFutureResponse>;
+    /**
+     * Read a future's state. `peek` leaves the future's log unconsumed, which is
+     * what polling loops want; the default consumes it like the Python client.
+     */
+    getFutureState(jobId: string, options?: ProjectGitFutureStateOptions): Promise<ProjectGitFutureState>;
+    /** Abort a running future. */
+    abortFuture(jobId: string): Promise<void>;
+    /**
+     * Poll until the future carries a result and return that result. Throws on
+     * an aborted or failed future and on an exhausted budget, so a caller never
+     * mistakes an unfinished future for a successful one.
+     */
+    waitForFuture(jobId: string, options?: ProjectGitFutureWaitOptions): Promise<unknown>;
+    private gitPath;
+    private actionPath;
+    private libraryPath;
+    private query;
+    private request;
+}