Refactor function parameters and update JSON struct tags

aws-gopher · aws-gopher · commit 6b617f948c15 · 2025-07-25T15:17:39.000-04:00
- Changed function parameters from `&lt;foo&gt;ID` to just `id` for consistency across client methods.
- Updated JSON struct tags in `CreateWorkflowRequest` and `UpdateWorkflowRequest` for better clarity and optional field handling.
- Renamed local variable in update methods to use the name `wrapper` instead of `shadow` for clarity.
- Improved error handling and consistency in job and source-related functions.
diff --git a/destination_update.go b/destination_update.go
@@ -22,13 +22,13 @@ func (c *Client) UpdateDestination(ctx context.Context, in UpdateDestinationRequ
 		return nil, fmt.Errorf("failed to marshal config: %w", err)
 	}
 
-	shadow := struct {
+	wrapper := struct {
 		Config json.RawMessage `json:"config"`
 	}{
 		Config: json.RawMessage(config),
 	}
 
-	body, err := json.Marshal(shadow)
+	body, err := json.Marshal(wrapper)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal update request: %w", err)
 	}
diff --git a/job.go b/job.go
@@ -1,8 +1,6 @@
 package unstructured
 
-import (
-	"time"
-)
+import "time"
 
 // Job represents a job, which is an execution of a workflow in Unstructured.io.
 type Job struct {
diff --git a/job_cancel.go b/job_cancel.go
@@ -7,10 +7,10 @@ import (
 )
 
 // CancelJob cancels a running job by its ID
-func (c *Client) CancelJob(ctx context.Context, jobID string) error {
+func (c *Client) CancelJob(ctx context.Context, id string) error {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodPost,
-		c.endpoint.JoinPath("/jobs", jobID, "cancel").String(),
+		c.endpoint.JoinPath("/jobs", id, "cancel").String(),
 		nil,
 	)
 	if err != nil {
diff --git a/job_details.go b/job_details.go
@@ -8,10 +8,10 @@ import (
 
 // GetJobDetails retrieves detailed processing information for a specific job by its ID.
 // It returns a JobDetails struct with node stats and processing status.
-func (c *Client) GetJobDetails(ctx context.Context, jobID string) (*JobDetails, error) {
+func (c *Client) GetJobDetails(ctx context.Context, id string) (*JobDetails, error) {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodGet,
-		c.endpoint.JoinPath("/jobs", jobID, "details").String(),
+		c.endpoint.JoinPath("/jobs", id, "details").String(),
 		nil,
 	)
 	if err != nil {
diff --git a/job_download.go b/job_download.go
@@ -8,10 +8,10 @@ import (
 )
 
 // DownloadJob downloads the output files from a completed job
-func (c *Client) DownloadJob(ctx context.Context, jobID string) (io.ReadCloser, error) {
+func (c *Client) DownloadJob(ctx context.Context, id string) (io.ReadCloser, error) {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodGet,
-		c.endpoint.JoinPath("/jobs", jobID, "download").String(),
+		c.endpoint.JoinPath("/jobs", id, "download").String(),
 		nil,
 	)
 	if err != nil {
diff --git a/job_failed_files.go b/job_failed_files.go
@@ -8,20 +8,20 @@ import (
 
 // GetJobFailedFiles retrieves the list of failed files for a specific job by its ID.
 // It returns a JobFailedFiles struct containing the failed files and error messages.
-func (c *Client) GetJobFailedFiles(ctx context.Context, jobID string) (*JobFailedFiles, error) {
+func (c *Client) GetJobFailedFiles(ctx context.Context, id string) (*JobFailedFiles, error) {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodGet,
-		c.endpoint.JoinPath("/jobs", jobID, "failed-files").String(),
+		c.endpoint.JoinPath("/jobs", id, "failed-files").String(),
 		nil,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create HTTP request: %w", err)
 	}
 
-	var failedFiles JobFailedFiles
-	if err := c.do(req, &failedFiles); err != nil {
+	var failed JobFailedFiles
+	if err := c.do(req, &failed); err != nil {
 		return nil, fmt.Errorf("failed to get job failed files: %w", err)
 	}
 
-	return &failedFiles, nil
+	return &failed, nil
 }
diff --git a/job_get.go b/job_get.go
@@ -7,10 +7,10 @@ import (
 )
 
 // GetJob retrieves detailed information for a specific job by its ID
-func (c *Client) GetJob(ctx context.Context, jobID string) (*Job, error) {
+func (c *Client) GetJob(ctx context.Context, id string) (*Job, error) {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodGet,
-		c.endpoint.JoinPath("/jobs", jobID).String(),
+		c.endpoint.JoinPath("/jobs", id).String(),
 		nil,
 	)
 	if err != nil {
diff --git a/source.go b/source.go
@@ -9,27 +9,27 @@ import (
 // sourceConfigFactories maps source type strings to factory functions
 // that create new instances of the appropriate concrete source config type.
 var sourceConfigFactories = map[string]func() SourceConfig{
-	ConnectorTypeAzure:             func() SourceConfig { return &AzureSourceConnectorConfig{} },
-	ConnectorTypeBox:               func() SourceConfig { return &BoxSourceConnectorConfig{} },
-	ConnectorTypeConfluence:        func() SourceConfig { return &ConfluenceSourceConnectorConfig{} },
-	ConnectorTypeCouchbase:         func() SourceConfig { return &CouchbaseSourceConnectorConfig{} },
-	ConnectorTypeDatabricksVolumes: func() SourceConfig { return &DatabricksVolumesConnectorConfig{} },
-	ConnectorTypeDropbox:           func() SourceConfig { return &DropboxSourceConnectorConfig{} },
-	ConnectorTypeElasticsearch:     func() SourceConfig { return &ElasticsearchConnectorConfig{} },
-	ConnectorTypeGCS:               func() SourceConfig { return &GCSSourceConnectorConfig{} },
-	ConnectorTypeGoogleDrive:       func() SourceConfig { return &GoogleDriveSourceConnectorConfig{} },
-	ConnectorTypeJira:              func() SourceConfig { return &JiraSourceConnectorConfig{} },
-	ConnectorTypeKafkaCloud:        func() SourceConfig { return &KafkaCloudSourceConnectorConfig{} },
-	ConnectorTypeMongoDB:           func() SourceConfig { return &MongoDBConnectorConfig{} },
-	ConnectorTypeOneDrive:          func() SourceConfig { return &OneDriveSourceConnectorConfig{} },
-	ConnectorTypeOutlook:           func() SourceConfig { return &OutlookSourceConnectorConfig{} },
-	ConnectorTypePostgres:          func() SourceConfig { return &PostgresSourceConnectorConfig{} },
-	ConnectorTypeS3:                func() SourceConfig { return &S3SourceConnectorConfig{} },
-	ConnectorTypeSalesforce:        func() SourceConfig { return &SalesforceSourceConnectorConfig{} },
-	ConnectorTypeSharePoint:        func() SourceConfig { return &SharePointSourceConnectorConfig{} },
-	ConnectorTypeSlack:             func() SourceConfig { return &SlackSourceConnectorConfig{} },
-	ConnectorTypeSnowflake:         func() SourceConfig { return &SnowflakeSourceConnectorConfig{} },
-	ConnectorTypeZendesk:           func() SourceConfig { return &ZendeskSourceConnectorConfig{} },
+	ConnectorTypeAzure:             func() SourceConfig { return new(AzureSourceConnectorConfig) },
+	ConnectorTypeBox:               func() SourceConfig { return new(BoxSourceConnectorConfig) },
+	ConnectorTypeConfluence:        func() SourceConfig { return new(ConfluenceSourceConnectorConfig) },
+	ConnectorTypeCouchbase:         func() SourceConfig { return new(CouchbaseSourceConnectorConfig) },
+	ConnectorTypeDatabricksVolumes: func() SourceConfig { return new(DatabricksVolumesConnectorConfig) },
+	ConnectorTypeDropbox:           func() SourceConfig { return new(DropboxSourceConnectorConfig) },
+	ConnectorTypeElasticsearch:     func() SourceConfig { return new(ElasticsearchConnectorConfig) },
+	ConnectorTypeGCS:               func() SourceConfig { return new(GCSSourceConnectorConfig) },
+	ConnectorTypeGoogleDrive:       func() SourceConfig { return new(GoogleDriveSourceConnectorConfig) },
+	ConnectorTypeJira:              func() SourceConfig { return new(JiraSourceConnectorConfig) },
+	ConnectorTypeKafkaCloud:        func() SourceConfig { return new(KafkaCloudSourceConnectorConfig) },
+	ConnectorTypeMongoDB:           func() SourceConfig { return new(MongoDBConnectorConfig) },
+	ConnectorTypeOneDrive:          func() SourceConfig { return new(OneDriveSourceConnectorConfig) },
+	ConnectorTypeOutlook:           func() SourceConfig { return new(OutlookSourceConnectorConfig) },
+	ConnectorTypePostgres:          func() SourceConfig { return new(PostgresSourceConnectorConfig) },
+	ConnectorTypeS3:                func() SourceConfig { return new(S3SourceConnectorConfig) },
+	ConnectorTypeSalesforce:        func() SourceConfig { return new(SalesforceSourceConnectorConfig) },
+	ConnectorTypeSharePoint:        func() SourceConfig { return new(SharePointSourceConnectorConfig) },
+	ConnectorTypeSlack:             func() SourceConfig { return new(SlackSourceConnectorConfig) },
+	ConnectorTypeSnowflake:         func() SourceConfig { return new(SnowflakeSourceConnectorConfig) },
+	ConnectorTypeZendesk:           func() SourceConfig { return new(ZendeskSourceConnectorConfig) },
 }
 
 // Source represents a source connector that ingests files or data from various locations.
diff --git a/source_connection_check.go b/source_connection_check.go
@@ -8,10 +8,10 @@ import (
 
 // CreateSourceConnectionCheck initiates a connection check for a source connector by its ID.
 // It returns a DagNodeConnectionCheck with the status of the check.
-func (c *Client) CreateSourceConnectionCheck(ctx context.Context, sourceID string) (*DagNodeConnectionCheck, error) {
+func (c *Client) CreateSourceConnectionCheck(ctx context.Context, id string) (*DagNodeConnectionCheck, error) {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodPost,
-		c.endpoint.JoinPath("/sources", sourceID, "connection-check").String(),
+		c.endpoint.JoinPath("/sources", id, "connection-check").String(),
 		nil,
 	)
 	if err != nil {
@@ -28,10 +28,10 @@ func (c *Client) CreateSourceConnectionCheck(ctx context.Context, sourceID strin
 
 // GetSourceConnectionCheck retrieves the status of a connection check for a source connector by its ID.
 // It returns a DagNodeConnectionCheck with the current status and reason if any.
-func (c *Client) GetSourceConnectionCheck(ctx context.Context, sourceID string) (*DagNodeConnectionCheck, error) {
+func (c *Client) GetSourceConnectionCheck(ctx context.Context, id string) (*DagNodeConnectionCheck, error) {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodGet,
-		c.endpoint.JoinPath("/sources", sourceID, "connection-check").String(),
+		c.endpoint.JoinPath("/sources", id, "connection-check").String(),
 		nil,
 	)
 	if err != nil {
diff --git a/source_delete.go b/source_delete.go
@@ -7,10 +7,10 @@ import (
 )
 
 // DeleteSource deletes a specific source connector identified by its ID
-func (c *Client) DeleteSource(ctx context.Context, sourceID string) error {
+func (c *Client) DeleteSource(ctx context.Context, id string) error {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodDelete,
-		c.endpoint.JoinPath("/sources", sourceID).String(),
+		c.endpoint.JoinPath("/sources", id).String(),
 		nil,
 	)
 	if err != nil {
diff --git a/source_get.go b/source_get.go
@@ -7,10 +7,10 @@ import (
 )
 
 // GetSource retrieves detailed information for a specific source connector by its ID
-func (c *Client) GetSource(ctx context.Context, sourceID string) (*Source, error) {
+func (c *Client) GetSource(ctx context.Context, id string) (*Source, error) {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodGet,
-		c.endpoint.JoinPath("/sources", sourceID).String(),
+		c.endpoint.JoinPath("/sources", id).String(),
 		nil,
 	)
 	if err != nil {
diff --git a/source_list.go b/source_list.go
@@ -7,7 +7,7 @@ import (
 )
 
 // ListSources retrieves a list of available source connectors
-func (c *Client) ListSources(ctx context.Context, sourceType *string) ([]Source, error) {
+func (c *Client) ListSources(ctx context.Context, typ string) ([]Source, error) {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodGet,
 		c.endpoint.JoinPath("/sources").String(),
@@ -17,9 +17,9 @@ func (c *Client) ListSources(ctx context.Context, sourceType *string) ([]Source,
 		return nil, fmt.Errorf("failed to create HTTP request: %w", err)
 	}
 
-	if sourceType != nil {
+	if typ != "" {
 		q := req.URL.Query()
-		q.Add("source_type", *sourceType)
+		q.Add("source_type", typ)
 		req.URL.RawQuery = q.Encode()
 	}
 
diff --git a/source_update.go b/source_update.go
@@ -10,31 +10,32 @@ import (
 
 // UpdateSourceRequest represents the request to update a source connector.
 type UpdateSourceRequest struct {
+	ID     string
 	Config SourceConfigInput
 }
 
 // UpdateSource updates the configuration of an existing source connector.
 // It returns the updated source connector.
-func (c *Client) UpdateSource(ctx context.Context, sourceID string, in UpdateSourceRequest) (*Source, error) {
+func (c *Client) UpdateSource(ctx context.Context, in UpdateSourceRequest) (*Source, error) {
 	config, err := json.Marshal(in.Config)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal config: %w", err)
 	}
 
-	shadow := struct {
+	wrapper := struct {
 		Config json.RawMessage `json:"config"`
 	}{
 		Config: json.RawMessage(config),
 	}
 
-	body, err := json.Marshal(shadow)
+	body, err := json.Marshal(wrapper)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal update request: %w", err)
 	}
 
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodPut,
-		c.endpoint.JoinPath("/sources", sourceID).String(),
+		c.endpoint.JoinPath("/sources", in.ID).String(),
 		bytes.NewReader(body),
 	)
 	if err != nil {
diff --git a/types.go b/types.go
@@ -1,11 +1,13 @@
 package unstructured
 
+import "time"
+
 // DagNodeConnectionCheck represents a connection check result for a DAG node (source or destination connector).
 type DagNodeConnectionCheck struct {
 	ID         string                `json:"id"`
 	Status     ConnectionCheckStatus `json:"status"`
 	Reason     *string               `json:"reason,omitempty"`
-	CreatedAt  string                `json:"created_at"`
+	CreatedAt  time.Time             `json:"created_at,omitempty"`
 	ReportedAt *string               `json:"reported_at,omitempty"`
 }
 
diff --git a/workflow.go b/workflow.go
@@ -1,8 +1,6 @@
 package unstructured
 
-import (
-	"time"
-)
+import "time"
 
 // Workflow represents a workflow, which defines a series of processing steps for data in Unstructured.io.
 // A workflow connects sources, destinations, and processing nodes.
diff --git a/workflow_create.go b/workflow_create.go
@@ -10,13 +10,13 @@ import (
 
 // CreateWorkflowRequest represents the request to create a workflow
 type CreateWorkflowRequest struct {
-	Name          string
-	SourceID      *string
-	DestinationID *string
-	WorkflowType  WorkflowType
-	WorkflowNodes []WorkflowNode
-	Schedule      *string
-	ReprocessAll  *bool
+	Name          string         `json:"name"`
+	SourceID      *string        `json:"source_id,omitempty"`
+	DestinationID *string        `json:"destination_id,omitempty"`
+	WorkflowType  WorkflowType   `json:"workflow_type"`
+	WorkflowNodes []WorkflowNode `json:"workflow_nodes,omitempty"`
+	Schedule      *string        `json:"schedule,omitempty"`
+	ReprocessAll  *bool          `json:"reprocess_all,omitempty"`
 }
 
 // CreateWorkflow creates a new workflow
diff --git a/workflow_delete.go b/workflow_delete.go
@@ -7,10 +7,10 @@ import (
 )
 
 // DeleteWorkflow deletes a workflow by its ID
-func (c *Client) DeleteWorkflow(ctx context.Context, workflowID string) error {
+func (c *Client) DeleteWorkflow(ctx context.Context, id string) error {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodDelete,
-		c.endpoint.JoinPath("/workflows", workflowID).String(),
+		c.endpoint.JoinPath("/workflows", id).String(),
 		nil,
 	)
 	if err != nil {
diff --git a/workflow_get.go b/workflow_get.go
@@ -7,10 +7,10 @@ import (
 )
 
 // GetWorkflow retrieves detailed information for a specific workflow by its ID
-func (c *Client) GetWorkflow(ctx context.Context, workflowID string) (*Workflow, error) {
+func (c *Client) GetWorkflow(ctx context.Context, id string) (*Workflow, error) {
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodGet,
-		c.endpoint.JoinPath("/workflows", workflowID).String(),
+		c.endpoint.JoinPath("/workflows", id).String(),
 		nil,
 	)
 	if err != nil {
diff --git a/workflow_run.go b/workflow_run.go
@@ -12,12 +12,12 @@ type RunWorkflowRequest struct {
 }
 
 // RunWorkflow runs a workflow by triggering a new job
-func (c *Client) RunWorkflow(ctx context.Context, workflowID string, _ *RunWorkflowRequest) (*Job, error) {
+func (c *Client) RunWorkflow(ctx context.Context, id string, _ *RunWorkflowRequest) (*Job, error) {
 	// For now, we'll implement a simple version without file uploads
 	// The actual implementation would need multipart form data handling
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodPost,
-		c.endpoint.JoinPath("/workflows", workflowID, "run").String(),
+		c.endpoint.JoinPath("/workflows", id, "run").String(),
 		nil,
 	)
 	if err != nil {
diff --git a/workflow_update.go b/workflow_update.go
@@ -10,26 +10,27 @@ import (
 
 // UpdateWorkflowRequest represents the request to update a workflow.
 type UpdateWorkflowRequest struct {
-	Name          *string
-	SourceID      *string
-	DestinationID *string
-	WorkflowType  *WorkflowType
-	WorkflowNodes []WorkflowNode
-	Schedule      *string
-	ReprocessAll  *bool
+	ID            string         `json:"-"`
+	Name          *string        `json:"name,omitempty"`
+	SourceID      *string        `json:"source_id,omitempty"`
+	DestinationID *string        `json:"destination_id,omitempty"`
+	WorkflowType  *WorkflowType  `json:"workflow_type,omitempty"`
+	WorkflowNodes []WorkflowNode `json:"workflow_nodes,omitempty"`
+	Schedule      *string        `json:"schedule,omitempty"`
+	ReprocessAll  *bool          `json:"reprocess_all,omitempty"`
 }
 
 // UpdateWorkflow updates the configuration of an existing workflow.
 // It returns the updated workflow.
-func (c *Client) UpdateWorkflow(ctx context.Context, workflowID string, in UpdateWorkflowRequest) (*Workflow, error) {
+func (c *Client) UpdateWorkflow(ctx context.Context, in UpdateWorkflowRequest) (*Workflow, error) {
 	body, err := json.Marshal(in)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal workflow update request: %w", err)
 	}
 
 	req, err := http.NewRequestWithContext(ctx,
 		http.MethodPut,
-		c.endpoint.JoinPath("/workflows", workflowID).String(),
+		c.endpoint.JoinPath("/workflows", in.ID).String(),
 		bytes.NewReader(body),
 	)
 	if err != nil {

Original file line number	Diff line number	Diff line change
`@@ -22,13 +22,13 @@ func (c *Client) UpdateDestination(ctx context.Context, in UpdateDestinationRequ`
`22`	`22`	`return nil, fmt.Errorf("failed to marshal config: %w", err)`
`23`	`23`	`}`
`24`	`24`
`25`		`- shadow := struct {`
	`25`	`+ wrapper := struct {`
`26`	`26`	Config json.RawMessage `json:"config"`
`27`	`27`	`}{`
`28`	`28`	`Config: json.RawMessage(config),`
`29`	`29`	`}`
`30`	`30`
`31`		`- body, err := json.Marshal(shadow)`
	`31`	`+ body, err := json.Marshal(wrapper)`
`32`	`32`	`if err != nil {`
`33`	`33`	`return nil, fmt.Errorf("failed to marshal update request: %w", err)`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ import (`
`7`	`7`	`)`
`8`	`8`
`9`	`9`	`// CancelJob cancels a running job by its ID`
`10`		`-func (c *Client) CancelJob(ctx context.Context, jobID string) error {`
	`10`	`+func (c *Client) CancelJob(ctx context.Context, id string) error {`
`11`	`11`	`req, err := http.NewRequestWithContext(ctx,`
`12`	`12`	`http.MethodPost,`
`13`		`- c.endpoint.JoinPath("/jobs", jobID, "cancel").String(),`
	`13`	`+ c.endpoint.JoinPath("/jobs", id, "cancel").String(),`
`14`	`14`	`nil,`
`15`	`15`	`)`
`16`	`16`	`if err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,10 @@ import (`
`8`	`8`	`)`
`9`	`9`
`10`	`10`	`// DownloadJob downloads the output files from a completed job`
`11`		`-func (c *Client) DownloadJob(ctx context.Context, jobID string) (io.ReadCloser, error) {`
	`11`	`+func (c *Client) DownloadJob(ctx context.Context, id string) (io.ReadCloser, error) {`
`12`	`12`	`req, err := http.NewRequestWithContext(ctx,`
`13`	`13`	`http.MethodGet,`
`14`		`- c.endpoint.JoinPath("/jobs", jobID, "download").String(),`
	`14`	`+ c.endpoint.JoinPath("/jobs", id, "download").String(),`
`15`	`15`	`nil,`
`16`	`16`	`)`
`17`	`17`	`if err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -8,20 +8,20 @@ import (`
`8`	`8`
`9`	`9`	`// GetJobFailedFiles retrieves the list of failed files for a specific job by its ID.`
`10`	`10`	`// It returns a JobFailedFiles struct containing the failed files and error messages.`
`11`		`-func (c Client) GetJobFailedFiles(ctx context.Context, jobID string) (JobFailedFiles, error) {`
	`11`	`+func (c Client) GetJobFailedFiles(ctx context.Context, id string) (JobFailedFiles, error) {`
`12`	`12`	`req, err := http.NewRequestWithContext(ctx,`
`13`	`13`	`http.MethodGet,`
`14`		`- c.endpoint.JoinPath("/jobs", jobID, "failed-files").String(),`
	`14`	`+ c.endpoint.JoinPath("/jobs", id, "failed-files").String(),`
`15`	`15`	`nil,`
`16`	`16`	`)`
`17`	`17`	`if err != nil {`
`18`	`18`	`return nil, fmt.Errorf("failed to create HTTP request: %w", err)`
`19`	`19`	`}`
`20`	`20`
`21`		`- var failedFiles JobFailedFiles`
`22`		`- if err := c.do(req, &failedFiles); err != nil {`
	`21`	`+ var failed JobFailedFiles`
	`22`	`+ if err := c.do(req, &failed); err != nil {`
`23`	`23`	`return nil, fmt.Errorf("failed to get job failed files: %w", err)`
`24`	`24`	`}`
`25`	`25`
`26`		`- return &failedFiles, nil`
	`26`	`+ return &failed, nil`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ import (`
`7`	`7`	`)`
`8`	`8`
`9`	`9`	`// GetJob retrieves detailed information for a specific job by its ID`
`10`		`-func (c Client) GetJob(ctx context.Context, jobID string) (Job, error) {`
	`10`	`+func (c Client) GetJob(ctx context.Context, id string) (Job, error) {`
`11`	`11`	`req, err := http.NewRequestWithContext(ctx,`
`12`	`12`	`http.MethodGet,`
`13`		`- c.endpoint.JoinPath("/jobs", jobID).String(),`
	`13`	`+ c.endpoint.JoinPath("/jobs", id).String(),`
`14`	`14`	`nil,`
`15`	`15`	`)`
`16`	`16`	`if err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ import (`
`7`	`7`	`)`
`8`	`8`
`9`	`9`	`// DeleteSource deletes a specific source connector identified by its ID`
`10`		`-func (c *Client) DeleteSource(ctx context.Context, sourceID string) error {`
	`10`	`+func (c *Client) DeleteSource(ctx context.Context, id string) error {`
`11`	`11`	`req, err := http.NewRequestWithContext(ctx,`
`12`	`12`	`http.MethodDelete,`
`13`		`- c.endpoint.JoinPath("/sources", sourceID).String(),`
	`13`	`+ c.endpoint.JoinPath("/sources", id).String(),`
`14`	`14`	`nil,`
`15`	`15`	`)`
`16`	`16`	`if err != nil {`