@google-cloud/kcmd 0.2.0 → 0.2.1

package/build/ts/kcmd/okf/init_okf_workspace.js

@@ -107,7 +107,7 @@ async function initOkfWorkspace(ctx, manifest, options = {}) {
         .readdirSync(okf_1.BUNDLE_DIR)
         .some((f) => f.endsWith('.md'));
     if (!fs.existsSync(indexPath) && !fs.existsSync(agentsPath) && !hasConceptFiles) {
-        fs.writeFileSync(indexPath, `---\nokf_version: "0.3"\n---\n# ${groupId}\n`, 'utf8');
+        fs.writeFileSync(indexPath, `---\nokf_version: "0.2"\n---\n# ${groupId}\n`, 'utf8');
     }
     return 0;
 }

package/build/ts/kcmd/semantic/deploy_bigquery.js

@@ -6,7 +6,7 @@
 // shared with the Knowledge Catalog leg so a multi-destination push parses each
 // document once), lowers each to `CREATE OR REPLACE PROPERTY GRAPH` DDL
 // (generator), and executes that DDL against the BigQuery project named by the
-// model's GOOGLE deployment target.
+// model's deployment target.
 //
 // This is a library module: it emits no console output. The generated DDL and
 // any loader/generator warnings are returned in `DeployResult` for the CLI
@@ -18,7 +18,7 @@ exports.datasetLocation = datasetLocation;
 exports.deployBigQuery = deployBigQuery;
 const bigquery_1 = require("../gcp/bigquery");
 const bigquery_2 = require("./bigquery");
-// The GOOGLE deployment-target reader lives in its own module so both deploy
+// The deployment-target reader lives in its own module so both deploy
 // legs (BigQuery, Spanner) and the push-time validator share one parse. The
 // BigQuery-facing views are re-exported here so existing importers
 // (validate.ts, knowledge_catalog.ts, and the deploy tests) keep their
@@ -150,25 +150,18 @@ async function deployBigQuery(models, ctx, options = {}) {
     };
     for (const { document, model } of models) {
         modelsSeen++;
-        let targets;
-        let malformed;
-        try {
-            ({ targets, malformed } = (0, deployment_target_1.bigQueryGraphTargets)(model));
-        }
-        catch (err) {
-            return fail(`Model '${model.name}' (${document}): ${err.message || err}`);
-        }
+        const { targets, malformed } = (0, deployment_target_1.bigQueryGraphTargets)(model);
         if (!targets.length) {
             // A malformed-but-present target must not be reported as "none
-            // declared" -- that sends the author hunting for an extension they
+            // declared" -- that sends the author hunting for a deployment they
             // already wrote. Name the URIs that failed to parse.
             if (malformed.length) {
                 return fail(`Model '${model.name}' (${document}) declares BigQuery Graph ` +
-                    `deploymentTarget(s) that could not be parsed: ` +
+                    `deployment target(s) that could not be parsed: ` +
                     `${malformed.join(', ')}. Expected ${deployment_target_1.BQ_GRAPH_FORM}.`);
             }
             return fail(`Model '${model.name}' (${document}) declares no BigQuery Graph ` +
-                `deploymentTarget in a GOOGLE custom_extension; nothing to deploy.`);
+                `deployment target; nothing to deploy.`);
         }
         // Malformed targets alongside valid ones: surface them so a typo'd URI is
         // not silently dropped when the deploy otherwise succeeds.

package/build/ts/kcmd/semantic/deploy_knowledge_catalog.d.ts

