@azure/ai-projects 2.0.1 → 2.0.2

package/dist/esm/api/datasets/operations.js

@@ -1,394 +1,327 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
 import fs from "node:fs";
 import nodePath from "node:path";
-import {
-  _pagedDatasetVersionDeserializer,
-  datasetVersionUnionSerializer,
-  datasetVersionUnionDeserializer,
-  pendingUploadRequestSerializer,
-  pendingUploadResponseDeserializer,
-  datasetCredentialDeserializer
-} from "../../models/models.js";
+import { _pagedDatasetVersionDeserializer, datasetVersionUnionSerializer, datasetVersionUnionDeserializer, pendingUploadRequestSerializer, pendingUploadResponseDeserializer, datasetCredentialDeserializer, } from "../../models/models.js";
 import { buildPagedAsyncIterator } from "../../static-helpers/pagingHelpers.js";
 import { expandUrlTemplate } from "../../static-helpers/urlTemplate.js";
 import { createRestError, operationOptionsToRequestParameters } from "@azure-rest/core-client";
 import { ContainerClient } from "@azure/storage-blob";
-function _getCredentialsSend(context, name, version, options = { requestOptions: {} }) {
-  const path = expandUrlTemplate(
-    "/datasets/{name}/versions/{version}/credentials{?api-version}",
-    {
-      name,
-      version,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
-    }
-  );
-  return context.path(path).post({
-    ...operationOptionsToRequestParameters(options),
-    headers: {
-      accept: "application/json",
-      ...options.requestOptions?.headers
+import { logger } from "../../logger.js";
+export function _getCredentialsSend(context, name, version, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/datasets/{name}/versions/{version}/credentials{?api-version}", {
+        name: name,
+        version: version,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _getCredentialsDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
     }
-  });
+    return datasetCredentialDeserializer(result.body);
 }
-async function _getCredentialsDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    throw createRestError(result);
-  }
-  return datasetCredentialDeserializer(result.body);
+/** Get the SAS credential to access the storage account associated with a Dataset version. */
+export async function getCredentials(context, name, version, options = { requestOptions: {} }) {
+    const result = await _getCredentialsSend(context, name, version, options);
+    return _getCredentialsDeserialize(result);
 }
-async function getCredentials(context, name, version, options = { requestOptions: {} }) {
-  const result = await _getCredentialsSend(context, name, version, options);
-  return _getCredentialsDeserialize(result);
+export function _pendingUploadSend(context, name, version, pendingUploadRequest, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/datasets/{name}/versions/{version}/startPendingUpload{?api-version}", {
+        name: name,
+        version: version,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: pendingUploadRequestSerializer(pendingUploadRequest),
+    });
 }
-function _pendingUploadSend(context, name, version, pendingUploadRequest, options = { requestOptions: {} }) {
-  const path = expandUrlTemplate(
-    "/datasets/{name}/versions/{version}/startPendingUpload{?api-version}",
-    {
-      name,
-      version,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _pendingUploadDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
     }
-  );
-  return context.path(path).post({
-    ...operationOptionsToRequestParameters(options),
-    contentType: "application/json",
-    headers: {
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    },
-    body: pendingUploadRequestSerializer(pendingUploadRequest)
-  });
+    return pendingUploadResponseDeserializer(result.body);
 }
-async function _pendingUploadDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    throw createRestError(result);
-  }
-  return pendingUploadResponseDeserializer(result.body);
+/** Start a new or get an existing pending upload of a dataset for a specific version. */
+export async function pendingUpload(context, name, version, pendingUploadRequest, options = { requestOptions: {} }) {
+    const result = await _pendingUploadSend(context, name, version, pendingUploadRequest, options);
+    return _pendingUploadDeserialize(result);
 }
-async function pendingUpload(context, name, version, pendingUploadRequest, options = { requestOptions: {} }) {
-  const result = await _pendingUploadSend(context, name, version, pendingUploadRequest, options);
-  return _pendingUploadDeserialize(result);
+export function _createOrUpdateSend(context, name, version, datasetVersion, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/datasets/{name}/versions/{version}{?api-version}", {
+        name: name,
+        version: version,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).patch({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/merge-patch+json",
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: datasetVersionUnionSerializer(datasetVersion),
+    });
 }
