@google-cloud/kcmd 0.1.0 → 0.2.1

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

@@ -37,14 +37,19 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.importSemanticModelYaml = importSemanticModelYaml;
 const yaml = __importStar(require("yaml"));
+const semantic_model_1 = require("../layouts/semantic-model");
+const deploy_knowledge_catalog_1 = require("./deploy_knowledge_catalog");
 const deployment_target_1 = require("./deployment_target");
 const ir_1 = require("./ir");
 const loader_1 = require("./loader");
 const names_1 = require("./names");
+const parameters_1 = require("./parameters");
 const resolve_profiles_1 = require("./resolve_profiles");
+const source_dialect_1 = require("./source_dialect");
 const sql_expr_utils_1 = require("./sql_expr_utils");
 const sql_parser_1 = require("./sql_parser");
 const transpile_1 = require("./transpile");
+const validate_1 = require("./validate");
 const yaml_options_1 = require("./yaml_options");
 const yaml_update_1 = require("./yaml_update");
 const STANDARD_AI_CONTEXT_KEYS = new Set(['instructions', 'synonyms', 'examples']);
@@ -53,10 +58,14 @@ const LOADER_SOURCE_WARNING = /^(.*?): source '(.*)' is not a valid GCP resource
 // Why no name to write is given when the name holds a quote.
 const NO_QUOTE = 'kcmd cannot name a table whose name holds a quote';
 // Each kind of --source-prefix for the service `prefix` names, or every kind
-// when there is no prefix.
+// when there is no prefix. The prefix's own kind comes first, so advice names
+// its form.
 function prefixKinds(prefix) {
     const host = prefix?.base.split('/')[0];
-    return SOURCE_PREFIX_PATTERNS.filter(k => host === undefined || k.form.startsWith(`${host}/`));
+    const own = prefix &&
+        SOURCE_PREFIX_PATTERNS.find(k => k.re.test(prefix.base))?.form;
+    return SOURCE_PREFIX_PATTERNS.filter(k => host === undefined || k.form.startsWith(`${host}/`))
+        .sort((a, b) => Number(b.form === own) - Number(a.form === own));
 }
 // The warning for `source`, which import leaves as written after a run with
 // `prefix`, if any. It gives the name to write when the loader names one,
@@ -96,6 +105,19 @@ function sourceWarning(ctx, source, prefix) {
             '.') +
         ((0, loader_1.isGoogleCloudForm)(source) ? '' : ` ${loader_1.THIRD_PARTY_SOURCE}`);
 }
