@google-cloud/kcmd 0.1.0 → 0.2.1

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

@@ -45,6 +45,15 @@ const HEADING = '## OKF Metadata';
 const OPEN = '```yaml';
 const CLOSE = '```';
 const MARKER = `\n\n${HEADING}\n\n${OPEN}\n`;
+// Frontmatter keys stored natively on the catalog entry or in kcmd residue/links,
+// so they are not duplicated into the trailing `## OKF Metadata` block.
+const NON_CARRIED_KEYS = new Set([
+    'type',
+    ...concept_1.ENTRY_SOURCE_KEYS,
+    concept_1.RESIDUE_KEY,
+    concept_1.EXTRA_KEY,
+    'links',
+]);
 /** Appends the section. The body is returned unchanged when there is none. */
 function appendOkfMetadata(body, frontmatter) {
     const carried = {};
@@ -52,6 +61,14 @@ function appendOkfMetadata(body, frontmatter) {
         if (frontmatter[key] !== undefined)
             carried[key] = frontmatter[key];
     }
+    // Preserve `x-*` producer extensions (SPEC §4.1) and any other unknown OKF
+    // frontmatter keys across push -> pull.
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (value === undefined || key in carried || NON_CARRIED_KEYS.has(key)) {
+            continue;
+        }
+        carried[key] = value;
+    }
     if (!Object.keys(carried).length)
         return body;
     const block = yaml.stringify(carried);

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

@@ -27,6 +27,7 @@ const graph_ddl_1 = require("./graph_ddl");
 const ir_1 = require("./ir");
 const sql_expr_utils_1 = require("./sql_expr_utils");
 const sql_identifiers_1 = require("./sql_identifiers");
