@malloy-publisher/server 0.0.185 → 0.0.186

package/dist/server.js

@@ -229669,14 +229669,14 @@ function parseFilterAnnotation(annotation) {
   };
 }
 function parseFilters(annotations) {
-  const filters = [];
+  const byName = new Map;
   for (const annotation of annotations) {
     const parsed = parseFilterAnnotation(annotation);
     if (parsed) {
-      filters.push(parsed);
+      byName.set(parsed.name, parsed);
     }
   }
-  return filters;
+  return [...byName.values()];
 }
 function escapeMalloyString(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
@@ -230207,9 +230207,17 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
     const sources = Object.values(modelDef.contents).filter((obj) => import_malloy2.isSourceDef(obj)).map((sourceObj) => {
       const sourceName = sourceObj.as || sourceObj.name;
       const annotations = sourceObj.annotation?.blockNotes?.filter((note) => note.at.url.includes(modelPath)).map((note) => note.text);
-      const allAnnotations = sourceObj.annotation?.blockNotes?.map((note) => note.text);
+      const collectedAnnotations = [];
+      let curAnnotation = sourceObj.annotation;
+      while (curAnnotation) {
+        if (curAnnotation.blockNotes) {
+          collectedAnnotations.push(curAnnotation.blockNotes.map((note) => note.text));
+        }
+        curAnnotation = curAnnotation.inherits;
+      }
+      const allAnnotations = collectedAnnotations.reverse().flat();
       let filters;
-      if (allAnnotations && allAnnotations.length > 0) {
+      if (allAnnotations.length > 0) {
         try {
           const parsed = parseFilters(allAnnotations);
           if (parsed.length > 0) {

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.185",
+   "version": "0.0.186",
    "main": "dist/server.js",
    "bin": {
       "malloy-publisher": "dist/server.js"

package/src/service/filter.spec.ts

@@ -170,6 +170,61 @@ describe("service/filter", () => {
          const filters = parseFilters(["#(doc) some docs", "# hidden"]);
          expect(filters).toHaveLength(0);
       });
+
+      it("deduplicates by name, later annotations win (extend pattern)", () => {
+         const annotations = [
+            // Base source annotations (come first in blockNotes via inherits chain)
+            "#(filter) name=Manufacturer dimension=Manufacturer type=in",
+            "#(filter) name=Subject dimension=Subject type=like",
+            '#(filter) name="Major Recall" dimension="Major Recall" type=equal',
+            // Extending source annotations (come later, should win)
+            "#(filter) name=Manufacturer dimension=Manufacturer type=equal required",
+            "#(filter) name=Subject dimension=Subject type=like",
+         ];
+         const filters = parseFilters(annotations);
+         // 3 unique names: Manufacturer, Subject, Major Recall
+         expect(filters).toHaveLength(3);
+
+         // Manufacturer: child overrides base (in → equal, gains required)
+         const mfr = filters.find((f) => f.name === "Manufacturer");
+         expect(mfr).toBeDefined();
+         expect(mfr!.type).toBe("equal");
+         expect(mfr!.required).toBe(true);
+
+         // Subject: child re-declares identically, no visible change
+         const subj = filters.find((f) => f.name === "Subject");
+         expect(subj).toBeDefined();
+         expect(subj!.type).toBe("like");
+         expect(subj!.required).toBeFalsy();
+
+         // Major Recall: only on base, preserved in child
+         const major = filters.find((f) => f.name === "Major Recall");
+         expect(major).toBeDefined();
+         expect(major!.type).toBe("equal");
+         expect(major!.dimension).toBe("Major Recall");
+      });
+
+      it("child can remove required flag by overriding", () => {
+         const annotations = [
+            "#(filter) name=status dimension=status type=equal required",
+            "#(filter) name=status dimension=status type=equal",
+         ];
+         const filters = parseFilters(annotations);
+         expect(filters).toHaveLength(1);
+         expect(filters[0].name).toBe("status");
+         expect(filters[0].required).toBeFalsy();
+      });
+
+      it("child can change filter type by overriding", () => {
+         const annotations = [
+            "#(filter) name=category dimension=category type=in",
+            "#(filter) name=category dimension=category type=equal required",
+         ];
+         const filters = parseFilters(annotations);
+         expect(filters).toHaveLength(1);
+         expect(filters[0].type).toBe("equal");
+         expect(filters[0].required).toBe(true);
+      });
    });
 
    // -----------------------------------------------------------------------

package/src/service/filter.ts

@@ -127,14 +127,19 @@ export function parseFilterAnnotation(
  * (as found on a Malloy source's `blockNotes`).
  */
 export function parseFilters(annotations: string[]): FilterDefinition[] {
-   const filters: FilterDefinition[] = [];
+   // Use a Map keyed by filter name so that later annotations (from an
+   // extending source) override earlier ones (from the base source).
+   // This is important when `source: child is parent extend {}` inherits
+   // blockNotes from the parent — the child's annotations come last and
+   // should win.
+   const byName = new Map<string, FilterDefinition>();
    for (const annotation of annotations) {
       const parsed = parseFilterAnnotation(annotation);
       if (parsed) {
-         filters.push(parsed);
+         byName.set(parsed.name, parsed);
       }
    }
-   return filters;
+   return [...byName.values()];
 }
 
 // ---------------------------------------------------------------------------

package/src/service/filter_integration.spec.ts

@@ -94,6 +94,45 @@ import "orders_optional.malloy"
 run: orders -> summary
 `;
 
+// Base source with 3 filters: region (in), status (equal), customer_id (equal, required)
+const MODEL_BASE_FOR_EXTEND = `
+#(filter) name=region dimension=region type=in
+#(filter) name=status dimension=status type=equal
+#(filter) name=tenant dimension=customer_id type=equal required
+source: base_orders is duckdb.table('orders') extend {
+   primary_key: order_id
+
+   measure:
+      order_count is count()
+      total_amount is sum(amount)
+
+   view: summary is {
+      aggregate: order_count, total_amount
+   }
+}
+`;
+
+// Extending source: overrides region (in → equal), overrides tenant
+// (removes required), keeps status from base unchanged
+const MODEL_CHILD_EXTEND = `
+import "base_orders.malloy"
+
+#(filter) name=region dimension=region type=equal
+#(filter) name=tenant dimension=customer_id type=equal
+source: child_orders is base_orders extend {}
+`;
+
+// Notebook against the extended source
+const NOTEBOOK_EXTEND = `>>>markdown
+# Extend Test
+
+>>>malloy
+import "child_orders.malloy"
+
+>>>malloy
+run: child_orders -> summary
+`;
+
 beforeAll(async () => {
    await fs.mkdir(TEST_DB_DIR, { recursive: true });
    await fs.mkdir(TEST_PKG_DIR, { recursive: true });
@@ -619,4 +658,168 @@ describe("filter integration", () => {
          expect(markdownCell.text).toContain("Test Notebook");
       });
    });
+
+   // -----------------------------------------------------------------------
+   // Extended source filter inheritance
+   // -----------------------------------------------------------------------
+   describe("extended source filter inheritance", () => {
+      beforeEach(async () => {
+         await writeFile("base_orders.malloy", MODEL_BASE_FOR_EXTEND);
+         await writeFile("child_orders.malloy", MODEL_CHILD_EXTEND);
+         await writeFile("extend_notebook.malloynb", NOTEBOOK_EXTEND);
+      });
+
+      it("inherits base-only filters on extended source", async () => {
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "child_orders.malloy",
+            getConnections(),
+         );
+
+         const sources = model.getSources();
+         const child = sources!.find((s) => s.name === "child_orders");
+         expect(child).toBeDefined();
+         expect(child!.filters).toBeDefined();
+
+         // status is defined only on the base — it should carry through
+         const statusFilter = child!.filters!.find((f) => f.name === "status");
+         expect(statusFilter).toBeDefined();
+         expect(statusFilter!.type).toBe("equal");
+      });
+
+      it("child overrides base filter type", async () => {
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "child_orders.malloy",
+            getConnections(),
+         );
+
+         const sources = model.getSources();
+         const child = sources!.find((s) => s.name === "child_orders");
+         expect(child).toBeDefined();
+
+         // region: base=in, child overrides to equal
+         const regionFilter = child!.filters!.find((f) => f.name === "region");
+         expect(regionFilter).toBeDefined();
+         expect(regionFilter!.type).toBe("equal");
+      });
+
+      it("child can remove required flag by overriding", async () => {
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "child_orders.malloy",
+            getConnections(),
+         );
+
+         const sources = model.getSources();
+         const child = sources!.find((s) => s.name === "child_orders");
+         expect(child).toBeDefined();
+
+         // tenant: base=required, child overrides without required
+         const tenantFilter = child!.filters!.find((f) => f.name === "tenant");
+         expect(tenantFilter).toBeDefined();
+         expect(tenantFilter!.required).toBeFalsy();
+      });
+
+      it("has exactly the expected merged filter set", async () => {
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "child_orders.malloy",
+            getConnections(),
+         );
+
+         const sources = model.getSources();
+         const child = sources!.find((s) => s.name === "child_orders");
+         expect(child).toBeDefined();
+
+         // 3 unique filter names: region, status (from base), tenant
+         const filterNames = child!.filters!.map((f) => f.name).sort();
+         expect(filterNames).toEqual(["region", "status", "tenant"]);
+      });
+
+      it("applies inherited filter to query on extended source", async () => {
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "child_orders.malloy",
+            getConnections(),
+         );
+
+         // status=active is inherited from the base; should work on child
+         const { compactResult } = await model.getQueryResults(
+            "child_orders",
+            "summary",
+            undefined,
+            { status: "active" },
+         );
+         const rows = asRows(compactResult);
+         expect(rows.length).toBe(1);
+         // 4 active rows: US(2), EU(1), APAC(1)
+         expect(Number(rows[0].order_count)).toBe(4);
+      });
+
+      it("applies overridden filter to query on extended source", async () => {
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "child_orders.malloy",
+            getConnections(),
+         );
+
+         // region is overridden to type=equal on the child
+         const { compactResult } = await model.getQueryResults(
+            "child_orders",
+            "summary",
+            undefined,
+            { region: "US" },
+         );
+         const rows = asRows(compactResult);
+         expect(rows.length).toBe(1);
+         // 2 US rows
+         expect(Number(rows[0].order_count)).toBe(2);
+      });
+
+      it("no longer requires base's required filter after child override", async () => {
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "child_orders.malloy",
+            getConnections(),
+         );
+
+         // On the base, tenant is required. On the child, it's not.
+         // Running without tenant should NOT throw.
+         const { compactResult } = await model.getQueryResults(
+            "child_orders",
+            "summary",
+         );
+         const rows = asRows(compactResult);
+         expect(rows.length).toBe(1);
+         expect(Number(rows[0].order_count)).toBe(6);
+      });
+
+      it("applies inherited filters to notebook cells", async () => {
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "extend_notebook.malloynb",
+            getConnections(),
+         );
+
+         // Apply status=cancelled (inherited from base) via notebook cell
+         const codeCell = await model.executeNotebookCell(2, {
+            status: "cancelled",
+         });
+         expect(codeCell.result).toBeDefined();
+
+         const rows = parseNotebookResult(codeCell.result!);
+         expect(rows.length).toBe(1);
+         // 2 cancelled rows: EU(1), APAC(1)
+         expect(Number(rows[0].order_count)).toBe(2);
+      });
+   });
 });

package/src/service/model.ts

@@ -750,13 +750,29 @@ export class Model {
                ?.filter((note) => note.at.url.includes(modelPath))
                .map((note) => note.text);
 
-            // Parse #(filter) from ALL annotations (including imports)
-            // so filters defined on an imported source are honored by notebooks
-            const allAnnotations = (
-               sourceObj as StructDef
-            ).annotation?.blockNotes?.map((note) => note.text);
+            // Parse #(filter) from ALL annotations, traversing the inherits
+            // chain so that filters on a base source (e.g. `recalls`) are
+            // picked up by an extending source (`manufacturer_recalls is
+            // recalls extend {}`).  The Malloy compiler stores the base
+            // source's annotations in `annotation.inherits`.
+            //
+            // The chain goes child → parent, so we collect child-first.
+            // parseFilters uses "last wins" dedup, so we reverse to put
+            // parent annotations first and child annotations last (winning).
+            const collectedAnnotations: string[][] = [];
+            let curAnnotation: Annotation | undefined = (sourceObj as StructDef)
+               .annotation;
+            while (curAnnotation) {
+               if (curAnnotation.blockNotes) {
+                  collectedAnnotations.push(
+                     curAnnotation.blockNotes.map((note) => note.text),
+                  );
+               }
+               curAnnotation = curAnnotation.inherits;
+            }
+            const allAnnotations = collectedAnnotations.reverse().flat();
             let filters: ApiFilter[] | undefined;
-            if (allAnnotations && allAnnotations.length > 0) {
+            if (allAnnotations.length > 0) {
                try {
                   const parsed = parseFilters(allAnnotations);
                   if (parsed.length > 0) {