@google-cloud/kcmd 0.0.0-stage → 0.2.0

package/build/ts/kcmd/snapshot.d.ts

@@ -0,0 +1,37 @@
+import * as gcp from './gcp/context';
+import * as dataplex from './gcp/dataplex';
+import * as md from './metadata';
+import { CatalogManifest } from './manifest';
+import { CatalogLayout, Layouts } from './layout';
+export interface SnapshotOptions {
+    layout?: Layouts;
+}
+export declare class CatalogSnapshot {
+    readonly manifest: CatalogManifest;
+    readonly basePath: string;
+    private readonly _entryTypes;
+    private readonly _aspectTypes;
+    private readonly _layout;
+    private readonly _catalog;
+    private constructor();
+    static fromManifest(basePath: string, manifest: CatalogManifest, ctx: gcp.ApiContext, options?: SnapshotOptions): Promise<CatalogSnapshot>;
+    static fromPath(basePath: string, ctx: gcp.ApiContext, options?: SnapshotOptions): Promise<CatalogSnapshot>;
+    get entryTypes(): Map<string, dataplex.EntryType>;
+    get aspectTypes(): Map<string, dataplex.AspectType>;
+    get layout(): CatalogLayout;
+    listEntries(): Promise<string[]>;
+    lookupEntry(name: string): Promise<md.Entry>;
+    updateEntry(entry: md.Entry, fields: string[]): Promise<void>;
+    createEntry(name: string, entry: md.Entry): Promise<void>;
+    deleteEntry(name: string): Promise<void>;
+    private _buildTypes;
+    _loadEntryType(entryType: string): Promise<void>;
+    _storeEntry(entry: dataplex.Entry): Promise<void>;
+    _previewStoreEntry(entry: dataplex.Entry): {
+        localName: string;
+        exists: boolean;
+    };
+    _fetchEntry(name: string): Promise<dataplex.Entry | undefined>;
+}
+export declare function toLocalEntry(entry: dataplex.Entry, localName: string): md.Entry;
+export declare function toServiceEntry(entry: md.Entry, serviceName: string, manifest: CatalogManifest, entryTypes: Map<string, dataplex.EntryType>, isOkf?: boolean): dataplex.Entry;

package/build/ts/kcmd/snapshot.js