-function _createOrUpdateSend(context, name, version, datasetVersion, options = { requestOptions: {} }) {
-  const path = expandUrlTemplate(
-    "/datasets/{name}/versions/{version}{?api-version}",
-    {
-      name,
-      version,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _createOrUpdateDeserialize(result) {
+    const expectedStatuses = ["201", "200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
     }
-  );
-  return context.path(path).patch({
-    ...operationOptionsToRequestParameters(options),
-    contentType: "application/merge-patch+json",
-    headers: {
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    },
-    body: datasetVersionUnionSerializer(datasetVersion)
-  });
+    return datasetVersionUnionDeserializer(result.body);
 }
-async function _createOrUpdateDeserialize(result) {
-  const expectedStatuses = ["201", "200"];
-  if (!expectedStatuses.includes(result.status)) {
-    throw createRestError(result);
-  }
-  return datasetVersionUnionDeserializer(result.body);
+/** Create a new or update an existing DatasetVersion with the given version id */
+export async function createOrUpdate(context, name, version, datasetVersion, options = { requestOptions: {} }) {
+    const result = await _createOrUpdateSend(context, name, version, datasetVersion, options);
+    return _createOrUpdateDeserialize(result);
 }
-async function createOrUpdate(context, name, version, datasetVersion, options = { requestOptions: {} }) {
-  const result = await _createOrUpdateSend(context, name, version, datasetVersion, options);
-  return _createOrUpdateDeserialize(result);
+export function _$deleteSend(context, name, version, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/datasets/{name}/versions/{version}{?api-version}", {
+        name: name,
+        version: version,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).delete({ ...operationOptionsToRequestParameters(options) });
 }
-function _$deleteSend(context, name, version, options = { requestOptions: {} }) {
-  const path = expandUrlTemplate(
-    "/datasets/{name}/versions/{version}{?api-version}",
-    {
-      name,
-      version,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _$deleteDeserialize(result) {
+    const expectedStatuses = ["204"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
     }
-  );
-  return context.path(path).delete({ ...operationOptionsToRequestParameters(options) });
+    return;
 }
-async function _$deleteDeserialize(result) {
-  const expectedStatuses = ["204"];
-  if (!expectedStatuses.includes(result.status)) {
-    throw createRestError(result);
-  }
-  return;
+/** Delete the specific version of the DatasetVersion. The service returns 204 No Content if the DatasetVersion was deleted successfully or if the DatasetVersion does not exist. */
+export async function $delete(context, name, version, options = { requestOptions: {} }) {
+    const result = await _$deleteSend(context, name, version, options);
+    return _$deleteDeserialize(result);
 }
-async function $delete(context, name, version, options = { requestOptions: {} }) {
-  const result = await _$deleteSend(context, name, version, options);
-  return _$deleteDeserialize(result);
+export function _getSend(context, name, version, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/datasets/{name}/versions/{version}{?api-version}", {
+        name: name,
+        version: version,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
 }
-function _getSend(context, name, version, options = { requestOptions: {} }) {
-  const path = expandUrlTemplate(
-    "/datasets/{name}/versions/{version}{?api-version}",
-    {
-      name,
-      version,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
-    }
-  );
-  return context.path(path).get({
-    ...operationOptionsToRequestParameters(options),
-    headers: {
-      accept: "application/json",
-      ...options.requestOptions?.headers
+export async function _getDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
     }
-  });
+    return datasetVersionUnionDeserializer(result.body);
 }
-async function _getDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    throw createRestError(result);
-  }
-  return datasetVersionUnionDeserializer(result.body);
+/** Get the specific version of the DatasetVersion. The service returns 404 Not Found error if the DatasetVersion does not exist. */
+export async function get(context, name, version, options = { requestOptions: {} }) {
+    const result = await _getSend(context, name, version, options);
+    return _getDeserialize(result);
 }
-async function get(context, name, version, options = { requestOptions: {} }) {
-  const result = await _getSend(context, name, version, options);
-  return _getDeserialize(result);
+export function _listSend(context, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/datasets{?api-version}", {
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
 }
-function _listSend(context, options = { requestOptions: {} }) {
-  const path = expandUrlTemplate(
-    "/datasets{?api-version}",
-    {
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _listDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
     }
-  );
-  return context.path(path).get({
-    ...operationOptionsToRequestParameters(options),
-    headers: {
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    }
-  });
+    return _pagedDatasetVersionDeserializer(result.body);
 }
-async function _listDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    throw createRestError(result);
-  }
-  return _pagedDatasetVersionDeserializer(result.body);
+/** List the latest version of each DatasetVersion */
+export function list(context, options = { requestOptions: {} }) {
+    return buildPagedAsyncIterator(context, () => _listSend(context, options), _listDeserialize, ["200"], { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion });
 }
-function list(context, options = { requestOptions: {} }) {
-  return buildPagedAsyncIterator(
-    context,
-    () => _listSend(context, options),
-    _listDeserialize,
-    ["200"],
-    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion }
-  );
+export function _listVersionsSend(context, name, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/datasets/{name}/versions{?api-version}", {
+        name: name,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
 }
-function _listVersionsSend(context, name, options = { requestOptions: {} }) {
-  const path = expandUrlTemplate(
-    "/datasets/{name}/versions{?api-version}",
-    {
-      name,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
-    }
-  );
-  return context.path(path).get({
-    ...operationOptionsToRequestParameters(options),
-    headers: {
-      accept: "application/json",
-      ...options.requestOptions?.headers
+export async function _listVersionsDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
     }
-  });
+    return _pagedDatasetVersionDeserializer(result.body);
 }
-async function _listVersionsDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    throw createRestError(result);
-  }
-  return _pagedDatasetVersionDeserializer(result.body);
-}
-function listVersions(context, name, options = { requestOptions: {} }) {
-  return buildPagedAsyncIterator(
-    context,
-    () => _listVersionsSend(context, name, options),
-    _listVersionsDeserialize,
-    ["200"],
-    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion }
-  );
+/** List all versions of the given DatasetVersion */
+export function listVersions(context, name, options = { requestOptions: {} }) {
+    return buildPagedAsyncIterator(context, () => _listVersionsSend(context, name, options), _listVersionsDeserialize, ["200"], { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion });
 }
+// Internal helper method to create a new dataset and return a ContainerClient from azure-storage-blob package, to the dataset's blob storage.
 async function createDatasetAndGetItsContainer(context, name, version, options) {
-  const { connectionName, projectOptions = {} } = options || {};
-  const pendingUploadResponse = await pendingUpload(context, name, version, {
-    pendingUploadType: "BlobReference",
-    connectionName
-  });
-  const blobReference = pendingUploadResponse.blobReference;
-  if (!blobReference) {
-    throw new Error("Blob reference for consumption is not present");
-  }
-  if (!blobReference.credential?.type) {
-    throw new Error("Credential type is not present");
-  }
-  if (blobReference.credential.type !== "SAS") {
-    throw new Error("Credential type is not SAS");
-  }
-  if (!blobReference.blobUri) {
-    throw new Error("Blob URI is not present or empty");
-  }
-  console.debug(
-    `[createDatasetAndGetItsContainer] pendingUploadResponse.pendingUploadId = ${pendingUploadResponse.pendingUploadId}`
-  );
-  console.debug(
-    `[createDatasetAndGetItsContainer] pendingUploadResponse.pendingUploadType = ${pendingUploadResponse.pendingUploadType}`
-  );
-  console.debug(
-    `[createDatasetAndGetItsContainer] blobReference.blobUri = ${blobReference.blobUri}`
-  );
-  console.debug(
-    `[createDatasetAndGetItsContainer] blobReference.storageAccountArmId = ${blobReference.storageAccountArmId}`
-  );
-  console.debug(
-    `[createDatasetAndGetItsContainer] blobReference.credential.sasUri = ${blobReference.credential.sasUri}`
-  );
-  console.debug(
-    `[createDatasetAndGetItsContainer] blobReference.credential.type = ${blobReference.credential.type}`
-  );
-  const containerClient = new ContainerClient(blobReference.credential.sasUri);
-  const pipeline = containerClient["storageClientContext"].pipeline;
-  for (const { policy } of projectOptions.additionalPolicies ?? []) {
-    pipeline.addPolicy(policy, { afterPhase: "Sign" });
-  }
-  return {
-    containerClient,
-    version
-  };
+    const { connectionName, projectOptions = {} } = options || {};
+    // Start a pending upload to get the container URL with SAS token
+    const pendingUploadResponse = await pendingUpload(context, name, version, {
+        pendingUploadType: "BlobReference",
+        connectionName,
+    });
+    const blobReference = pendingUploadResponse.blobReference;
+    // Validate the response
+    if (!blobReference) {
+        throw new Error("Blob reference for consumption is not present");
+    }
+    if (!blobReference.credential?.type) {
+        throw new Error("Credential type is not present");
+    }
+    if (blobReference.credential.type !== "SAS") {
+        throw new Error("Credential type is not SAS");
+    }
+    if (!blobReference.blobUri) {
+        throw new Error("Blob URI is not present or empty");
+    }
+    // Optional debug logging
+    logger.verbose(`[createDatasetAndGetItsContainer] pendingUploadResponse.pendingUploadId = ${pendingUploadResponse.pendingUploadId}`);
+    logger.verbose(`[createDatasetAndGetItsContainer] pendingUploadResponse.pendingUploadType = ${pendingUploadResponse.pendingUploadType}`);
+    logger.verbose(`[createDatasetAndGetItsContainer] blobReference.blobUri = ${blobReference.blobUri}`);
+    logger.verbose(`[createDatasetAndGetItsContainer] blobReference.storageAccountArmId = ${blobReference.storageAccountArmId}`);
+    logger.verbose(`[createDatasetAndGetItsContainer] blobReference.credential.sasUri = ${blobReference.credential.sasUri}`);
+    logger.verbose(`[createDatasetAndGetItsContainer] blobReference.credential.type = ${blobReference.credential.type}`);
+    // Create container client from the blob URI (which includes the SAS token)
+    const containerClient = new ContainerClient(blobReference.credential.sasUri);
+    const pipeline = containerClient["storageClientContext"].pipeline;
+    for (const { policy } of projectOptions.additionalPolicies ?? []) {
+        pipeline.addPolicy(policy, { afterPhase: "Sign" });
+    }
+    return {
+        containerClient,
+        version,
+    };
 }
-async function uploadFile(context, name, version, filePath, options) {
-  const fileExists = fs.existsSync(filePath);
-  if (!fileExists) {
-    throw new Error(`File does not exist at path: ${filePath}`);
-  }
-  const isDirectory = fs.lstatSync(filePath).isDirectory();
-  if (isDirectory) {
-    throw new Error(`The provided file is actually a folder. Use method uploadFolder instead`);
-  }
-  const { containerClient, version: outputVersion } = await createDatasetAndGetItsContainer(
-    context,
-    name,
-    version,
-    options
-  );
-  const blobName = nodePath.basename(filePath);
-  const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-  await blockBlobClient.uploadStream(fs.createReadStream(filePath));
-  const datasetVersion = await createOrUpdate(context, name, outputVersion, {
-    name,
-    version: outputVersion,
-    type: "uri_file",
-    dataUri: blockBlobClient.url
-  });
-  return datasetVersion;
+export async function uploadFile(context, name, version, filePath, options) {
+    // if file does not exist
+    const fileExists = fs.existsSync(filePath);
+    if (!fileExists) {
+        throw new Error(`File does not exist at path: ${filePath}`);
+    }
+    // Check if the file is a directory
+    const isDirectory = fs.lstatSync(filePath).isDirectory();
+    if (isDirectory) {
+        throw new Error(`The provided file is actually a folder. Use method uploadFolder instead`);
+    }
+    const { containerClient, version: outputVersion } = await createDatasetAndGetItsContainer(context, name, version, options);
+    // file name as blob name
+    const blobName = nodePath.basename(filePath);
+    const blockBlobClient = containerClient.getBlockBlobClient(blobName);
+    await blockBlobClient.uploadStream(fs.createReadStream(filePath));
+    const datasetVersion = await createOrUpdate(context, name, outputVersion, {
+        name: name,
+        version: outputVersion,
+        type: "uri_file",
+        dataUri: blockBlobClient.url,
+    });
+    return datasetVersion;
 }
-async function uploadFolder(context, name, version, folderPath, options) {
-  const folderExists = fs.existsSync(folderPath);
-  if (!folderExists) {
-    throw new Error(`Folder does not exist at path: ${folderPath}`);
-  }
-  const isFile = fs.lstatSync(folderPath).isFile();
-  if (isFile) {
-    throw new Error(`The provided path is actually a file. Use method uploadFile instead`);
-  }
-  const { containerClient, version: outputVersion } = await createDatasetAndGetItsContainer(
-    context,
-    name,
-    version,
-    options
-  );
-  async function getAllFiles(dir, fileList = []) {
-    const files = await fs.promises.readdir(dir);
-    for (const file of files) {
-      const filePath = `${dir}/${file}`;
-      const stat = await fs.promises.lstat(filePath);
-      if (stat.isDirectory()) {
-        await getAllFiles(filePath, fileList);
-      } else {
-        fileList.push(filePath);
-      }
+export async function uploadFolder(context, name, version, folderPath, options) {
+    // Check if the folder exists
+    const folderExists = fs.existsSync(folderPath);
+    if (!folderExists) {
+        throw new Error(`Folder does not exist at path: ${folderPath}`);
+    }
+    // Check if the folder is a file
+    const isFile = fs.lstatSync(folderPath).isFile();
+    if (isFile) {
+        throw new Error(`The provided path is actually a file. Use method uploadFile instead`);
+    }
+    const { containerClient, version: outputVersion } = await createDatasetAndGetItsContainer(context, name, version, options);
+    // Helper function to recursively get all files in a directory
+    async function getAllFiles(dir, fileList = []) {
+        const files = await fs.promises.readdir(dir);
+        for (const file of files) {
+            const filePath = `${dir}/${file}`;
+            const stat = await fs.promises.lstat(filePath);
+            if (stat.isDirectory()) {
+                await getAllFiles(filePath, fileList);
+            }
+            else {
+                fileList.push(filePath);
+            }
+        }
+        return fileList;
+    }
+    // Get all files in the folder
+    const allFiles = await getAllFiles(folderPath);
+    let filteredFiles = allFiles;
+    if (options?.filePattern) {
+        try {
+            const filePattern = new RegExp(options.filePattern);
+            filteredFiles = allFiles.filter((file) => filePattern.test(file));
+        }
+        catch {
+            // If regex pattern is invalid, ignore the pattern and upload all files
+        }
+    }
+    if (filteredFiles.length === 0) {
+        throw new Error("The provided folder is empty.");
     }
-    return fileList;
-  }
-  const allFiles = await getAllFiles(folderPath);
-  let filteredFiles = allFiles;
-  if (options?.filePattern) {
-    try {
-      const filePattern = new RegExp(options.filePattern);
-      filteredFiles = allFiles.filter((file) => filePattern.test(file));
-    } catch {
+    // Upload each file to blob storage while maintaining relative paths
+    for (const filePath of filteredFiles) {
+        // Create blob name as relative path from the base folder
+        const relativePath = nodePath.relative(folderPath, filePath).split(nodePath.sep).join("/");
+        logger.verbose(`[uploadFolderAndCreate] Start uploading file '${filePath}' as blob '${relativePath}'`);
+        // Get a block blob client for the relative path
+        const blobClient = containerClient.getBlockBlobClient(relativePath);
+        // Upload the file using a readable stream for better performance
+        const fileStream = fs.createReadStream(filePath);
+        await blobClient.uploadStream(fileStream);
+        logger.verbose(`[uploadFolderAndCreate] Done uploading file '${filePath}' as blob '${relativePath}'`);
     }
-  }
-  if (filteredFiles.length === 0) {
-    throw new Error("The provided folder is empty.");
-  }
-  for (const filePath of filteredFiles) {
-    const relativePath = nodePath.relative(folderPath, filePath).split(nodePath.sep).join("/");
-    console.debug(
-      `[uploadFolderAndCreate] Start uploading file '${filePath}' as blob '${relativePath}'`
-    );
-    const blobClient = containerClient.getBlockBlobClient(relativePath);
-    const fileStream = fs.createReadStream(filePath);
-    await blobClient.uploadStream(fileStream);
-    console.debug(
-      `[uploadFolderAndCreate] Done uploading file '${filePath}' as blob '${relativePath}'`
-    );
-  }
-  const datasetVersion = await createOrUpdate(context, name, outputVersion, {
-    name,
-    version: outputVersion,
-    type: "uri_folder",
-    dataUri: containerClient.url
-  });
-  return datasetVersion;
+    // Create dataset version that references this folder
+    const datasetVersion = await createOrUpdate(context, name, outputVersion, {
+        name: name,
+        version: outputVersion,
+        type: "uri_folder",
+        dataUri: containerClient.url,
+    });
+    return datasetVersion;
 }
-export {
-  $delete,
-  _$deleteDeserialize,
-  _$deleteSend,
-  _createOrUpdateDeserialize,
-  _createOrUpdateSend,
-  _getCredentialsDeserialize,
-  _getCredentialsSend,
-  _getDeserialize,
-  _getSend,
-  _listDeserialize,
-  _listSend,
-  _listVersionsDeserialize,
-  _listVersionsSend,
-  _pendingUploadDeserialize,
-  _pendingUploadSend,
-  createOrUpdate,
-  get,
-  getCredentials,
-  list,
-  listVersions,
-  pendingUpload,
-  uploadFile,
-  uploadFolder
-};
+//# sourceMappingURL=operations.js.map