AWS.DataZone reference

AcceptPredictions

Source: src/AWS/DataZone/AcceptPredictions.ts

Runtime binding for datazone:AcceptPredictions.

Accepts ML-generated metadata predictions (business-name suggestions) on an asset in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.AcceptPredictionsHttp).

AcceptPredictions: Publishing Assets

// init — bind the operation to the domain
const acceptPredictions = yield* AWS.DataZone.AcceptPredictions(domain);

// runtime
yield* acceptPredictions({ identifier: assetId, acceptRule: { rule: "ALL" } });

AcceptSubscriptionRequest

Source: src/AWS/DataZone/AcceptSubscriptionRequest.ts

Runtime binding for datazone:AcceptSubscriptionRequest.

Approves a pending subscription request in the bound domain — the core of an automated approval workflow. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.AcceptSubscriptionRequestHttp).

AcceptSubscriptionRequest: Subscription Workflows

// init — bind the operation to the domain
const acceptSubscriptionRequest = yield* AWS.DataZone.AcceptSubscriptionRequest(domain);

// runtime
yield* acceptSubscriptionRequest({ identifier: requestId, decisionComment: "auto-approved" });

CancelSubscription

Source: src/AWS/DataZone/CancelSubscription.ts

Runtime binding for datazone:CancelSubscription.

Cancels a subscription in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.CancelSubscriptionHttp).

CancelSubscription: Subscription Workflows

// init — bind the operation to the domain
const cancelSubscription = yield* AWS.DataZone.CancelSubscription(domain);

// runtime
yield* cancelSubscription({ identifier: subscriptionId });

CreateAsset

Source: src/AWS/DataZone/CreateAsset.ts

Runtime binding for datazone:CreateAsset.

Creates an asset in the bound domain’s inventory, e.g. to register data produced by the function itself. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.CreateAssetHttp).

CreateAsset: Publishing Assets

// init — bind the operation to the domain
const createAsset = yield* AWS.DataZone.CreateAsset(domain);

// runtime
const asset = yield* createAsset({
  name: "daily-orders",
  typeIdentifier: "amazon.datazone.S3ObjectCollectionAssetType",
  owningProjectIdentifier: projectId,
});

CreateAssetRevision

Source: src/AWS/DataZone/CreateAssetRevision.ts

Runtime binding for datazone:CreateAssetRevision.

Creates a new revision of an existing asset in the bound domain, e.g. after a schema change. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.CreateAssetRevisionHttp).

CreateAssetRevision: Publishing Assets

// init — bind the operation to the domain
const createAssetRevision = yield* AWS.DataZone.CreateAssetRevision(domain);

// runtime
yield* createAssetRevision({ identifier: assetId, name: "daily-orders" });

CreateSubscriptionRequest

Source: src/AWS/DataZone/CreateSubscriptionRequest.ts

Runtime binding for datazone:CreateSubscriptionRequest.

Requests a subscription to a published listing in the bound domain on behalf of a project. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.CreateSubscriptionRequestHttp).

CreateSubscriptionRequest: Subscription Workflows

// init — bind the operation to the domain
const createSubscriptionRequest = yield* AWS.DataZone.CreateSubscriptionRequest(domain);

// runtime
yield* createSubscriptionRequest({
  subscribedPrincipals: [{ project: { identifier: projectId } }],
  subscribedListings: [{ identifier: listingId }],
  requestReason: "nightly enrichment job needs read access",
});

Domain

Source: src/AWS/DataZone/Domain.ts

An Amazon DataZone domain — the top-level container for data-governance projects, environments, glossaries, and assets.

Domain owns the domain lifecycle. Domain creation is asynchronous (typically 1–2 minutes) and is polled to AVAILABLE with a bounded wait. An execution role is created automatically (trusted by datazone.amazonaws.com, with the AmazonDataZoneDomainExecutionRolePolicy managed policy) unless an explicit domainExecutionRole is supplied.

Domain: Creating Domains

Minimal Domain

import * as DataZone from "alchemy/AWS/DataZone";

const domain = yield* DataZone.Domain("governance", {
  description: "Company-wide data governance domain",
});

Domain with an Explicit Execution Role

const domain = yield* DataZone.Domain("governance", {
  name: "acme-governance",
  domainExecutionRole: role.roleArn,
  tags: { Team: "data-platform" },
});

