@datashow/super-visual-semantic 0.0.0-stage → 0.1.0-rc.1

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "@datashow/super-visual-semantic",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-rc.1",
+  "description": "Governed TMDL and report-specific widget broker adapter compiler for Super Visual.",
+  "type": "module",
+  "exports": "./src/index.mjs",
+  "files": [
+    "src"
+  ],
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Datashow-Pty-Ltd/super-visual.git",
+    "directory": "packages/semantic"
+  },
+  "homepage": "https://github.com/Datashow-Pty-Ltd/super-visual#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@datashow/super-visual-compliance": "0.1.0-rc.1"
+  }
+}

package/src/compile-broker-adapter.mjs

@@ -0,0 +1,109 @@
+import { cp, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { validateWidgetBrokerContract } from "@datashow/super-visual-compliance";
+
+const tmdlIdentifier = (value) => `'${value.replaceAll("'", "''")}'`;
+const daxString = (value) => `"${value.replaceAll('"', '""')}"`;
+const daxReference = (table, object) => `${tmdlIdentifier(table)}[${object.replaceAll("]", "]]" )}]`;
+
+function parseObjectReference(semantic, reference, kind) {
+  const separator = typeof reference === "string" && reference.endsWith("]")
+    ? reference.lastIndexOf("[", reference.length - 2)
+    : -1;
+  const qualified = separator > 0 && separator < reference.length - 2
+    ? { table: reference.slice(0, separator), object: reference.slice(separator + 1, -1) }
+    : null;
+  if (qualified) {
+    const table = semantic.tables.find((candidate) => candidate.name === qualified.table);
+    const object = (kind === "column" ? table?.columns : table?.measures)?.find((candidate) => candidate.name === qualified.object);
+    if (!table || !object) throw new Error(`Unknown semantic ${kind} ${reference}`);
+    return { table, object, reference: daxReference(table.name, object.name) };
+  }
+  if (kind === "measure" && reference.startsWith("[") && reference.endsWith("]")) {
+    const name = reference.slice(1, -1);
+    const matches = semantic.tables.flatMap((table) => (table.measures ?? []).filter((measure) => measure.name === name).map((object) => ({ table, object })));
+    if (matches.length !== 1) throw new Error(`Measure ${reference} must resolve uniquely`);
+    return { ...matches[0], reference: `[${name.replaceAll("]", "]]" )}]` };
+  }
+  throw new Error(`${kind} reference must use Table[Object] notation: ${reference}`);
+}
+
+function axisKeyExpression(axis) {
+  if (axis.object.dataType === "String") return axis.reference;
+  if (axis.object.dataType === "DateTime") return `FORMAT(${axis.reference}, "yyyy-MM-dd")`;
+  return `FORMAT(${axis.reference}, "0.############")`;
+}
+
+function typedAxisKey(axis, expression) {
+  if (axis.object.dataType === "String") return expression;
+  if (axis.object.dataType === "DateTime") return `IFERROR(DATE(VALUE(LEFT(${expression}, 4)), VALUE(MID(${expression}, 6, 2)), VALUE(MID(${expression}, 9, 2))), BLANK())`;
+  return `IFERROR(VALUE(${expression}), BLANK())`;
+}
+
+function sortExpression(semantic, axis) {
+  const sortName = axis.object.sortByColumn;
+  if (sortName) {
+    const sort = parseObjectReference(semantic, `${axis.table.name}[${sortName}]`, "column");
+    if (sort.object.dataType === "DateTime") return `VALUE(FORMAT(${sort.reference}, "yyyymmdd"))`;
+    if (["Int64", "Decimal"].includes(sort.object.dataType)) return `INT(${sort.reference})`;
+  }
+  if (axis.object.dataType === "DateTime") return `VALUE(FORMAT(${axis.reference}, "yyyymmdd"))`;
+  if (["Int64", "Decimal"].includes(axis.object.dataType)) return `INT(${axis.reference})`;
+  return "0";
+}
+
+const measureLabel = (reference) => {
+  if (typeof reference !== "string" || !reference.endsWith("]")) return reference;
+  const separator = reference.lastIndexOf("[", reference.length - 2);
+  return separator >= 0 ? reference.slice(separator + 1, -1) : reference;
+};
+const pathExpression = (dimensions, formatter) => dimensions.map(formatter).join(' & "␟" & ');
+
+function widgetRows(semantic, widget, index) {
+  const axis = widget.axisObject;
+  const sortReference = axis.object.sortByColumn ? parseObjectReference(semantic, `${axis.table.name}[${axis.object.sortByColumn}]`, "column").reference : null;
+  const groupBy = [...new Set([...widget.dimensionObjects.flatMap((dimension) => [dimension.keyObject.reference, dimension.labelObject.reference]), ...(sortReference ? [sortReference] : [])])];
+  const variable = `_widgetRows${index + 1}`;
+  const candidate = `_widgetCandidates${index + 1}`;
+  const selected = `_widgetSelected${index + 1}`;
+  const order = ["top-by-value", "bottom-by-value"].includes(widget.rowSelection)
+    ? `[__RankValue], ${widget.rowSelection === "bottom-by-value" ? "ASC" : "DESC"}, [__Sort], ASC`
+    : `[__Sort], ${widget.rowSelection === "last-by-axis" ? "DESC" : "ASC"}, [AxisKey], ASC`;
+  const seriesRows = widget.measures.map((measure) => `SELECTCOLUMNS(\n                ${selected},\n                "WidgetId", ${daxString(widget.id)},\n                "AxisKey", [AxisKey],\n                "Label", [Label],\n                "Sort", [__Sort],\n                "SeriesKey", ${daxString(measure)},\n                "SeriesLabel", ${daxString(measureLabel(measure))}\n            )`);
+  return {
+    variable,
+    dax: `VAR ${candidate} =\n        FILTER(\n            SELECTCOLUMNS(\n                SUMMARIZECOLUMNS(${groupBy.join(", ")}, "__RankValue", CALCULATE(${widget.measureObjects[0].reference})),\n                "AxisKey", ${pathExpression(widget.dimensionObjects, (dimension) => axisKeyExpression(dimension.keyObject))},\n                "Label", ${pathExpression(widget.dimensionObjects, (dimension) => `FORMAT(${dimension.labelObject.reference}, "")`)},\n                "__Sort", ${sortExpression(semantic, axis)},\n                "__RankValue", [__RankValue]\n            ),\n            NOT ISBLANK([__RankValue])\n        )\n    VAR ${selected} = TOPN(${widget.rowLimit}, ${candidate}, ${order})\n    VAR ${variable} =\n        ${seriesRows.length === 1 ? seriesRows[0] : `UNION(\n            ${seriesRows.join(",\n            ")}\n        )`}`,
+  };
+}
+
+export async function compileBrokerAdapter({ baseModelDirectory, outputDirectory, broker, semanticModel }) {
+  if (broker.adapterMode !== "source-direct-import" || broker.baseModelMutation !== false) throw new Error("Broker contract must preserve a source-direct report adapter without base-model mutation");
+  const errors = validateWidgetBrokerContract(broker, semanticModel);
+  if (errors.length) throw new Error(`Widget broker validation failed:\n- ${errors.join("\n- ")}`);
+  const widgets = broker.widgets.map((widget) => ({
+    ...widget,
+    axisObject: parseObjectReference(semanticModel, widget.axis, "column"),
+    dimensionObjects: widget.dimensions.map((dimension) => ({ keyObject: parseObjectReference(semanticModel, dimension.key, "column"), labelObject: parseObjectReference(semanticModel, dimension.label, "column") })),
+    measureObjects: widget.measures.map((measure) => parseObjectReference(semanticModel, measure, "measure")),
+  }));
+  const rows = widgets.map((widget, index) => widgetRows(semanticModel, widget, index));
+  const rowSet = rows.length === 1 ? rows[0].variable : `UNION(${rows.map((item) => item.variable).join(", ")})`;
+  const valueCases = widgets.flatMap((widget) => {
+    const removeFilter = widget.selectable ? `, REMOVEFILTERS(${widget.axisObject.reference})` : "";
+    const filters = widget.dimensionObjects.map((dimension, index) => {
+      const part = `PATHITEM(SUBSTITUTE(_axisKey, "␟", "|"), ${index + 1})`;
+      return `TREATAS({ ${typedAxisKey(dimension.keyObject, part)} }, ${dimension.keyObject.reference})`;
+    });
+    return widget.measureObjects.map((measureObject, index) => `            ${daxString(`${widget.id}|${widget.measures[index]}`)}, CALCULATE(${measureObject.reference}${removeFilter}${filters.length ? `, ${filters.join(", ")}` : ""})`);
+  }).join(",\n");
+  const contextParts = widgets.map((widget) => `${daxString(`${widget.id}=`)} & CONCATENATEX(TOPN(5, VALUES(${widget.axisObject.reference}), ${widget.axisObject.reference}, ASC), FORMAT(${widget.axisObject.reference}, ""), ",")`);
+  await rm(outputDirectory, { recursive: true, force: true });
+  await cp(baseModelDirectory, outputDirectory, { recursive: true });
+  const definition = path.join(outputDirectory, "definition");
+  const tablePath = path.join(definition, "tables", "Widget Axis.tmdl");
+  await writeFile(tablePath, `/// Report-specific disconnected broker generated from the validated widget contract.\ntable 'Widget Axis'\n\n\tmeasure 'Widget Value' = \`\`\`\n\t\t\tVAR _widget = SELECTEDVALUE('Widget Axis'[WidgetId])\n\t\t\tVAR _axisKey = SELECTEDVALUE('Widget Axis'[AxisKey])\n\t\t\tVAR _seriesKey = SELECTEDVALUE('Widget Axis'[SeriesKey])\n\t\t\tRETURN\n\t\t\t\tSWITCH(\n\t\t\t\t\t_widget & "|" & _seriesKey,\n${valueCases}\n\t\t\t\t)\n\t\t\t\`\`\`\n\t\tformatString: $#,##0.00\n\t\tdisplayFolder: Broker\n\n\tmeasure 'Broker Context' = ${contextParts.join(' & ";" & ')}\n\t\tdisplayFolder: Broker\n\n\tcolumn WidgetId\n\t\tdataType: string\n\t\tsummarizeBy: none\n\t\tsourceColumn: [WidgetId]\n\n\tcolumn AxisKey\n\t\tdataType: string\n\t\tsummarizeBy: none\n\t\tsourceColumn: [AxisKey]\n\n\tcolumn Label\n\t\tdataType: string\n\t\tsummarizeBy: none\n\t\tsourceColumn: [Label]\n\n\tcolumn Sort\n\t\tdataType: int64\n\t\tsummarizeBy: none\n\t\tsourceColumn: [Sort]\n\n\tcolumn SeriesKey\n\t\tdataType: string\n\t\tsummarizeBy: none\n\t\tsourceColumn: [SeriesKey]\n\n\tcolumn SeriesLabel\n\t\tdataType: string\n\t\tsummarizeBy: none\n\t\tsourceColumn: [SeriesLabel]\n\n\tpartition 'Widget Axis' = calculated\n\t\tmode: import\n\t\tsource = \`\`\`\n\t\t\t${rows.map((item) => item.dax).join("\n    ")}\n\t\t\tRETURN ${rowSet}\n\t\t\t\`\`\`\n`);
+  const modelPath = path.join(definition, "model.tmdl");
+  const model = await readFile(modelPath, "utf8");
+  if (!model.includes("ref table 'Widget Axis'")) await writeFile(modelPath, `${model.trimEnd()}\nref table 'Widget Axis'\n`);
+  return { outputDirectory, widgets: widgets.map(({ id, shape, dimensions, axis, measures }) => ({ id, shape, dimensions, axis, measures })) };
+}

package/src/compile-tmdl.mjs

@@ -0,0 +1,141 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+function identifier(value) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) ? value : `'${value.replaceAll("'", "''")}'`;
+}
+
+function documentation(value) {
+  const words = String(value).replaceAll("\r", " ").replaceAll("\n", " ").trim().split(/\s+/);
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    if (line && `${line} ${word}`.length > 76) {
+      lines.push(line);
+      line = word;
+    } else line = line ? `${line} ${word}` : word;
+  }
+  if (line) lines.push(line);
+  return lines.map((item) => `/// ${item}`).join("\n");
+}
+
+function stableDatabaseId(name) {
+  const bytes = createHash("sha256").update(name).digest().subarray(0, 16);
+  bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x50;
+  bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+function mString(value) {
+  return `"${String(value).replaceAll('"', '""').replaceAll("\r\n", "#(lf)").replaceAll("\r", "#(cr)").replaceAll("\n", "#(lf)")}"`;
+}
+
+function renderMeasure(measure) {
+  const expression = measure.expression.includes("\n")
+    ? `\`\`\`\n${measure.expression.split("\n").map((line) => `\t\t\t${line}`).join("\n")}\n\t\t\t\`\`\``
+    : measure.expression;
+  return [
+    `\t${documentation(measure.description).replaceAll("\n", "\n\t")}`,
+    `\tmeasure ${identifier(measure.name)} = ${expression}`,
+    `\t\tformatString: ${measure.formatString}`,
+    `\t\tdisplayFolder: ${measure.displayFolder}`,
+  ].join("\n");
+}
+
+function renderColumn(column, sortKeys, hierarchyLevels) {
+  const type = { Int64: "int64", Decimal: "decimal", String: "string", DateTime: "dateTime", Boolean: "boolean" }[column.dataType];
+  const lines = [
+    `\t${documentation(column.description).replaceAll("\n", "\n\t")}`,
+    `\tcolumn ${identifier(column.name)}`,
+    `\t\tdataType: ${type}`,
+  ];
+  if (column.formatString) lines.push(`\t\tformatString: ${column.formatString}`);
+  if (column.hidden) lines.push("\t\tisHidden");
+  lines.push(`\t\tsummarizeBy: ${column.summarizeBy ?? "none"}`);
+  lines.push(`\t\tsourceColumn: ${column.sourceColumn}`);
+  if (column.dataCategory) lines.push(`\t\tdataCategory: ${column.dataCategory}`);
+  if (column.sortByColumn) lines.push(`\t\tsortByColumn: ${identifier(column.sortByColumn)}`);
+  if (column.hidden && !column.sortByColumn && !sortKeys.has(column.name) && !hierarchyLevels.has(column.name)) lines.push("\t\tisAvailableInMdx: false");
+  return lines.join("\n");
+}
+
+function renderTable(table) {
+  const sortKeys = new Set(table.columns.flatMap((column) => column.sortByColumn ? [column.sortByColumn] : []));
+  const hierarchyLevels = new Set((table.hierarchies ?? []).flatMap((hierarchy) => hierarchy.levels.map((level) => level.column)));
+  const measures = (table.measures ?? []).map(renderMeasure).join("\n\n");
+  const columns = table.columns.map((column) => renderColumn(column, sortKeys, hierarchyLevels)).join("\n\n");
+  const hierarchies = (table.hierarchies ?? []).map((hierarchy) => [
+    `\thierarchy ${identifier(hierarchy.name)}`,
+    ...hierarchy.levels.flatMap((level) => [`\n\t\tlevel ${identifier(level.name)}`, `\t\t\tcolumn: ${identifier(level.column)}`]),
+  ].join("\n")).join("\n\n");
+  return [
+    `${documentation(`${table.description} Grain: ${table.grain}`)}\ntable ${identifier(table.name)}`,
+    table.dataCategory ? `\tdataCategory: ${table.dataCategory}` : "",
+    measures,
+    columns,
+    hierarchies,
+    `\tpartition ${identifier(table.name)} = m`,
+    "\t\tmode: import",
+    "\t\tsource =",
+    "\t\t\tlet",
+    "\t\t\t\tSource = Sql.Database(#\"Server\", #\"Database\"),",
+    "\t\t\t\t// Selected and shaped business columns required by the governed model.",
+    `\t\t\t\t#\"Queried Rows\" = Value.NativeQuery(Source, ${mString(table.source.sql.trim())}, null, [EnableFolding=true])`,
+    "\t\t\tin",
+    "\t\t\t\t#\"Queried Rows\"",
+  ].filter(Boolean).join("\n\n").replaceAll("\n\n\t\t", "\n\t\t") + "\n";
+}
+
+export function validateSemanticModel(model) {
+  const errors = [];
+  if (model?.contractVersion !== 1) errors.push("semantic model contractVersion must be 1");
+  if (!model?.name) errors.push("semantic model name is required");
+  if (!Array.isArray(model?.tables) || !model.tables.length) errors.push("semantic model requires tables");
+  const tableNames = new Set();
+  const measures = new Set();
+  for (const table of model?.tables ?? []) {
+    if (tableNames.has(table.name)) errors.push(`duplicate semantic table ${table.name}`);
+    tableNames.add(table.name);
+    if (!/^\s*(select|with)\b/i.test(table.source?.sql ?? "") || /\b(insert|update|delete|merge|drop|alter|create|truncate|execute|exec|grant|revoke)\b/i.test(table.source?.sql ?? "")) errors.push(`${table.name}: source SQL must be read-only`);
+    const columns = new Set();
+    for (const column of table.columns ?? []) {
+      if (columns.has(column.name)) errors.push(`${table.name}: duplicate column ${column.name}`);
+      columns.add(column.name);
+      if (column.sortByColumn && !(table.columns ?? []).some((candidate) => candidate.name === column.sortByColumn)) errors.push(`${table.name}.${column.name}: missing sort column ${column.sortByColumn}`);
+    }
+    for (const measure of table.measures ?? []) {
+      if (measures.has(measure.name)) errors.push(`measure ${measure.name} must be globally unique`);
+      measures.add(measure.name);
+    }
+  }
+  for (const relationship of model?.relationships ?? []) {
+    for (const [side, tableName, columnName] of [["from", relationship.fromTable, relationship.fromColumn], ["to", relationship.toTable, relationship.toColumn]]) {
+      const table = (model.tables ?? []).find((candidate) => candidate.name === tableName);
+      if (!table?.columns?.some((column) => column.name === columnName)) errors.push(`${relationship.name}: unresolved ${side} column ${tableName}[${columnName}]`);
+    }
+  }
+  return errors;
+}
+
+export async function compileTmdl(model, outputDirectory) {
+  const errors = validateSemanticModel(model);
+  if (errors.length) throw new Error(`Semantic model validation failed:\n- ${errors.join("\n- ")}`);
+  const definition = path.join(outputDirectory, "definition");
+  const tables = path.join(definition, "tables");
+  await mkdir(tables, { recursive: true });
+  await writeFile(path.join(outputDirectory, "definition.pbism"), `${JSON.stringify({ $schema: "https://developer.microsoft.com/json-schemas/fabric/item/semanticModel/definitionProperties/1.0.0/schema.json", version: "4.2", settings: { qnaEnabled: true } }, null, 2)}\n`);
+  await writeFile(path.join(definition, "database.tmdl"), `database ${stableDatabaseId(model.name)}\n\tcompatibilityLevel: ${model.compatibilityLevel}\n\tcompatibilityMode: powerBI\n\tlanguage: 3081\n`);
+  await writeFile(path.join(definition, "model.tmdl"), `model Model\n\tculture: ${model.culture}\n\tdefaultPowerBIDataSourceVersion: powerBI_V3\n\tsourceQueryCulture: ${model.culture}\n\tdiscourageImplicitMeasures\n\n${model.tables.map((table) => `ref table ${identifier(table.name)}`).join("\n")}\n`);
+  await writeFile(path.join(definition, "expressions.tmdl"), `expression Server = ${mString(model.sourceParameters.server)} meta [IsParameterQuery=true, Type="Text", IsParameterQueryRequired=true]\n\nexpression Database = ${mString(model.sourceParameters.database)} meta [IsParameterQuery=true, Type="Text", IsParameterQueryRequired=true]\n`);
+  await writeFile(path.join(definition, "relationships.tmdl"), (model.relationships ?? []).map((relationship) => [
+    `relationship ${identifier(relationship.name)}`,
+    relationship.active === false ? "\tisActive: false" : "",
+    `\tcrossFilteringBehavior: ${relationship.crossFilteringBehavior ?? "oneDirection"}`,
+    `\tfromColumn: ${identifier(relationship.fromTable)}.${identifier(relationship.fromColumn)}`,
+    `\ttoColumn: ${identifier(relationship.toTable)}.${identifier(relationship.toColumn)}`,
+  ].filter(Boolean).join("\n")).join("\n\n"));
+  for (const table of model.tables) await writeFile(path.join(tables, `${table.name}.tmdl`), renderTable(table));
+  return { outputDirectory, tableCount: model.tables.length, databaseId: stableDatabaseId(model.name) };
+}

package/src/index.mjs

@@ -0,0 +1,3 @@
+export { compileTmdl, validateSemanticModel } from "./compile-tmdl.mjs";
+export { compileBrokerAdapter } from "./compile-broker-adapter.mjs";
+export { brokerUsesSemanticCatalog, semanticModelWithCatalog, SEMANTIC_CATALOG_TABLE } from "./semantic-catalog.mjs";

package/src/semantic-catalog.mjs

@@ -0,0 +1,75 @@
+export const SEMANTIC_CATALOG_TABLE = "Super Visual Model Catalog";
+
+function referencesCatalog(reference) {
+  return typeof reference === "string" && reference.startsWith(`${SEMANTIC_CATALOG_TABLE}[`);
+}
+
+export function brokerUsesSemanticCatalog(broker) {
+  return (broker?.widgets ?? []).some((widget) => [
+    widget.axis,
+    ...(widget.dimensions ?? []).flatMap((dimension) => [dimension.key, dimension.label]),
+    ...(widget.measures ?? []),
+  ].some(referencesCatalog));
+}
+
+function sqlString(value) {
+  return `N'${String(value ?? "").replaceAll("'", "''")}'`;
+}
+
+function catalogEntities(model) {
+  const modelName = model.name ?? model.displayName ?? "Semantic model";
+  const entities = [{ type: "Model", parent: "", name: modelName }];
+  for (const table of model.tables ?? []) {
+    if ([SEMANTIC_CATALOG_TABLE, "Widget Axis"].includes(table.name)) continue;
+    entities.push({ type: "Table", parent: modelName, name: table.name });
+    for (const column of table.columns ?? []) entities.push({ type: "Column", parent: table.name, name: column.name });
+    for (const measure of table.measures ?? []) entities.push({ type: "Measure", parent: table.name, name: measure.name });
+    for (const hierarchy of table.hierarchies ?? []) {
+      entities.push({ type: "Hierarchy", parent: table.name, name: hierarchy.name });
+      for (const level of hierarchy.levels ?? []) entities.push({ type: "Hierarchy level", parent: `${table.name}.${hierarchy.name}`, name: level.name });
+    }
+  }
+  for (const relationship of model.relationships ?? []) {
+    entities.push({ type: "Relationship", parent: `${relationship.fromTable ?? relationship.from ?? ""} → ${relationship.toTable ?? relationship.to ?? ""}`, name: relationship.name });
+  }
+  const parameterNames = new Set([...Object.keys(model.sourceParameters ?? {}), ...(model.parameters ?? []).map((parameter) => parameter.name)]);
+  for (const name of [...parameterNames].sort()) {
+    entities.push({ type: "Parameter", parent: modelName, name: name[0].toUpperCase() + name.slice(1) });
+  }
+  return entities;
+}
+
+export function semanticModelWithCatalog(model, broker, catalogSource = model) {
+  if (!brokerUsesSemanticCatalog(broker)) return model;
+  if ((model.tables ?? []).some((table) => table.name === SEMANTIC_CATALOG_TABLE)) throw new Error(`${SEMANTIC_CATALOG_TABLE} is reserved for the generated semantic catalog`);
+  const entities = catalogEntities(catalogSource);
+  const values = entities.map((entity, index) => `(${sqlString(entity.type)}, ${sqlString(entity.parent)}, ${sqlString(entity.name)}, ${index + 1})`).join(",\n          ");
+  const catalog = {
+    name: SEMANTIC_CATALOG_TABLE,
+    role: "dimension",
+    grain: "One row per declared semantic-model entity.",
+    description: "Generated searchable inventory used by the Super Visual connectivity sample.",
+    source: {
+      referencedTables: [],
+      sql: `SELECT catalog.[EntityType], catalog.[Parent], catalog.[Entity], catalog.[Sort]\nFROM (VALUES\n          ${values}\n     ) AS catalog([EntityType], [Parent], [Entity], [Sort])`,
+    },
+    columns: [
+      { name: "Entity Type", sourceColumn: "EntityType", dataType: "String", hidden: false, summarizeBy: "none", description: "Kind of semantic entity." },
+      { name: "Parent", sourceColumn: "Parent", dataType: "String", hidden: false, summarizeBy: "none", description: "Containing model, table, hierarchy, or relationship endpoints." },
+      { name: "Entity", sourceColumn: "Entity", dataType: "String", hidden: false, summarizeBy: "none", description: "Readable semantic entity name." },
+      { name: "Sort", sourceColumn: "Sort", dataType: "Int64", hidden: true, summarizeBy: "none", description: "Stable catalog order." },
+    ],
+    measures: [
+      { name: "Entity Count", expression: `COUNTROWS('${SEMANTIC_CATALOG_TABLE}')`, formatString: "0", displayFolder: "Connectivity", description: "Count of catalog entities in the active context." },
+    ],
+    hierarchies: [{
+      name: "Semantic Entity",
+      levels: [
+        { name: "Entity Type", column: "Entity Type" },
+        { name: "Parent", column: "Parent" },
+        { name: "Entity", column: "Entity" },
+      ],
+    }],
+  };
+  return { ...model, tables: [...model.tables, catalog] };
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.