@@ -0,0 +1,386 @@
+"use strict";
+// Implements a local catalog interface
+//
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogSnapshot = void 0;
+exports.toLocalEntry = toLocalEntry;
+exports.toServiceEntry = toServiceEntry;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const dataplex = __importStar(require("./gcp/dataplex"));
+const manifest_1 = require("./manifest");
+const layout_1 = require("./layout");
+const okf_1 = require("./layouts/okf");
+const source_1 = require("./source");
+class CatalogSnapshot {
+    manifest;
+    basePath;
+    _entryTypes = new Map();
+    _aspectTypes = new Map();
+    _layout;
+    _catalog;
+    constructor(basePath, manifest, ctx, options = {}) {
+        this.basePath = basePath;
+        this.manifest = manifest;
+        this._catalog = new dataplex.CatalogClient(ctx);
+        const effectiveLayout = options.layout ??
+            (manifest.layout === 'okf' ? layout_1.Layouts.OKF : manifest.source.layout);
+        if (effectiveLayout === layout_1.Layouts.OKF) {
+            const coords = (0, source_1.entryGroupCoordinates)(manifest.source);
+            const bundlePath = path.join(this.basePath, okf_1.BUNDLE_DIR);
+            this._layout = (0, layout_1.createLayout)(layout_1.Layouts.OKF, bundlePath, coords.container);
+        }
+        else {
+            const catalogPath = path.join(this.basePath, 'catalog');
+            this._layout = (0, layout_1.createLayout)(effectiveLayout, catalogPath, manifest.source.entryGroup);
+        }
+    }
+    static async fromManifest(basePath, manifest, ctx, options = {}) {
+        const snapshot = new CatalogSnapshot(basePath, manifest, ctx, options);
+        if (!(snapshot._layout instanceof okf_1.OkfLayout)) {
+            await snapshot._buildTypes(manifest);
+        }
+        await snapshot._layout.init();
+        return snapshot;
+    }
+    static async fromPath(basePath, ctx, options = {}) {
+        const manifestPath = path.join(basePath, 'catalog.yaml');
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error(`Cannot find catalog manifest at '${manifestPath}'`);
+        }
+        const manifest = await manifest_1.CatalogManifest.load(manifestPath, ctx);
+        return await CatalogSnapshot.fromManifest(basePath, manifest, ctx, options);
+    }
+    get entryTypes() {
+        return this._entryTypes;
+    }
+    get aspectTypes() {
+        return this._aspectTypes;
+    }
+    get layout() {
+        return this._layout;
+    }
+    // Retrieves the list of locally (pulled and/or created) managed entries
+    async listEntries() {
+        return this._layout.listEntries();
+    }
+    // Retrieves the local copy of the entry using its local name
+    async lookupEntry(name) {
+        return await this._layout.loadEntry(name);
+    }
+    // Updates the locally managed entry, referenced by its local name.
+    // The list of fields can either be "resource" to update the resource-level metadata
+    // (which is relevant in case of non-ingested entries) or an aspect identified by it
+    // key (project.location.type).
+    async updateEntry(entry, fields) {
+        const existingEntry = await this._layout.loadEntry(entry.name);
+        for (const f of fields) {
+            if (f == 'resource') {
+                if (!existingEntry.resource) {
+                    existingEntry.resource = {};
+                }
+                if (!entry.resource) {
+                    entry.resource = {};
+                }
+                existingEntry.resource.description = entry.resource.description;
+            }
+            else {
+                await this._loadEntryType(existingEntry.type);
+                const aspectType = dataplex._typeRefToName(aspectTypeRefOf(f), 'aspect');
+                if (!this._aspectTypes.has(aspectType)) {
+                    throw new Error(`The aspect '${f}' is not registered in the snapshot.`);
+                }
+                if (this.manifest.source.ingestedEntries) {
+                    const entryType = this._entryTypes.get(existingEntry.type);
+                    if (!entryType || entryType.requiredAspects?.find((a) => a.type == aspectType)) {
+                        throw new Error(`The aspect '${f}' is not modifiable on the entry.`);
+                    }
+                }
+                if (!existingEntry.aspects) {
+                    existingEntry.aspects = {};
+                }
+                if (entry.aspects && entry.aspects[f]) {
+                    existingEntry.aspects[f] = entry.aspects[f];
+                }
+                else {
+                    delete existingEntry.aspects[f];
+                }
+            }
+        }
+        await this._layout.saveEntry(entry.name, existingEntry);
+    }
+    // Creates an entry within the locally catalog snapshot. This capabilitiy is only supported
+    // when the associated EntryGroup is user-managed, i.e. not contain ingested metadata.
+    async createEntry(name, entry) {
+        if (this.manifest.source.ingestedEntries) {
+            throw new Error(`Entry cannot be created as entries are ingested.`);
+        }
+        // TODO: Validate aspect and other things
+        if (this._layout.entryExists(name)) {
+            throw new Error(`Entry '${name}' already exists`);
+        }
+        await this._layout.saveEntry(name, entry);
+    }
+    // Deletes an entry within the locally catalog snapshot. This capabilitiy is only supported
+    // when the associated EntryGroup is user-managed, i.e. not contain ingested metadata.
+    async deleteEntry(name) {
+        if (this.manifest.source.ingestedEntries) {
+            throw new Error(`Entry cannot be deleted as entries are ingested.`);
+        }
+        await this._layout.deleteEntry(name);
+    }
+    // Loads the entry and aspect types listed under snapshot in catalog.yaml.
+    // Types are stored using two keys: the resource name and the 3-part type name.
+    async _buildTypes(manifest) {
+        for (const entryType of manifest.snapshotConfig?.entries || []) {
+            await this._loadEntryType(entryType);
+        }
+        for (const aspectType of manifest.snapshotConfig?.aspects || []) {
+            if (this._aspectTypes.has(aspectType)) {
+                continue;
+            }
+            const parts = aspectType.split('.');
+            const res = await this._catalog.getAspectType(parts[0], parts[1], parts[2]);
+            let type = res.result;
+            // Dataplex refuses the definition of some types whose aspects callers can
+            // still read and write. A refused type is registered by its name.
+            if (res.status == 403) {
+                type = { name: dataplex._typeRefToName(aspectType, 'aspect') };
+                console.warn(`Warning: Permission denied reading the definition of aspect type ${aspectType}. ` +
+                    `Its aspects are still pulled and pushed. If none are pulled, check the type name.`);
+            }
+            if (!type) {
+                throw new Error(`Unable to load type information for aspect type ${aspectType}`);
+            }
+            this._aspectTypes.set(type.name, type);
+            this._aspectTypes.set(aspectType, type);
+        }
+    }
+    // Loads an entry type, given as project.location.type, and the aspect types
+    // it requires. Does nothing when entryType is empty or already loaded.
+    async _loadEntryType(entryType) {
+        if (!entryType || this._entryTypes.has(entryType)) {
+            return;
+        }
+        const parts = entryType.split('.');
+        const res = await this._catalog.getEntryType(parts[0], parts[1], parts[2]);
+        if (!res.result) {
+            throw new Error(`Unable to load type information for entry type ${entryType}`);
+        }
+        this._entryTypes.set(res.result.name, res.result);
+        this._entryTypes.set(entryType, res.result);
+        for (const requiredAspect of res.result.requiredAspects ?? []) {
+            if (!this._aspectTypes.has(requiredAspect.type)) {
+                const parts = requiredAspect.type.split('/');
+                const res = await this._catalog.getAspectType(parts[1], parts[3], parts[5]);
+                if (!res.result) {
+                    throw new Error(`Unable to load type information for aspect type ${requiredAspect.type}`);
+                }
+                this._aspectTypes.set(res.result.name, res.result);
+                this._aspectTypes.set(`${parts[1]}.${parts[3]}.${parts[5]}`, res.result);
+            }
+        }
+    }
+    // Stores a Dataplex entry into the locally managed catalog snapshot. This will internally map
+    // The service representation into the local metadata representation.
+    // This is only meant to be used within the syncing process (as part of pull operations).
+    async _storeEntry(entry) {
+        const localName = this.manifest.source.localName(entry);
+        const local = toLocalEntry(entry, localName);
+        // Preserve the parent so a pull after a push round-trips it, mirroring the
+        // inverse conversion _fetchEntry applies on push: store the parent as a
+        // local name (Dataplex requires parentEntry to be in the same entry group,
+        // so localName always resolves), not the service name. Ingested entries
+        // never carry a parentEntry back to the service (toServiceEntry drops it),
+        // so recording one would be misleading -- skip them.
+        if (entry.parentEntry &&
+            (this._layout instanceof okf_1.OkfLayout || !this.manifest.source.ingestedEntries)) {
+            local.resource.parent =
+                this.manifest.source.localName({ ...entry, name: entry.parentEntry });
+        }
+        await this._layout.saveEntry(localName, local);
+    }
+    // Reports what _storeEntry would do with a Dataplex entry, without writing:
+    // the local name it maps to and whether a local copy already exists. Used by
+    // `pull --dry-run`.
+    _previewStoreEntry(entry) {
+        const localName = this.manifest.source.localName(entry);
+        return { localName, exists: this._layout.entryExists(localName) };
+    }
+    // Fetches a Dataplex entry from its local metadata representation.
+    // This is only meant to be used within the syncing process (as part of push operations).
+    async _fetchEntry(name) {
+        const entry = await this._layout.loadEntry(name);
+        if (this.manifest.publishingConfig?.entries?.length &&
+            !this.manifest.publishingConfig.entries.includes(entry.type)) {
+            return undefined;
+        }
+        if (this._layout instanceof okf_1.OkfLayout) {
+            if (!this._entryTypes.has(entry.type)) {
+                const typeName = dataplex._typeRefToName(entry.type, 'entry');
+                const stub = { name: typeName, requiredAspects: [] };
+                this._entryTypes.set(typeName, stub);
+                this._entryTypes.set(entry.type, stub);
+            }
+        }
+        else {
+            await this._loadEntryType(entry.type);
+        }
+        const serviceName = this.manifest.source.serviceName(name);
+        if (entry.resource?.parent && !entry.resource.parent.startsWith('projects/')) {
+            entry.resource.parent = this.manifest.source.serviceName(entry.resource.parent);
+        }
+        return toServiceEntry(entry, serviceName, this.manifest, this._entryTypes, this._layout instanceof okf_1.OkfLayout);
+    }
+}
+exports.CatalogSnapshot = CatalogSnapshot;
+// Converts a Dataplex entry into the local metadata representation.
+function toLocalEntry(entry, localName) {
+    const aspects = {};
+    if (entry.aspects) {
+        for (const key in entry.aspects) {
+            aspects[key] = entry.aspects[key].data ?? {};
+        }
+    }
+    const entrySource = entry.entrySource ?? {};
+    return {
+        name: localName,
+        type: dataplex._nameToTypeRef(entry.entryType),
+        resource: {
+            name: entrySource.resource ?? undefined,
+            system: entrySource.system ?? undefined,
+            platform: entrySource.platform ?? undefined,
+            displayName: entrySource.displayName ?? undefined,
+            description: entrySource.description ?? undefined,
+            labels: entrySource.labels ?? undefined,
+            location: entrySource.location ?? undefined,
+            ancestors: entrySource.ancestors ?? undefined,
+            createTime: entrySource.createTime ?? undefined,
+            updateTime: entrySource.updateTime ?? undefined
+        },
+        aspects: aspects ?? undefined
+    };
+}
+// Converts a local metadata representation into a Dataplex Entry
+function toServiceEntry(entry, serviceName, manifest, entryTypes, isOkf = false) {
+    const entryType = entryTypes.get(entry.type);
+    if (!entryType) {
+        throw new Error(`Unknown entry type ${entry.type} in snapshot`);
+    }
+    const aspects = {};
+    if (entry.aspects) {
+        for (const key in entry.aspects) {
+            if (manifest.publishingConfig &&
+                !manifest.publishingConfig.aspects?.includes(aspectTypeRefOf(key))) {
+                continue;
+            }
+            // A field-level aspect keeps its `@<path>` in the key it is written under.
+            const aspectType = dataplex._typeRefToName(aspectTypeRefOf(key), 'aspect');
+            if (manifest.source.ingestedEntries &&
+                entryType.requiredAspects?.find((aspectInfo) => aspectInfo.type == aspectType)) {
+                continue;
+            }
+            aspects[key] = { aspectType, data: entry.aspects[key] };
+        }
+    }
+    const resource = entry.resource ?? {};
+    const entryTypeName = dataplex._typeRefToName(entry.type, 'entry');
+    if (manifest.source.ingestedEntries ||
+        !entry.resource || !Object.keys(entry.resource).length) {
+        return {
+            name: serviceName,
+            entryType: entryTypeName,
+            aspects: aspects
+        };
+    }
+    if (!isOkf) {
+        return {
+            name: serviceName,
+            entryType: entryTypeName,
+            parentEntry: resource.parent,
+            entrySource: {
+                resource: resource.name,
+                ancestors: resource.ancestors,
+                displayName: resource.displayName,
+                description: resource.description,
+                labels: resource.labels,
+                location: resource.location,
+                createTime: resource.createTime,
+                updateTime: resource.updateTime
+            },
+            aspects: aspects
+        };
+    }
+    const entrySource = {};
+    if (resource.name !== undefined)
+        entrySource.resource = resource.name;
+    if (resource.system !== undefined)
+        entrySource.system = resource.system;
+    if (resource.platform !== undefined)
+        entrySource.platform = resource.platform;
+    if (resource.ancestors !== undefined)
+        entrySource.ancestors = resource.ancestors;
+    if (resource.displayName !== undefined)
+        entrySource.displayName = resource.displayName;
+    if (resource.description !== undefined)
+        entrySource.description = resource.description;
+    if (resource.labels !== undefined)
+        entrySource.labels = resource.labels;
+    if (resource.location !== undefined)
+        entrySource.location = resource.location;
+    if (resource.createTime !== undefined)
+        entrySource.createTime = resource.createTime;
+    if (resource.updateTime !== undefined)
+        entrySource.updateTime = resource.updateTime;
+    const out = {
+        name: serviceName,
+        entryType: entryTypeName,
+        aspects: aspects
+    };
+    if (resource.parent !== undefined) {
+        out.parentEntry = resource.parent;
+    }
+    if (Object.keys(entrySource).length) {
+        out.entrySource = entrySource;
+    }
+    return out;
+}
+// The aspect type reference in an aspect key: the part before any `@<path>`,
+// as in `p.global.guidelines@Schema.col1`.
+function aspectTypeRefOf(key) {
+    const at = key.indexOf('@');
+    return at < 0 ? key : key.slice(0, at);
+}