Domain: Using the Domain

const project = yield* DataZone.Project("analytics", {
  domainId: domain.domainId,
  description: "Analytics team project",
});

Environment

Source: src/AWS/DataZone/Environment.ts

An Amazon DataZone environment — the provisioned collection of AWS resources (Glue databases, IAM roles, Athena workgroups, …) a project works with, deployed from an environment blueprint via CloudFormation.

Environment deployment is asynchronous (minutes — DataZone drives a CloudFormation stack) and is polled to ACTIVE with a bounded wait. The environment’s blueprint must be configured in the domain first (see EnvironmentBlueprintConfiguration).

Environment: Creating Environments

Environment from a Profile (V1 Domains)

import * as DataZone from "alchemy/AWS/DataZone";

const env = yield* DataZone.Environment("datalake-env", {
  domainId: domain.domainId,
  projectId: project.projectId,
  environmentProfileId: profileId,
});

Environment with Provisioning Parameters

const env = yield* DataZone.Environment("datalake-env", {
  domainId: domain.domainId,
  projectId: project.projectId,
  environmentProfileId: profileId,
  description: "Analytics data lake environment",
  userParameters: [
    { name: "glueDbName", value: "analytics_db" },
  ],
});

EnvironmentBlueprintConfiguration

Source: src/AWS/DataZone/EnvironmentBlueprintConfiguration.ts

The account/domain configuration of an Amazon DataZone environment blueprint — enables a managed blueprint (like DefaultDataLake) in specific regions with the IAM roles DataZone should provision with.

The blueprint itself is an AWS-managed definition; this resource owns only its per-domain configuration (a PUT-style singleton keyed by domain + blueprint).

EnvironmentBlueprintConfiguration: Configuring Blueprints

Enable the DefaultDataLake Blueprint

import * as DataZone from "alchemy/AWS/DataZone";

const config = yield* DataZone.EnvironmentBlueprintConfiguration(
  "datalake",
  {
    domainId: domain.domainId,
    environmentBlueprint: "DefaultDataLake",
    enabledRegions: ["us-west-2"],
    provisioningRoleArn: provisioningRole.roleArn,
    manageAccessRoleArn: manageAccessRole.roleArn,
    regionalParameters: {
      "us-west-2": { S3Location: "s3://my-datalake-bucket" },
    },
  },
);

Blueprint with Lake Formation Provisioning

const config = yield* DataZone.EnvironmentBlueprintConfiguration(
  "datalake",
  {
    domainId: domain.domainId,
    environmentBlueprint: "DefaultDataLake",
    enabledRegions: ["us-west-2"],
    provisioningRoleArn: provisioningRole.roleArn,
    provisioningConfigurations: [
      {
        lakeFormationConfiguration: {
          locationRegistrationRole: registrationRole.roleArn,
        },
      },
    ],
  },
);

GetAsset

Source: src/AWS/DataZone/GetAsset.ts

Runtime binding for datazone:GetAsset.

Reads an asset in the bound domain — its forms, glossary terms, and latest revision. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetAssetHttp).

GetAsset: Searching the Catalog

// init — bind the operation to the domain
const getAsset = yield* AWS.DataZone.GetAsset(domain);

// runtime
const asset = yield* getAsset({ identifier: assetId });

GetDataSourceRun

Source: src/AWS/DataZone/GetDataSourceRun.ts

Runtime binding for datazone:GetDataSourceRun.

Reads the status of a data source run in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetDataSourceRunHttp).

GetDataSourceRun: Data Source Runs

// init — bind the operation to the domain
const getDataSourceRun = yield* AWS.DataZone.GetDataSourceRun(domain);

// runtime
const run = yield* getDataSourceRun({ identifier: runId });
if (run.status === "FAILED") { yield* Effect.logError(run.errorMessage); }

GetEnvironmentCredentials

Source: src/AWS/DataZone/GetEnvironmentCredentials.ts

Runtime binding for datazone:GetEnvironmentCredentials.

Fetches the short-lived AWS credentials of the bound environment’s provisioned user role. The secretAccessKey and sessionToken are Redacted — unwrap with Redacted.value only at the point of use. The domain and environment ids are injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetEnvironmentCredentialsHttp).

