@api-client/core 0.12.3 → 0.12.4

package/src/models/DataCatalogVersion.ts

@@ -0,0 +1,235 @@
+import { DataCatalogScope } from './DataCatalog.js'
+import { DataCatalogVersionKind } from './kinds.js'
+
+export type DataCatalogLifecycle = 'stable' | 'beta' | 'dev'
+
+export interface DataCatalogVersionSchema {
+  /**
+   * The key of the version.
+   *
+   * The key can only be set when creating a new data catalog entry.
+   * @readonly
+   */
+  key: string
+  /**
+   * The kind of the schema
+   */
+  readonly kind: typeof DataCatalogVersionKind
+  /**
+   * The key of the parent data catalog entry.
+   * It is only populated by the API when creating the version.
+   * @readonly
+   */
+  catalogKey: string
+  /**
+   * The publication scope of the data catalog entry.
+   *
+   * When the scope is set to a different value than the one of the parent data catalog entry,
+   * then this value is used to determine the visibility of the data catalog entry. However,
+   * the reader cannot access the version with a "public" scope if the parent data catalog entry is private.
+   *
+   * @required
+   */
+  scope: DataCatalogScope
+  /**
+   * The lifecycle of the data catalog entry.
+   *
+   * - `stable`: The data catalog entry is stable and can be used in production.
+   * - `beta`: The data catalog entry is in beta and may change in the future.
+   * - `dev`: The data catalog entry is in development and likely will change in the future.
+   *
+   * The lifecycle is a readonly property and is set by the API when creating or updating the data catalog entry.
+   * A version is immutable and to change the lifecycle, a new version must be created.
+   *
+   * @required
+   */
+  lifecycle: DataCatalogLifecycle
+  /**
+   * The version string according to the [semantic versioning](https://semver.org/) specification.
+   * Note, this value is limited to 32 characters by the API.
+   * @required
+   */
+  version: string
+  /**
+   * The id of the user who created the version.
+   * It is ignored when creating or updating a data catalog entry.
+   * @readonly
+   */
+  publishedBy: string
+  /**
+   * The timestamp when this version was unpublished.
+   * Only set when the version was unpublished.
+   * @readonly
+   */
+  unpublishedAt?: number
+  /**
+   * A flag indicating if the version is deprecated.
+   * @readonly
+   */
+  deprecated?: boolean
+  /**
+   * The timestamp when the version was deprecated.
+   * Only set when the version was deprecated.
+   * @readonly
+   */
+  deprecatedAt?: number
+  /**
+   * The id of the user who deprecated the version.
+   * Only set when the version was deprecated.
+   * @readonly
+   */
+  deprecatedBy?: string
+  /**
+   * The reason why the version was deprecated.
+   * Only set when the version was deprecated.
+   */
+  deprecationReason?: string
+  /**
+   * The timestamp when the data catalog entry was created.
+   * It is ignored when creating or updating a data catalog entry.
+   * @readonly
+   */
+  createdAt: number
+  /**
+   * The timestamp when the data catalog entry was last updated.
+   * It is ignored when creating or updating a data catalog entry.
+   * @readonly
+   */
+  updatedAt: number
+  /**
+   * The changelog of the data catalog entry.
+   * Note, this value is required by the API when creating the version.
+   */
+  changelog?: string
+}
+
+export class DataCatalogVersion implements DataCatalogVersionSchema {
+  key: string
+
+  get kind(): typeof DataCatalogVersionKind {
+    return DataCatalogVersionKind
+  }
+
+  catalogKey: string
+  scope: DataCatalogScope
+  lifecycle: DataCatalogLifecycle
+  version: string
+  publishedBy: string
+  unpublishedAt?: number | undefined
+  deprecated?: boolean | undefined
+  deprecatedAt?: number | undefined
+  deprecatedBy?: string | undefined
+  deprecationReason?: string | undefined
+  createdAt: number
+  updatedAt: number
+  changelog?: string | undefined
+
+  static createSchema(input: Partial<DataCatalogVersionSchema>): DataCatalogVersionSchema {
+    const {
+      key = '',
+      scope = 'private',
+      publishedBy = '',
+      createdAt = 0,
+      updatedAt = 0,
+      catalogKey = '',
+      lifecycle = 'stable',
+      version = '',
+    } = input
+    if (['public', 'private', 'organization'].indexOf(scope) === -1) {
+      throw new Error(`Invalid scope: ${scope}`)
+    }
+    const result: DataCatalogVersionSchema = {
+      key,
+      kind: DataCatalogVersionKind,
+      scope,
+      publishedBy,
+      createdAt,
+      updatedAt,
+      catalogKey,
+      lifecycle,
+      version,
+    }
+    if (typeof input.deprecated === 'boolean') {
+      result.deprecated = input.deprecated
+    }
+    if (typeof input.deprecatedAt === 'number') {
+      result.deprecatedAt = input.deprecatedAt
+    }
+    if (typeof input.deprecatedBy === 'string') {
+      result.deprecatedBy = input.deprecatedBy
+    }
+    if (typeof input.changelog === 'string') {
+      result.changelog = input.changelog
+    }
+    if (typeof input.deprecationReason === 'string') {
+      result.deprecationReason = input.deprecationReason
+    }
+    if (typeof input.unpublishedAt === 'number') {
+      result.unpublishedAt = input.unpublishedAt
+    }
+    return result
+  }
+
+  constructor(input: Partial<DataCatalogVersionSchema> = {}) {
+    const init = DataCatalogVersion.createSchema(input)
+    this.key = init.key
+    this.catalogKey = init.catalogKey
+    this.lifecycle = init.lifecycle
+    this.scope = init.scope
+    this.version = init.version
+    this.publishedBy = init.publishedBy
+    this.createdAt = init.createdAt
+    this.updatedAt = init.updatedAt
+    if (typeof init.changelog === 'string') {
+      this.changelog = init.changelog
+    }
+    if (typeof init.deprecated === 'boolean') {
+      this.deprecated = init.deprecated
+    }
+    if (typeof init.deprecatedAt === 'number') {
+      this.deprecatedAt = init.deprecatedAt
+    }
+    if (typeof init.deprecatedBy === 'string') {
+      this.deprecatedBy = init.deprecatedBy
+    }
+    if (typeof init.deprecationReason === 'string') {
+      this.deprecationReason = init.deprecationReason
+    }
+    if (typeof init.unpublishedAt === 'number') {
+      this.unpublishedAt = init.unpublishedAt
+    }
+  }
+
+  toJSON(): DataCatalogVersionSchema {
+    const result: DataCatalogVersionSchema = {
+      key: this.key,
+      kind: DataCatalogVersionKind,
+      scope: this.scope,
+      publishedBy: this.publishedBy,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      catalogKey: this.catalogKey,
+      lifecycle: this.lifecycle,
+      version: this.version,
+    }
+    if (typeof this.deprecated === 'boolean') {
+      result.deprecated = this.deprecated
+    }
+    if (typeof this.deprecatedAt === 'number') {
+      result.deprecatedAt = this.deprecatedAt
+    }
+    if (typeof this.deprecatedBy === 'string') {
+      result.deprecatedBy = this.deprecatedBy
+    }
+    if (typeof this.deprecationReason === 'string') {
+      result.deprecationReason = this.deprecationReason
+    }
+    if (typeof this.unpublishedAt === 'number') {
+      result.unpublishedAt = this.unpublishedAt
+    }
+    if (typeof this.changelog === 'string' && this.changelog) {
+      result.changelog = this.changelog
+    }
+    return result
+  }
+}