package/build/ts/kcmd/source.d.ts

@@ -0,0 +1,31 @@
+import * as gcp from './gcp';
+import { Layouts } from './layout';
+export declare enum Sources {
+    ENTRYGROUP = "entryGroup",
+    BIGQUERY_DATASET = "bq-dataset",
+    KB = "kb",
+    SEMANTIC_MODEL = "semantic-model"
+}
+export interface CatalogSource {
+    readonly type: string;
+    readonly name: string;
+    readonly ingestedEntries: boolean;
+    readonly layout: Layouts;
+    readonly project?: string;
+    readonly location?: string;
+    readonly entryGroup?: string;
+    readonly defaultAspects: readonly string[];
+    readonly systemAspects: readonly string[];
+    entries(ctx: gcp.ApiContext): AsyncGenerator<gcp.Entry, void, unknown>;
+    localName(entry: gcp.Entry): string;
+    serviceName(localName: string): string;
+}
+export declare function createSource(type: string, name: string, ctx: gcp.ApiContext): Promise<CatalogSource>;
+export interface EntryGroupCoordinates {
+    project: string;
+    location: string;
+    entryGroup: string;
+    container: string;
+}
+/** Validates and extracts `<project>.<location>.<entryGroup>` coordinates. */
+export declare function entryGroupCoordinates(source: CatalogSource): EntryGroupCoordinates;

