@malloy-publisher/server 0.0.235 → 0.0.236

package/src/service/annotations.spec.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { ModelDef } from "@malloydata/malloy";
-import {
-   annotationTexts,
-   isReservedRoute,
-   modelAnnotations,
-} from "./annotations";
-
-// Minimal `ModelDef` carrying only what `modelAnnotations` reads: `modelID`
-// and the `modelAnnotations` registry (modelID → { ownNotes, inheritsFrom }).
-const makeModelDef = (
-   modelID: string,
-   registry: Record<
-      string,
-      {
-         ownNotes: { notes?: string[]; blockNotes?: string[] };
-         inheritsFrom: string[];
-      }
-   >,
-): ModelDef =>
-   ({
-      modelID,
-      modelAnnotations: Object.fromEntries(
-         Object.entries(registry).map(([id, { ownNotes, inheritsFrom }]) => [
-            id,
-            {
-               ownNotes: {
-                  notes: ownNotes.notes?.map((text) => ({ text, at: {} })),
-                  blockNotes: ownNotes.blockNotes?.map((text) => ({
-                     text,
-                     at: {},
-                  })),
-               },
-               inheritsFrom,
-            },
-         ]),
-      ),
-   }) as unknown as ModelDef;
-
-const noteTexts = (def: ModelDef): string[] =>
-   (modelAnnotations(def).notes ?? []).map((note) => note.text);
-
-describe("isReservedRoute", () => {
-   it("treats the empty route (MOTLY / render config) as reserved", () => {
-      expect(isReservedRoute("")).toBe(true);
-   });
-
-   it("treats Malloy's punctuation sigils as reserved", () => {
-      // Form 2 reserves the entire punct-only namespace, not just the
-      // currently-claimed sigils (`!` `@` `"` `:`).
-      for (const route of ["!", "@", '"', ":", "%", "-", "::"]) {
-         expect(isReservedRoute(route)).toBe(true);
-      }
-   });
-
-   it("treats bracketed app routes as not reserved", () => {
-      for (const route of [
-         "doc",
-         "label",
-         "filter",
-         "bar-chart",
-         "https://example.com/ns",
-         "123",
-         "══SECURITY══",
-      ]) {
-         expect(isReservedRoute(route)).toBe(false);
-      }
-   });
-});
-
-describe("modelAnnotations", () => {
-   it("returns the local model's own `##` notes", () => {
-      const def = makeModelDef("local", {
-         local: { ownNotes: { notes: ["## local"] }, inheritsFrom: [] },
-      });
-      expect(noteTexts(def)).toEqual(["## local"]);
-   });
-
-   it("falls back to an imported model's notes when the local model has no own `##` (authorize must not fail open)", () => {
-      // Regression: a `##(authorize)` declared in an imported file must still
-      // flow into the importing file's file-level gate even when the importing
-      // file declares no `##` of its own. An earlier fold kept an empty local
-      // link at the top, so `.notes` returned [] and the gate failed open.
-      const def = makeModelDef("local", {
-         local: { ownNotes: {}, inheritsFrom: ["base"] },
-         base: {
-            ownNotes: { notes: ['## (authorize) request.user == "admin"'] },
-            inheritsFrom: [],
-         },
-      });
-      expect(noteTexts(def)).toEqual([
-         '## (authorize) request.user == "admin"',
-      ]);
-   });
-
-   it("surfaces the local model's notes at the top when both local and import have `##`", () => {
-      const def = makeModelDef("local", {
-         local: { ownNotes: { notes: ["## local"] }, inheritsFrom: ["base"] },
-         base: { ownNotes: { notes: ["## base"] }, inheritsFrom: [] },
-      });
-      // `.notes` is the top (local); `.texts()` flattens the whole lineage
-      // ancestral-first.
-      expect(noteTexts(def)).toEqual(["## local"]);
-      expect(annotationTexts(modelAnnotations(def))).toEqual([
-         "## base",
-         "## local",
-      ]);
-   });
-
-   it("is cycle-safe and returns an empty bundle for a model with no annotations", () => {
-      const def = makeModelDef("local", {
-         local: { ownNotes: {}, inheritsFrom: ["base"] },
-         base: { ownNotes: {}, inheritsFrom: ["local"] }, // back-edge cycle
-      });
-      expect(modelAnnotations(def)).toEqual({});
-      expect(noteTexts(def)).toEqual([]);
-   });
-});

package/src/service/annotations.ts