package/src/models/kinds.ts

@@ -16,6 +16,8 @@ export const DomainModelKind = 'Domain#Model'
 export const DomainEntityKind = 'Domain#Entity'
 export const DomainAssociationKind = 'Domain#Association'
 export const DomainPropertyKind = 'Domain#Property'
+export const DataCatalogKind = 'Core#DataCatalog'
+export const DataCatalogVersionKind = 'Core#DataCatalogVersion'
 
 /**
  * @deprecated Not used anymore.

package/src/runtime/store/DataCatalogSdk.ts

@@ -0,0 +1,473 @@
+import {
+  SdkBase,
+  E_RESPONSE_STATUS,
+  E_RESPONSE_NO_VALUE,
+  E_INVALID_JSON,
+  E_RESPONSE_UNKNOWN,
+  SdkOptions,
+} from './SdkBase.js'
+import { ContextListResult, ContextListOptions, ContextChangeRecord } from '../../events/BaseEvents.js'
+import type {
+  DataCatalogSchema,
+  DataCatalogSchemaWithVersion,
+  DataCatalogScope,
+  DataCatalogStatus,
+} from '../../models/DataCatalog.js'
+import { RouteBuilder } from './RouteBuilder.js'
+import { SdkError } from './Errors.js'
+import { DataCatalogKind, DataCatalogVersionKind } from '../../models/kinds.js'
+import type { DataCatalogVersionSchema } from '../../models/DataCatalogVersion.js'
+import type { ForeignDomainDependency } from '../../modeling/types.js'
+import type { DataDomainSchema } from '../../modeling/DataDomain.js'
+
+export interface DataCatalogListOptions extends ContextListOptions {
+  scope?: DataCatalogScope
+}
+
+export class DataCatalogSdk extends SdkBase {
+  async list(
+    options: DataCatalogListOptions = {},
+    request: SdkOptions = {}
+  ): Promise<ContextListResult<DataCatalogSchemaWithVersion>> {
+    const { token } = request
+    const opts = { ...options }
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalog())
+    this.sdk.appendListOptions(url, opts)
+    if (opts.scope) {
+      url.searchParams.set('scope', opts.scope)
+    }
+    const result = await this.sdk.http.get(url.toString(), { token })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to list data domains. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+
+    let data: ContextListResult<DataCatalogSchemaWithVersion>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (!Array.isArray(data.items)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  async listVersions(
+    key: string,
+    request: SdkOptions = {}
+  ): Promise<ContextListResult<{ key: string; version: string; published: number }>> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogEntryVersions(key))
+    const result = await this.sdk.http.get(url.toString(), { token })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to list data domain versions. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: ContextListResult<{ key: string; version: string; published: number }>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (!Array.isArray(data.items)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  /**
+   * Publishes a new data catalog entry.
+   * To publish a version, use the `publishVersion` method.
+   * @param entry The data catalog entry to publish.
+   * @returns The created data catalog entry.
+   */
+  async publish(entry: DataCatalogSchema, request: SdkOptions = {}): Promise<ContextChangeRecord<DataCatalogSchema>> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalog())
+    const body = JSON.stringify(entry)
+    const result = await this.sdk.http.post(url.toString(), {
+      token,
+      body,
+      headers: {
+        'content-type': 'application/json',
+      },
+    })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to publish data domain. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: ContextChangeRecord<DataCatalogSchema>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (!data.key) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  async read(key: string, request: SdkOptions = {}): Promise<DataCatalogSchema> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogEntry(key))
+    const result = await this.sdk.http.get(url.toString(), { token })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to read data domain. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: DataCatalogSchema
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (data.kind !== DataCatalogKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  /**
+   * Deprecates the entire data catalog entry.
+   * To deprecate a version, use the `deprecateVersion` method.
+   * @param key The key of the data catalog entry to deprecate.
+   * @param reason The reason for deprecation.
+   */
+  async deprecate(
+    key: string,
+    reason: string,
+    request: SdkOptions = {}
+  ): Promise<ContextChangeRecord<DataCatalogSchema>> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogDeprecate(key))
+    const body = JSON.stringify({ reason })
+    const result = await this.sdk.http.put(url.toString(), {
+      token,
+      body,
+      headers: {
+        'content-type': 'application/json',
+      },
+    })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to deprecate data domain. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: ContextChangeRecord<DataCatalogSchema>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (data.kind !== DataCatalogKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  /**
+   * Removes the data catalog entry from the catalog. The entry is preserved in the database
+   * and the user can still access it. It is used to recover from error when the entry was published
+   * by mistake.
+   * @param key The key of the data catalog entry to unpublish.
+   */
+  async unpublish(key: string, request: SdkOptions = {}): Promise<ContextChangeRecord<DataCatalogSchema>> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogUnpublish(key))
+    const result = await this.sdk.http.put(url.toString(), { token })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to unpublish data domain. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: ContextChangeRecord<DataCatalogSchema>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (data.kind !== DataCatalogKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  async publishVersion(
+    key: string,
+    version: DataCatalogVersionSchema,
+    request: SdkOptions = {}
+  ): Promise<ContextChangeRecord<DataCatalogVersionSchema>> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogEntryVersions(key))
+    const body = JSON.stringify(version)
+    const result = await this.sdk.http.post(url.toString(), {
+      token,
+      body,
+      headers: {
+        'content-type': 'application/json',
+      },
+    })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to publish data domain version. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: ContextChangeRecord<DataCatalogVersionSchema>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (data.kind !== DataCatalogVersionKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  async readVersion(key: string, version: string, request: SdkOptions = {}): Promise<DataCatalogVersionSchema> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogVersion(key, version))
+    const result = await this.sdk.http.get(url.toString(), { token })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to read data domain version. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: DataCatalogVersionSchema
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (data.kind !== DataCatalogVersionKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  async listDependencies(
+    dependencies?: ForeignDomainDependency[],
+    request: SdkOptions = {}
+  ): Promise<ContextListResult<DataDomainSchema[]>> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogDependencies())
+    const body = JSON.stringify({ items: dependencies })
+    const result = await this.sdk.http.post(url.toString(), {
+      token,
+      body,
+      headers: {
+        'content-type': 'application/json',
+      },
+    })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to list data domain dependencies. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: ContextListResult<DataDomainSchema[]>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (!Array.isArray(data.items)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  async deprecateVersion(
+    key: string,
+    version: string,
+    reason: string,
+    request: SdkOptions = {}
+  ): Promise<ContextChangeRecord<DataCatalogVersionSchema>> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogVersion(key, version))
+    const body = JSON.stringify({ reason })
+    const result = await this.sdk.http.put(url.toString(), {
+      token,
+      body,
+      headers: {
+        'content-type': 'application/json',
+      },
+    })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to deprecate data domain version. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: ContextChangeRecord<DataCatalogVersionSchema>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (data.kind !== DataCatalogVersionKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  async unpublishVersion(
+    key: string,
+    version: string,
+    request: SdkOptions = {}
+  ): Promise<ContextChangeRecord<DataCatalogVersionSchema>> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogVersion(key, version))
+    const result = await this.sdk.http.put(url.toString(), { token })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to unpublish data domain version. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: ContextChangeRecord<DataCatalogVersionSchema>
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (data.kind !== DataCatalogVersionKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+
+  async checkPublicationStatus(domainId: string, request: SdkOptions = {}): Promise<DataCatalogStatus> {
+    const { token } = request
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogStatus(domainId))
+    const result = await this.sdk.http.get(url.toString(), { token })
+    this.inspectCommonStatusCodes(result)
+    const E_PREFIX = 'Unable to check data domain publication status. '
+    if (result.status !== 200) {
+      this.logInvalidResponse(result)
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status)
+        e.response = result.body
+      }
+      throw e
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`)
+    }
+    let data: DataCatalogStatus
+    try {
+      data = JSON.parse(result.body)
+    } catch {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`)
+    }
+    if (data.kind !== DataCatalogKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
+    }
+    return data
+  }
+}