@aifabrix/builder 2.11.0 → 2.20.0

package/lib/api/auth.api.js

@@ -0,0 +1,304 @@
+/**
+ * @fileoverview Authentication API functions
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { ApiClient } = require('./index');
+
+/**
+ * Get authentication token using client credentials
+ * POST /api/v1/auth/token
+ * @async
+ * @function getToken
+ * @param {string} clientId - Client ID
+ * @param {string} clientSecret - Client secret
+ * @param {string} controllerUrl - Controller base URL
+ * @returns {Promise<Object>} Token response with access token
+ * @throws {Error} If authentication fails
+ */
+async function getToken(clientId, clientSecret, controllerUrl) {
+  const client = new ApiClient(controllerUrl, {
+    type: 'client-credentials',
+    clientId,
+    clientSecret
+  });
+
+  return await client.post('/api/v1/auth/token');
+}
+
+/**
+ * Get client token for frontend application
+ * GET/POST /api/v1/auth/client-token
+ * @async
+ * @function getClientToken
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} [method] - HTTP method ('GET' or 'POST', default: 'POST')
+ * @returns {Promise<Object>} Client token response
+ * @throws {Error} If token generation fails
+ */
+async function getClientToken(controllerUrl, method = 'POST') {
+  const client = new ApiClient(controllerUrl);
+
+  if (method === 'GET') {
+    return await client.get('/api/v1/auth/client-token');
+  }
+
+  return await client.post('/api/v1/auth/client-token');
+}
+
+/**
+ * Get current user information
+ * GET /api/v1/auth/user
+ * @async
+ * @function getAuthUser
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} User information response
+ * @throws {Error} If request fails
+ */
+async function getAuthUser(controllerUrl, authConfig) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get('/api/v1/auth/user');
+}
+
+/**
+ * Get login URL for OAuth2 authorization flow
+ * GET /api/v1/auth/login
+ * @async
+ * @function getAuthLogin
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} redirect - Redirect URI for OAuth2 callback
+ * @param {string} [state] - State parameter for CSRF protection
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Login URL response
+ * @throws {Error} If request fails
+ */
+async function getAuthLogin(controllerUrl, redirect, state, authConfig) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get('/api/v1/auth/login', {
+    params: { redirect, state }
+  });
+}
+
+/**
+ * Initiate OAuth2 Device Code Flow
+ * POST /api/v1/auth/login
+ * @async
+ * @function initiateDeviceCodeFlow
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} [environment] - Environment key
+ * @param {string} [scope] - OAuth2 scope string (defaults to 'openid profile email')
+ * @returns {Promise<Object>} Device code response
+ * @throws {Error} If device code flow initiation fails
+ */
+async function initiateDeviceCodeFlow(controllerUrl, environment, scope) {
+  const client = new ApiClient(controllerUrl);
+  const body = {};
+
+  if (environment) {
+    body.environment = environment;
+  }
+  if (scope) {
+    body.scope = scope;
+  }
+
+  // Use query params if environment provided (per OpenAPI spec)
+  if (environment) {
+    const params = { environment };
+    if (scope) {
+      params.scope = scope;
+    }
+    return await client.post('/api/v1/auth/login', {
+      params
+    });
+  }
+
+  // Otherwise use body
+  return await client.post('/api/v1/auth/login', {
+    body: Object.keys(body).length > 0 ? body : undefined
+  });
+}
+
+/**
+ * Poll for device code token
+ * POST /api/v1/auth/login/device/token
+ * @async
+ * @function pollDeviceCodeToken
+ * @param {string} deviceCode - Device code from initiate device code flow
+ * @param {string} controllerUrl - Controller base URL
+ * @returns {Promise<Object>} Token response (may return 202 with authorization_pending)
+ * @throws {Error} If polling fails
+ */
+async function pollDeviceCodeToken(deviceCode, controllerUrl) {
+  const client = new ApiClient(controllerUrl);
+  return await client.post('/api/v1/auth/login/device/token', {
+    body: { deviceCode }
+  });
+}
+
+/**
+ * Refresh device code access token
+ * POST /api/v1/auth/login/device/refresh
+ * @async
+ * @function refreshDeviceToken
+ * @param {string} refreshToken - Refresh token obtained from device code token flow
+ * @param {string} controllerUrl - Controller base URL
+ * @returns {Promise<Object>} New token response
+ * @throws {Error} If token refresh fails
+ */
+async function refreshDeviceToken(refreshToken, controllerUrl) {
+  const client = new ApiClient(controllerUrl);
+  return await client.post('/api/v1/auth/login/device/refresh', {
+    body: { refreshToken }
+  });
+}
+
+/**
+ * Refresh user access token
+ * POST /api/v1/auth/refresh
+ * @async
+ * @function refreshUserToken
+ * @param {string} refreshToken - Refresh token obtained from OAuth callback flow
+ * @param {string} controllerUrl - Controller base URL
+ * @returns {Promise<Object>} New token response
+ * @throws {Error} If token refresh fails
+ */
+async function refreshUserToken(refreshToken, controllerUrl) {
+  const client = new ApiClient(controllerUrl);
+  return await client.post('/api/v1/auth/refresh', {
+    body: { refreshToken }
+  });
+}
+
+/**
+ * Validate authentication token
+ * POST /api/v1/auth/validate
+ * @async
+ * @function validateToken
+ * @param {string} token - JWT token to validate
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} [environment] - Optional environment key
+ * @param {string} [application] - Optional application key
+ * @returns {Promise<Object>} Token validation response
+ * @throws {Error} If validation fails
+ */
+async function validateToken(token, controllerUrl, authConfig, environment, application) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  const body = { token };
+
+  if (environment) {
+    body.environment = environment;
+  }
+  if (application) {
+    body.application = application;
+  }
+
+  return await client.post('/api/v1/auth/validate', {
+    body
+  });
+}
+
+/**
+ * Get user roles
+ * GET /api/v1/auth/roles
+ * @async
+ * @function getAuthRoles
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} [environment] - Optional environment key filter
+ * @param {string} [application] - Optional application key filter
+ * @returns {Promise<Object>} User roles response
+ * @throws {Error} If request fails
+ */
+async function getAuthRoles(controllerUrl, authConfig, environment, application) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get('/api/v1/auth/roles', {
+    params: { environment, application }
+  });
+}
+
+/**
+ * Refresh user roles
+ * GET /api/v1/auth/roles/refresh
+ * @async
+ * @function refreshAuthRoles
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Refreshed roles response
+ * @throws {Error} If request fails
+ */
+async function refreshAuthRoles(controllerUrl, authConfig) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get('/api/v1/auth/roles/refresh');
+}
+
+/**
+ * Get user permissions
+ * GET /api/v1/auth/permissions
+ * @async
+ * @function getAuthPermissions
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} [environment] - Optional environment key filter
+ * @param {string} [application] - Optional application key filter
+ * @returns {Promise<Object>} User permissions response
+ * @throws {Error} If request fails
+ */
+async function getAuthPermissions(controllerUrl, authConfig, environment, application) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get('/api/v1/auth/permissions', {
+    params: { environment, application }
+  });
+}
+
+/**
+ * Refresh user permissions
+ * GET /api/v1/auth/permissions/refresh
+ * @async
+ * @function refreshAuthPermissions
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Refreshed permissions response
+ * @throws {Error} If request fails
+ */
+async function refreshAuthPermissions(controllerUrl, authConfig) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get('/api/v1/auth/permissions/refresh');
+}
+
+/**
+ * Get device code login diagnostics
+ * GET /api/v1/auth/login/diagnostics
+ * @async
+ * @function getAuthLoginDiagnostics
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} [environment] - Optional environment key
+ * @returns {Promise<Object>} Diagnostic information response
+ * @throws {Error} If request fails
+ */
+async function getAuthLoginDiagnostics(controllerUrl, environment) {
+  const client = new ApiClient(controllerUrl);
+  return await client.get('/api/v1/auth/login/diagnostics', {
+    params: { environment }
+  });
+}
+
+module.exports = {
+  getToken,
+  getClientToken,
+  getAuthUser,
+  getAuthLogin,
+  initiateDeviceCodeFlow,
+  pollDeviceCodeToken,
+  refreshDeviceToken,
+  refreshUserToken,
+  validateToken,
+  getAuthRoles,
+  refreshAuthRoles,
+  getAuthPermissions,
+  refreshAuthPermissions,
+  getAuthLoginDiagnostics
+};
+

