@pbiplint/core 0.1.0

package/src/rules/microsoft-bpa/columns.ts

@@ -0,0 +1,192 @@
+import type { Column, Model } from "../../model/types.js";
+import {
+  allColumns,
+  allMeasures,
+  allTablePermissions,
+  dataType,
+  escapeRegExp,
+  finding,
+  hiddenOrTableHidden,
+  isBlank,
+  isNumericType,
+} from "../helpers.js";
+import type { RuleContext, RuleFinding } from "../types.js";
+import { bpaRule } from "./define.js";
+
+const columns = (m: Model, pred: (c: Column) => boolean): RuleFinding[] =>
+  allColumns(m).filter(pred).map(finding.column);
+
+export const AVOID_FLOATING_POINT_DATA_TYPES = bpaRule("AVOID_FLOATING_POINT_DATA_TYPES", (m) =>
+  columns(m, (c) => dataType(c) === "double"),
+);
+
+export const DATECOLUMN_FORMATSTRING = bpaRule("DATECOLUMN_FORMATSTRING", (m) =>
+  columns(
+    m,
+    (c) =>
+      /date/i.test(c.name) && dataType(c) === "datetime" && (c.formatString ?? "") !== "mm/dd/yyyy",
+  ),
+);
+
+export const MONTHCOLUMN_FORMATSTRING = bpaRule("MONTHCOLUMN_FORMATSTRING", (m) =>
+  columns(
+    m,
+    (c) =>
+      /month/i.test(c.name) && dataType(c) === "datetime" && (c.formatString ?? "") !== "MMMM yyyy",
+  ),
+);
+
+export const ADD_DATA_CATEGORY_FOR_COLUMNS = bpaRule("ADD_DATA_CATEGORY_FOR_COLUMNS", (m) =>
+  columns(m, (c) => {
+    const n = c.name.toLowerCase();
+    const d = dataType(c);
+    return (
+      isBlank(c.dataCategory) &&
+      (((n.includes("country") || n.includes("continent") || n.includes("city")) &&
+        d === "string") ||
+        ((n === "latitude" || n === "longitude") && (d === "decimal" || d === "double")))
+    );
+  }),
+);
+
+export const MONTH_AS_A_STRING_MUST_BE_SORTED = bpaRule("MONTH_(AS_A_STRING)_MUST_BE_SORTED", (m) =>
+  columns(m, (c) => {
+    const u = c.name.toUpperCase();
+    return (
+      u.includes("MONTH") &&
+      !u.includes("MONTHS") &&
+      dataType(c) === "string" &&
+      c.sortByColumn === undefined
+    );
+  }),
+);
+
+// TOM's default SummarizeBy is Default, which is not None, so a column without the property is flagged.
+export const NUMERIC_COLUMN_SUMMARIZE_BY = bpaRule("NUMERIC_COLUMN_SUMMARIZE_BY", (m) =>
+  columns(
+    m,
+    (c) =>
+      isNumericType(c) &&
+      (c.summarizeBy ?? "default").toLowerCase() !== "none" &&
+      !hiddenOrTableHidden(c),
+  ),
+);
+
+export const FORMAT_FLAG_COLUMNS_AS_YES_NO_VALUE_STRINGS = bpaRule(
+  "FORMAT_FLAG_COLUMNS_AS_YES/NO_VALUE_STRINGS",
+  (m) =>
+    columns(
+      m,
+      (c) =>
+        !hiddenOrTableHidden(c) &&
+        ((c.name.startsWith("Is") && dataType(c) === "int64") ||
+          (c.name.endsWith(" Flag") && dataType(c) !== "string")),
+    ),
+);
+
+export const DATA_COLUMNS_MUST_HAVE_A_SOURCE_COLUMN = bpaRule(
+  "DATA_COLUMNS_MUST_HAVE_A_SOURCE_COLUMN",
+  (m) => columns(m, (c) => c.kind === "data" && isBlank(c.sourceColumn)),
+);
+
+export const ISAVAILABLEINMDX_FALSE_NONATTRIBUTE_COLUMNS = bpaRule(
+  "ISAVAILABLEINMDX_FALSE_NONATTRIBUTE_COLUMNS",
+  (m, { indexes: { usage } }: RuleContext) =>
+    columns(
+      m,
+      (c) =>
+        c.isAvailableInMdx &&
+        hiddenOrTableHidden(c) &&
+        !usage.usedInSortBy(c) &&
+        !usage.usedInHierarchies(c) &&
+        !usage.usedInVariations(c) &&
+        c.sortByColumn === undefined,
+    ),
+);
+
+export const SET_ISAVAILABLEINMDX_TO_TRUE_ON_NECESSARY_COLUMNS = bpaRule(
+  "SET_ISAVAILABLEINMDX_TO_TRUE_ON_NECESSARY_COLUMNS",
+  (m, { indexes: { usage } }: RuleContext) =>
+    columns(
+      m,
+      (c) =>
+        !c.isAvailableInMdx &&
+        (usage.usedInSortBy(c) ||
+          usage.usedInHierarchies(c) ||
+          usage.usedInVariations(c) ||
+          c.sortByColumn !== undefined),
+    ),
+);
+
+export const UNNECESSARY_COLUMNS = bpaRule("UNNECESSARY_COLUMNS", (m, { indexes }: RuleContext) => {
+  const permissions = allTablePermissions(m);
+  return columns(m, (c) => {
+    if (!hiddenOrTableHidden(c)) return false;
+    if (indexes.references.columnReferencedBy(c).length > 0) return false;
+    if (indexes.relationships.forColumn(c.table.name, c.name).length > 0) return false;
+    if (indexes.usage.usedInSortBy(c) || indexes.usage.usedInHierarchies(c)) return false;
+    // The source rule also does plain substring checks on RLS filters (case-insensitive).
+    const bare = `[${c.name}]`.toLowerCase();
+    const qualified = [
+      `${c.table.name}[${c.name}]`.toLowerCase(),
+      `'${c.table.name}'[${c.name}]`.toLowerCase(),
+    ];
+    for (const tp of permissions) {
+      const f = tp.filter?.toLowerCase();
+      if (f === undefined) continue;
+      if (tp.table === c.table.name && f.includes(bare)) return false;
+      if (qualified.some((q) => f.includes(q))) return false;
+    }
+    // Object-level security on the column or its table.
+    for (const tp of permissions) {
+      if (tp.table !== c.table.name) continue;
+      if (tp.metadataPermission === "none") return false;
+      if (tp.columnPermissions.some((cp) => cp.column === c.name && cp.permission === "none"))
+        return false;
+    }
+    return true;
+  });
+});
+
+const AGGREGATIONS = [
+  "COUNT",
+  "COUNTBLANK",
+  "SUM",
+  "AVERAGE",
+  "VALUES",
+  "DISTINCT",
+  "DISTINCTCOUNT",
+  "MIN",
+  "MAX",
+  "COUNTA",
+  "AVERAGEA",
+  "MAXA",
+  "MINA",
+];
+
+export const HIDE_FACT_TABLE_COLUMNS = bpaRule("HIDE_FACT_TABLE_COLUMNS", (m) => {
+  const measures = allMeasures(m);
+  return columns(m, (c) => {
+    if (c.isHidden || !isNumericType(c)) return false;
+    const re = new RegExp(
+      `(?:${AGGREGATIONS.join("|")})\\s*\\(\\s*'*${escapeRegExp(c.table.name)}'*\\[${escapeRegExp(c.name)}\\]\\s*\\)`,
+      "i",
+    );
+    return measures.some((x) => re.test(x.expression));
+  });
+});
+
+export const columnRules = [
+  AVOID_FLOATING_POINT_DATA_TYPES,
+  DATECOLUMN_FORMATSTRING,
+  MONTHCOLUMN_FORMATSTRING,
+  ADD_DATA_CATEGORY_FOR_COLUMNS,
+  MONTH_AS_A_STRING_MUST_BE_SORTED,
+  NUMERIC_COLUMN_SUMMARIZE_BY,
+  FORMAT_FLAG_COLUMNS_AS_YES_NO_VALUE_STRINGS,
+  DATA_COLUMNS_MUST_HAVE_A_SOURCE_COLUMN,
+  ISAVAILABLEINMDX_FALSE_NONATTRIBUTE_COLUMNS,
+  SET_ISAVAILABLEINMDX_TO_TRUE_ON_NECESSARY_COLUMNS,
+  UNNECESSARY_COLUMNS,
+  HIDE_FACT_TABLE_COLUMNS,
+];