GetEnvironmentCredentials: Environment Credentials

// init — bind the operation to the environment
const getEnvironmentCredentials = yield* AWS.DataZone.GetEnvironmentCredentials(environment);

// runtime
const creds = yield* getEnvironmentCredentials();
const secret = Redacted.value(creds.secretAccessKey!);

GetIamPortalLoginUrl

Source: src/AWS/DataZone/GetIamPortalLoginUrl.ts

Runtime binding for datazone:GetIamPortalLoginUrl.

Mints a single-use data portal sign-in URL for the bound domain, e.g. to embed in a notification. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetIamPortalLoginUrlHttp).

GetIamPortalLoginUrl: Portal, Profiles & Notifications

// init — bind the operation to the domain
const getIamPortalLoginUrl = yield* AWS.DataZone.GetIamPortalLoginUrl(domain);

// runtime
const { authCodeUrl } = yield* getIamPortalLoginUrl();

GetLineageNode

Source: src/AWS/DataZone/GetLineageNode.ts

Runtime binding for datazone:GetLineageNode.

Reads a data lineage node in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetLineageNodeHttp).

GetLineageNode: Data Lineage

// init — bind the operation to the domain
const getLineageNode = yield* AWS.DataZone.GetLineageNode(domain);

// runtime
const node = yield* getLineageNode({ identifier: nodeId });

GetListing

Source: src/AWS/DataZone/GetListing.ts

Runtime binding for datazone:GetListing.

Reads a published listing in the bound domain by id. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetListingHttp).

GetListing: Searching the Catalog

// init — bind the operation to the domain
const getListing = yield* AWS.DataZone.GetListing(domain);

// runtime
const listing = yield* getListing({ identifier: listingId });

GetMetadataGenerationRun

Source: src/AWS/DataZone/GetMetadataGenerationRun.ts

Runtime binding for datazone:GetMetadataGenerationRun.

Reads the status of a metadata generation run in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetMetadataGenerationRunHttp).

GetMetadataGenerationRun: Metadata Generation

// init — bind the operation to the domain
const getMetadataGenerationRun = yield* AWS.DataZone.GetMetadataGenerationRun(domain);

// runtime
const run = yield* getMetadataGenerationRun({ identifier: runId });

GetSubscription

Source: src/AWS/DataZone/GetSubscription.ts

Runtime binding for datazone:GetSubscription.

Reads a subscription in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetSubscriptionHttp).

GetSubscription: Subscription Workflows

// init — bind the operation to the domain
const getSubscription = yield* AWS.DataZone.GetSubscription(domain);

// runtime
const sub = yield* getSubscription({ identifier: subscriptionId });

GetTimeSeriesDataPoint

Source: src/AWS/DataZone/GetTimeSeriesDataPoint.ts

Runtime binding for datazone:GetTimeSeriesDataPoint.

Reads a single time series data point on an asset or listing in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetTimeSeriesDataPointHttp).

GetTimeSeriesDataPoint: Time Series Metadata

// init — bind the operation to the domain
const getTimeSeriesDataPoint = yield* AWS.DataZone.GetTimeSeriesDataPoint(domain);

// runtime
const point = yield* getTimeSeriesDataPoint({
  entityIdentifier: assetId,
  entityType: "ASSET",
  formName: "quality",
  identifier: dataPointId,
});

GetUserProfile

Source: src/AWS/DataZone/GetUserProfile.ts

Runtime binding for datazone:GetUserProfile.

Reads a user profile in the bound domain — e.g. to resolve the requester of a subscription request. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.GetUserProfileHttp).

GetUserProfile: Portal, Profiles & Notifications

// init — bind the operation to the domain
const getUserProfile = yield* AWS.DataZone.GetUserProfile(domain);

// runtime
const profile = yield* getUserProfile({ userIdentifier: userId });

ListDataSourceRuns

Source: src/AWS/DataZone/ListDataSourceRuns.ts

Runtime binding for datazone:ListDataSourceRuns.

Lists the runs of a data source in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.ListDataSourceRunsHttp).

ListDataSourceRuns: Data Source Runs

// init — bind the operation to the domain
const listDataSourceRuns = yield* AWS.DataZone.ListDataSourceRuns(domain);

// runtime
const runs = yield* listDataSourceRuns({ dataSourceIdentifier: dataSourceId });

