@google-cloud/kcmd 0.0.0-stage → 0.1.0

package/build/ts/kcmd/gcp/crm.js

@@ -0,0 +1,91 @@
+"use strict";
+// API client for Cloud Resource Manager
+//
+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.ResourceManagerClient = void 0;
+exports.projectNumber = projectNumber;
+exports.fixProject = fixProject;
+const api = __importStar(require("./api"));
+const PROJECT_NUM_TO_ID_CACHE = new Map();
+PROJECT_NUM_TO_ID_CACHE.set('655216118709', 'dataplex-types');
+class ResourceManagerClient extends api.ApiClient {
+    constructor(ctx) {
+        super('https://cloudresourcemanager.googleapis.com', 'v3', ctx);
+    }
+    async getProject(project) {
+        const name = `projects/${project}`;
+        return await this._get(name);
+    }
+}
+exports.ResourceManagerClient = ResourceManagerClient;
+// Returns the project number of `project`, which is a project ID or number.
+// Uses the number `fixProject` already resolved for this ID when there is one.
+// Returns undefined when Cloud Resource Manager does not give it, for example
+// when the caller lacks `resourcemanager.projects.get`.
+async function projectNumber(project, ctx) {
+    if (/^\d+$/.test(project))
+        return project;
+    for (const [number, id] of PROJECT_NUM_TO_ID_CACHE) {
+        if (id === project)
+            return number;
+    }
+    try {
+        const res = await new ResourceManagerClient(ctx).getProject(project);
+        // A project's resource name is `projects/<project number>`.
+        const number = res.status == 200 ? res.result?.name?.split('/')[1] : undefined;
+        return number && /^\d+$/.test(number) ? number : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function fixProject(resource, ctx) {
+    // projects/<project_id> or projects/<project_number> -> projects/<project_id>
+    const parts = resource.split('/');
+    if (/^\d+$/.test(parts[1])) {
+        let id = PROJECT_NUM_TO_ID_CACHE.get(parts[1]);
+        if (!id) {
+            const res = await new ResourceManagerClient(ctx).getProject(parts[1]);
+            id = res.status == 200 ? res.result?.projectId : '';
+        }
+        if (id) {
+            PROJECT_NUM_TO_ID_CACHE.set(parts[1], id);
+            parts[1] = id;
+        }
+        resource = parts.join('/');
+    }
+    return resource;
+}

package/build/ts/kcmd/gcp/dataplex.d.ts

@@ -0,0 +1,147 @@
+import * as api from './api';
+import * as context from './context';
+export interface EntryGroup {
+    name: string;
+    [key: string]: any;
+}
+export interface EntryType {
+    name: string;
+    requiredAspects: {
+        type: string;
+    }[];
+    [key: string]: any;
+}
+export interface AspectType {
+    name: string;
+    [key: string]: any;
+}
+export interface Operation {
+    name?: string;
+    done?: boolean;
+    error?: {
+        code?: number;
+        message?: string;
+    };
+    metadata?: {
+        failedRequests?: Record<string, {
+            code?: number;
+            message?: string;
+        }>;
+    };
+}
+export interface MetadataChange {
+    createEntryRequest?: {
+        parent: string;
+        entryId: string;
+        entry: Entry;
+    };
+    updateEntryRequest?: {
+        entry: Entry;
+        updateMask: string;
+        aspectKeys: string[];
+        deleteMissingAspects: boolean;
+    };
+    deleteEntryRequest?: {
+        name: string;
+    };
+    createEntryLinkRequest?: {
+        parent: string;
+        entryLinkId: string;
+        entryLink: EntryLink;
+    };
+    updateEntryLinkRequest?: {
+        entryLink: EntryLink;
+        allowMissing?: boolean;
+        aspectKeys?: string[];
+    };
+    deleteEntryLinkRequest?: {
+        name: string;
+    };
+}
+export interface LookupEntryOptions {
+    aspects?: string[];
+    paths?: string[];
+    view?: 'BASIC' | 'CUSTOM' | 'ALL';
+}
+export interface Aspect {
+    aspectType?: string;
+    path?: string;
+    data?: Record<string, any>;
+}
+export interface Entry {
+    name: string;
+    entryType: string;
+    parentEntry?: string;
+    fullyQualifiedName?: string;
+    createTime?: string;
+    updateTime?: string;
+    entrySource?: {
+        resource?: string;
+        system?: string;
+        platform?: string;
+        ancestors?: {
+            name: string;
+            type: string;
+        }[];
+        displayName?: string;
+        description?: string;
+        labels?: Record<string, string>;
+        location?: string;
+        createTime?: string;
+        updateTime?: string;
+    };
+    aspects?: Record<string, Aspect>;
+}
+export interface EntryReference {
+    name: string;
+    path?: string;
+    type: 'UNSPECIFIED' | 'SOURCE' | 'TARGET';
+}
+export interface EntryLink {
+    name?: string;
+    entryLinkType: string;
+    entryReferences: EntryReference[];
+    aspects?: Record<string, Aspect>;
+}
+export declare class CatalogClient extends api.ApiClient {
+    constructor(ctx: context.ApiContext);
+    getEntryGroup(project: string, location: string, entryGroup: string): Promise<api.ApiResult<EntryGroup>>;
+    getEntryType(project: string, location: string, type: string): Promise<api.ApiResult<EntryType>>;
+    getAspectType(project: string, location: string, type: string): Promise<api.ApiResult<AspectType>>;
+    getEntry(project: string, location: string, entryGroup: string, entry: string, aspects?: string[], fix?: FixOptions): Promise<api.ApiResult<Entry>>;
+    lookupEntry(project: string, location: string, name: string, opts?: LookupEntryOptions): Promise<api.ApiResult<Entry>>;
+    lookupEntryAspectTypes(project: string, location: string, name: string): Promise<api.ApiResult<string[]>>;
+    modifyEntry(project: string, location: string, entry: Entry, updateMask?: string[], aspectKeys?: string[]): Promise<api.ApiResult<Entry>>;
+    updateEntry(entry: Entry, updateMask?: string[], aspectKeys?: string[], deleteMissingAspects?: boolean): Promise<api.ApiResult<Entry>>;
+    listEntries(project: string, location: string, entryGroup: string, fix?: FixOptions): AsyncGenerator<Entry, void, unknown>;
+    createEntry(project: string, location: string, entryGroup: string, entryId: string, entry?: Entry): Promise<api.ApiResult<Entry>>;
+    deleteEntry(project: string, location: string, entryGroup: string, entry: string): Promise<api.ApiResult<Entry>>;
+    batchChangeMetadata(project: string, location: string, entryGroup: string, changes: MetadataChange[]): Promise<api.ApiResult<Operation>>;
+    createEntryGroup(project: string, location: string, entryGroupId: string, entryGroup?: EntryGroup): Promise<api.ApiResult<EntryGroup>>;
+    updateEntryGroup(project: string, location: string, entryGroupId: string, entryGroup: Partial<EntryGroup>, updateMask?: string[]): Promise<api.ApiResult<Operation>>;
+    createAspectType(project: string, location: string, aspectTypeId: string, aspectType: Omit<AspectType, 'name'>): Promise<api.ApiResult<Operation>>;
+    updateAspectType(project: string, location: string, aspectTypeId: string, aspectType: Omit<AspectType, 'name'>, updateMask?: string[]): Promise<api.ApiResult<Operation>>;
+    createEntryType(project: string, location: string, entryTypeId: string, entryType: Omit<EntryType, 'name'>): Promise<api.ApiResult<Operation>>;
+    getOperation(operationName: string): Promise<api.ApiResult<Operation>>;
+    pollOperation(op: Operation | undefined, what: string, timeoutMs?: number): Promise<{
+        operation?: Operation;
+        error?: string;
+    }>;
+    awaitOperation(op: Operation | undefined, what: string, timeoutMs?: number): Promise<string | undefined>;
+    createEntryLink(project: string, location: string, entryGroup: string, entryLinkId: string, entryLink: EntryLink): Promise<api.ApiResult<EntryLink>>;
+    updateEntryLink(entryLink: EntryLink, aspectKeys?: string[]): Promise<api.ApiResult<EntryLink>>;
+    getEntryLink(name: string): Promise<api.ApiResult<EntryLink>>;
+    deleteEntryLink(project: string, location: string, entryGroup: string, entryLinkId: string): Promise<api.ApiResult<EntryLink>>;
+    lookupEntryLinks(project: string, location: string, opts: {
+        entry: string;
+        entryLinkTypes?: string[];
+        entryMode?: 'UNSPECIFIED' | 'SOURCE' | 'TARGET';
+    }): Promise<api.ApiResult<EntryLink[]>>;
+}
+export interface FixOptions {
+    keepSourceResource?: boolean;
+}
+export declare function _fixEntry(entry: Entry, ctx: context.ApiContext, fix?: FixOptions): Promise<void>;
+export declare function catalogContainer(project: string, location: string, entryGroup?: string): string;
+export declare function _typeRefToName(ref: string, type: string): string;
+export declare function _nameToTypeRef(name: string): string;

package/build/ts/kcmd/gcp/dataplex.js

@@ -0,0 +1,406 @@
+"use strict";
+// API client for Knowledge Catalog (Dataplex)
+//
+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.CatalogClient = void 0;
+exports._fixEntry = _fixEntry;
+exports.catalogContainer = catalogContainer;
+exports._typeRefToName = _typeRefToName;
+exports._nameToTypeRef = _nameToTypeRef;
+const api = __importStar(require("./api"));
+const crm = __importStar(require("./crm"));
+// Renders a finished operation's failure as a message, or returns undefined
+// when it succeeded.
+function operationFailure(op, what) {
+    if (!op.error)
+        return undefined;
+    return `${what}: ${op.error.message || `operation failed (${op.error.code})`}`;
+}
+class CatalogClient extends api.ApiClient {
+    constructor(ctx) {
+        // Defaults to the production Dataplex endpoint. Override via DATAPLEX_ENDPOINT
+        // to target a non-prod host (e.g. an autopush/sandbox EAP), same env-var
+        // knob style as GCP_LOG.
+        super(process.env.DATAPLEX_ENDPOINT || 'https://dataplex.googleapis.com', 'v1', ctx);
+    }
+    async getEntryGroup(project, location, entryGroup) {
+        const name = catalogContainer(project, location, entryGroup);
+        return await this._get(name);
+    }
+    async getEntryType(project, location, type) {
+        const name = `${catalogContainer(project, location)}/entryTypes/${type}`;
+        return await this._get(name);
+    }
+    async getAspectType(project, location, type) {
+        const name = `${catalogContainer(project, location)}/aspectTypes/${type}`;
+        return await this._get(name);
+    }
+    // `fix.keepSourceResource` returns `entrySource.resource` exactly as stored.
+    async getEntry(project, location, entryGroup, entry, aspects, fix = {}) {
+        const name = `${catalogContainer(project, location, entryGroup)}/entries/${entry}`;
+        const params = { view: 'BASIC' };
+        if (aspects && aspects.length) {
+            params.view = 'CUSTOM';
+            params.aspectTypes = aspects;
+        }
+        const res = await this._get(name, params);
+        if (res.status == 200 && res.result) {
+            await _fixEntry(res.result, this.context, fix);
+        }
+        return res;
+    }
+    // With `opts.aspects`, `opts.paths` keeps only the aspects at those paths.
+    // The path '' is the entry itself, and `Schema.<field>` is a field. Passing
+    // `{view: 'ALL'}` reads every aspect without naming aspect types.
+    async lookupEntry(project, location, name, opts = {}) {
+        const container = `${catalogContainer(project, location)}:lookupEntry`;
+        const params = { entry: name, view: opts.view ?? 'BASIC' };
+        if (opts.view !== 'ALL' && opts.aspects && opts.aspects.length) {
+            params.view = 'CUSTOM';
+            params.aspectTypes = opts.aspects;
+            params.paths = opts.paths;
+        }
+        const res = await this._get(container, params);
+        if (res.status == 200 && res.result) {
+            await _fixEntry(res.result, this.context);
+        }
+        return res;
+    }
+    // The type of every aspect on an entry, as project.location.type, each
+    // once. A FULL read lists every aspect but gives data only to those the
+    // entry's type requires, so this reads the keys alone, which lookupEntry
+    // would drop.
+    async lookupEntryAspectTypes(project, location, name) {
+        const container = `${catalogContainer(project, location)}:lookupEntry`;
+        const res = await this._get(container, { entry: name, view: 'FULL' });
+        if (res.status != 200 || !res.result) {
+            return { status: res.status, message: res.message, body: res.body };
+        }
+        // Each type is resolved once: crm caches only the projects it can read,
+        // so several field-path keys of one unreadable type would each look it up.
+        const typeRefs = new Set(Object.keys(res.result.aspects ?? {})
+            .map(key => key.split('@')[0]));
+        const types = new Set();
+        for (const typeRef of typeRefs) {
+            const { aspectType } = await _aspectTypeOfKey(typeRef, this.context);
+            types.add(_nameToTypeRef(aspectType));
+        }
+        return { status: 200, result: [...types] };
+    }
+    async modifyEntry(project, location, entry, updateMask, aspectKeys) {
+        const container = `${catalogContainer(project, location)}:modifyEntry`;
+        const body = {
+            entry: entry,
+            updateMask: updateMask ? updateMask.join(',') : undefined,
+            aspectKeys: aspectKeys ?? undefined
+        };
+        const res = await this._post(container, body);
+        if (res.status == 200 && res.result) {
+            await _fixEntry(res.result, this.context);
+        }
+        return res;
+    }
+    // `deleteMissingAspects` removes each aspect `aspectKeys` names that `entry`
+    // does not carry. Without it Dataplex keeps such an aspect. The returned
+    // entry leaves out every aspect the update removed.
+    async updateEntry(entry, updateMask, aspectKeys, deleteMissingAspects) {
+        const params = {};
+        if (updateMask && updateMask.length) {
+            params.updateMask = updateMask.join(',');
+        }
+        if (aspectKeys && aspectKeys.length) {
+            params.aspectKeys = aspectKeys;
+        }
+        if (deleteMissingAspects) {
+            params.deleteMissingAspects = true;
+        }
+        const res = await this._patch(entry.name, entry, params);
+        if (res.status == 200 && res.result) {
+            await _fixEntry(res.result, this.context);
+        }
+        return res;
+    }
+    // `fix.keepSourceResource` returns each `entrySource.resource` exactly as
+    // stored.
+    async *listEntries(project, location, entryGroup, fix = {}) {
+        const parent = catalogContainer(project, location, entryGroup);
+        const resourceName = `${parent}/entries`;
+        let pageToken = undefined;
+        do {
+            const params = { pageSize: 1000 };
+            if (pageToken) {
+                params.pageToken = pageToken;
+            }
+            const res = await this._get(resourceName, params);
+            if (res.status !== 200) {
+                throw new Error(`Failed to list entries: ${res.message || res.status}`);
+            }
+            const entries = res.result?.entries || [];
+            for (const entry of entries) {
+                await _fixEntry(entry, this.context, fix);
+                yield entry;
+            }
+            pageToken = res.result?.nextPageToken;
+        } while (pageToken);
+    }
+    async createEntry(project, location, entryGroup, entryId, entry) {
+        const parent = catalogContainer(project, location, entryGroup);
+        const resourceName = `${parent}/entries`;
+        const params = { entryId };
+        const res = await this._post(resourceName, entry, params);
+        if (res.status == 200 && res.result) {
+            await _fixEntry(res.result, this.context);
+        }
+        return res;
+    }
+    async deleteEntry(project, location, entryGroup, entry) {
+        const name = `${catalogContainer(project, location, entryGroup)}/entries/${entry}`;
+        return await this._delete(name);
+    }
+    // Applies up to 250 entry changes to one entry group in a single call, and
+    // returns the LRO to poll. Per-change failures arrive in the operation's
+    // metadata rather than as a non-200.
+    async batchChangeMetadata(project, location, entryGroup, changes) {
+        const name = catalogContainer(project, location, entryGroup);
+        return await this._post(`${name}:batchChangeMetadata`, { name, changes });
+    }
+    async createEntryGroup(project, location, entryGroupId, entryGroup) {
+        const parent = catalogContainer(project, location);
+        const resourceName = `${parent}/entryGroups`;
+        const params = { entryGroupId };
+        const res = await this._post(resourceName, entryGroup, params);
+        return res;
+    }
+    async updateEntryGroup(project, location, entryGroupId, entryGroup, updateMask) {
+        const name = catalogContainer(project, location, entryGroupId);
+        const params = {};
+        if (updateMask && updateMask.length) {
+            params.updateMask = updateMask.join(',');
+        }
+        return await this._patch(name, entryGroup, params);
+    }
+    // Creates a custom aspect type. `aspectType` carries the display name,
+    // description and metadataTemplate; the resource name comes from the id.
+    async createAspectType(project, location, aspectTypeId, aspectType) {
+        const resourceName = `${catalogContainer(project, location)}/aspectTypes`;
+        const params = { aspectTypeId };
+        return await this._post(resourceName, aspectType, params);
+    }
+    // Patches an existing aspect type. Dataplex rejects a backwards-incompatible
+    // metadataTemplate change, so an update only ever adds fields.
+    async updateAspectType(project, location, aspectTypeId, aspectType, updateMask) {
+        const name = `${catalogContainer(project, location)}/aspectTypes/${aspectTypeId}`;
+        const params = {};
+        if (updateMask && updateMask.length) {
+            params.updateMask = updateMask.join(',');
+        }
+        return await this._patch(name, aspectType, params);
+    }
+    // Creates a custom entry type.
+    async createEntryType(project, location, entryTypeId, entryType) {
+        const resourceName = `${catalogContainer(project, location)}/entryTypes`;
+        const params = { entryTypeId };
+        return await this._post(resourceName, entryType, params);
+    }
+    // Fetches a long-running operation by the resource name the call that started
+    // it returned. Disables per-call _get retry so poll loops control backoff.
+    async getOperation(operationName) {
+        return await this._get(operationName, undefined, { retry: false });
+    }
+    // Polls a long-running operation until it finishes, returning both the final
+    // operation (for callers that inspect `metadata.failedRequests`) and any
+    // failure message.
+    async pollOperation(op, what, timeoutMs = 120000) {
+        if (!op || !op.name)
+            return { operation: op };
+        if (op.done)
+            return { operation: op, error: operationFailure(op, what) };
+        const deadline = Date.now() + timeoutMs;
+        let delayMs = 500;
+        while (Date.now() < deadline) {
+            await new Promise(resolve => setTimeout(resolve, delayMs));
+            delayMs = Math.min(delayMs * 2, 5000);
+            const polled = await this.getOperation(op.name);
+            // A client error will not resolve itself, so report it rather than spend
+            // the whole timeout rediscovering it and then blame the timeout. A 5xx or
+            // a throttle is worth another attempt.
+            if (polled.status >= 400 && polled.status < 500 &&
+                polled.status !== 429) {
+                return {
+                    error: `${what}: reading ${op.name}: ${polled.message || polled.status}`
+                };
+            }
+            if (polled.status !== 200 || !polled.result)
+                continue;
+            if (polled.result.done) {
+                return {
+                    operation: polled.result,
+                    error: operationFailure(polled.result, what)
+                };
+            }
+        }
+        return { error: `${what}: timed out after ${timeoutMs}ms waiting for ${op.name}` };
+    }
+    // Polls a long-running operation until it finishes, and returns a message
+    // describing the failure when it fails or does not finish in time. Creating a
+    // type is asynchronous, so a caller that skips this races the server: an
+    // entry type that names an aspect type the server cannot see yet is rejected
+    // with `The following aspect types do not exist`.
+    async awaitOperation(op, what, timeoutMs = 120000) {
+        return (await this.pollOperation(op, what, timeoutMs)).error;
+    }
+    async createEntryLink(project, location, entryGroup, entryLinkId, entryLink) {
+        const parent = catalogContainer(project, location, entryGroup);
+        const resourceName = `${parent}/entryLinks`;
+        const params = { entryLinkId };
+        return await this._post(resourceName, entryLink, params);
+    }
+    // Patches an existing entry link. UpdateEntryLink has no update mask: the
+    // aspects present in the request body are the ones written, narrowed to
+    // `aspectKeys` (each `project.location.aspectType`) when given. The entry
+    // references and link type are immutable server-side.
+    async updateEntryLink(entryLink, aspectKeys) {
+        const params = {};
+        if (aspectKeys && aspectKeys.length) {
+            params.aspectKeys = aspectKeys;
+        }
+        return await this._patch(entryLink.name, entryLink, params);
+    }
+    // Reads an entry link by its full resource name.
+    async getEntryLink(name) {
+        return await this._get(name);
+    }
+    async deleteEntryLink(project, location, entryGroup, entryLinkId) {
+        const name = `${catalogContainer(project, location, entryGroup)}/entryLinks/${entryLinkId}`;
+        return await this._delete(name);
+    }
+    // Returns every entry link that references `entry` (its full resource name),
+    // draining all pages. There is no list-entry-links collection API; the server
+    // only exposes links per referenced entry, via the location-scoped
+    // :lookupEntryLinks custom verb (mirroring :lookupEntry). `entryLinkTypes`
+    // optionally filters to specific link types (server caps it at 10); `entryMode`
+    // filters by the entry's role in the link (SOURCE/TARGET). The server caps a
+    // page at 10 links, so this follows nextPageToken until exhausted and returns
+    // the flat list. A non-200 on any page aborts and is returned as-is.
+    async lookupEntryLinks(project, location, opts) {
+        const container = `${catalogContainer(project, location)}:lookupEntryLinks`;
+        const links = [];
+        let pageToken = undefined;
+        do {
+            const params = {
+                entry: opts.entry,
+                entryLinkTypes: opts.entryLinkTypes,
+                entryMode: opts.entryMode,
+                pageSize: 10,
+                pageToken,
+            };
+            const res = await this._get(container, params);
+            if (res.status != 200) {
+                return { status: res.status, message: res.message, body: res.body };
+            }
+            for (const link of res.result?.entryLinks ?? []) {
+                links.push(link);
+            }
+            pageToken = res.result?.nextPageToken;
+        } while (pageToken);
+        return { status: 200, result: links };
+    }
+}
+exports.CatalogClient = CatalogClient;
+// Normalises an entry and its aspects in place so resource names and aspect
+// keys consistently use project IDs (rather than project numbers), while
+// preserving `@<path>` suffixes and `path` fields on field-level aspects.
+// Drops an aspect whose value is null or has no fields. An update's response
+// lists each aspect it removed with an empty value.
+async function _fixEntry(entry, ctx, fix = {}) {
+    entry.name = await crm.fixProject(entry.name, ctx);
+    entry.entryType = await crm.fixProject(entry.entryType, ctx);
+    if (entry.entrySource?.resource && !fix.keepSourceResource) {
+        entry.entrySource.resource = await crm.fixProject(entry.entrySource.resource, ctx);
+    }
+    if (entry.aspects) {
+        const fixedAspects = {};
+        for (const [aspectKey, aspectValue] of Object.entries(entry.aspects)) {
+            if (!aspectValue || !Object.keys(aspectValue).length)
+                continue;
+            const { aspectType, keyPath } = await _aspectTypeOfKey(aspectKey, ctx);
+            const path = aspectValue.path || keyPath;
+            const baseKey = _nameToTypeRef(aspectType);
+            const fixedKey = path ? `${baseKey}@${path}` : baseKey;
+            fixedAspects[fixedKey] = {
+                aspectType: aspectType,
+                ...(path ? { path } : {}),
+                data: aspectValue.data ?? {}
+            };
+        }
+        entry.aspects = fixedAspects;
+    }
+}
+// The aspect type an aspect key names, as a resource name with a project ID,
+// and the key's `@<path>` part, if any.
+async function _aspectTypeOfKey(key, ctx) {
+    const atIdx = key.indexOf('@');
+    const typeRef = atIdx === -1 ? key : key.slice(0, atIdx);
+    return {
+        aspectType: await crm.fixProject(_typeRefToName(typeRef, 'aspect'), ctx),
+        keyPath: atIdx === -1 ? undefined : key.slice(atIdx + 1),
+    };
+}
+// Constructs canonical names for catalog container resources, identified by project, location and
+// optionally, depending on use-case, the entry group.
+function catalogContainer(project, location, entryGroup = '') {
+    let container = `projects/${project}/locations/${location}`;
+    if (entryGroup) {
+        container += `/entryGroups/${entryGroup}`;
+    }
+    return container;
+}
+// Converts project.location.type to projects/${project}/locations/${location}/typeTypes/${type}
+function _typeRefToName(ref, type) {
+    const refParts = ref.split('.');
+    if (refParts.length !== 3) {
+        throw new Error(`Invalid type reference: ${ref}`);
+    }
+    return `projects/${refParts[0]}/locations/${refParts[1]}/${type}Types/${refParts[2]}`;
+}
+// Converts projects/${project}/locations/${location}/typeTypes/${type} -> project.location.type
+function _nameToTypeRef(name) {
+    const nameParts = name.split('/');
+    if (nameParts.length < 6) {
+        throw new Error(`Invalid type name: ${name}`);
+    }
+    return `${nameParts[1]}.${nameParts[3]}.${nameParts[5]}`;
+}

package/build/ts/kcmd/gcp/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context';
+export * from './api';
+export * from './dataplex';

package/build/ts/kcmd/gcp/index.js

@@ -0,0 +1,21 @@
+"use strict";
+// GCP Client Library and Helpers
+//
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./context"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./dataplex"), exports);