package/lib/api/datasources-core.api.js

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Datasources Core API functions
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { ApiClient } = require('./index');
+
+async function listDatasources(dataplaneUrl, authConfig, options = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get('/api/v1/external/', { params: options });
+}
+async function createDatasource(dataplaneUrl, authConfig, datasourceData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/external/', { body: datasourceData });
+}
+async function getDatasource(dataplaneUrl, sourceIdOrKey, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}`);
+}
+async function updateDatasource(dataplaneUrl, sourceIdOrKey, authConfig, updateData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.put(`/api/v1/external/${sourceIdOrKey}`, { body: updateData });
+}
+async function deleteDatasource(dataplaneUrl, sourceIdOrKey, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.delete(`/api/v1/external/${sourceIdOrKey}`);
+}
+async function getDatasourceConfig(dataplaneUrl, sourceIdOrKey, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/config`);
+}
+async function publishDatasource(dataplaneUrl, sourceIdOrKey, authConfig, publishData = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/${sourceIdOrKey}/publish`, { body: publishData });
+}
+async function rollbackDatasource(dataplaneUrl, sourceIdOrKey, authConfig, rollbackData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/${sourceIdOrKey}/rollback`, { body: rollbackData });
+}
+async function testDatasource(dataplaneUrl, sourceIdOrKey, authConfig, testData = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/${sourceIdOrKey}/test`, { body: testData });
+}
+async function listDatasourceOpenAPIEndpoints(dataplaneUrl, sourceIdOrKey, authConfig, options = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/openapi-endpoints`, { params: options });
+}
+async function listExecutionLogs(dataplaneUrl, sourceIdOrKey, authConfig, options = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/executions`, { params: options });
+}
+async function getExecutionLog(dataplaneUrl, sourceIdOrKey, executionId, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/executions/${executionId}`);
+}
+async function listAllExecutionLogs(dataplaneUrl, authConfig, options = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get('/api/v1/external/executions', { params: options });
+}
+async function bulkOperation(dataplaneUrl, sourceIdOrKey, authConfig, bulkData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/${sourceIdOrKey}/bulk`, { body: bulkData });
+}
+async function getDatasourceStatus(dataplaneUrl, sourceIdOrKey, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/status`);
+}
+
+module.exports = {
+  listDatasources,
+  createDatasource,
+  getDatasource,
+  updateDatasource,
+  deleteDatasource,
+  getDatasourceConfig,
+  publishDatasource,
+  rollbackDatasource,
+  testDatasource,
+  listDatasourceOpenAPIEndpoints,
+  listExecutionLogs,
+  getExecutionLog,
+  listAllExecutionLogs,
+  bulkOperation,
+  getDatasourceStatus
+};
+