ListNotifications

Source: src/AWS/DataZone/ListNotifications.ts

Runtime binding for datazone:ListNotifications.

Lists task or event notifications for the calling user in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.ListNotificationsHttp).

ListNotifications: Portal, Profiles & Notifications

// init — bind the operation to the domain
const listNotifications = yield* AWS.DataZone.ListNotifications(domain);

// runtime
const tasks = yield* listNotifications({ type: "TASK", taskStatus: "ACTIVE" });

ListSubscriptionRequests

Source: src/AWS/DataZone/ListSubscriptionRequests.ts

Runtime binding for datazone:ListSubscriptionRequests.

Lists subscription requests in the bound domain, optionally by status — e.g. the PENDING queue an approval bot works through. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.ListSubscriptionRequestsHttp).

ListSubscriptionRequests: Subscription Workflows

// init — bind the operation to the domain
const listSubscriptionRequests = yield* AWS.DataZone.ListSubscriptionRequests(domain);

// runtime
const pending = yield* listSubscriptionRequests({ status: "PENDING" });

ListSubscriptions

Source: src/AWS/DataZone/ListSubscriptions.ts

Runtime binding for datazone:ListSubscriptions.

Lists subscriptions in the bound domain, optionally by status. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.ListSubscriptionsHttp).

ListSubscriptions: Subscription Workflows

// init — bind the operation to the domain
const listSubscriptions = yield* AWS.DataZone.ListSubscriptions(domain);

// runtime
const subs = yield* listSubscriptions({ status: "APPROVED" });

ListTimeSeriesDataPoints

Source: src/AWS/DataZone/ListTimeSeriesDataPoints.ts

Runtime binding for datazone:ListTimeSeriesDataPoints.

Lists time series data points recorded on an asset or listing in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.ListTimeSeriesDataPointsHttp).

ListTimeSeriesDataPoints: Time Series Metadata

// init — bind the operation to the domain
const listTimeSeriesDataPoints = yield* AWS.DataZone.ListTimeSeriesDataPoints(domain);

// runtime
const points = yield* listTimeSeriesDataPoints({
  entityIdentifier: assetId,
  entityType: "ASSET",
  formName: "quality",
});

PostLineageEvent

Source: src/AWS/DataZone/PostLineageEvent.ts

Runtime binding for datazone:PostLineageEvent.

Posts an OpenLineage run event to the bound domain, recording the lineage of a data transformation the function performed. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.PostLineageEventHttp).

PostLineageEvent: Data Lineage

// init — bind the operation to the domain
const postLineageEvent = yield* AWS.DataZone.PostLineageEvent(domain);

// runtime
yield* postLineageEvent({ event: JSON.stringify(openLineageRunEvent) });

PostTimeSeriesDataPoints

Source: src/AWS/DataZone/PostTimeSeriesDataPoints.ts

Runtime binding for datazone:PostTimeSeriesDataPoints.

Posts time series data points (e.g. data-quality metrics) onto an asset or listing in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.PostTimeSeriesDataPointsHttp).

PostTimeSeriesDataPoints: Time Series Metadata

// init — bind the operation to the domain
const postTimeSeriesDataPoints = yield* AWS.DataZone.PostTimeSeriesDataPoints(domain);

// runtime
yield* postTimeSeriesDataPoints({
  entityIdentifier: assetId,
  entityType: "ASSET",
  forms: [{ formName: "quality", typeIdentifier: "amazon.datazone.DataQualityResultFormType", content: "{}", timestamp: new Date() }],
});

Project

Source: src/AWS/DataZone/Project.ts

An Amazon DataZone project — the collaboration space within a domain where teams catalog, publish, and subscribe to data assets.

The creating principal is automatically the project owner. DataZone projects do not support resource tags, so ownership is tracked purely by identity.

Project: Creating Projects

Minimal Project

import * as DataZone from "alchemy/AWS/DataZone";

const domain = yield* DataZone.Domain("governance", {});

const project = yield* DataZone.Project("analytics", {
  domainId: domain.domainId,
  description: "Analytics team project",
});

Project with an Explicit Name

const project = yield* DataZone.Project("analytics", {
  domainId: domain.domainId,
  name: "analytics-team",
  glossaryTerms: [term.id],
});

RejectPredictions