@@ -1,91 +0,0 @@
-import { Annotations, type ModelDef } from "@malloydata/malloy";
-
-/**
- * The raw IR annotation bundle. Workaround: `@malloydata/malloy` exports the
- * `Annotations` view but not the underlying `AnnotationsDef` type, so we
- * recover it from the view's constructor parameter. Replace with a direct
- * `import type { AnnotationsDef }` once malloy exports it.
- */
-export type AnnotationsDef = NonNullable<
-   ConstructorParameters<typeof Annotations>[0]
->;
-
-/**
- * True if a route belongs to Malloy's own reserved namespace rather than an
- * application. Malloy claims the empty route (`''` — MOTLY tags / render
- * config) and the whole punctuation-sigil namespace (`!` `@` `"` `:`, and
- * any punct-only route — Form 2 reserves all of them). Everything else is a
- * bracketed app route (`#(doc)`, `#<label>`, …).
- *
- * TODO: this route classification belongs in `@malloydata/malloy` core,
- * beside `parsePrefix` — otherwise every consumer reinvents it. Remove when
- * core exports an equivalent.
- */
-export function isReservedRoute(route: string): boolean {
-   return route === "" || !/[\p{L}\p{N}]/u.test(route);
-}
-
-/**
- * The model (`##`) annotation bundle for one model, folded across its
- * import/extend lineage.
- *
- * Workaround: malloy 0.0.405 moved model annotations off `ModelDef.annotation`
- * and onto `ModelDef.modelAnnotations` (a `modelID → {ownNotes, inheritsFrom}`
- * registry), folded by the `getModelAnnotations` helper — which malloy does
- * NOT export from its public barrel. We replicate it (matching
- * `@malloydata/malloy/dist/model/annotation_utils.js`): a post-order DFS over
- * `inheritsFrom` (cycle-safe, each model emitted once at its most-ancestral
- * slot) yields ancestral-first / local-last order, folded into an
- * `AnnotationsDef` whose `inherits` chain runs most-ancestral-deepest / local
- * at the top.
- *
- * A model that contributes no `##` of its own adds NO link to the chain (we
- * skip empty `ownNotes`), so `.notes` returns the nearest ancestor that
- * actually has notes — not an empty local node. This matters because `.notes`
- * feeds file-level `##(authorize)` enforcement: an imported model's
- * `##(authorize)` must still flow into an importing file that declares no `##`
- * of its own. We also copy only `notes`/`blockNotes` rather than spreading
- * `ownNotes`, whose own `inherits` would otherwise leak in. Replace with a
- * direct `import { getModelAnnotations }` once malloy exports it.
- */
-export function modelAnnotations(modelDef: ModelDef): AnnotationsDef {
-   const registry = modelDef.modelAnnotations ?? {};
-   const visited = new Set<string>();
-   const order: string[] = [];
-   const visit = (id: string): void => {
-      if (visited.has(id)) return;
-      visited.add(id);
-      const entry = registry[id];
-      if (!entry) return;
-      for (const dep of entry.inheritsFrom) visit(dep);
-      order.push(id); // post-order: ancestors precede the model itself
-   };
-   visit(modelDef.modelID);
-
-   // Fold most-ancestral → local so the local model lands at the top of the
-   // resulting `inherits` chain. Models with no own notes add no link.
-   let folded: AnnotationsDef | undefined;
-   for (const id of order) {
-      const own = registry[id].ownNotes;
-      if (!own.notes?.length && !own.blockNotes?.length) continue;
-      folded = {
-         notes: own.notes,
-         blockNotes: own.blockNotes,
-         inherits: folded,
-      };
-   }
-   return folded ?? {};
-}
-
-/**
- * Every annotation text on an entity — its own `notes` and `blockNotes`
- * plus everything inherited from its ancestors. All of an entity's
- * annotations apply; none are dropped by source location. Returns
- * `undefined`, not `[]`, when empty, to match the optional API shape.
- */
-export function annotationTexts(
-   annote: AnnotationsDef | undefined,
-): string[] | undefined {
-   const texts = new Annotations(annote).texts();
-   return texts.length > 0 ? texts : undefined;
-}

package/src/service/authorize.spec.ts