+const sql_parser_1 = require("./sql_parser");
 /**
  * Generates the BigQuery property-graph DDL for a semantic model.
  *
@@ -58,8 +59,9 @@ function bigQueryEngine(opts) {
 // it to a MEASURE over an exposed property (see placeMetric).
 function placeMetrics(metrics, input, warnings) {
     const loweringByEntity = new Map();
+    const metricNames = new Set(metrics.map(m => m.name));
     for (const metric of metrics) {
-        placeMetric(metric, input, loweringByEntity, warnings);
+        placeMetric(metric, input, metricNames, loweringByEntity, warnings);
     }
     // The operand properties come first: the measures aggregate them.
     const placed = new Map();
@@ -69,36 +71,65 @@ function placeMetrics(metrics, input, warnings) {
     return placed;
 }
 // Builds the lowering state for an entity, seeded with its declared fields so
-// an operand equal to an existing field reuses that property instead of
-// duplicating.
-function newLowering(entity) {
+// an operand with the same SQL as a field reuses that property instead of
+// duplicating it. A field the node table leaves out has no property to reuse,
+// and neither has an ambiguous one.
+//
+// A field is ambiguous when the node's table has a column of its name that the
+// field does not read whole, such as `amount` bound to `amount_usd` while
+// `amount_local` is bound to the column `amount`. A measure that names it
+// names both, and BigQuery rejects the graph: "Name amount is ambiguous
+// because it exists as both a column and a graph property". The columns the
+// table is known to have are its key columns and those the fields' SQL reads.
+function newLowering(entity, input, metricNames) {
     const taken = new Set();
-    const fieldNames = new Set();
-    const byLocalExpr = new Map();
+    const sqlOf = new Map();
     for (const f of entity.fields) {
         taken.add(f.name);
-        fieldNames.add(f.name);
-        const expr = fieldExpression(f);
-        if (expr === undefined)
-            continue;
-        const local = (0, sql_expr_utils_1.stripQualifier)(expr, entity.name);
-        if (!byLocalExpr.has(local))
-            byLocalExpr.set(local, f.name);
+        const read = input.renderedFieldSql(entity, f);
+        if ('sql' in read)
+            sqlOf.set(f.name, read.sql);
+    }
+    const columns = new Set((0, graph_ddl_1.nodeKey)(entity).map(k => k.replace(/^`(.*)`$/, '$1').toLowerCase()));
+    for (const sql of sqlOf.values()) {
+        // The SQL is local to the table, so `a.b` reads the column `a`.
+        for (const c of (0, sql_expr_utils_1.columnReferences)((0, sql_identifiers_1.quoteIfReserved)(sql), 'BIGQUERY') ?? []) {
+            columns.add((c.qualifier ?? c.name).toLowerCase());
+        }
+    }
+    const ambiguous = new Set();
+    const byLocalExpr = new Map();
+    for (const [name, sql] of sqlOf) {
+        if (columns.has(name.toLowerCase()) &&
+            loneColumn(sql)?.toLowerCase() !== name.toLowerCase()) {
+            ambiguous.add(name);
+        }
+        else if (!byLocalExpr.has(sql)) {
+            byLocalExpr.set(sql, name);
+        }
     }
     return {
         derivedProperties: [],
         measures: [],
         taken,
-        fieldNames,
+        metricNames,
+        ambiguous,
         byLocalExpr,
         operandToName: new Map()
     };
 }
+// The column `sql`, BigQuery SQL local to a table, is when it is one column of
+// that table and nothing else, without its quotes, as in `amount` or
+// `` `order` ``. Undefined otherwise.
+function loneColumn(sql) {
+    const column = (0, sql_parser_1.soleColumn)((0, sql_identifiers_1.quoteIfReserved)(sql), 'BIGQUERY');
+    return column && column.qualifier === undefined ? column.name : undefined;
+}
 // Assigns a metric to the node table of the single entity its aggregate
 // references, lowering it to a MEASURE over an exposed property. Records a
 // warning (and skips) when it references zero/multiple entities or is not a
 // single supported aggregate over one operand.
-function placeMetric(metric, input, loweringByEntity, warnings) {
+function placeMetric(metric, input, metricNames, loweringByEntity, warnings) {
     const { entityByName, skipped, ancestorsUsed } = input;
     // A measure is emitted from the metric's BigQuery SQL (see
     // metricExpression). A metric with SQL only for other engines is skipped
@@ -113,17 +144,15 @@ function placeMetric(metric, input, loweringByEntity, warnings) {
                 `to emit as a MEASURE)`);
         return;
     }
-    // The entities whose `<name>.` qualifier the expression uses. String literals
-    // are ignored, so a value like 'orders.x' does not reference `orders`.
-    let referenced = (0, sql_expr_utils_1.referencedEntityNames)(expression, [...entityByName.keys()]);
-    // A qualifier-free aggregate (e.g. COUNT(*)) names no entity in its
-    // expression; fall back to `metric.entity` when the IR provides one (an
-    // authored `entity` in `0.2.0.dev0/google`, an entity inferred from another
-    // dialect entry, or hand-built IR), so it can still be placed rather than
-    // dropped as "references no entity".
-    if (referenced.length === 0 && metric.entity) {
-        referenced = [metric.entity];
-    }
+    // The entities whose qualifier the expression writes before a column, as
+    // the SQL parser reads it (see measureEntities), so neither a value like
+    // 'orders.x' nor a function namespace such as `NET.` in `NET.HOST(...)`
+    // references an entity. A qualifier-free aggregate (e.g. COUNT(*)) names no
+    // entity in its expression; it falls back to `metric.entity` when the IR
+    // provides one (an authored `entity` in `0.2.0.dev0/google`, an entity
+    // inferred from another dialect entry, or hand-built IR), so it can still be
+    // placed rather than dropped as "references no entity".
+    const referenced = (0, sql_expr_utils_1.measureEntities)(expression, [...entityByName.keys()], metric.entity);
     if (referenced.length !== 1) {
         const detail = referenced.length === 0 ?
             'references no known entity' :
@@ -180,42 +209,49 @@ function placeMetric(metric, input, loweringByEntity, warnings) {
             `subtype tables; skipped`);
         return;
     }
-    const body = (0, sql_expr_utils_1.stripQualifier)(expression, entityName);
+    const body = (0, sql_expr_utils_1.withoutQualifier)(expression, entityName);
     // A graph measure must be one supported aggregate wrapping a single operand;
     // anything else (a non-aggregate, or a compound of aggregates like a ratio)
     // cannot be a single MEASURE. Flag it rather than emit DDL BigQuery rejects.
-    const agg = extractAggregate(body);
+    // The SQL parser finds the aggregate and its operand with the entity's
+    // qualifier renamed to a name it does not reserve, since it cannot read one
+    // it reserves, as in `SUM(Date.days)`.
+    const stand = (0, sql_expr_utils_1.unusedName)(expression, 'kcmd_entity');
+    const agg = (0, sql_expr_utils_1.singleAggregate)((0, sql_expr_utils_1.requalified)(expression, entityName, stand), 'BIGQUERY');
     if (!agg) {
         warnings.push(`metric '${metric.name}' expression '${body}' is not a single supported aggregate ` +
             `(${sql_expr_utils_1.SUPPORTED_AGGREGATES.join(', ')}) over one operand; skipped (cannot be a single MEASURE)`);
         return;
     }
-    const lowering = loweringByEntity.get(entityName) ?? newLowering(entity);
+    const lowering = loweringByEntity.get(entityName) ??
+        newLowering(entity, input, metricNames);
     loweringByEntity.set(entityName, lowering);
-    // Resolve the aggregate's operand to an exposed property. COUNT(*) has no
-    // operand column, so it counts the first column of the node's key instead:
-    // the primary key, else the first unique key (nodeKey).
-    let operandExpr = agg.operand;
-    const countsKey = agg.operand === '*';
-    if (countsKey) {
-        // The entity is already known to have a key (checked above), so only the
-        // aggregate itself can disqualify a `*` operand: BigQuery lowers `COUNT(*)`
-        // to a count over the key, but no other aggregate has a `*` form.
-        if (agg.fn.toUpperCase() !== 'COUNT') {
-            warnings.push(`metric '${metric.name}': '${agg.fn}(*)' is not supported; skipped ` +
-                `(only COUNT(*) over a keyed node can be lowered)`);
-            return;
-        }
-        operandExpr = (0, graph_ddl_1.nodeKey)(entity)[0];
+    // Resolve the aggregate's operand to an exposed property. It is read as
+    // written, qualifiers kept, so readOperand can tell the entity's fields from
+    // its columns. COUNT(*) has no operand column, so it counts the first column
+    // of the node's key instead: the primary key, else the first unique key
+    // (nodeKey). singleAggregate gives a `*` operand for COUNT(*) alone.
+    const operand = (0, sql_expr_utils_1.requalified)(agg.operand, stand, entityName);
+    let read;
+    if (operand === '*') {
+        // A key names a column, never a field, so a field of the same name does
+        // not stand in for it. A simple name is quoted, if reserved, where it is
+        // exposed (exposeOperand).
+        const key = (0, graph_ddl_1.nodeKey)(entity)[0];
+        read = {
+            sql: (0, sql_identifiers_1.isSimpleIdentifier)(key) ? key : (0, graph_ddl_1.physicalColumn)(key),
+            column: true
+        };
+    }
+    else {
+        // A field the node table leaves out declares no property, so neither a
+        // measure over it nor a property derived from SQL that names it can read
+        // it.
+        read = readOperand(entity, operand, input);
     }
-    // A field with no BigQuery SQL is left out of the node table, so a measure
-    // over it would aggregate a property the table does not declare.
-    if (!countsKey &&
-        entity.fields.some(f => f.name === operandExpr && (0, ir_1.isFieldBound)(f) &&
-            fieldExpression(f) === undefined)) {
-        warnings.push(`metric '${metric.name}' aggregates field '${operandExpr}', which ` +
-            `has no 'BIGQUERY' or 'ANSI_SQL' expression; skipped (nothing to ` +
-            `emit as a MEASURE)`);
+    if ('skip' in read) {
+        warnings.push(`metric '${metric.name}' ${read.skip}; skipped (nothing to emit as a ` +
+            `MEASURE)`);
         return;
     }
     // The measure is itself exposed as a node property named `metric.name`, so it
@@ -231,168 +267,76 @@ function placeMetric(metric, input, loweringByEntity, warnings) {
         return;
     }
     lowering.taken.add(metric.name);
-    const propName = countsKey ?
-        exposeKeyColumn(lowering, operandExpr, metric.name) :
-        exposeOperand(lowering, operandExpr, metric.name);
+    const propName = exposeOperand(lowering, read, metric.name);
     const aggregate = `${agg.fn}(${agg.distinct ? 'DISTINCT ' : ''}${(0, sql_identifiers_1.quoteIfReserved)(propName)})`;
     const opts = optionsClause(elementDescription(metric.description, metric.aiContext), metric.aiContext?.synonyms);
     const measure = `MEASURE(${aggregate}) AS ${(0, sql_identifiers_1.quoteIfReserved)(metric.name)}`;
     lowering.measures.push(opts ? `${measure} ${opts}` : measure);
 }
-// Ensures `operandExpr` is exposed as a node property and returns its property
-// name. Reuses an existing field (or a previously derived property) with the
-// same expression; a bare column is exposed under its own name; any other
-// expression gets a synthesized, unique name derived from the metric.
-function exposeOperand(lowering, operandExpr, metricName) {
-    const existing = lowering.byLocalExpr.get(operandExpr) ??
-        lowering.operandToName.get(operandExpr);
-    if (existing)
-        return existing;
-    // An operand that names a declared field is already an exposed property, so a
-    // MEASURE may aggregate it directly by name -- even when a profile bound that
-    // field to a differently named physical column (the property is
+function readOperand(entity, operand, input) {
+    // Checked before any column: a field is read through its own SQL, which may
+    // name another column, while a column of the same name may hold something
+    // else. The SQL parser reads the entity's qualifier renamed, as placeMetric
+    // does, since it cannot read one it reserves, as in `Date.days`.
+    const stand = (0, sql_expr_utils_1.unusedName)(operand, 'kcmd_entity');
+    const column = (0, sql_parser_1.soleColumn)((0, sql_expr_utils_1.requalified)(operand, entity.name, stand), 'BIGQUERY');
+    const own = column !== undefined &&
+        (column.qualifier === undefined ||
+            column.qualifier.toLowerCase() === stand);
+    const field = own ? entity.fields.find(f => f.name === column.name) : undefined;
+    if (field) {
+        const read = input.renderedFieldSql(entity, field);
+        return 'sql' in read ?
+            { field: field.name, sql: read.sql, column: !!loneColumn(read.sql) } :
+            { skip: `aggregates ${read.reads}` };
+    }
+    const read = input.localSql(entity, operand);
+    return 'sql' in read ? { sql: read.sql, column: own } :
+        { skip: `reads ${read.reads}` };
+}
+// Ensures the operand `read` is exposed as a node property and returns its
+// property name. A field is one already, unless it is ambiguous (see
+// newLowering); its SQL is then exposed as any other SQL is. Other SQL reuses
+// a field (or a previously derived property) with the same SQL; a column no
+// field names is exposed under its own name; any other SQL gets a
+// synthesized, unique name derived from the metric.
+function exposeOperand(lowering, read, metricName) {
+    // A MEASURE may aggregate a field directly by name -- even when a profile
+    // bound that field to a differently named physical column (the property is
     // `<column> AS <field>`, and a MEASURE may reference a sibling alias).
     // Synthesizing an input property here would emit `<field> AS ..._input`, and
     // an alias is illegal inside a property expression -- BigQuery rejects it with
-    // "Unrecognized name". (A raw column that is not a field still falls through
-    // to be exposed under its own name, which BigQuery requires.)
-    if (lowering.fieldNames.has(operandExpr))
-        return operandExpr;
+    // "Unrecognized name".
+    if (read.field !== undefined && !lowering.ambiguous.has(read.field)) {
+        return read.field;
+    }
+    const { sql } = read;
+    const existing = lowering.byLocalExpr.get(sql) ?? lowering.operandToName.get(sql);
+    if (existing)
+        return existing;
+    const isFree = (name) => !lowering.taken.has(name) && !lowering.metricNames.has(name);
     let name;
-    if ((0, sql_identifiers_1.isSimpleIdentifier)(operandExpr) && !lowering.taken.has(operandExpr)) {
-        // A bare column not already declared: expose it under its own name.
-        name = operandExpr;
+    if (read.column && (0, sql_identifiers_1.isSimpleIdentifier)(sql) && isFree(sql)) {
+        // A column not already declared: expose it under its own name.
+        name = sql;
         lowering.derivedProperties.push((0, sql_identifiers_1.quoteIfReserved)(name));
     }
     else {
-        name = uniqueName(`${metricName}_input`, lowering.taken);
-        lowering.derivedProperties.push(`${(0, sql_identifiers_1.quoteIfReserved)(operandExpr)} AS ${name}`);
+        name = uniqueName(`${metricName}_input`, isFree);
+        // Only a column is quoted: a keyword such as TRUE stays a keyword.
+        lowering.derivedProperties.push(`${read.column ? (0, sql_identifiers_1.quoteIfReserved)(sql) : sql} AS ${name}`);
     }
     lowering.taken.add(name);
-    lowering.operandToName.set(operandExpr, name);
-    return name;
-}
-// Exposes the key column COUNT(*) counts and returns its property name,
-// reusing a field whose expression is exactly that column, or the property an
-// earlier metric exposed for it.
-function exposeKeyColumn(lowering, column, metricName) {
-    const existing = lowering.byLocalExpr.get(column) ?? lowering.operandToName.get(column);
-    if (existing)
-        return existing;
-    const bare = (0, sql_identifiers_1.isSimpleIdentifier)(column) && !lowering.taken.has(column);
-    const name = bare ? column : uniqueName(`${metricName}_input`, lowering.taken);
-    lowering.derivedProperties.push(bare ? (0, sql_identifiers_1.quoteIfReserved)(column) : `${(0, graph_ddl_1.physicalColumn)(column)} AS ${name}`);
-    lowering.taken.add(name);
-    // An operand named like a field reads that field (exposeOperand), so only a
-    // column no field is named after is shared with a later metric's operand.
-    if (!lowering.fieldNames.has(column))
-        lowering.operandToName.set(column, name);
+    lowering.operandToName.set(sql, name);
     return name;
 }
-// Extracts the function name and operand from a single-aggregate expression, or
-// returns null when the body is not exactly one supported aggregate wrapping
-// one operand (a non-aggregate, a compound like `SUM(x)/SUM(y)`, a call with no
-// operand, or a multi-argument call). `COUNT(DISTINCT x)` is recognized,
-// yielding operand `x` with distinct.
-function extractAggregate(body) {
-    const s = body.trim();
-    const head = s.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
-    if (!head)
-        return null;
-    const fn = head[1];
-    if (!sql_expr_utils_1.SUPPORTED_AGGREGATES.includes(fn.toUpperCase()))
-        return null;
-    // Find the operand bounded by the aggregate's outer parentheses, tracking
-    // string literals and backtick-quoted identifiers and nesting so inner
-    // parens/quotes/backticks don't end it early.
-    let depth = 0, inStr = false, inTick = false, start = -1, end = -1;
-    for (let i = head[0].length - 1; i < s.length; i++) {
-        const c = s[i];
-        if (inStr) {
-            if (c === '\'')
-                inStr = false;
-            continue;
-        }
-        if (inTick) {
-            if (c === '`')
-                inTick = false;
-            continue;
-        }
-        if (c === '\'') {
-            inStr = true;
-            continue;
-        }
-        if (c === '`') {
-            inTick = true;
-            continue;
-        }
-        if (c === '(') {
-            if (depth === 0)
-                start = i + 1;
-            depth++;
-        }
-        else if (c === ')') {
-            if (--depth === 0) {
-                end = i;
-                break;
-            }
-        }
-    }
-    if (start < 0 || end < 0)
-        return null;
-    if (s.slice(end + 1).trim() !== '')
-        return null; // trailing ops => not a single aggregate
-    let operand = s.slice(start, end).trim();
-    let distinct = false;
-    const dm = operand.match(/^DISTINCT(?:\s+(.*))?$/is);
-    if (dm) {
-        distinct = true;
-        operand = (dm[1] ?? '').trim();
-    }
-    if (operand === '')
-        return null; // no operand, as in SUM() or SUM(DISTINCT)
-    if (operand !== '*' && hasTopLevelComma(operand))
-        return null; // multi-arg aggregate
-    return { fn, operand, distinct };
-}
-// True if `expr` contains a comma outside any nested parentheses, string
-// literal, or backtick-quoted identifier (i.e. it is really several arguments,
-// not one operand). A backtick-quoted column like `` `weird,name` `` must not
-// be mistaken for a multi-argument aggregate.
-function hasTopLevelComma(expr) {
-    let depth = 0, inStr = false, inTick = false;
-    for (const c of expr) {
-        if (inStr) {
-            if (c === '\'')
-                inStr = false;
-            continue;
-        }
-        if (inTick) {
-            if (c === '`')
-                inTick = false;
-            continue;
-        }
-        if (c === '\'')
-            inStr = true;
-        else if (c === '`')
-            inTick = true;
-        else if (c === '(')
-            depth++;
-        else if (c === ')')
-            depth--;
-        else if (c === ',' && depth === 0)
-            return true;
-    }
-    return false;
-}
-// Returns `base` if free, else the first `base_2`, `base_3`, ... not in
-// `taken`.
-function uniqueName(base, taken) {
-    if (!taken.has(base))
+// Returns `base` if free, else the first of `base_2`, `base_3`, ... that is.
+function uniqueName(base, isFree) {
+    if (isFree(base))
         return base;
     for (let i = 2;; i++) {
         const candidate = `${base}_${i}`;
-        if (!taken.has(candidate))
+        if (isFree(candidate))
             return candidate;
     }
 }

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

@@ -14,17 +14,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.boundTable = boundTable;
 exports.spannerTable = spannerTable;
+const loader_1 = require("./loader");
 const sql_identifiers_1 = require("./sql_identifiers");
-// Maps the IR's `dataSource` to the BARE table name a statement references. A
-// property graph names input tables within its own database, so only the final
-// segment of a qualified `project.dataset.table` (or any dotted source) is
-// meaningful; the leading qualifiers name where a BigQuery copy lives and have
-// no bearing on the operational table. A resource-name URI
-// (`//spanner.googleapis.com/.../tables/<t>`, or any other `scheme://.../<t>`)
-// names its table by the final PATH segment for the same reason — the leading
-// path locates the store, not the table. A verbatim query (contains whitespace)
-// cannot back a graph element table, so it is passed through parenthesized with
-// a warning.
+// The table `dataSource` names within its own database: its final dotted or
+// path segment, except that a Spanner table keeps its schema (`ops.stations`),
+// each part quoted. A query, which holds whitespace, is returned in
+// parentheses with a warning.
 function boundTable(dataSource, warnings, context, quote) {
     const trimmed = (dataSource ?? '').trim();
     if (!trimmed) {
@@ -36,12 +31,12 @@ function boundTable(dataSource, warnings, context, quote) {
             `emitting it verbatim (a graph element table requires a table)`);
         return `(${trimmed})`;
     }
-    // A BigQuery or BigLake source reaches here dotted, but a Spanner, AlloyDB or
-    // Cloud SQL source as its resource URI (see isResourceUri), so reduce a URI
-    // to its final path segment before the dotted reduction below.
+    // Reduce a URI to its final path segment. A Spanner source keeps every
+    // dotted part of it, and any other source keeps the last.
     const source = isResourceUri(trimmed) ? finalPathSegment(trimmed) : trimmed;
-    const last = splitDotted(source).map(unquote).pop() ?? source;
-    return quote(last);
+    const parts = splitDotted(source).map(unquote);
+    const kept = (0, loader_1.sourceTableOf)(trimmed)?.system === 'spanner' ? parts : parts.slice(-1);
+    return kept.map(quote).join('.');
 }
 // `boundTable` in GoogleSQL, which is what the Spanner DDL generator wants and
 // what every caller wanted when there was one backend.
@@ -50,10 +45,10 @@ function spannerTable(dataSource, warnings, context) {
 }
 // A resource URI (`//host/...`) or any `scheme://...` URI, as opposed to a bare
 // or dotted table reference. The loader gives the IR a BigQuery or BigLake
-// table, or a legacy bare name, as its dotted name, a Spanner, AlloyDB or Cloud
-// SQL table as its resource URI, with the leading `//`, and a third-party table
-// as its entry name (see `parseSource` and `sourceToDataSource`). It rejects
-// any `scheme://` source, so only a hand-built IR reaches that arm.
+// table as its dotted name, a Spanner, AlloyDB or Cloud SQL table as its
+// resource URI, with the leading `//`, and a third-party table as its entry
+// name (see `parseSource` and `sourceToDataSource`). It rejects any `scheme://`
+// source, so only a hand-built IR reaches that arm.
 function isResourceUri(source) {
     return source.startsWith('//') || /^[a-z][\w+.-]*:\/\//i.test(source);
 }

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

@@ -1,7 +1,6 @@
 import * as context from '../gcp/context';
-import { CatalogClient, Entry } from '../gcp/dataplex';
+import { Entry } from '../gcp/dataplex';
 import type { OverviewSidecar } from '../layouts/semantic-model';
-import { FileCopy } from './kc_custom_types';
 import * as kcEmit from './knowledge_catalog';
 import { LoadedModel } from './loader';
 export interface KcDeployOptions {
@@ -12,9 +11,7 @@ export interface KcDeployOptions {
     systemTypeLocation?: string;
     emitExpressions?: boolean;
     v2Aspects?: boolean;
-    sourceFiles?: FileCopy[];
     overviews?: ReadonlyMap<string, OverviewSidecar>;
-    fileCopyTypeChecked?: boolean;
     onWarnings?: (warnings: readonly string[]) => void;
     validateOnly?: boolean;
     forceRemove?: boolean;
@@ -55,14 +52,13 @@ export interface KcPreparedDeploy {
  *
  * The method performs the following actions:
  *   1. Translates the IR models into catalog resources.
- *   2. Verifies that exactly one model is being deployed and that each file
- *      copy fits in one aspect, builds the dry-run plan, and returns early
- *      when `opts.validateOnly` is set.
- *   3. Lists the destination entry group and fails if an unrecognized model's
- *      anchor entry is present without `--force-remove`.
+ *   2. Verifies that exactly one model is being deployed, builds the dry-run
+ *      plan, and returns early when `opts.validateOnly` is set.
+ *   3. Fails when the destination entry group does not exist. Lists it and
+ *      fails if an unrecognized model's anchor entry is present without
+ *      `--force-remove`.
  *   4. Verifies that every custom entry type and aspect type required by the
- *      model exists in the target project. Skips the file-copy type when
- *      `opts.fileCopyTypeChecked` is set.
+ *      model exists in the target project.
  *   5. Returns the emitted resources, entry-group listing, warnings, and plan
  *      as `prepared` for `applyKnowledgeCatalog`.
  * With `opts.v2Aspects` set, step 2 also checks every aspect's size.
@@ -98,32 +94,11 @@ export declare function deployEmittedModels(emitted: EmittedModel[], emitWarning
 export declare function oneModelPerEntryGroupMessage(entryGroup: string, models: number): string;
 export declare const MAX_ASPECT_DATA_BYTES: number;
 /**
- * Checks a push's file copies before anything is written. Returns the error
- * to report, or undefined when every copy fits in one aspect and no two file
- * names map to one entry id.
- *
- * Push calls it before any graph deploys. Every copy of a model shares the
- * model's part of the entry id, so two file names collide when their slugs
- * do.
- */
-export declare function checkFileCopies(files: readonly FileCopy[]): string | undefined;
-/**
- * The emitter's warnings for `models` with v2Aspects on, and why push's
- * catalog leg cannot write them: an emit error or an aspect too large to
- * store. 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;
     warnings: string[];
 };
-/**
- * Checks that each custom type in `typeIds` exists in the destination
- * project. Returns the error to report, or undefined when every one exists.
- *
- * Push also calls it before any graph deploys, for the file-copy type every
- * push with v2Aspects off needs. Push then sets `fileCopyTypeChecked`, so the
- * catalog preflight looks up only the other custom types.
- */
-export declare function checkCustomTypes(cat: CatalogClient, dest: {
-    project: string;
-}, typeIds: readonly string[]): Promise<string | undefined>;