Source: src/AWS/DataZone/RejectPredictions.ts

Runtime binding for datazone:RejectPredictions.

Rejects ML-generated metadata predictions on an asset in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.RejectPredictionsHttp).

RejectPredictions: Publishing Assets

// init — bind the operation to the domain
const rejectPredictions = yield* AWS.DataZone.RejectPredictions(domain);

// runtime
yield* rejectPredictions({ identifier: assetId, rejectRule: { rule: "ALL" } });

RejectSubscriptionRequest

Source: src/AWS/DataZone/RejectSubscriptionRequest.ts

Runtime binding for datazone:RejectSubscriptionRequest.

Rejects a pending subscription request in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.RejectSubscriptionRequestHttp).

RejectSubscriptionRequest: Subscription Workflows

// init — bind the operation to the domain
const rejectSubscriptionRequest = yield* AWS.DataZone.RejectSubscriptionRequest(domain);

// runtime
yield* rejectSubscriptionRequest({ identifier: requestId, decisionComment: "PII policy" });

RevokeSubscription

Source: src/AWS/DataZone/RevokeSubscription.ts

Runtime binding for datazone:RevokeSubscription.

Revokes an approved subscription in the bound domain, optionally retaining already-granted permissions. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.RevokeSubscriptionHttp).

RevokeSubscription: Subscription Workflows

// init — bind the operation to the domain
const revokeSubscription = yield* AWS.DataZone.RevokeSubscription(domain);

// runtime
yield* revokeSubscription({ identifier: subscriptionId, retainPermissions: false });

Search

Source: src/AWS/DataZone/Search.ts

Runtime binding for datazone:Search.

Searches the bound domain’s inventory — assets, glossaries, and data products visible to the calling project. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.SearchHttp).

Search: Searching the Catalog

// init — bind the operation to the domain
const search = yield* AWS.DataZone.Search(domain);

// runtime
const result = yield* search({ searchScope: "ASSET", searchText: "orders" });
const names = result.items?.map((i) => i.assetItem?.name);

SearchListings

Source: src/AWS/DataZone/SearchListings.ts

Runtime binding for datazone:SearchListings.

Searches published listings (the catalog of subscribable assets and data products) in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.SearchListingsHttp).

SearchListings: Searching the Catalog

// init — bind the operation to the domain
const searchListings = yield* AWS.DataZone.SearchListings(domain);

// runtime
const result = yield* searchListings({ searchText: "customer" });
const listings = result.items?.map((i) => i.assetListing?.name);

SearchTypes

Source: src/AWS/DataZone/SearchTypes.ts

Runtime binding for datazone:SearchTypes.

Searches asset types and form types registered in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.SearchTypesHttp).

SearchTypes: Searching the Catalog

// init — bind the operation to the domain
const searchTypes = yield* AWS.DataZone.SearchTypes(domain);

// runtime
const result = yield* searchTypes({ searchScope: "ASSET_TYPE", managed: true });

StartDataSourceRun

Source: src/AWS/DataZone/StartDataSourceRun.ts

Runtime binding for datazone:StartDataSourceRun.

Triggers an on-demand run of a data source in the bound domain, ingesting new technical assets into the inventory. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.StartDataSourceRunHttp).

StartDataSourceRun: Data Source Runs

// init — bind the operation to the domain
const startDataSourceRun = yield* AWS.DataZone.StartDataSourceRun(domain);

// runtime
const run = yield* startDataSourceRun({ dataSourceIdentifier: dataSourceId });

StartMetadataGenerationRun

Source: src/AWS/DataZone/StartMetadataGenerationRun.ts

Runtime binding for datazone:StartMetadataGenerationRun.

Starts an ML metadata generation run (business description suggestions) for an asset in the bound domain. The domain id is injected from the binding. Provide the implementation with Effect.provide(AWS.DataZone.StartMetadataGenerationRunHttp).

StartMetadataGenerationRun: Metadata Generation

// init — bind the operation to the domain
const startMetadataGenerationRun = yield* AWS.DataZone.StartMetadataGenerationRun(domain);

// runtime
const run = yield* startMetadataGenerationRun({
  types: ["BUSINESS_DESCRIPTIONS"],
  target: { type: "ASSET", identifier: assetId },
  owningProjectIdentifier: projectId,
});