package/src/rules/microsoft-bpa/define.ts

@@ -0,0 +1,84 @@
+import type { Model } from "../../model/types.js";
+import type { Category, ObjectType, Rule, RuleContext, RuleFinding, Severity } from "../types.js";
+import { RULE_SUMMARIES } from "../rule-summaries.data.js";
+import { BPA_RULES, type BpaRuleMeta } from "./bpa-rules.data.js";
+
+const byId = new Map(BPA_RULES.map((r) => [r.id, r]));
+
+/** Microsoft scope name to pbiplint object type. KPI is not modeled in v1 and maps to nothing. */
+const SCOPE_MAP: Record<string, ObjectType | null> = {
+  Model: "Model",
+  Table: "Table",
+  CalculatedTable: "CalculatedTable",
+  CalculationGroup: "CalculationGroupTable",
+  DataColumn: "Column",
+  CalculatedColumn: "CalculatedColumn",
+  CalculatedTableColumn: "CalculatedTableColumn",
+  Measure: "Measure",
+  Partition: "Partition",
+  Relationship: "Relationship",
+  ModelRole: "Role",
+  TablePermission: "TablePermission",
+  Perspective: "Perspective",
+  Hierarchy: "Hierarchy",
+  Level: "Level",
+  CalculationItem: "CalculationItem",
+  NamedExpression: "NamedExpression",
+  ProviderDataSource: "DataSource",
+  StructuredDataSource: "DataSource",
+  KPI: null,
+};
+
+export function mapScope(scope: string): ObjectType[] {
+  const out: ObjectType[] = [];
+  for (const s of scope
+    .split(",")
+    .map((x) => x.trim())
+    .filter((x) => x.length > 0)) {
+    if (!(s in SCOPE_MAP)) throw new Error(`Unknown BPA scope: ${s}`);
+    const t = SCOPE_MAP[s];
+    if (t && !out.includes(t)) out.push(t);
+  }
+  return out;
+}
+
+export const metaOf = (id: string): BpaRuleMeta => {
+  const meta = byId.get(id);
+  if (!meta) throw new Error(`Unknown BPA rule id: ${id}`);
+  return meta;
+};
+
+const stripCategory = (name: string): string => name.replace(/^\[[^\]]*\]\s*/, "");
+
+const extractUrls = (text: string): string[] => [
+  ...new Set((text.match(/https?:\/\/[^\s)"]+/g) ?? []).map((u) => u.replace(/[.,]$/, ""))),
+];
+
+/**
+ * A literal port of one Microsoft BPA rule: metadata from the ruleset, behavior from `check`.
+ * The description is pbiplint's own summary from the rule page, never the ruleset's text; the
+ * ruleset description is read only for the reference URLs it carries.
+ */
+export function bpaRule(
+  id: string,
+  check: (model: Model, ctx: RuleContext) => RuleFinding[],
+): Rule {
+  const meta = metaOf(id);
+  return {
+    id,
+    name: stripCategory(meta.name),
+    category: meta.category as Category,
+    severity: meta.severity as Severity,
+    scope: mapScope(meta.scope),
+    description: RULE_SUMMARIES[id] ?? stripCategory(meta.name),
+    fixExpression: meta.fixExpression,
+    references: extractUrls(meta.description),
+    status: "ported",
+    check,
+  };
+}
+
+/** A rule that needs VertiPaq statistics: declared so it can be listed, never run. */
+export function liveModelRule(id: string): Rule {
+  return { ...bpaRule(id, () => []), status: "needsLiveModel" };
+}

package/src/rules/microsoft-bpa/dependencies.ts

@@ -0,0 +1,95 @@
+import type { RefOwner } from "../../index/references.js";
+import { measureRef } from "../../model/names.js";
+import type {
+  CalculationItem,
+  Column,
+  Measure,
+  Table,
+  TablePermission,
+} from "../../model/types.js";
+import { allMeasures, finding } from "../helpers.js";
+import type { RuleContext, RuleFinding } from "../types.js";
+import { bpaRule } from "./define.js";
+
+/** The finding shell for whichever object owns a DAX expression. */
+export function ownerFinding(o: RefOwner): RuleFinding {
+  switch (o.kind) {
+    case "measure":
+      return finding.measure(o.object as Measure);
+    case "calculatedColumn":
+      return finding.column(o.object as Column);
+    case "calculatedTable":
+      return finding.table(o.object as Table);
+    case "tablePermission":
+      return finding.tablePermission(o.object as TablePermission);
+    case "calculationItem":
+      return finding.calculationItem(o.object as CalculationItem);
+  }
+}
+
+// Scope: Measure, KPI, TablePermission, CalculationItem. KPIs are not modeled in v1. Calculation items
+// never resolve bare references to columns (ground-truth item 3), so they never fire here.
+export const DAX_COLUMNS_FULLY_QUALIFIED = bpaRule(
+  "DAX_COLUMNS_FULLY_QUALIFIED",
+  (_m, { indexes: { references } }: RuleContext) =>
+    references.owners
+      .filter(
+        (o) =>
+          (o.kind === "measure" || o.kind === "tablePermission" || o.kind === "calculationItem") &&
+          o.refs.some((r) => r.kind === "column" && !r.qualified),
+      )
+      .map(ownerFinding),
+);
+
+// Scope: Measure, CalculatedColumn, CalculatedTable, KPI, CalculationItem.
+export const DAX_MEASURES_UNQUALIFIED = bpaRule(
+  "DAX_MEASURES_UNQUALIFIED",
+  (_m, { indexes: { references } }: RuleContext) =>
+    references.owners
+      .filter(
+        (o) =>
+          o.kind !== "tablePermission" && o.refs.some((r) => r.kind === "measure" && r.qualified),
+      )
+      .map(ownerFinding),
+);
+
+const stripWhitespace = (s: string): string => s.replace(/[ \n\r\t]/g, "");
+
+export const AVOID_DUPLICATE_MEASURES = bpaRule("AVOID_DUPLICATE_MEASURES", (m) => {
+  const all = allMeasures(m);
+  const counts = new Map<string, number>();
+  for (const x of all) {
+    const k = stripWhitespace(x.expression);
+    counts.set(k, (counts.get(k) ?? 0) + 1);
+  }
+  return all
+    .filter((x) => (counts.get(stripWhitespace(x.expression)) ?? 0) > 1)
+    .map(finding.measure);
+});
+
+export const MEASURES_SHOULD_NOT_BE_DIRECT_REFERENCES_OF_OTHER_MEASURES = bpaRule(
+  "MEASURES_SHOULD_NOT_BE_DIRECT_REFERENCES_OF_OTHER_MEASURES",
+  (m) => {
+    const all = allMeasures(m);
+    const names = new Set(all.map((x) => measureRef(x.name)));
+    return all.filter((x) => names.has(x.expression)).map(finding.measure);
+  },
+);
+
+export const UNNECESSARY_MEASURES = bpaRule(
+  "UNNECESSARY_MEASURES",
+  (m, { indexes: { references } }: RuleContext) =>
+    allMeasures(m)
+      .filter(
+        (x) => (x.table.isHidden || x.isHidden) && references.measureReferencedBy(x).length === 0,
+      )
+      .map(finding.measure),
+);
+
+export const dependencyRules = [
+  DAX_COLUMNS_FULLY_QUALIFIED,
+  DAX_MEASURES_UNQUALIFIED,
+  AVOID_DUPLICATE_MEASURES,
+  MEASURES_SHOULD_NOT_BE_DIRECT_REFERENCES_OF_OTHER_MEASURES,
+  UNNECESSARY_MEASURES,
+];

package/src/rules/microsoft-bpa/index.ts

@@ -0,0 +1,22 @@
+import type { Rule } from "../types.js";
+import { BPA_RULES } from "./bpa-rules.data.js";
+import { columnRules } from "./columns.js";
+import { dependencyRules } from "./dependencies.js";
+import { liveModelRules } from "./live-model.js";
+import { measureRules } from "./measures.js";
+import { namingRules } from "./naming.js";
+import { relationshipRules } from "./relationships.js";
+import { tableRules } from "./tables.js";
+
+const order = new Map(BPA_RULES.map((r, i) => [r.id, i]));
+
+/** The microsoft-bpa pack: every rule in BPARules.json, in ruleset order. */
+export const microsoftBpaRules: Rule[] = [
+  ...columnRules,
+  ...relationshipRules,
+  ...measureRules,
+  ...dependencyRules,
+  ...tableRules,
+  ...namingRules,
+  ...liveModelRules,
+].sort((a, b) => order.get(a.id)! - order.get(b.id)!);

package/src/rules/microsoft-bpa/live-model.ts

@@ -0,0 +1,10 @@
+import { liveModelRule } from "./define.js";
+
+/** Rules that read VertiPaq statistics stored as annotations by a Tabular Editor script. Files never carry them. */
+export const liveModelRules = [
+  liveModelRule("AVOID_BI-DIRECTIONAL_RELATIONSHIPS_AGAINST_HIGH-CARDINALITY_COLUMNS"),
+  liveModelRule("REDUCE_USAGE_OF_LONG-LENGTH_COLUMNS_WITH_HIGH_CARDINALITY"),
+  liveModelRule("SPLIT_DATE_AND_TIME"),
+  liveModelRule("LARGE_TABLES_SHOULD_BE_PARTITIONED"),
+  liveModelRule("FIX_REFERENTIAL_INTEGRITY_VIOLATIONS"),
+];

package/src/rules/microsoft-bpa/measures.ts

@@ -0,0 +1,143 @@
+import {
+  allMeasures,
+  expressionObjects,
+  finding,
+  isBlank,
+  type ExpressionKind,
+} from "../helpers.js";
+import type { Measure } from "../../model/types.js";
+import type { Rule } from "../types.js";
+import { bpaRule } from "./define.js";
+
+const M: ExpressionKind = "measure";
+const CC: ExpressionKind = "calculatedColumn";
+const CI: ExpressionKind = "calculationItem";
+
+/** A rule that flags every object in `kinds` whose expression matches any pattern. */
+const patternRule = (id: string, kinds: ExpressionKind[], patterns: RegExp[]): Rule =>
+  bpaRule(id, (m) =>
+    expressionObjects(m, kinds)
+      .filter((o) => patterns.some((p) => p.test(o.expression)))
+      .map((o) => o.finding),
+  );
+
+export const PROVIDE_FORMAT_STRING_FOR_MEASURES = bpaRule(
+  "PROVIDE_FORMAT_STRING_FOR_MEASURES",
+  (m) =>
+    allMeasures(m)
+      .filter(
+        (x) =>
+          !x.isHidden &&
+          !x.table.isHidden &&
+          isBlank(x.formatString) &&
+          isBlank(x.formatStringDefinition),
+      )
+      .map(finding.measure),
+);
+
+// The source rule reads only the static format string, so an unformatted currency or percentage
+// measure fires under a name that calls it a whole number. The detail says what the rule saw.
+const formatStringDetail = (x: Measure): string => {
+  const fs = x.formatString ?? "";
+  if (fs.trim() !== "") return `format string "${fs}"`;
+  return isBlank(x.formatStringDefinition) ? "no format string" : "dynamic format string only";
+};
+
+export const INTEGER_FORMATTING = bpaRule("INTEGER_FORMATTING", (m) =>
+  allMeasures(m)
+    .filter((x) => {
+      const fs = x.formatString ?? "";
+      return !fs.includes("$") && !fs.includes("%") && !(fs === "#,0" || fs === "#,0.0");
+    })
+    .map((x) => ({ ...finding.measure(x), detail: formatStringDetail(x) })),
+);
+
+export const PERCENTAGE_FORMATTING = bpaRule("PERCENTAGE_FORMATTING", (m) =>
+  allMeasures(m)
+    .filter(
+      (x) => (x.formatString ?? "").includes("%") && x.formatString !== "#,0.0%;-#,0.0%;#,0.0%",
+    )
+    .map(finding.measure),
+);
+
+export const USE_THE_DIVIDE_FUNCTION_FOR_DIVISION = patternRule(
+  "USE_THE_DIVIDE_FUNCTION_FOR_DIVISION",
+  [M, CC, CI],
+  [/\]\s*\/(?!\/)(?!\*)/, /\)\s*\/(?!\/)(?!\*)/],
+);
+
+export const AVOID_USING_THE_IFERROR_FUNCTION = patternRule(
+  "AVOID_USING_THE_IFERROR_FUNCTION",
+  [M, CC],
+  [/IFERROR\s*\(/i],
+);
+
+export const USE_THE_TREATAS_FUNCTION_INSTEAD_OF_INTERSECT = patternRule(
+  "USE_THE_TREATAS_FUNCTION_INSTEAD_OF_INTERSECT",
+  [M, CI],
+  [/INTERSECT\s*\(/i],
+);
+
+export const FILTER_COLUMN_VALUES = patternRule(
+  "FILTER_COLUMN_VALUES",
+  [M, CC, CI],
+  [
+    /CALCULATE\s*\(\s*[^,]+,\s*FILTER\s*\(\s*'*[A-Za-z0-9 _]+'*\s*,\s*'*[A-Za-z0-9 _]+'*\[[A-Za-z0-9 _]+\]/i,
+    /CALCULATETABLE\s*\([^,]*,\s*FILTER\s*\(\s*'*[A-Za-z0-9 _]+'*,\s*'*[A-Za-z0-9 _]+'*\[[A-Za-z0-9 _]+\]/i,
+  ],
+);
+
+export const FILTER_MEASURE_VALUES_BY_COLUMNS = patternRule(
+  "FILTER_MEASURE_VALUES_BY_COLUMNS",
+  [M, CC, CI],
+  [
+    /CALCULATE\s*\(\s*[^,]+,\s*FILTER\s*\(\s*'*[A-Za-z0-9 _]+'*\s*,\s*\[[^\]]+\]/i,
+    /CALCULATETABLE\s*\([^,]*,\s*FILTER\s*\(\s*'*[A-Za-z0-9 _]+'*,\s*\[/i,
+  ],
+);
+
+export const AVOID_USING_1_X_Y_SYNTAX = patternRule(
+  "AVOID_USING_'1-(X/Y)'_SYNTAX",
+  [M, CC, CI],
+  [
+    /[0-9]+\s*[-+]\s*[(]*\s*SUM\s*\(\s*'*[A-Za-z0-9 _]+'*\s*\[[A-Za-z0-9 _]+\]\s*\)\s*\//i,
+    /[0-9]+\s*[-+]\s*DIVIDE\s*\(/i,
+  ],
+);
+
+export const EVALUATEANDLOG_SHOULD_NOT_BE_USED_IN_PRODUCTION_MODELS = patternRule(
+  "EVALUATEANDLOG_SHOULD_NOT_BE_USED_IN_PRODUCTION_MODELS",
+  [M],
+  [/EVALUATEANDLOG\s*\(/i],
+);
+
+export const REDUCE_USAGE_OF_CALCULATED_COLUMNS_THAT_USE_THE_RELATED_FUNCTION = patternRule(
+  "REDUCE_USAGE_OF_CALCULATED_COLUMNS_THAT_USE_THE_RELATED_FUNCTION",
+  [CC],
+  [/RELATED\s*\(/i],
+);
+
+// The TMDL reader never yields an empty expression (the next indented line becomes the expression),
+// so this rule can only fire on models built some other way. It is kept for completeness.
+export const EXPRESSION_RELIANT_OBJECTS_MUST_HAVE_AN_EXPRESSION = bpaRule(
+  "EXPRESSION_RELIANT_OBJECTS_MUST_HAVE_AN_EXPRESSION",
+  (m) =>
+    expressionObjects(m, [M, CC, CI])
+      .filter((o) => isBlank(o.expression))
+      .map((o) => o.finding),
+);
+
+export const measureRules = [
+  PROVIDE_FORMAT_STRING_FOR_MEASURES,
+  INTEGER_FORMATTING,
+  PERCENTAGE_FORMATTING,
+  USE_THE_DIVIDE_FUNCTION_FOR_DIVISION,
+  AVOID_USING_THE_IFERROR_FUNCTION,
+  USE_THE_TREATAS_FUNCTION_INSTEAD_OF_INTERSECT,
+  FILTER_COLUMN_VALUES,
+  FILTER_MEASURE_VALUES_BY_COLUMNS,
+  AVOID_USING_1_X_Y_SYNTAX,
+  EVALUATEANDLOG_SHOULD_NOT_BE_USED_IN_PRODUCTION_MODELS,
+  REDUCE_USAGE_OF_CALCULATED_COLUMNS_THAT_USE_THE_RELATED_FUNCTION,
+  EXPRESSION_RELIANT_OBJECTS_MUST_HAVE_AN_EXPRESSION,
+];

package/src/rules/microsoft-bpa/naming.ts

@@ -0,0 +1,104 @@
+import { allPartitions, finding, namedObjects } from "../helpers.js";
+import type { Rule } from "../types.js";
+import { bpaRule, mapScope, metaOf } from "./define.js";
+
+/** A rule over every object in the rule's own scope, testing name and description. */
+const namedObjectRule = (
+  id: string,
+  test: (name: string, description: string | undefined) => boolean,
+): Rule =>
+  bpaRule(id, (m) =>
+    namedObjects(m, mapScope(metaOf(id).scope))
+      .filter((o) => test(o.name, o.description))
+      .map((o) => o.finding),
+  );
+
+const startsOrEndsWithSpace = (name: string): boolean => name.startsWith(" ") || name.endsWith(" ");
+
+export const TRIM_OBJECT_NAMES = namedObjectRule("TRIM_OBJECT_NAMES", startsOrEndsWithSpace);
+
+export const OBJECTS_SHOULD_NOT_START_OR_END_WITH_A_SPACE = namedObjectRule(
+  "OBJECTS_SHOULD_NOT_START_OR_END_WITH_A_SPACE",
+  startsOrEndsWithSpace,
+);
+
+export const SPECIAL_CHARS_IN_OBJECT_NAMES = namedObjectRule(
+  "SPECIAL_CHARS_IN_OBJECT_NAMES",
+  (name) => /[\t\n\r]/.test(name),
+);
+
+// .NET char.IsControl minus char.IsWhiteSpace: U+0000..U+001F and U+007F..U+009F, except U+0009..U+000D and U+0085.
+// eslint-disable-next-line no-control-regex -- matching control characters is the whole point of these two rules
+const CONTROL_NOT_WHITESPACE = /[\x00-\x08\x0E-\x1F\x7F-\x84\x86-\x9F]/;
+
+export const AVOID_INVALID_NAME_CHARACTERS = namedObjectRule(
+  "AVOID_INVALID_NAME_CHARACTERS",
+  (name) => CONTROL_NOT_WHITESPACE.test(name),
+);
+
+export const AVOID_INVALID_DESCRIPTION_CHARACTERS = namedObjectRule(
+  "AVOID_INVALID_DESCRIPTION_CHARACTERS",
+  (_name, description) => CONTROL_NOT_WHITESPACE.test(description ?? ""),
+);
+
+export const FIRST_LETTER_OF_OBJECTS_MUST_BE_CAPITALIZED = namedObjectRule(
+  "FIRST_LETTER_OF_OBJECTS_MUST_BE_CAPITALIZED",
+  (name) => name.length > 0 && name.slice(0, 1).toUpperCase() !== name.slice(0, 1),
+);
+
+export const PERSPECTIVES_WITH_NO_OBJECTS = bpaRule("PERSPECTIVES_WITH_NO_OBJECTS", (m) =>
+  m.perspectives.filter((p) => p.tables.length === 0).map(finding.perspective),
+);
+
+export const CALCULATION_GROUPS_WITH_NO_CALCULATION_ITEMS = bpaRule(
+  "CALCULATION_GROUPS_WITH_NO_CALCULATION_ITEMS",
+  (m) =>
+    m.tables
+      .filter((t) => t.calculationGroup !== undefined && t.calculationGroup.items.length === 0)
+      .map(finding.table),
+);
+
+export const REMOVE_ROLES_WITH_NO_MEMBERS = bpaRule("REMOVE_ROLES_WITH_NO_MEMBERS", (m) =>
+  m.roles.filter((r) => r.members.length === 0).map(finding.role),
+);
+
+// Table.SourceExpression in the source is approximated by every partition's query or M text.
+export const REMOVE_DATA_SOURCES_NOT_REFERENCED_BY_ANY_PARTITIONS = bpaRule(
+  "REMOVE_DATA_SOURCES_NOT_REFERENCED_BY_ANY_PARTITIONS",
+  (m) => {
+    const partitions = allPartitions(m);
+    return m.dataSources
+      .filter(
+        (ds) =>
+          !partitions.some((p) => p.dataSource === ds.name) &&
+          !partitions.some((p) => (p.source ?? "").includes(ds.name)),
+      )
+      .map(finding.dataSource);
+  },
+);
+
+export const AVOID_STRUCTURED_DATA_SOURCES_WITH_PROVIDER_PARTITIONS = bpaRule(
+  "AVOID_STRUCTURED_DATA_SOURCES_WITH_PROVIDER_PARTITIONS",
+  (m) =>
+    allPartitions(m)
+      .filter(
+        (p) =>
+          p.sourceType === "query" &&
+          m.dataSources.some((ds) => ds.name === p.dataSource && ds.kind === "structured"),
+      )
+      .map(finding.partition),
+);
+
+export const namingRules = [
+  TRIM_OBJECT_NAMES,
+  OBJECTS_SHOULD_NOT_START_OR_END_WITH_A_SPACE,
+  SPECIAL_CHARS_IN_OBJECT_NAMES,
+  AVOID_INVALID_NAME_CHARACTERS,
+  AVOID_INVALID_DESCRIPTION_CHARACTERS,
+  FIRST_LETTER_OF_OBJECTS_MUST_BE_CAPITALIZED,
+  PERSPECTIVES_WITH_NO_OBJECTS,
+  CALCULATION_GROUPS_WITH_NO_CALCULATION_ITEMS,
+  REMOVE_ROLES_WITH_NO_MEMBERS,
+  REMOVE_DATA_SOURCES_NOT_REFERENCED_BY_ANY_PARTITIONS,
+  AVOID_STRUCTURED_DATA_SOURCES_WITH_PROVIDER_PARTITIONS,
+];