+// Push's error for `source`, read as the loader reads a source in `ctx`, or
+// undefined when push accepts it.
+function sourceError(source, ctx) {
+    try {
+        (0, loader_1.parseSource)(source, {}, ctx);
+        return undefined;
+    }
+    catch (err) {
+        if (!(err instanceof loader_1.SemanticModelError))
+            throw err;
+        return (0, resolve_profiles_1.readerMessage)(err);
+    }
+}
 const ALLOWED_DIALECT_SET = new Set(ir_1.ALLOWED_DIALECTS);
 const DIALECT_ALIASES = {
     GOOGLE_SQL: 'BIGQUERY',
@@ -124,6 +146,10 @@ const SOURCE_PREFIX_PATTERNS = [
         re: /^biglake\.googleapis\.com\/projects\/([^/]+)\/catalogs\/([^/.]+)\/namespaces\/([^/.]+)$/,
         form: loader_1.TABLE_FORMS.biglake,
     },
+    {
+        re: /^biglake\.googleapis\.com\/projects\/([^/]+)\/catalogs\/([^/.]+)\/databases\/([^/.]+)$/,
+        form: loader_1.TABLE_FORMS.biglakeHive,
+    },
     {
         re: /^spanner\.googleapis\.com\/projects\/([^/]+)\/instances\/([^/]+)\/databases\/([^/]+)$/,
         form: loader_1.TABLE_FORMS.spanner,
@@ -146,6 +172,10 @@ const SOURCE_PREFIX_PATTERNS = [
         form: loader_1.TABLE_FORMS.cloudsqlSchema,
     },
 ];
+// An entry group a `--source-prefix` names. A system entry group, such as
+// `@bigquery`, is refused, since its entries are Google Cloud tables, which a
+// source names by resource name.
+const ENTRY_GROUP_PREFIX = /^projects\/([^/]+)\/locations\/([^/]+)\/entryGroups\/([^/]+)$/;
 /** Filters an unknown array down to its plain-object elements. */
 function asRecords(v) {
     return Array.isArray(v) ? v.filter(loader_1.isRecord) : [];
@@ -217,20 +247,42 @@ function parseImportDocument(rawYaml, opts) {
             return err?.message ?? String(err);
         }
     }
-    // 3. Validate `opts.sourcePrefix` against the 8 supported first-party GCP
-    // container resource name patterns before doing any document work.
+    // 3. Validate `opts.sourcePrefix` against the supported first-party GCP
+    // container resource name patterns, or as an entry group, before doing any
+    // document work.
     let sourcePrefix;
+    let entryGroup;
     if (opts.sourcePrefix !== undefined) {
         const base = opts.sourcePrefix.trim();
         const match = SOURCE_PREFIX_PATTERNS.map(p => ({ m: base.match(p.re), p }))
             .find(x => x.m !== null);
-        if (!match?.m) {
+        const group = base.match(ENTRY_GROUP_PREFIX);
+        if (match?.m) {
+            sourcePrefix = { base, known: match.m.slice(1), child: match.p.child };
+        }
+        else if (group?.[3].startsWith('@')) {
+            return `sourcePrefix '${opts.sourcePrefix}' names the system entry ` +
+                `group '${group[3]}', whose entries are Google Cloud tables. Pass ` +
+                `the GCP resource name of their database instead, such as ` +
+                `'bigquery.googleapis.com/projects/<p>/datasets/<d>'.`;
+        }
+        else if (group) {
+            entryGroup = {
+                base,
+                project: group[1],
+                location: group[2],
+                group: group[3],
+                list: opts.listEntries,
+            };
+        }
+        else {
             return `Invalid sourcePrefix '${opts.sourcePrefix}'; expected the GCP ` +
                 `resource name of a BigQuery project or dataset, a BigLake ` +
-                `catalog or namespace, a Spanner database, an AlloyDB database ` +
-                `or schema, or a Cloud SQL database or schema (with no leading '//').`;
+                `catalog, namespace or Hive database, a Spanner database, an ` +
+                `AlloyDB database or schema, or a Cloud SQL database or schema ` +
+                `(with no leading '//'), or the name of a Knowledge Catalog entry ` +
+                `group ('projects/<p>/locations/<l>/entryGroups/<g>').`;
         }
-        sourcePrefix = { base, known: match.m.slice(1), child: match.p.child };
     }
     // 4. Reject a document written for kcmd when `strict` is false: one with a
     // `GOOGLE` block, or a Google-flavor model converting to vanilla.
@@ -269,6 +321,7 @@ function parseImportDocument(rawYaml, opts) {
         inputVersion,
         targetVersion,
         sourcePrefix,
+        entryGroup,
         strict,
         modified: false,
         warnings,
@@ -308,11 +361,10 @@ function parseGoogleBlocks(exts) {
 }
 /**
  * Validates all model, deployment, profile, entity/dataset, field,
- * relationship, and metric names in `doc` (plus any `googleBlocks` and
- * `profileFiles`) in a single pass so every invalid or over-length identifier
- * is reported at once.
+ * relationship, and metric names in `doc` (plus any `googleBlocks`) in a
+ * single pass so every invalid or over-length identifier is reported at once.
  */
-function validateObjectNames(doc, googleBlocks, modelScope, profileFiles) {
+function validateObjectNames(doc, googleBlocks, modelScope) {
     // Validates a single identifier `name` against `kind`'s rules via
     // `nameProblem` and appends any error to `doc.errors`.
     const validateName = (kind, name, scope) => {
@@ -327,8 +379,8 @@ function validateObjectNames(doc, googleBlocks, modelScope, profileFiles) {
         for (const record of records)
             validateName(kind, record.name, scope);
     };
-    // 1. Validate model, deployment, and profile names (inline, `GOOGLE` block,
-    // and sibling `profileFiles`).
+    // 1. Validate model, deployment, and profile names (inline and `GOOGLE`
+    // block).
     validateName('model', doc.model.name);
     validateRecords('deployment', asRecords(doc.model.deployments), modelScope);
     validateRecords('profile', asRecords(doc.model.profiles), modelScope);
@@ -336,11 +388,6 @@ function validateObjectNames(doc, googleBlocks, modelScope, profileFiles) {
         validateRecords('deployment', asRecords(g.deployments), modelScope);
         validateRecords('profile', asRecords(g.profiles), modelScope);
     }
-    if (doc.targetVersion === loader_1.OSSIE_VERSION) {
-        for (const pf of profileFiles ?? []) {
-            validateName('profile', parseProfileName(pf.fileName), modelScope);
-        }
-    }
     // 2. Validate dataset/entity, field, relationship, and metric names.
     for (const ds of doc.datasets) {
         validateName('entity', ds.name);
@@ -352,15 +399,14 @@ function validateObjectNames(doc, googleBlocks, modelScope, profileFiles) {
 }
 /**
  * Phase 2 (Pre-validation): Validates all identifier names in the input
- * document and any attached `profileFiles`. The loader rejects a model's
- * legacy `deploymentTargets`.
+ * document. The loader rejects a model's legacy `deploymentTargets`.
  */
-function validateInputDocument(doc, profileFiles) {
+function validateInputDocument(doc) {
     const modelScope = typeof doc.model.name === 'string' ?
         `model '${doc.model.name}'` :
         'model';
     const googleBlocks = parseGoogleBlocks(doc.model.custom_extensions);
-    validateObjectNames(doc, googleBlocks, modelScope, profileFiles);
+    validateObjectNames(doc, googleBlocks, modelScope);
 }
 /**
  * The parts of a bare dot-separated table name `source` as `prefix` reads
@@ -375,7 +421,7 @@ function sourceParts(source, prefix) {
         (0, loader_1.hasUnquotedWhitespace)(trimmed)) {
         return undefined;
     }
-    const segs = prefixParts(trimmed, prefix.base);
+    const segs = prefixParts(trimmed, prefix?.base ?? '');
     return segs.length && segs.every(s => s.text.length) ? segs : undefined;
 }
 /**
@@ -478,6 +524,79 @@ function completes(source, kinds) {
             qualifyTableSource(source, prefix) !== undefined;
     });
 }
+/**
+ * Phase 2b (Catalog read): When `doc.entryGroup` is set and a dataset's
+ * source is a bare table name, lists the entry group's entries once into
+ * `doc.entryTables`, keeping those whose fullyQualifiedName names a table or
+ * view. Returns the error when the list fails.
+ */
+async function listEntryTables(doc) {
+    const group = doc.entryGroup;
+    if (!group ||
+        !doc.datasets.some(ds => typeof ds.source === 'string' && sourceParts(ds.source))) {
+        return undefined;
+    }
+    const tables = [];
+    try {
+        for await (const e of group.list(group.project, group.location, group.group)) {
+            const fqn = e.fullyQualifiedName ?? '';
+            const table = (0, source_dialect_1.tableFqnParts)(fqn);
+            if (!table)
+                continue;
+            tables.push({
+                name: `${group.base}${e.name.slice(e.name.indexOf('/entries/'))}`,
+                fullyQualifiedName: fqn,
+                parts: table.parts,
+            });
+        }
+    }
+    catch (err) {
+        return `Could not list the entries of entry group '${group.base}' to ` +
+            `complete bare table names: ${err?.message ?? err}`;
+    }
+    doc.entryTables = tables;
+    return undefined;
+}
+/**
+ * Completes the bare table name `source` of `ds` with the one entry in
+ * `doc.entryTables` whose fullyQualifiedName ends in its parts, an unquoted
+ * part in any letter case and a quoted part in its own case. Leaves a name no
+ * entry or several entries end in as written, and reports it with the
+ * candidates.
+ */
+function completeFromEntryGroup(ds, source, parts, doc) {
+    const dsLabel = `dataset '${ds.name}'`;
+    const group = doc.entryGroup.base;
+    // Compared from the end, so a name with more parts than an entry's matches
+    // none.
+    const matches = doc.entryTables.filter(t => parts.every((p, i) => {
+        const e = t.parts.at(i - parts.length);
+        return p.quoted ? p.text === e : p.text.toLowerCase() === e?.toLowerCase();
+    }));
+    if (matches.length === 1) {
+        // The author asked for this rewrite with --source-prefix, so it is a
+        // warning in strict mode too.
+        const [m] = matches;
+        doc.warnings.push(`${dsLabel}: rewrote bare source '${source}' to '${m.name}', the ` +
+            `entry whose fullyQualifiedName is '${m.fullyQualifiedName}'.`);
+        ds.source = m.name;
+        doc.modified = true;
+        return;
+    }
+    const left = `${dsLabel}: left bare source '${source}' as written, since `;
+    if (matches.length) {
+        const names = matches.map(m => `'${m.name}' (${m.fullyQualifiedName})`).join(', ');
+        doc.warnOrError(`${left}several entries in entry group '${group}' have a ` +
+            `fullyQualifiedName that ends in it: ${names}. 'kcmd push' rejects ` +
+            `the file until the source names one of them.`);
+    }
+    else {
+        doc.warnOrError(`${left}no entry for a table or view in entry group '${group}' has ` +
+            `a fullyQualifiedName that ends in it. 'kcmd push' rejects the file ` +
+            `until the source is the table's GCP resource name. ` +
+            loader_1.THIRD_PARTY_SOURCE);
+    }
+}
 /**
  * When the output's flavor rejects `obj.datatype`, writes it in its canonical
  * casing, such as `Integer` for `integer`, or deletes an `Opaque` in another
@@ -618,19 +737,22 @@ function repairField(f, dsName, doc) {
 }
 /**
  * Repairs a dataset's `source` (removing query-valued sources, qualifying bare
- * table names against `doc.sourcePrefix`, and warning on unaccepted sources),
- * truncates its `description`, and repairs each of its `fields`.
+ * table names against `doc.sourcePrefix` or completing them from
+ * `doc.entryTables`, and warning on unaccepted sources), truncates its
+ * `description`, and repairs each of its `fields`.
  */
 function repairDataset(ds, doc) {
     // 1. Repair or diagnose `ds.source`: remove query-valued sources (in the
-    // Google version), qualify bare table names against `doc.sourcePrefix`, or
-    // warn on unaccepted source formats.
+    // Google version), qualify bare table names against `doc.sourcePrefix` or
+    // complete them from `doc.entryTables`, or warn on unaccepted source
+    // formats.
     const dsLabel = `dataset '${ds.name}'`;
     if (typeof ds.source === 'string') {
         const trimmed = ds.source.trim();
         const qualified = doc.sourcePrefix ?
             qualifyTableSource(trimmed, doc.sourcePrefix) :
             undefined;
+        const parts = doc.entryTables ? sourceParts(trimmed) : undefined;
         if ((0, loader_1.hasUnquotedWhitespace)(trimmed)) {
             if (doc.targetVersion === loader_1.OSSIE_VERSION) {
                 doc.errors.push(`${dsLabel}: query-valued source '${trimmed}' is not supported, ` +
@@ -651,8 +773,10 @@ function repairDataset(ds, doc) {
             ds.source = qualified;
             doc.modified = true;
         }
-        else if (!((0, loader_1.oldSourceForm)(trimmed) === undefined &&
-            (0, loader_1.isAcceptedSource)(trimmed))) {
+        else if (parts) {
+            completeFromEntryGroup(ds, trimmed, parts, doc);
+        }
+        else if (sourceError(trimmed, dsLabel) !== undefined) {
             // Why a prefix that nearly fits the name cannot complete it.
             const p = doc.sourcePrefix;
             const caseOnly = !!p && qualifyTableSource(trimmed, p, true) !== undefined;
@@ -719,12 +843,51 @@ function repairMetric(mt, entityNames, impliedDialect, doc) {
     truncateDescription(mt, mtLabel, doc);
     return true;
 }
+/**
+ * Reads, with `opts.readDialects`, the dialect of each Cloud SQL, Spanner and
+ * third-party table the repaired model and its profile files name, as push
+ * reads them. A read that fails is one warning per table, or per database for
+ * Spanner, and the dialect of the tables it reads stays unknown. A lookup that
+ * cannot start is one warning for the run, and every such table's dialect
+ * stays unknown. An entry that was read and gives no dialect is reported as
+ * push's other refusals are.
+ */
+async function readSourceDialects(doc, opts) {
+    // The repaired sources are in `doc.root`, and JSON is YAML.
+    const texts = [
+        JSON.stringify(doc.root),
+        ...(opts.profileFiles ?? []).map(f => f.content),
+    ];
+    if (!opts.readDialects || !(0, source_dialect_1.sourcesToLookUp)(texts).length)
+        return {};
+    let got;
+    try {
+        got = await opts.readDialects(texts);
+    }
+    catch (err) {
+        // The lookup could not start, for example with no credentials. gcloud
+        // prints the details, so the warning keeps the first line.
+        const why = String(err?.message ?? err).split('\n')[0];
+        doc.warnings.push(`${(0, parameters_1.sentence)(`kcmd could not look up table dialects: ${why}`)} Import ` +
+            "skipped the checks that need a table's dialect.");
+        return {};
+    }
+    const skipped = 'Import skipped the checks that need its dialect.';
+    for (const e of got.errors) {
+        if (got.unread.includes(e))
+            doc.warnings.push(`${(0, parameters_1.sentence)(e)} ${skipped}`);
+        else
+            doc.warnOrError(e);
+    }
+    return { sourceDialects: got.dialects, sourceDatabases: got.databases };
+}
 /**
  * Phase 3 (Repair): Repairs third-party constructs in-place on `doc` (pruning
  * extra models, repairing datasets and their fields, pruning unanchored
- * metrics, and truncating descriptions > 2,000 chars).
+ * metrics, and truncating descriptions > 2,000 chars). Returns the source
+ * dialects it reads after repairing the datasets.
  */
-function repairDocument(doc) {
+async function repairDocument(doc, opts) {
     // 1. Prune extra models after `semantic_model[0]` because `kcmd` allows only
     // a single model per document, and cap the model's `description` at 2,000
     // characters (`MAX_ENTRY_DESCRIPTION`).
@@ -742,16 +905,24 @@ function repairDocument(doc) {
     for (const ds of doc.datasets) {
         repairDataset(ds, doc);
     }
-    // 3. Infer the model's source dialect from its repaired datasets via
-    // `sourcesDialect`, and repair or prune each metric (`repairMetric`).
+    // 3. Read the source dialects, infer the model's source dialect from its
+    // repaired datasets via `sourcesDialect`, and repair or prune each metric
+    // (`repairMetric`). An ANSI_SQL text is not read when no lookup gave its
+    // tables' dialect, as push's checks read none.
+    const load = await readSourceDialects(doc, opts);
     const entityNames = doc.datasets.map(ds => ds.name)
         .filter((n) => typeof n === 'string');
     const impliedDialect = (0, resolve_profiles_1.sourcesDialect)({
-        entities: doc.datasets.map(ds => ({
-            abstract: Boolean(ds.abstract),
-            authoredSource: typeof ds.source === 'string' ? ds.source : undefined,
-            dataSource: '',
-        })),
+        entities: doc.datasets.map(ds => {
+            const source = typeof ds.source === 'string' ? ds.source : undefined;
+            const key = source && (0, loader_1.dialectLookupKey)(source.trim());
+            return {
+                abstract: Boolean(ds.abstract),
+                authoredSource: source,
+                dataSource: '',
+                sourceDialect: key ? load.sourceDialects?.get(key) : undefined,
+            };
+        }),
     });
     doc.metrics = doc.metrics.filter(mt => repairMetric(mt, entityNames, impliedDialect, doc));
     if (Array.isArray(doc.model.metrics) && doc.model.metrics.length) {
@@ -766,6 +937,7 @@ function repairDocument(doc) {
             truncateDescription(b, rLabel, doc);
         }
     }
+    return load;
 }
 /**
  * Sets `version` to `doc.targetVersion`, and names the model's entity list as
@@ -985,9 +1157,13 @@ function moveConstructs(doc, profileFiles) {
 /**
  * Loads `doc.root` into the `SemanticModel` IR, runs `transpileModel` to
  * translate vendor or double-quoted `ANSI_SQL` expressions to `BIGQUERY`, and
- * writes any newly added `BIGQUERY` dialect entries back onto `doc`.
+ * writes any newly added `BIGQUERY` dialect entries back onto `doc`, including
+ * the field bindings of each BigQuery profile (`isBigQueryProfile`) in the
+ * model's `GOOGLE` blocks. Translates the BigQuery profiles among
+ * `profileFiles` the same way and returns every file. A warning about a JSON
+ * profile file names the matching file of `inputFiles`.
  */
-async function transpileDocument(doc) {
+async function transpileDocument(doc, profileFiles, inputFiles = profileFiles) {
     let preLoaded;
     try {
         preLoaded = (0, loader_1.fromDocument)(doc.root, { bindingOptional: true, warnUnacceptedSource: true });
@@ -995,24 +1171,37 @@ async function transpileDocument(doc) {
     catch (err) {
         if (!(err instanceof loader_1.SemanticModelError))
             throw err;
-        return;
+        return profileFiles;
     }
-    // Writes `irDialects` back onto `rawNode.expression` when `transpileModel`
-    // appended a new dialect entry (e.g. `BIGQUERY`).
-    const syncNode = (rawNode, irDialects) => {
-        const prevCount = typeof rawNode.expression === 'string' ?
-            1 :
-            asRecords(rawNode.expression?.dialects).length;
-        if (prevCount > 0 && irDialects && irDialects.length > prevCount) {
-            rawNode.expression = {
-                dialects: irDialects.map(d => ({ dialect: d.dialect, expression: d.expression })),
-            };
+    const syncNode = (...args) => {
+        if (syncDialects(...args))
             doc.modified = true;
-        }
     };
+    // Each of `profileFiles` as loaded, or undefined for one that does not
+    // load. That one is written as it is when it parses, since push reports it.
+    const loaded = profileFiles.map(pf => {
+        try {
+            return (0, resolve_profiles_1.loadProfileFile)(pf.content, parseProfileName(pf.fileName), { skipActions: true });
+        }
+        catch (err) {
+            if (!(err instanceof loader_1.SemanticModelError))
+                throw err;
+            return undefined;
+        }
+    });
+    let translatedFiles = profileFiles;
     for (const m of preLoaded.models) {
-        const transpiled = await (0, transpile_1.transpileModel)(m);
+        const transpiled = await (0, transpile_1.transpileModel)({
+            ...m,
+            profiles: [...(m.profiles ?? []), ...loaded.filter(p => p !== undefined)],
+        }, { translatesProfile: isBigQueryProfile });
         doc.warnings.push(...transpiled.warnings);
+        const profile = (name) => transpiled.model.profiles?.find(p => p.name === name);
+        translatedFiles = profileFiles.map((pf, i) => {
+            const p = loaded[i] && profile(loaded[i].name);
+            const named = { ...pf, fileName: inputFiles[i].fileName };
+            return p ? { ...pf, content: withDialects(named, p, doc) } : pf;
+        });
         for (const ds of doc.datasets) {
             const irEntity = transpiled.model.entities.find(e => e.name === ds.name);
             for (const f of asRecords(ds.fields)) {
@@ -1022,57 +1211,143 @@ async function transpileDocument(doc) {
         for (const mt of doc.metrics) {
             syncNode(mt, transpiled.model.metrics.find(x => x.name === mt.name)?.dialects);
         }
+        // A profile in a GOOGLE block is JSON text, so a block whose profiles
+        // gained an entry is written back as JSON.
+        for (const block of asRecords(doc.model.custom_extensions)) {
+            const data = parseGoogleBlocks([block])[0];
+            let changed = false;
+            for (const p of asRecords(data?.profiles)) {
+                changed = syncProfile(p, profile(p.name)) || changed;
+            }
+            if (changed) {
+                block.data = JSON.stringify(data);
+                doc.modified = true;
+            }
+        }
+    }
+    return translatedFiles;
+}
+// Whether `profile` is a BigQuery profile of `model`, by the rule push's import
+// hint uses: each source push accepts that it states for a concrete entity of
+// `model` is a BigQuery or BigLake table, and it states at least one.
+function isBigQueryProfile(profile, model) {
+    const concrete = new Set(model.entities.filter(e => !e.abstract).map(e => e.name));
+    const entities = profile.entities.flatMap(({ name, source }) => concrete.has(name) && source !== undefined &&
+        sourceError(source, '') === undefined ?
+        [{ authoredSource: source, dataSource: source }] :
+        []);
+    return (0, resolve_profiles_1.sourcesDialect)({ entities }) === 'BIGQUERY';
+}
+/**
+ * Adds to `rawNode.expression` each dialect entry, such as `BIGQUERY`, that
+ * `transpileModel` appended to `irDialects`, and returns whether it added any.
+ * The entries already in a dialects list stay as written.
+ */
+function syncDialects(rawNode, irDialects) {
+    const dialects = rawNode.expression?.dialects;
+    const prevCount = typeof rawNode.expression === 'string' ?
+        1 :
+        asRecords(dialects).length;
+    if (prevCount === 0 || !irDialects || irDialects.length <= prevCount) {
+        return false;
+    }
+    const entries = irDialects.map(d => ({ dialect: d.dialect, expression: d.expression }));
+    if (typeof rawNode.expression === 'string') {
+        rawNode.expression = { dialects: entries };
+    }
+    else {
+        dialects.push(...entries.slice(prevCount));
+    }
+    return true;
+}
+/**
+ * Writes onto the raw profile `p` each field expression that gained a dialect
+ * entry in the translated `irProfile`, and returns whether any did.
+ */
+function syncProfile(p, irProfile) {
+    let changed = false;
+    for (const pe of asRecords(p.entities)) {
+        const irEntity = irProfile?.entities.find(x => x.name === pe.name);
+        for (const f of asRecords(pe.fields)) {
+            const irField = irEntity?.fields?.find(x => x.name === f.name);
+            changed = syncDialects(f, irField?.dialects) || changed;
+        }
     }
+    return changed;
+}
+/**
+ * Returns the content of the profile file `file` with each field expression
+ * that gained a dialect entry in the translated `profile`, written as the
+ * model file is. A JSON file that changes is written as YAML, and a warning
+ * on `doc` names it.
+ */
+function withDialects({ fileName, content }, profile, doc) {
+    const { document, text } = (0, yaml_update_1.parseForUpdate)(content);
+    const root = (0, resolve_profiles_1.plainCopy)(document.toJS());
+    const links = (0, yaml_update_1.linkNodes)(root, document.contents);
+    if (!syncProfile(root, profile))
+        return content;
+    if (text !== content)
+        doc.warnings.push(`Converted '${fileName}' to YAML.`);
+    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));
         }
     }
 }
+/**
+ * Records push's error for the profile files `profileFiles` beside a vanilla
+ * input in `modelFile`, which keeps its profiles in its `GOOGLE` block. Push
+ * checks the name of each file first. The message is an error in strict mode
+ * and a warning otherwise.
+ */
+function checkVanillaProfileFiles(doc, profileFiles, modelFile) {
+    if (doc.inputVersion !== loader_1.OSSIE_VERSION || profileFiles.length === 0)
+        return;
+    const badName = profileFiles
+        .map(pf => (0, semantic_model_1.profileNameError)(pf.fileName, parseProfileName(pf.fileName)))
+        .find(e => e !== undefined);
+    doc.warnOrError(badName ?? (0, semantic_model_1.vanillaSiblingError)(profileFiles[0].fileName, modelFile));
+}
 /**
  * Loads each sibling `<model>.profile.<name>.yaml` entry in `profileFiles` via
  * `loadProfileFile` and attaches the resulting `ProfileSpec` list to
- * `model.profiles`, recording any reserved or duplicate profile name or
- * profile load error in `doc.errors`.
+ * `model.profiles`. Records in `doc.errors` push's error for the first file
+ * that breaks a file rule beside `modelFile`, or each profile's load error
+ * labeled with its file.
  */
-function attachProfileFiles(model, profileFiles, doc) {
-    if (!profileFiles?.length)
+function attachProfileFiles(model, profileFiles, doc, modelFile) {
+    const files = (profileFiles ?? []).map(pf => ({ ...pf, name: parseProfileName(pf.fileName) }));
+    // Push checks every file's name before it loads any profile, and stops at
+    // the first file that breaks a file rule.
+    const seen = new Map();
+    try {
+        for (const pf of files) {
+            (0, semantic_model_1.checkProfileFileName)(modelFile, pf.fileName, pf.name, pf.content, seen);
+        }
+    }
+    catch (err) {
+        if (!(err instanceof semantic_model_1.ProfileFileError))
+            throw err;
+        doc.errors.push(err.message);
         return;
+    }
     const profiles = [];
-    const seen = new Set();
-    for (const pf of profileFiles) {
-        const profileName = parseProfileName(pf.fileName);
-        if ((0, names_1.nameProblem)('profile', profileName))
-            continue;
-        const lower = profileName.toLowerCase();
-        if (lower === resolve_profiles_1.DEFAULT_PROFILE) {
-            doc.errors.push(`model '${model.name}': a profile may not be named ` +
-                `'${profileName}'; '${resolve_profiles_1.DEFAULT_PROFILE}' names the model's inline ` +
-                `bindings.`);
-            continue;
-        }
-        if (seen.has(lower)) {
-            doc.errors.push(`model '${model.name}': duplicate profile name '${profileName}'; ` +
-                `profile names must be unique ignoring case.`);
-            continue;
-        }
-        seen.add(lower);
+    for (const pf of files) {
         try {
-            profiles.push((0, resolve_profiles_1.loadProfileFile)(pf.content, profileName));
+            profiles.push((0, resolve_profiles_1.loadProfileFile)(pf.content, pf.name));
         }
         catch (err) {
             if (!(err instanceof loader_1.SemanticModelError))
                 throw err;
-            doc.errors.push(err.message);
+            doc.errors.push(`[${pf.fileName}] ${err.message}`);
         }
     }
     if (profiles.length > 0) {
@@ -1152,7 +1427,7 @@ async function generateConvertedFiles(doc, opts) {
     if (!model)
         return [];
     if (doc.targetVersion === loader_1.OSSIE_VERSION) {
-        attachProfileFiles(model, opts.profileFiles, doc);
+        attachProfileFiles(model, opts.profileFiles, doc, opts.fileName ?? `${model.name}.yaml`);
         validateOssieConversion(model, doc);
         if (doc.errors.length > 0)
             return [];
@@ -1163,13 +1438,22 @@ async function generateConvertedFiles(doc, opts) {
  * Phase 4 (Adapt): Adapts `doc` in place to its target version
  * (`moveConstructs`, then `adaptToGoogleVersion` or `adaptToOssieVersion`),
  * optionally transpiles expressions via `transpileDocument`, and returns the
- * output files. Every value these steps do not change keeps its text.
+ * output files: the model file, then the profile files. An import that keeps
+ * the flavor writes `profileFiles` under the model's name. Every value these
+ * steps do not change keeps its text.
  */
 async function generateAdaptedFiles(doc, transpile, profileFiles = []) {
     // 1. Adapt `doc` in place to the target output version (`0.2.0.dev0/google`
-    // or `0.2.0.dev0`).
-    const profiles = doc.inputVersion === doc.targetVersion ?
-        [] :
+    // or `0.2.0.dev0`). Each of `profileFiles` goes under the model's name. A
+    // nameless `<file>.profile.yaml` stays nameless, so push reports it.
+    let profiles = doc.inputVersion === doc.targetVersion ?
+        profileFiles.map(pf => ({
+            fileName: /\.profile\.ya?ml$/i.test(pf.fileName) &&
+                parseProfileName(pf.fileName) === '' ?
+                `${doc.model.name}.profile.yaml` :
+                `${doc.model.name}.profile.${parseProfileName(pf.fileName)}.yaml`,
+            content: pf.content,
+        })) :
         moveConstructs(doc, profileFiles);
     if (doc.inputVersion === loader_1.OSSIE_VERSION &&
         doc.targetVersion === loader_1.GOOGLE_VERSION) {
@@ -1179,9 +1463,10 @@ async function generateAdaptedFiles(doc, transpile, profileFiles = []) {
         adaptToOssieVersion(doc);
     }
     // 2. When `transpile` is enabled and no prior errors occurred, translate
-    // vendor or double-quoted `ANSI_SQL` expressions to `BIGQUERY`.
+    // vendor or double-quoted `ANSI_SQL` expressions to `BIGQUERY`, in the model
+    // and in each BigQuery profile, in its GOOGLE blocks or among `profiles`.
     if (transpile && doc.errors.length === 0) {
-        await transpileDocument(doc);
+        profiles = await transpileDocument(doc, profiles, doc.inputVersion === doc.targetVersion ? profileFiles : profiles);
     }
     // 3. Write `doc.root` into the input's text when modified or preserve the
     // text verbatim when unmodified.
@@ -1211,17 +1496,29 @@ function writeDocument(doc, root) {
     return (0, yaml_update_1.updateText)(doc.text, doc.document, root, doc.links);
 }
 /**
- * Phase 5 (Post-validation): Validates the serialized output YAML with
- * `loadModels` (`warnUnacceptedSource: !doc.strict`) and checks deployment
- * targets.
+ * Phase 5 (Post-validation): Validates the output model file with `loadModels`
+ * (`warnUnacceptedSource: !doc.strict`), checks deployment targets, and runs
+ * push's local checks (`localChecks`) on the model file and each profile it
+ * declares, with the source dialects in `load`. With KC_V2_ASPECTS on, it also
+ * checks that Knowledge Catalog can store each aspect. It also gives push's
+ * warnings from the Knowledge Catalog entry builder, the pruning and each
+ * graph, and leaves out push's notes.
  */
-function validateOutputDocument(content, doc) {
+async function validateOutputDocument(files, doc, opts, load) {
+    const [{ fileName, content }, ...profileFiles] = files;
     try {
         // 1. Load the serialized output YAML with `loadModels`
         // (`warnUnacceptedSource: !doc.strict`) to run full schema and semantic
         // validation while turning unaccepted table sources into warnings in
-        // non-strict mode, deduplicating warnings already recorded.
-        const loaded = (0, loader_1.loadModels)(content, { bindingOptional: true, warnUnacceptedSource: !doc.strict });
+        // non-strict mode, deduplicating warnings already recorded. Step 2 gives
+        // push's error for a field its table cannot run, so the load does not
+        // warn about it too.
+        const loaded = (0, loader_1.loadModels)(content, {
+            bindingOptional: true,
+            warnUnacceptedSource: !doc.strict,
+            fieldTextChecked: true,
+            sourceDialects: load.sourceDialects,
+        });
         for (const w of loaded.warnings) {
             // The repair step has reported each source the loader warns about.
             if (LOADER_SOURCE_WARNING.test(w))
@@ -1230,10 +1527,105 @@ function validateOutputDocument(content, doc) {
                 doc.warnings.push(w);
             }
         }
-        // 2. Validate every deployment target on the loaded model using
-        // `validateDeploymentTargets`.
-        for (const m of loaded.models) {
-            validateDeploymentTargets(m, doc);
+        // 2. Run push's local checks on the model file and each profile it
+        // declares. What push rejects is an error in strict mode and a warning
+        // otherwise.
+        const input = doc.strict ? opts.fileName : undefined;
+        const model = {
+            name: (input ?? fileName).replace(/\.ya?ml$/, ''),
+            text: content,
+        };
+        // Where the input holds profile `name`, which the output writes in
+        // `written`: its profile file, or the model file's GOOGLE block. Strict
+        // mode writes nothing on an error, so its messages name the input.
+        const inputFiles = doc.inputVersion === loader_1.GOOGLE_VERSION ? opts.profileFiles ?? [] : [];
+        const where = (name, written) => !input ? written :
+            inputFiles.find(pf => parseProfileName(pf.fileName) === name)
+                ?.fileName ??
+                model.name;
+        // Push stops at a profile file that breaks a file rule, then at a
+        // deployment target in no accepted form. validateDeploymentTargets reports
+        // such a target as an error in either mode.
+        let read;
+        try {
+            const seen = new Map();
+            read = profileFiles.map(f => {
+                const name = parseProfileName(f.fileName);
+                const label = where(name, f.fileName);
+                (0, semantic_model_1.checkProfileFileName)(input ?? fileName, label, name, f.content, seen);
+                return { name, text: f.content, fileName: label };
+            });
+        }
+        catch (err) {
+            if (!(err instanceof semantic_model_1.ProfileFileError))
+                throw err;
+            doc.warnOrError(err.message);
+        }
+        if (!doc.errors.length) {
+            for (const m of loaded.models)
+                validateDeploymentTargets(m, doc);
+        }
+        const profiles = read;
+        if (!profiles)
+            return;
+        const declaredBy = () => (0, resolve_profiles_1.declaredProfiles)(model, profiles).map(p => 'spec' in p ? { ...p, label: where(p.name, model.name) } : p);
+        // Push stops at a source its loader rejects. Import still reports each
+        // profile's problems, its sources among them.
+        if (loaded.warnings.some(w => LOADER_SOURCE_WARNING.test(w))) {
+            for (const { error } of (0, resolve_profiles_1.namedProfileErrors)([model], new Map([[model.name, loaded.models[0]]]), () => profiles, declaredBy, doc.warnings, load)) {
+                doc.warnOrError(error);
+            }
+            return;
+        }
+        if (doc.errors.length)
+            return;
+        const base = { document: model.name, model: loaded.models[0] };
+        const own = loaded.warnings.map(w => `[${model.name}] ${w}`);
+        // Push prints each warning once, after the load's. Each is a warning in
+        // either mode.
+        const warn = (w) => {
+            if (!own.includes(w) && !doc.warnings.includes(w))
+                doc.warnings.push(w);
+        };
+        const withFiles = (0, validate_1.withProfileFiles)(base, () => profiles);
+        const checked = 'errors' in withFiles ? withFiles : await (0, validate_1.localChecks)({
+            docs: [model],
+            loaded: { models: [base], warnings: own },
+            models: [withFiles],
+            profileDocs: () => profiles,
+            declaredBy,
+            load,
+        }, warn);
+        // Push prints each error once.
+        const errors = 'errors' in checked ? checked.errors : [];
+        for (const error of new Set(errors.map(e => e.error))) {
+            doc.warnOrError(error);
+        }
+        if ('errors' in checked || 'errors' in withFiles)
+            return;
+        // Push next builds the Knowledge Catalog entries and prints the builder's
+        // warnings. With KC_V2_ASPECTS on, it also checks that Knowledge Catalog
+        // can store each aspect. The entry group does not change an aspect's size.
+        const v2Aspects = (0, validate_1.kcV2Aspects)();
+        const catalog = (0, deploy_knowledge_catalog_1.checkCatalogAspects)([withFiles], {
+            project: 'p', location: 'l', entryGroup: 'g',
+            systemTypeProject: process.env.KC_TYPE_PROJECT, v2Aspects,
+        });
+        for (const w of catalog.warnings)
+            warn(w);
+        if (v2Aspects && catalog.error) {
+            doc.warnOrError(catalog.error);
+            return;
+        }
+        // Push then warns about what pruning leaves out of each deployment, and
+        // about what each graph leaves out. Import leaves out push's notes.
+        for (const line of checked.plans.flatMap(validate_1.pruningLines)) {
+            if (line.startsWith('Warning: '))
+                warn(line.slice('Warning: '.length));
+        }
+        for (const { generated } of checked.plans) {
+            for (const w of generated?.warnings ?? [])
+                warn(w);
         }
     }
     catch (err) {
@@ -1248,23 +1640,51 @@ function validateOutputDocument(content, doc) {
  * errors.
  */
 async function importSemanticModelYaml(rawYaml, opts = {}) {
-    // 1. Initialize the SQL parser and parse/pre-validate the input document.
+    // 1. Initialize the SQL parser and parse/pre-validate the input document,
+    // and report any profile file beside a vanilla input as push does.
     await (0, sql_parser_1.loadSqlEngine)();
     const doc = parseImportDocument(rawYaml, opts);
     if (typeof doc === 'string') {
         return { ok: false, files: [], warnings: [], errors: [doc] };
     }
-    validateInputDocument(doc, opts.profileFiles);
-    // 2. Run third-party repairs (which record errors in `strict` mode).
-    repairDocument(doc);
-    // 3. Generate the converted or adapted output file(s).
+    validateInputDocument(doc);
+    checkVanillaProfileFiles(doc, opts.profileFiles ?? [], opts.fileName ?? `${doc.model.name}.yaml`);
+    // 2. Read the `--source-prefix` entry group, if needed, and run third-party
+    // repairs (which record errors in `strict` mode) and read the source
+    // dialects.
+    const listError = await listEntryTables(doc);
+    if (listError) {
+        return {
+            ok: false,
+            files: [],
+            warnings: doc.warnings,
+            errors: [...doc.errors, listError],
+        };
+    }
+    const load = await repairDocument(doc, opts);
+    // 3. Generate the converted or adapted output file(s). A conversion to
+    // `0.2.0.dev0` writes the sibling profile files inside the model file, and
+    // a Google-flavor import of a Google-flavor model writes them beside it.
     const shouldConvert = doc.inputVersion !== doc.targetVersion && doc.strict;
+    const googleToGoogle = doc.inputVersion === loader_1.GOOGLE_VERSION &&
+        doc.targetVersion === loader_1.GOOGLE_VERSION;
     const files = shouldConvert ?
         await generateConvertedFiles(doc, opts) :
-        await generateAdaptedFiles(doc, !!opts.transpile);
-    // 4. Validate the primary output document and return the result.
+        await generateAdaptedFiles(doc, !!opts.transpile, googleToGoogle ? opts.profileFiles ?? [] : []);
+    // 4. Check that each profile file the import writes parses, validate the
+    // output files, and return the result.
+    for (const [i, f] of files.slice(1).entries()) {
+        const [problem] = yaml.parseDocument(f.content, yaml_options_1.YAML_OPTIONS).errors;
+        if (!problem)
+            continue;
+        // A file import passes through unchanged is the input's own file.
+        const input = opts.profileFiles?.[i];
+        doc.errors.push(input?.content === f.content ?
+            (0, semantic_model_1.profileParseError)(input.fileName, problem.message) :
+            `the import writes '${f.fileName}', which does not parse: ${problem.message}`);
+    }
     if (files.length > 0 && doc.errors.length === 0) {
-        validateOutputDocument(files[0].content, doc);
+        await validateOutputDocument(files, doc, opts, load);
     }
     return {
         ok: doc.errors.length === 0,