@@ -94,9 +94,9 @@ export declare function deployEmittedModels(emitted: EmittedModel[], emitWarning
 export declare function oneModelPerEntryGroupMessage(entryGroup: string, models: number): string;
 export declare const MAX_ASPECT_DATA_BYTES: number;
 /**
- * The emitter's warnings for `models`, and an emit error or the first aspect
- * too large to store. With v2Aspects on, that error is why push's catalog leg
- * cannot write them. Calls no service.
+ * The emitter's warnings for `models`, and the first aspect too large to
+ * store. With v2Aspects on, that error is why push's catalog leg cannot write
+ * them. Calls no service.
  */
 export declare function checkCatalogAspects(models: LoadedModel[], opts: KcDeployOptions): {
     error?: string;

package/build/ts/kcmd/semantic/deploy_knowledge_catalog.js

@@ -121,21 +121,6 @@ function sleep(ms) {
  */
 async function preflightKnowledgeCatalog(models, ctx, opts) {
     const emit = emitModels(models, opts);
-    if (emit.error) {
-        return {
-            result: {
-                success: false,
-                details: emit.error,
-                warnings: emit.warnings,
-                created: 0,
-                updated: 0,
-                deleted: 0,
-                linked: 0,
-                unlinked: 0,
-                plan: [],
-            },
-        };
-    }
     return preflightEmittedModels(emit.emitted, emit.warnings, ctx, opts);
 }
 /**
@@ -340,13 +325,13 @@ function validateEntryGroup(model, existing, opts, result) {
 exports.MAX_ASPECT_DATA_BYTES = 120 * 1024;
 const MAX_SCHEMA_ASPECT_DATA_BYTES = 2 * 1024 * 1024;
 /**
- * The emitter's warnings for `models`, and an emit error or the first aspect
- * too large to store. With v2Aspects on, that error is why push's catalog leg
- * cannot write them. Calls no service.
+ * The emitter's warnings for `models`, and the first aspect too large to
+ * store. With v2Aspects on, that error is why push's catalog leg cannot write
+ * them. Calls no service.
  */
 function checkCatalogAspects(models, opts) {
     const emit = emitModels(models, opts);
-    const error = emit.error ?? emit.emitted.map(emittedAspectsError).find(e => e);
+    const error = emit.emitted.map(emittedAspectsError).find(e => e);
     return { error, warnings: emit.warnings };
 }
 // Why push cannot write what `model` emits, or undefined when it can.
@@ -438,35 +423,22 @@ async function checkCustomTypes(cat, dest, typeIds) {
  * Turns every authored model into its catalog resources.
  *
  * Pure (no network I/O), so the dry-run plan and any generation warnings are
- * produced even when a later write fails. A malformed GOOGLE
- * `custom_extension` (reached via the `semantic-model` aspect) throws; report
- * it against its document, as the BigQuery leg does, rather than letting it
- * escape as an uncaught stack trace.
+ * produced even when a later write fails.
  */
 function emitModels(models, opts) {
     const emitted = [];
     const warnings = [];
-    for (const { document, model } of models) {
-        let resources;
-        try {
-            resources = kcEmit.generateCatalogResources(model, {
-                project: opts.project,
-                location: opts.location,
-                entryGroup: opts.entryGroup,
-                systemTypeProject: opts.systemTypeProject,
-                systemTypeLocation: opts.systemTypeLocation,
-                emitExpressions: opts.emitExpressions,
-                v2Aspects: opts.v2Aspects,
-                overviews: opts.overviews,
-            });
-        }
-        catch (err) {
-            return {
-                emitted,
-                warnings,
-                error: `Model '${model.name}' (${document}): ${err.message || err}`,
-            };
-        }
+    for (const { model } of models) {
+        const resources = kcEmit.generateCatalogResources(model, {
+            project: opts.project,
+            location: opts.location,
+            entryGroup: opts.entryGroup,
+            systemTypeProject: opts.systemTypeProject,
+            systemTypeLocation: opts.systemTypeLocation,
+            emitExpressions: opts.emitExpressions,
+            v2Aspects: opts.v2Aspects,
+            overviews: opts.overviews,
+        });
         for (const w of resources.warnings)
             warnings.push(`[${model.name}] ${w}`);
         emitted.push({ model: model.name, resources });

package/build/ts/kcmd/semantic/deploy_spanner.js

@@ -3,10 +3,10 @@
 //
 // This is the Spanner leg of `kcmd push` for the semantic-model scope, a
 // sibling to deploy_bigquery: it consumes models already parsed into the
-// semantic IR (see loadSemanticModels, shared across legs so a multi-destination
-// push parses each document once), lowers each to `CREATE OR REPLACE PROPERTY
-// GRAPH` DDL (generator: ./spanner), and applies that DDL to the Spanner
-// database named by the model's GOOGLE deployment target.
+// semantic IR (see loadSemanticModels, shared across legs so a
+// multi-destination push parses each document once), lowers each to `CREATE OR
+// REPLACE PROPERTY GRAPH` DDL (generator: ./spanner), and applies that DDL to
+// the Spanner database named by the model's deployment target.
 //
 // Spanner DDL is asynchronous: updateDatabaseDdl returns a long-running
 // operation which this leg polls to completion, unlike the BigQuery leg's
@@ -86,23 +86,16 @@ async function deploySpanner(models, ctx, options = {}) {
     const backoffMs = options.pollBackoffMs ?? POLL_BACKOFF_MS;
     for (const { document, model } of models) {
         modelsSeen++;
-        let targets;
-        let malformed;
-        try {
-            ({ targets, malformed } = (0, deployment_target_1.spannerGraphTargets)(model));
-        }
-        catch (err) {
-            return fail(`Model '${model.name}' (${document}): ${err.message || err}`);
-        }
+        const { targets, malformed } = (0, deployment_target_1.spannerGraphTargets)(model);
         if (!targets.length) {
             // A malformed-but-present target must not be reported as "none declared".
             if (malformed.length) {
                 return fail(`Model '${model.name}' (${document}) declares Spanner Graph ` +
-                    `deploymentTarget(s) that could not be parsed: ` +
+                    `deployment target(s) that could not be parsed: ` +
                     `${malformed.join(', ')}. Expected ${deployment_target_1.SPANNER_GRAPH_FORM}.`);
             }
             return fail(`Model '${model.name}' (${document}) declares no Spanner Graph ` +
-                `deploymentTarget in a GOOGLE custom_extension; nothing to deploy.`);
+                `deployment target; nothing to deploy.`);
         }
         for (const bad of malformed) {
             warnings.push(`[${model.name}] ignoring unparseable Spanner Graph target: ${bad}`);

package/build/ts/kcmd/semantic/deployment_target.d.ts

@@ -1,4 +1,4 @@
-import { CustomExtension, DeploymentSpec, SemanticModel } from './ir';
+import { DeploymentSpec, SemanticModel } from './ir';
 export declare const BQ_GRAPH_FORM = "bigquery.googleapis.com/projects/<p>/datasets/<d>/propertyGraphs/<g>";
 export declare const SPANNER_GRAPH_FORM = "spanner.googleapis.com/projects/<p>/instances/<i>/databases/<db>/graphs/<g>";
 export declare const ALLOYDB_FORM = "alloydb.googleapis.com/projects/<p>/locations/<l>/clusters/<c>/databases/<db>";
@@ -45,8 +45,6 @@ export type ResolvedDeployment = ParsedDeploymentTarget & {
 };
 /** Why a deployment's target is not accepted in a `deployments:` list. */
 export declare function deploymentTargetError(model: SemanticModel, d: DeploymentSpec): string;
-/** Why a target in a GOOGLE block's `deploymentTargets` is not accepted. */
-export declare function googleBlockTargetError(model: SemanticModel, target: string): string;
 /**
  * Why a push would reject `target`, or undefined when it accepts it. `at` says
  * where it is written.
@@ -73,7 +71,6 @@ export declare function resolveModelDeployments(model: SemanticModel, selected?:
 } | {
     error: string;
 };
-export declare function googleBlockTargets(exts: readonly CustomExtension[] | undefined, modelName: string): string[];
 export declare function unnamedDeployments(targets: readonly string[]): Array<{
     name: string;
     target: string;

package/build/ts/kcmd/semantic/deployment_target.js

@@ -2,10 +2,8 @@
 // Reads where a model deploys and classifies each declared target.
 //
 // A semantic model names where it deploys with its `deployments:` list. Each
-// entry has a name, a target and optionally the binding profile it uses. The
-// loader also folds every target into `deploymentTargets` in a GOOGLE
-// `custom_extensions` block, which is also where a vanilla document's GOOGLE
-// block carries them. Three destination types are recognized here, each a
+// entry has a name, a target and optionally the binding profile it uses. Three
+// destination types are recognized here, each a
 // GCP resource name, written with no leading `//`:
 //
 //   BigQuery Graph:
@@ -36,11 +34,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ALLOYDB_FORM = exports.SPANNER_GRAPH_FORM = exports.BQ_GRAPH_FORM = void 0;
 exports.deploymentTargetError = deploymentTargetError;
-exports.googleBlockTargetError = googleBlockTargetError;
 exports.targetProblem = targetProblem;
 exports.parseDeploymentSelection = parseDeploymentSelection;
 exports.resolveModelDeployments = resolveModelDeployments;
-exports.googleBlockTargets = googleBlockTargets;
 exports.unnamedDeployments = unnamedDeployments;
 exports.googleDeploymentTargets = googleDeploymentTargets;
 exports.bigQueryGraphTargets = bigQueryGraphTargets;
@@ -48,8 +44,6 @@ exports.spannerGraphTargets = spannerGraphTargets;
 exports.alloyDbTargets = alloyDbTargets;
 const loader_1 = require("./loader");
 const resolve_profiles_1 = require("./resolve_profiles");
-// Our own vendor tag in the Ossie `custom_extensions` list.
-const GOOGLE_VENDOR = 'GOOGLE';
 // A BigQuery Graph deployment target.
 const BQ_GRAPH_TARGET = /^\/\/bigquery\.googleapis\.com\/projects\/([A-Za-z0-9_-]+)\/datasets\/([A-Za-z0-9_-]+)\/propertyGraphs\/([A-Za-z0-9_-]+)$/;
 // A Spanner Graph deployment target, named as Dataplex names the graph's
@@ -140,11 +134,6 @@ function clusterUri(legacy) {
 function deploymentTargetError(model, d) {
     return targetError(`Model '${model.name}': deployment '${d.name}' targets '${d.target}'`, d.target);
 }
-/** Why a target in a GOOGLE block's `deploymentTargets` is not accepted. */
-function googleBlockTargetError(model, target) {
-    return targetError(`Model '${model.name}': the GOOGLE custom_extension's ` +
-        `'deploymentTargets' lists '${target}'`, target);
-}
 // The Dataplex name of a Spanner graph `target` names with `propertyGraphs`,
 // or undefined for any other target.
 function spannerGraphName(target) {
@@ -251,53 +240,13 @@ function resolveModelDeployments(model, selected) {
 }
 // Memoizes the parse per model object so the several callers within one push
 // (validation, source-project lookup, per-leg routing, each deploy leg) share a
-// single parse rather than re-running JSON.parse + the regexes once per reader.
+// single parse rather than re-running the regexes once per reader.
 // Keyed by model identity: the IR object is stable through a push (the loader
 // and inheritance passes each hand on a fixed set of objects) and
-// neither its deployments nor its customExtensions are mutated after loading.
+// its deployments are not mutated after loading.
 // A caller that narrows `deployments` builds a new model object. The returned
 // value is read-only by convention -- no caller mutates its arrays.
 const targetsCache = new WeakMap();
-// The targets in a model's GOOGLE custom_extension(s). The extension `data` is
-// an opaque, vendor-serialized JSON string (the loader keeps it verbatim); we
-// own its `deploymentTargets` shape. Throws on malformed extension JSON.
-function extensionTargets(model) {
-    return googleBlockTargets(model.customExtensions, model.name);
-}
-// The targets listed in the GOOGLE blocks among `exts`, in order. A string
-// target is trimmed, and a blank one is dropped. A padded target is the same
-// target, so trimming here keeps the duplicate check and the stored list in
-// step. An entry that is not a string is kept as its JSON text, which parses
-// as no supported destination. Throws when a GOOGLE block's data is not valid
-// JSON.
-function googleBlockTargets(exts, modelName) {
-    const uris = [];
-    for (const ext of exts ?? []) {
-        if (ext.vendorName !== GOOGLE_VENDOR) {
-            continue;
-        }
-        let data;
-        try {
-            data = JSON.parse(ext.data);
-        }
-        catch {
-            throw new Error(`Model '${modelName}': GOOGLE custom_extension 'data' is not valid JSON.`);
-        }
-        const list = data?.deploymentTargets;
-        if (!Array.isArray(list)) {
-            continue;
-        }
-        for (const uri of list) {
-            if (typeof uri !== 'string') {
-                uris.push(JSON.stringify(uri));
-            }
-            else if (uri.trim() !== '') {
-                uris.push(uri.trim());
-            }
-        }
-    }
-    return uris;
-}
 // Deployments for targets whose names are not known: a pull reads only the
 // targets back from the catalog. One target is `default`; several are
 // `deployment_1`, `deployment_2`, and so on. Targets are trimmed, and blank
@@ -317,17 +266,12 @@ function unnamedDeployments(targets) {
     }));
 }
 // Reads a model's deployment targets in a single pass and returns the facts
-// every caller derives from them. The targets come from `model.deployments`
-// when the model has it, and otherwise from its GOOGLE custom_extension(s).
-// Never both: in the Google flavor, the loader's GOOGLE block holds a copy of
-// the list. Throws on malformed extension JSON.
+// every caller derives from them. The targets come from `model.deployments`.
 function googleDeploymentTargets(model) {
     const cached = targetsCache.get(model);
     if (cached)
         return cached;
-    const uris = model.deployments !== undefined ?
-        model.deployments.map(d => d.target) :
-        extensionTargets(model);
+    const uris = (model.deployments ?? []).map(d => d.target);
     const bigQuery = [];
     const spanner = [];
     const alloyDb = [];

package/build/ts/kcmd/semantic/import_model.js

@@ -1292,16 +1292,13 @@ function withDialects({ fileName, content }, profile, doc) {
     return writeDocument({ document, links, text }, root);
 }
 /**
- * Validates every deployment target on `model` using `googleDeploymentTargets`
- * and `targetProblem` so invalid targets fail import with `kcmd push`'s exact
- * message.
+ * Validates every deployment target on `model` using `targetProblem` so
+ * invalid targets fail import with `kcmd push`'s exact message.
  */
 function validateDeploymentTargets(model, doc) {
-    for (const t of (0, deployment_target_1.googleDeploymentTargets)(model).uris) {
-        if ((0, deployment_target_1.targetProblem)('', t)) {
-            const d = model.deployments?.find(x => x.target === t);
-            doc.errors.push(d ? (0, deployment_target_1.deploymentTargetError)(model, d) :
-                (0, deployment_target_1.googleBlockTargetError)(model, t));
+    for (const d of model.deployments ?? []) {
+        if ((0, deployment_target_1.targetProblem)('', d.target)) {
+            doc.errors.push((0, deployment_target_1.deploymentTargetError)(model, d));
         }
     }
 }

package/build/ts/kcmd/semantic/ir.d.ts

@@ -33,10 +33,8 @@ export interface CustomExtension {
  * (edges), with model-level metrics defined over them.
  *
  * The IR is primarily semantics. The loader reads a model's named
- * `deployments:` list onto `deployments`. In the Google flavor it also folds
- * their target URIs into a model-level GOOGLE `custom_extensions` block for the
- * consumers that read it. A vanilla model lists its deployments in its GOOGLE
- * block, which the loader reads and does not fold.
+ * `deployments:` list onto `deployments` (from `deployments:` in the Google
+ * flavor or from the model-level GOOGLE `custom_extensions` block in vanilla).
  */
 export interface SemanticModel {
     name: string;

package/build/ts/kcmd/semantic/kc_converter.js

@@ -31,9 +31,8 @@
 // `guidelines` aspect, on the model/entity/metric), each metric's attach entity
 // (re-derived from its expression, as the loader does, when the catalog holds
 // one, else the value the emitter persisted), the model's deployment targets
-// (from the semantic-model aspect, back into `deployments` and the GOOGLE
-// `custom_extensions` block), and 1:1 / 1:N relationships (from the
-// `schema-join` entry links a pull fetched -- see
+// (from the semantic-model aspect, back into `deployments`), and 1:1 / 1:N
+// relationships (from the `schema-join` entry links a pull fetched -- see
 // `modelsFromCatalogResources`'s `entryLinks` argument).
 // The per-field `semantics` block -- field/metric expressions and the DIMENSION
 // role
@@ -176,13 +175,11 @@ function modelsFromCatalogResources(entries, entryLinks = [], opts = {}) {
         if (description !== undefined)
             model.description = description;
         readActionsAndConstraints(model, children(actionEntries), children(constraintEntries), warnings);
-        // Deployment targets ride back in both the GOOGLE custom_extensions block
-        // and as synthesized `deployments` entries (`default` when one,
-        // `deployment_1`, `deployment_2`, ... when several).
-        const targets = readDeploymentTargets(anchor, name, warnings);
-        if (targets) {
-            model.customExtensions = [targets.extension];
-            model.deployments = targets.deployments;
+        // Deployment targets ride back as synthesized `deployments` entries
+        // (`default` when one, `deployment_1`, `deployment_2`, ... when several).
+        const deployments = readDeploymentTargets(anchor, name, warnings);
+        if (deployments) {
+            model.deployments = deployments;
         }
         const ai = readAiContext(anchor);
         if (ai)
@@ -679,10 +676,10 @@ function aspectDataOf(aspects, type, path = '') {
     return {};
 }
 // Recovers the model's deployment targets from its semantic-model aspect back
-// into both the GOOGLE custom_extension shim and a `deployments` list (`default`
-// when there is one target, `deployment_1`, `deployment_2`, ... when there are
-// several), warning that the original deployment names were not recovered.
-// Returns undefined when the model has none.
+// into a `deployments` list (`default` when there is one target,
+// `deployment_1`, `deployment_2`, ... when there are several), warning that the
+// original deployment names were not recovered. Returns undefined when the
+// model has none.
 function readDeploymentTargets(anchor, modelName, warnings) {
     const deployments = (0, deployment_target_1.unnamedDeployments)(asArray(aspectData(anchor, 'semantic-model').deploymentTargets)
         .filter((t) => typeof t === 'string'));
@@ -695,16 +692,9 @@ function readDeploymentTargets(anchor, modelName, warnings) {
         if (problem !== undefined)
             warnings.push(problem);
     }
-    const targets = deployments.map(d => d.target);
     warnings.push(`model '${modelName}': deployment names were not recovered (the ` +
         `catalog stores target URIs only); using ${deployments.map(d => `'${d.name}'`).join(', ')}`);
-    return {
-        extension: {
-            vendorName: 'GOOGLE',
-            data: JSON.stringify({ deploymentTargets: targets }),
-        },
-        deployments,
-    };
+    return deployments;
 }
 // Inverts schemaJoinAspectData (knowledge_catalog.ts): each schema-join link
 // whose two endpoints are both this model's entity entries becomes one

package/build/ts/kcmd/semantic/kc_custom_types.js

@@ -671,40 +671,46 @@ async function provisionOne(cat, dest, type) {
     const aspectLabel = `aspect type '${type.id}'`;
     const aspect = await cat.createAspectType(home.project, home.location, type.id, type.aspectType);
     if (aspect.status === 409) {
-        const upd = await cat.updateAspectType(home.project, home.location, type.id, type.aspectType, ['description', 'display_name', 'metadata_template']);
-        // Patching an existing type forward is best effort. Dataplex refuses a
-        // template change it judges backwards-incompatible -- removing a field, or
-        // renumbering one -- and the type already there is the one every published
-        // entry depends on. Leaving it alone and saying so beats aborting an init
-        // that has already created the entry group.
-        //
-        // What the warning has to carry is the way OUT, because there is no way
-        // forward: `kcmd` creates and patches aspect types and does not delete
-        // them, so a project holding a template this build cannot patch stays that
-        // way until someone removes it by hand. Naming the resource and the
-        // command is the whole of the fix; a reader who has only "left it
-        // unchanged" has to work out which of several types in which project, and
-        // then that `gcloud dataplex aspect-types` is where it lives.
+        const upd = await cat.updateAspectType(home.project, home.location, type.id, type.aspectType, ['description', 'display_name', 'metadata_template'])
+            // A thrown error, such as a network failure, gets the retry warning.
+            .catch((err) => ({ status: 0, message: String(err?.message || err) }));
+        // Patching an existing type is best effort. Published entries depend on
+        // the type already there, so a failed patch leaves it and init goes on.
         const reason = upd.status !== 200 ?
             `${upd.message || upd.status}` :
-            await cat.awaitOperation(upd.result, `updating ${aspectLabel}`);
+            await cat.awaitOperation(upd.result, 'the update operation')
+                .catch((err) => String(err?.message || err));
         if (upd.status === 403) {
             // The type exists, so a refusal to patch it leaves it as it is.
             warnings.push(`no permission to update the existing ${aspectLabel} in project ` +
                 `'${home.project}' (${reason}); left it unchanged`);
         }
-        else if (reason) {
+        else if (reason &&
+            /Backwards incompatible template change/i.test(reason)) {
+            // Dataplex refuses a backwards-incompatible template change with this
+            // message, and the same template gets the same answer on every run.
+            // kcmd never deletes a type, so the warning names the gcloud commands
+            // that do.
             const resource = customAspectTypeName(type.id, dest);
             warnings.push(`left the existing ${aspectLabel} unchanged (${reason}). It is ` +
                 `${resource}, and Dataplex will not patch it into the template ` +
                 `this build states -- a template field that was removed or ` +
                 `renumbered is a backwards-incompatible change and is refused. A ` +
                 `push will fail wherever the two disagree. To move it forward, ` +
-                `delete it and re-run this command: gcloud dataplex aspect-types ` +
-                `delete ${type.id} --project=${home.project} ` +
-                `--location=${home.location}. Deleting takes the aspects of every ` +
-                `entry already published with this type, so re-push those models ` +
-                `afterwards.`);
+                `delete the entry type and then the aspect type, and re-run this ` +
+                `command: gcloud dataplex entry-types delete ${type.id} ` +
+                `--project=${home.project} --location=${home.location} && gcloud ` +
+                `dataplex aspect-types delete ${type.id} --project=${home.project} ` +
+                `--location=${home.location}. Deleting the entry type also deletes ` +
+                `every entry of that type in the project, so push the models that ` +
+                `had them again afterwards.`);
+        }
+        else if (reason) {
+            // Any other failure, such as a 429 from the write quota, a 5xx, a failed
+            // operation or a network error, can pass on a later run.
+            warnings.push(`could not update the existing ${aspectLabel} in project ` +
+                `'${home.project}' (${reason}). Run this command again in a minute ` +
+                `to retry the update.`);
         }
     }
     else if (aspect.status !== 200) {

package/build/ts/kcmd/semantic/loader.js

@@ -1065,17 +1065,14 @@ function composeDescription(...parts) {
         .filter((p) => !!p);
     return kept.length ? kept.join('\n\n') : undefined;
 }
-// The vendor tag for Google-specific extension blocks (kept in sync with the
-// deploy leg's reader). A model-level `deployments:` list folds into one.
+// The vendor tag for Google-specific extension blocks.
 exports.GOOGLE_VENDOR = 'GOOGLE';
 // Rewrites the author-friendly sugar forms into the canonical wire shape the
 // schema validates, and rejects deprecated or flavor-mismatched model keys up
 // front with actionable messages: the removed `deployment_target:` key,
 // inline `profiles:` in either flavor, and `deployments:` or
 // `entities:` in vanilla. Under the extended profile, `entities:` is rewritten
-// to `datasets:` and `deployments:` is left in place here and folded into a
-// GOOGLE `custom_extensions` block on the IR after validation (see
-// convertModel). Operates on the parsed document before validation.
+// to `datasets:`. Operates on the parsed document before validation.
 function normalizeDocumentSugars(doc, extended) {
     if (!doc || typeof doc !== 'object')
         return doc;
@@ -1154,17 +1151,6 @@ function normalizeModelSugars(m, extended) {
         delete m.entities;
     }
 }
-// Builds the GOOGLE custom-extension block that carries a model's deployment
-// target URIs on the IR (the form the deploy leg reads). The native
-// `deployments:` list folds into this block after validation (see
-// convertModel). The extended profile rejects any authored GOOGLE block (see
-// rejectGoogleBlock), so there is never a pre-existing one to reconcile with.
-function deploymentTargetsExtension(targets) {
-    return {
-        vendorName: exports.GOOGLE_VENDOR,
-        data: JSON.stringify({ deploymentTargets: targets }),
-    };
-}
 // True when `vendorName` names the GOOGLE vendor, in any letter case.
 function isGoogleVendor(vendorName) {
     return typeof vendorName === 'string' &&
@@ -2081,20 +2067,9 @@ function convertModel(m, version, opts, warnings) {
     const ai = aiContextOrUndefined(m.ai_context);
     if (ai)
         model.aiContext = ai;
-    // The blocks the model keeps are carried verbatim. Under the extended
-    // profile the native `deployments` list is folded into a GOOGLE block
-    // appended after them; no authored GOOGLE block can collide with it, since
-    // that flavor rejects one (see rejectGoogleBlock).
-    // Vanilla deployments, read from a GOOGLE block, are not folded.
+    // The blocks the model keeps are carried verbatim.
     if (block.kept)
         model.customExtensions = block.kept;
-    const foldedTargets = version === exports.GOOGLE_VERSION ? deployments.map(d => d.target) : [];
-    if (foldedTargets.length) {
-        model.customExtensions = [
-            ...(model.customExtensions ?? []),
-            deploymentTargetsExtension(foldedTargets),
-        ];
-    }
     return model;
 }
 // Converts the dataset `ds`, whose GOOGLE blocks convertModel has read into