package/build/ts/kcmd/source.js

@@ -0,0 +1,119 @@
+"use strict";
+// Defines a Catalog metadata source abstraction
+//
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sources = void 0;
+exports.createSource = createSource;
+exports.entryGroupCoordinates = entryGroupCoordinates;
+const gcp = __importStar(require("./gcp"));
+const bq = __importStar(require("./gcp/bigquery"));
+const dataplex = __importStar(require("./gcp/dataplex"));
+const entrygroup_1 = require("./sources/entrygroup");
+const bq_dataset_1 = require("./sources/bq-dataset");
+const kb_1 = require("./sources/kb");
+const semantic_model_1 = require("./sources/semantic-model");
+var Sources;
+(function (Sources) {
+    Sources["ENTRYGROUP"] = "entryGroup";
+    Sources["BIGQUERY_DATASET"] = "bq-dataset";
+    Sources["KB"] = "kb";
+    Sources["SEMANTIC_MODEL"] = "semantic-model";
+})(Sources || (exports.Sources = Sources = {}));
+async function getEntryGroup(name, ctx) {
+    const [project, location, entryGroup] = name.split('.');
+    if (!project || !location || !entryGroup) {
+        throw new Error('EntryGroup must be in format <projectId>.<locationId>.<entryGroupId>');
+    }
+    const catalog = new gcp.CatalogClient(ctx);
+    const res = await catalog.getEntryGroup(project, location, entryGroup);
+    if (!res.result) {
+        throw new Error(`Failed to locate EntryGroup '${name}'.`);
+    }
+    return res.result;
+}
+async function getBigQueryDatasets(name, ctx) {
+    const datasets = new Map();
+    const names = name.split(',');
+    const bigQuery = new bq.BigQueryClient(ctx);
+    for (const n of names) {
+        const [project, dataset] = n.split('.');
+        if (!project || !dataset) {
+            throw new Error(`BigQuery dataset must be in format <projectId>.<datasetId>: ${n}`);
+        }
+        const res = await bigQuery.getDataset(project, dataset);
+        if (!res.result) {
+            throw new Error(`Failed to locate BigQuery dataset '${n}'.`);
+        }
+        datasets.set(n, res.result);
+    }
+    return datasets;
+}
+async function createSource(type, name, ctx) {
+    switch (type) {
+        case Sources.ENTRYGROUP:
+            const entryGroup = await getEntryGroup(name, ctx);
+            return new entrygroup_1.EntryGroupSource(Sources.ENTRYGROUP, name, entryGroup);
+        case Sources.BIGQUERY_DATASET:
+            const datasets = await getBigQueryDatasets(name, ctx);
+            return new bq_dataset_1.BigQueryDatasetSource(Sources.BIGQUERY_DATASET, name, datasets);
+        case Sources.KB:
+            const knowledgeBase = await getEntryGroup(name, ctx);
+            return new kb_1.KnowledgeBaseSource(Sources.KB, name, knowledgeBase);
+        case Sources.SEMANTIC_MODEL:
+            return new semantic_model_1.SemanticModelSource(Sources.SEMANTIC_MODEL, name);
+        default:
+            throw new Error(`Unknown source type: ${type}`);
+    }
+}
+/** Validates and extracts `<project>.<location>.<entryGroup>` coordinates. */
+function entryGroupCoordinates(source) {
+    if (source.type && source.type !== Sources.ENTRYGROUP && source.type !== Sources.KB) {
+        throw new Error(`OKF layout applies only to '${Sources.ENTRYGROUP}' and '${Sources.KB}' scopes, got '${source.type}'.`);
+    }
+    const project = source.project ?? source.name.split('.')[0];
+    const location = source.location ?? source.name.split('.')[1];
+    const entryGroup = source.entryGroup ?? source.name.split('.')[2];
+    const parts = source.name.split('.');
+    if (!project || !location || !entryGroup || parts.length !== 3) {
+        throw new Error(`EntryGroup must be in format <projectId>.<locationId>.<entryGroupId>: '${source.name}'`);
+    }
+    return {
+        project,
+        location,
+        entryGroup,
+        container: dataplex.catalogContainer(project, location, entryGroup),
+    };
+}

package/build/ts/kcmd/sources/bq-dataset.d.ts

@@ -0,0 +1,17 @@
+import * as gcp from '../gcp';
+import * as bq from '../gcp/bigquery';
+import { Layouts } from '../layout';
+import { CatalogSource } from '../source';
+export declare class BigQueryDatasetSource implements CatalogSource {
+    readonly type: string;
+    readonly name: string;
+    readonly ingestedEntries = true;
+    readonly layout = Layouts.STANDARD;
+    readonly defaultAspects: string[];
+    readonly systemAspects: string[];
+    private readonly _datasets;
+    constructor(type: string, name: string, datasets: Map<string, bq.Dataset>);
+    entries(ctx: gcp.ApiContext): AsyncGenerator<gcp.Entry, void, unknown>;
+    localName(entry: gcp.Entry): string;
+    serviceName(localName: string): string;
+}