package/lib/api/datasources-extended.api.js

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview Datasources Extended API functions (records, grants, policies, sync, documents)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { ApiClient } = require('./index');
+
+async function listRecords(dataplaneUrl, sourceIdOrKey, authConfig, options = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/records`, { params: options });
+}
+async function createRecord(dataplaneUrl, sourceIdOrKey, authConfig, recordData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/${sourceIdOrKey}/records`, { body: recordData });
+}
+async function getRecord(dataplaneUrl, sourceIdOrKey, recordIdOrKey, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/records/${recordIdOrKey}`);
+}
+async function updateRecord(dataplaneUrl, sourceIdOrKey, recordIdOrKey, authConfig, updateData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.put(`/api/v1/external/${sourceIdOrKey}/records/${recordIdOrKey}`, { body: updateData });
+}
+async function deleteRecord(dataplaneUrl, sourceIdOrKey, recordIdOrKey, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.delete(`/api/v1/external/${sourceIdOrKey}/records/${recordIdOrKey}`);
+}
+async function listGrants(dataplaneUrl, sourceIdOrKey, authConfig, options = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/grants`, { params: options });
+}
+async function createGrant(dataplaneUrl, sourceIdOrKey, authConfig, grantData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/${sourceIdOrKey}/grants`, { body: grantData });
+}
+async function getGrant(dataplaneUrl, sourceIdOrKey, grantIdOrKey, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/grants/${grantIdOrKey}`);
+}
+async function updateGrant(dataplaneUrl, sourceIdOrKey, grantIdOrKey, authConfig, updateData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.put(`/api/v1/external/${sourceIdOrKey}/grants/${grantIdOrKey}`, { body: updateData });
+}
+async function deleteGrant(dataplaneUrl, sourceIdOrKey, grantIdOrKey, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.delete(`/api/v1/external/${sourceIdOrKey}/grants/${grantIdOrKey}`);
+}
+async function listPolicies(dataplaneUrl, sourceIdOrKey, authConfig, options = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/policies`, { params: options });
+}
+async function attachPolicy(dataplaneUrl, sourceIdOrKey, authConfig, policyData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/${sourceIdOrKey}/policies`, { body: policyData });
+}
+async function detachPolicy(dataplaneUrl, sourceIdOrKey, policyIdOrKey, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.delete(`/api/v1/external/${sourceIdOrKey}/policies/${policyIdOrKey}`);
+}
+async function listSyncJobs(dataplaneUrl, sourceIdOrKey, authConfig, options = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/sync`, { params: options });
+}
+async function createSyncJob(dataplaneUrl, sourceIdOrKey, authConfig, syncData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/${sourceIdOrKey}/sync`, { body: syncData });
+}
+async function getSyncJob(dataplaneUrl, sourceIdOrKey, syncJobId, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/${sourceIdOrKey}/sync/${syncJobId}`);
+}
+async function updateSyncJob(dataplaneUrl, sourceIdOrKey, syncJobId, authConfig, updateData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.put(`/api/v1/external/${sourceIdOrKey}/sync/${syncJobId}`, { body: updateData });
+}
+async function executeSyncJob(dataplaneUrl, sourceIdOrKey, syncJobId, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/${sourceIdOrKey}/sync/${syncJobId}/execute`);
+}
+async function validateDocuments(dataplaneUrl, sourceIdOrKey, authConfig, validateData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/data-sources/${sourceIdOrKey}/documents/validate`, { body: validateData });
+}
+async function bulkDocuments(dataplaneUrl, sourceIdOrKey, authConfig, bulkData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/external/data-sources/${sourceIdOrKey}/documents/bulk`, { body: bulkData });
+}
+async function listDocuments(dataplaneUrl, sourceIdOrKey, authConfig, options = {}) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/external/data-sources/${sourceIdOrKey}/documents`, { params: options });
+}
+
+module.exports = {
+  listRecords,
+  createRecord,
+  getRecord,
+  updateRecord,
+  deleteRecord,
+  listGrants,
+  createGrant,
+  getGrant,
+  updateGrant,
+  deleteGrant,
+  listPolicies,
+  attachPolicy,
+  detachPolicy,
+  listSyncJobs,
+  createSyncJob,
+  getSyncJob,
+  updateSyncJob,
+  executeSyncJob,
+  validateDocuments,
+  bulkDocuments,
+  listDocuments
+};
+

package/lib/api/datasources.api.js

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Datasources API functions
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const coreApi = require('./datasources-core.api');
+const extendedApi = require('./datasources-extended.api');
+
+module.exports = {
+  ...coreApi,
+  ...extendedApi
+};

package/lib/api/deployments.api.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Deployments API functions
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { ApiClient } = require('./index');
+
+/**
+ * Deploy an application to an environment
+ * POST /api/v1/environments/{envKey}/applications/deploy
+ * @async
+ * @function deployApplication
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} envKey - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} deployData - Deployment data
+ * @param {string} deployData.applicationKey - Application key to deploy
+ * @param {string} deployData.image - Container image path
+ * @param {Object} [deployData.configuration] - Additional deployment configuration
+ * @param {boolean} [deployData.dryRun] - If true, perform a dry run
+ * @returns {Promise<Object>} Deployment response
+ * @throws {Error} If deployment fails
+ */
+async function deployApplication(controllerUrl, envKey, authConfig, deployData) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.post(`/api/v1/environments/${envKey}/applications/deploy`, {
+    body: deployData
+  });
+}
+
+/**
+ * Deploy environment infrastructure
+ * POST /api/v1/environments/{envKey}/deploy
+ * @async
+ * @function deployEnvironment
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} envKey - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} deployData - Deployment data
+ * @param {Object} deployData.environmentConfig - Environment configuration
+ * @param {boolean} [deployData.dryRun] - If true, perform a dry run
+ * @returns {Promise<Object>} Deployment response
+ * @throws {Error} If deployment fails
+ */
+async function deployEnvironment(controllerUrl, envKey, authConfig, deployData) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.post(`/api/v1/environments/${envKey}/deploy`, {
+    body: deployData
+  });
+}
+
+/**
+ * List deployments for an environment
+ * GET /api/v1/environments/{envKey}/deployments
+ * @async
+ * @function listDeployments
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} envKey - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} [options] - List options
+ * @param {number} [options.page] - Page number
+ * @property {number} [options.pageSize] - Items per page
+ * @param {string} [options.sort] - Sort parameter
+ * @param {string} [options.filter] - Filter parameter
+ * @param {string} [options.search] - Search term
+ * @param {string} [options.status] - Filter by status (legacy)
+ * @param {string} [options.deploymentType] - Filter by deployment type (legacy)
+ * @returns {Promise<Object>} Paginated list of deployments
+ * @throws {Error} If request fails
+ */
+async function listDeployments(controllerUrl, envKey, authConfig, options = {}) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get(`/api/v1/environments/${envKey}/deployments`, {
+    params: options
+  });
+}
+
+/**
+ * Get deployment with jobs and logs
+ * GET /api/v1/environments/{envKey}/deployments/{deploymentId}
+ * @async
+ * @function getDeployment
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} envKey - Environment key
+ * @param {string} deploymentId - Deployment ID
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Full deployment record with jobs and logs
+ * @throws {Error} If request fails
+ */
+async function getDeployment(controllerUrl, envKey, deploymentId, authConfig) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get(`/api/v1/environments/${envKey}/deployments/${deploymentId}`);
+}
+
+/**
+ * Get deployment job logs
+ * GET /api/v1/environments/{envKey}/deployments/{deploymentId}/logs
+ * @async
+ * @function getDeploymentLogs
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} envKey - Environment key
+ * @param {string} deploymentId - Deployment ID
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} [options] - Log options
+ * @param {string} [options.jobId] - Filter logs for specific job ID
+ * @param {string} [options.level] - Filter by log level
+ * @param {string} [options.since] - Get logs since timestamp (ISO 8601)
+ * @returns {Promise<Object>} Array of job logs
+ * @throws {Error} If request fails
+ */
+async function getDeploymentLogs(controllerUrl, envKey, deploymentId, authConfig, options = {}) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get(`/api/v1/environments/${envKey}/deployments/${deploymentId}/logs`, {
+    params: options
+  });
+}
+
+module.exports = {
+  deployApplication,
+  deployEnvironment,
+  listDeployments,
+  getDeployment,
+  getDeploymentLogs
+};
+