@@ -1,154 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-   collectAuthorizeExprs,
-   isProbeTrue,
-   parseAuthorizeAnnotation,
-   referencedGivenNames,
-} from "./authorize";
-
-describe("referencedGivenNames", () => {
-   it("returns the $NAME tokens deduped in first-seen order", () => {
-      expect(
-         referencedGivenNames("$ROLE = 'admin' and $ROLE != $PRIOR"),
-      ).toEqual(["ROLE", "PRIOR"]);
-   });
-
-   it("ignores a $NAME inside a string literal (not a real reference)", () => {
-      // Otherwise a joined gate's referenced-given count is inflated and the
-      // full-coverage check wrongly denies a correctly-authorized request.
-      expect(referencedGivenNames("$ROLE = 'the $BOSS role'")).toEqual([
-         "ROLE",
-      ]);
-      expect(referencedGivenNames("'$A $B $C'")).toEqual([]);
-      expect(referencedGivenNames("$X = 'it\\'s $Y' or $Z = 1")).toEqual([
-         "X",
-         "Z",
-      ]);
-   });
-});
-
-describe("isProbeTrue", () => {
-   it("grants only on a genuine true / 1 / 'true'", () => {
-      expect(isProbeTrue(true)).toBe(true);
-      expect(isProbeTrue(1)).toBe(true);
-      expect(isProbeTrue("true")).toBe(true);
-   });
-
-   it("denies on anything else (fail closed)", () => {
-      for (const v of [false, 0, "false", "", null, undefined, {}, "TRUE", 2]) {
-         expect(isProbeTrue(v)).toBe(false);
-      }
-   });
-});
-
-describe("parseAuthorizeAnnotation", () => {
-   it("parses a source-level #(authorize) expression", () => {
-      expect(parseAuthorizeAnnotation(`#(authorize) "$ROLE = 'analyst'"`)).toBe(
-         "$ROLE = 'analyst'",
-      );
-   });
-
-   it("parses a file-level ##(authorize) expression", () => {
-      expect(parseAuthorizeAnnotation(`##(authorize) "$ROLE = 'admin'"`)).toBe(
-         "$ROLE = 'admin'",
-      );
-   });
-
-   it("tolerates the trailing newline Malloy keeps on note text", () => {
-      expect(
-         parseAuthorizeAnnotation(`#(authorize) "$REGION = 'us-west'"\n`),
-      ).toBe("$REGION = 'us-west'");
-   });
-
-   it("preserves inner single quotes (Malloy string literals)", () => {
-      expect(
-         parseAuthorizeAnnotation(`#(authorize) "$TENANT in ['a', 'b']"`),
-      ).toBe("$TENANT in ['a', 'b']");
-   });
-
-   it("unescapes escaped inner double quotes", () => {
-      expect(parseAuthorizeAnnotation(`#(authorize) "$NAME = \\"foo\\""`)).toBe(
-         `$NAME = "foo"`,
-      );
-   });
-
-   it("handles a constant false gate", () => {
-      expect(parseAuthorizeAnnotation(`#(authorize) "false"`)).toBe("false");
-   });
-
-   it("returns null for non-authorize annotations", () => {
-      expect(
-         parseAuthorizeAnnotation(`#(filter) dimension=x type=equal`),
-      ).toBeNull();
-      expect(parseAuthorizeAnnotation(`##! experimental.givens`)).toBeNull();
-      expect(parseAuthorizeAnnotation(`## just a doc comment`)).toBeNull();
-      expect(parseAuthorizeAnnotation(`# plain`)).toBeNull();
-      expect(parseAuthorizeAnnotation(``)).toBeNull();
-   });
-
-   it("throws when the body is not quoted", () => {
-      expect(() =>
-         parseAuthorizeAnnotation(`#(authorize) $ROLE = 'analyst'`),
-      ).toThrow(/double-quoted/);
-   });
-
-   it("throws on mismatched / unterminated quotes", () => {
-      expect(() =>
-         parseAuthorizeAnnotation(`#(authorize) "$ROLE = 'analyst'`),
-      ).toThrow(/mismatched quotes/);
-   });
-
-   it("throws on an empty expression body", () => {
-      expect(() => parseAuthorizeAnnotation(`#(authorize) ""`)).toThrow(
-         /empty expression/,
-      );
-   });
-
-   it("throws on content after the closing quote", () => {
-      expect(() =>
-         parseAuthorizeAnnotation(`#(authorize) "$ROLE = 'a'" extra`),
-      ).toThrow(/unexpected content/);
-   });
-
-   it("throws when the prefix has no body", () => {
-      expect(() => parseAuthorizeAnnotation(`#(authorize)`)).toThrow(
-         /double-quoted/,
-      );
-   });
-});
-
-describe("collectAuthorizeExprs", () => {
-   it("collects authorize expressions in declaration order", () => {
-      expect(
-         collectAuthorizeExprs([
-            `##(authorize) "$ROLE = 'admin'"`,
-            `#(filter) dimension=x type=equal`,
-            `#(authorize) "$REGION = 'us-west'"`,
-         ]),
-      ).toEqual(["$ROLE = 'admin'", "$REGION = 'us-west'"]);
-   });
-
-   it("returns [] when there are no authorize annotations", () => {
-      expect(
-         collectAuthorizeExprs([`#(filter) dimension=x type=equal`, `## doc`]),
-      ).toEqual([]);
-   });
-
-   it("keeps duplicate gates (no dedup — OR semantics)", () => {
-      expect(
-         collectAuthorizeExprs([
-            `#(authorize) "$ROLE = 'admin'"`,
-            `#(authorize) "$ROLE = 'admin'"`,
-         ]),
-      ).toEqual(["$ROLE = 'admin'", "$ROLE = 'admin'"]);
-   });
-
-   it("propagates the throw from a malformed authorize annotation", () => {
-      expect(() =>
-         collectAuthorizeExprs([
-            `#(authorize) "$ROLE = 'admin'"`,
-            `#(authorize) "unterminated`,
-         ]),
-      ).toThrow(/mismatched quotes/);
-   });
-});