import assert from "node:assert/strict"; import { execFileSync, spawnSync } from "node:child_process"; import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import path from "node:path"; import { test } from "node:test"; import { fileURLToPath } from "node:url"; import { PUBLIC_MANIFEST } from "./owners.mjs"; import { gitBinary } from "./verify-package-lockfiles.mjs"; import { ALLOW_FILE, BoundaryError, RULES, dependencyNames, importSpecifiers, isFnPackage, loadParsers, packageNameOf, packageNamesOf, parseAllowFile, verifyPublicBoundary, workspacePatterns, } from "./verify-public-boundary.mjs"; const script = fileURLToPath(new URL("./verify-public-boundary.mjs", import.meta.url)); const manifest = () => ({ version: 1, paths: { datafn: "public", scripts: "public" }, rootFiles: { public: ["package.json", "release-packages.json", PUBLIC_MANIFEST], generated: ["package-lock.json"] }, releases: { "datafn-core": "public" }, python: { datafn: "public" }, }); const json = (value) => `${JSON.stringify(value, null, 2)}\n`; function fixture(t, { owners = manifest(), releases, allow = {}, workspaces = ["datafn/*"], files = {}, links = {}, gitlinks = [] } = {}) { const root = mkdtempSync(path.join(tmpdir(), "verify-public-boundary-")); t.after(() => rmSync(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 })); const all = { "package.json": json({ name: "root", private: true, workspaces }), "package-lock.json": "{}\n", "release-packages.json": json(releases ?? [{ slug: "datafn-core", path: "datafn/core", name: "@datafn/core" }]), [PUBLIC_MANIFEST]: json(owners), [ALLOW_FILE]: json({ version: 1, packages: allow }), "datafn/core/package.json": json({ name: "@datafn/core", dependencies: { zod: "^3.0.0" } }), "datafn/core/src/index.ts": 'import { z } from "zod";\nexport const schema = z.string();\n', "datafn/client/package.json": json({ name: "@datafn/client", dependencies: { "@datafn/core": "*" } }), "datafn/client/src/index.ts": 'export * from "@datafn/core";\n', "datafn/python/pyproject.toml": '[project]\nname = "datafn"\nversion = "0.1.0"\n', ...files, }; for (const [file, content] of Object.entries(all)) { if (content === null) continue; mkdirSync(path.dirname(path.join(root, file)), { recursive: true }); writeFileSync(path.join(root, file), content); } for (const [link, target] of Object.entries(links)) { mkdirSync(path.dirname(path.join(root, link)), { recursive: true }); symlinkSync(target, path.join(root, link)); } execFileSync(gitBinary(), ["init", "-q"], { cwd: root }); execFileSync(gitBinary(), ["add", "-A"], { cwd: root }); for (const gitlink of gitlinks) { execFileSync(gitBinary(), ["update-index", "--add", "--cacheinfo", `160000,${"1".repeat(40)},${gitlink}`], { cwd: root }); } return root; } const run = (root) => spawnSync(process.execPath, [script, "--root", root], { encoding: "utf8" }); const findings = async (root) => (await verifyPublicBoundary({ root })).map(({ file, rule }) => `${file} ${rule}`); const parsers = await loadParsers(); const specifiers = (file, source) => importSpecifiers(file, source, parsers).map(({ specifier, line }) => `${line} ${specifier}`); test("a tree inside the public boundary passes", (t) => { const result = run(fixture(t)); assert.equal(result.status, 0, result.stderr); assert.match(result.stdout, /Public boundary holds/); }); test("an unlisted top-level directory fails, naming the directory and the rule", (t) => { const result = run(fixture(t, { files: { "flowfn/core/index.ts": "export {};\n" } })); assert.equal(result.status, 1); assert.match(result.stderr, /flowfn\/: \[top-level-path\] top-level directory is not listed in superfunctions\.owners\.json paths/); }); test("an unlisted root file fails, naming the file and the rule", async (t) => { const root = fixture(t, { files: { "superfunctions.owners.next.json": "{}\n" } }); assert.deepEqual(await findings(root), [`superfunctions.owners.next.json ${RULES.topLevelPath}`]); }); test("a release entry for an unlisted directory fails, naming the release file, entry and rule", (t) => { const owners = { ...manifest(), releases: { "datafn-core": "public", "flowfn-core": "public" } }; const releases = [ { slug: "datafn-core", path: "datafn/core", name: "@datafn/core" }, { slug: "flowfn-core", path: "flowfn/core", name: "@flowfn/core" }, ]; const result = run(fixture(t, { owners, releases })); assert.equal(result.status, 1); assert.match(result.stderr, /release-packages\.json: \[public-release\] release "flowfn-core" \(flowfn\/core\) is not under a top-level directory listed/); }); test("a release entry the manifest does not list as public fails", (t) => { const releases = [ { slug: "datafn-core", path: "datafn/core", name: "@datafn/core" }, { slug: "datafn-client", path: "datafn/client", name: "@datafn/client" }, ]; const result = run(fixture(t, { releases })); assert.equal(result.status, 1); assert.match(result.stderr, /release-packages\.json: \[public-release\] release "datafn-client" \(datafn\/client\) is not listed as public/); }); test("a Python project the manifest does not list fails, naming its pyproject.toml", async (t) => { const root = fixture(t, { files: { "datafn/agent/pyproject.toml": '[project]\nname = "datafn-agent"\n' } }); assert.deepEqual(await findings(root), [`datafn/agent/pyproject.toml ${RULES.publicRelease}`]); }); test("a workspace package in an unlisted directory fails as a workspace package and as a top-level path", async (t) => { const root = fixture(t, { workspaces: ["datafn/*", "flowfn/*"], files: { "flowfn/core/package.json": json({ name: "@flowfn/core" }) }, }); assert.deepEqual((await findings(root)).sort(), [`flowfn/ ${RULES.topLevelPath}`, `flowfn/core/package.json ${RULES.workspacePackage}`]); }); test("workspace package names must resolve to exactly one directory", async (t) => { const root = fixture(t, { files: { "datafn/server/package.json": json({ name: "@datafn/client" }), "datafn/cli/package.json": json({ private: true }), }, }); assert.deepEqual((await findings(root)).sort(), [ `datafn/cli/package.json ${RULES.workspacePackage}`, `datafn/client/package.json ${RULES.workspacePackage}`, `datafn/server/package.json ${RULES.workspacePackage}`, ]); }); test("an import of an unlisted *fn package fails, naming the file, line and rule", (t) => { const source = 'import { z } from "zod";\n\nimport { flow } from "@flowfn/core/runtime";\n'; const result = run(fixture(t, { files: { "datafn/core/src/flow.ts": source } })); assert.equal(result.status, 1); assert.match(result.stderr, /datafn\/core\/src\/flow\.ts:3: \[fn-dependency\] imports "@flowfn\/core\/runtime": package "@flowfn\/core", which is neither a public workspace package nor allowed/); }); test("a package.json dependency on an unlisted *fn package fails, naming the file, field and rule", (t) => { const pkg = json({ name: "@datafn/server", devDependencies: { flowfn: "^1.0.0" } }); const result = run(fixture(t, { files: { "datafn/server/package.json": pkg } })); assert.equal(result.status, 1); assert.match(result.stderr, /datafn\/server\/package\.json: \[fn-dependency\] devDependencies depends on "flowfn"/); }); test("allow-listed *fn packages pass as imports and dependencies", async (t) => { const root = fixture(t, { allow: { "@flowfn/core": { reason: "published flow engine" }, flowfn: { reason: "published CLI" } }, files: { "datafn/server/package.json": json({ name: "@datafn/server", dependencies: { "@flowfn/core": "^1.0.0", flowfn: "^1.0.0" } }), "datafn/server/src/index.ts": 'import { flow } from "@flowfn/core";\nconst cli = require("flowfn/bin");\n', }, }); assert.deepEqual(await findings(root), []); }); test("an allow entry with paths applies only under those directories", async (t) => { const root = fixture(t, { allow: { "@flowfn/core": { reason: "alias in the server", paths: ["datafn/server"] } }, files: { "datafn/server/src/index.ts": 'import "@flowfn/core";\n', "datafn/serverless/src/index.ts": 'import "@flowfn/core";\n', }, }); assert.deepEqual(await findings(root), [`datafn/serverless/src/index.ts:1 ${RULES.fnDependency}`]); }); test("an allow entry naming a public workspace package is refused", async (t) => { const root = fixture(t, { allow: { "@datafn/core": { reason: "redundant" } } }); assert.deepEqual(await findings(root), [`${ALLOW_FILE} ${RULES.fnDependency}`]); }); test("prose, comments and strings that mention *fn packages are not checked", async (t) => { const root = fixture(t, { files: { "datafn/README.md": 'import { flow } from "@flowfn/core";\n', "datafn/core/src/notes.ts": '// import { flow } from "@flowfn/core";\nconst doc = `import { flow } from "@flowfn/core"`;\nexport const name = "flowfn";\n', "datafn/docs/guide.mdx": '# Guide\n\nYou can import flowfn from the registry when it ships.\n\n```ts\nimport { flow } from "@flowfn/core";\n```\n', }, }); assert.deepEqual(await findings(root), []); }); test("imports in svelte, html and mdx module code are checked", async (t) => { const root = fixture(t, { files: { "datafn/svelte/src/View.svelte": '\n

import "@flowfn/text"

\n', "datafn/site/index.html": '\n\n', "datafn/docs/page.mdx": '# Page\n\nimport { Demo } from "@flowfn/docs";\n\nText.\n', }, }); assert.deepEqual(await findings(root), [ `datafn/docs/page.mdx:3 ${RULES.fnDependency}`, `datafn/site/index.html:2 ${RULES.fnDependency}`, `datafn/svelte/src/View.svelte:2 ${RULES.fnDependency}`, ]); }); test("imports in svelte templates, mdx expressions and html handlers are checked", async (t) => { const root = fixture(t, { files: { "datafn/svelte/src/Await.svelte": '\n{#await import("@flowfn/await") then m}{/await}\n\n', "datafn/docs/jsx.mdx": '# Page\n\n\n\n{await import("@flowfn/expr")}\n', "datafn/docs/frontmatter.mdx": '---\ntitle: Page\n---\nimport { Demo } from "@flowfn/esm";\n', "datafn/docs/heading.mdx": '# Page\nimport { Demo } from "@flowfn/heading";\n', "datafn/site/handler.html": 'go\n', "datafn/core/src/registry.ts": 'import "npm:@flowfn/npm@^1";\nimport "jsr:@flowfn/jsr";\n', }, }); assert.deepEqual(await findings(root), [ `datafn/core/src/registry.ts:1 ${RULES.fnDependency}`, `datafn/core/src/registry.ts:2 ${RULES.fnDependency}`, `datafn/docs/frontmatter.mdx:4 ${RULES.fnDependency}`, `datafn/docs/heading.mdx:2 ${RULES.fnDependency}`, `datafn/docs/jsx.mdx:3 ${RULES.fnDependency}`, `datafn/docs/jsx.mdx:5 ${RULES.fnDependency}`, `datafn/site/handler.html:2 ${RULES.fnDependency}`, `datafn/svelte/src/Await.svelte:4 ${RULES.fnDependency}`, `datafn/svelte/src/Await.svelte:5 ${RULES.fnDependency}`, ]); }); test("html comments, jsx text and regex literals that look like imports are not code", async (t) => { const root = fixture(t, { files: { "datafn/site/comment.html": '\n

x

\n', "datafn/svelte/src/Comment.svelte": '\n

import "@flowfn/text"

\n', "datafn/core/src/View.tsx": 'export const View = () =>

import "@flowfn/core"

;\n', "datafn/core/src/pattern.ts": 'export const pattern = /import("@flowfn\\/core")/;\n', }, }); assert.deepEqual(await findings(root), []); }); test("parentheses, as, satisfies, type assertions and ! around a specifier do not hide it", async (t) => { const root = fixture(t, { files: { "datafn/core/src/wrapped.ts": [ 'await import(("@flowfn/paren"));', 'require(("@flowfn/require"));', 'await import("@flowfn/as" as string);', 'await import("@flowfn/satisfies" satisfies string);', 'await import("@flowfn/bang"!);', 'await import("@flowfn/assertion");', 'require.resolve((("@flowfn/resolve") as string)!);', ].join("\n"), "datafn/svelte/src/Wrapped.svelte": [ '", '', ].join("\n"), }, }); assert.deepEqual(await findings(root), [ ...[1, 2, 3, 4, 5, 6, 7].map((line) => `datafn/core/src/wrapped.ts:${line} ${RULES.fnDependency}`), ...[2, 3, 4, 5, 6, 8].map((line) => `datafn/svelte/src/Wrapped.svelte:${line} ${RULES.fnDependency}`), ]); }); test("every module loader form is read; unrelated calls and plain strings are not", async (t) => { const root = fixture(t, { files: { "datafn/core/src/loaders.mts": [ 'import { createRequire } from "node:module";', 'import { createRequire as makeRequire } from "module";', 'import * as nodeModule from "node:module";', "const r = createRequire(import.meta.url);", 'r("@flowfn/a");', 'createRequire(import.meta.url).resolve("@flowfn/b");', 'import.meta.resolve("@flowfn/c");', '(require)("@flowfn/d");', '(require.resolve)("@flowfn/e");', 'require["resolve"]("@flowfn/f");', '(require as NodeRequire)("@flowfn/g");', 'makeRequire(import.meta.url)("@flowfn/h");', 'nodeModule.createRequire(import.meta.url)("@flowfn/i");', "const resolveFrom = r.resolve;", 'resolveFrom("@flowfn/j");', "let later; later = createRequire(import.meta.url);", 'later("@flowfn/k");', "const copy = r;", 'copy("@flowfn/l");', '(createRequire(import.meta.url) as NodeRequire)["resolve"]!("@flowfn/m");', 'unrelated("@flowfn/n"); other.resolve("@flowfn/o"); createRequire("@flowfn/p"); const s = "@flowfn/q";', ].join("\n"), "datafn/svelte/src/Loaders.svelte": [ '", '', ].join("\n"), "datafn/docs/loaders.mdx": [ 'import { createRequire } from "node:module";', "", "export const load = createRequire(import.meta.url);", "", '{load.resolve("@flowfn/a")} and {import.meta.resolve("@flowfn/b")} and {unrelated("@flowfn/c")}', "", ].join("\n"), }, }); const result = run(root); assert.equal(result.status, 1); assert.match(result.stderr, /datafn\/core\/src\/loaders\.mts:5: \[fn-dependency\] imports "@flowfn\/a"/); assert.deepEqual(await findings(root), [ ...[5, 7, 6, 8, 9, 10, 11, 12, 13, 15, 17, 19, 20].sort((a, b) => a - b).map((line) => `datafn/core/src/loaders.mts:${line} ${RULES.fnDependency}`), ...[5, 5].map((line) => `datafn/docs/loaders.mdx:${line} ${RULES.fnDependency}`), ...[4, 5, 8].map((line) => `datafn/svelte/src/Loaders.svelte:${line} ${RULES.fnDependency}`), ]); }); test("Module#require and destructured loaders are read; the same names on unrelated objects are not", async (t) => { const root = fixture(t, { files: { "datafn/core/src/commonjs.cts": [ 'module.require("@flowfn/a");', 'module["require"]("@flowfn/b");', 'require.main.require("@flowfn/c");', '(module as NodeModule)!.require("@flowfn/d");', "const { resolve } = require;", 'resolve("@flowfn/e");', "const { require: load, main } = module;", 'load("@flowfn/f");', "const { main: entry } = require;", 'entry.require("@flowfn/g");', "let later; ({ resolve: later } = require);", 'later("@flowfn/h");', 'obj.require("@flowfn/x"); const { resolve: other } = obj; other("@flowfn/y"); const s = "@flowfn/z";', ].join("\n"), "datafn/core/src/esm.mts": [ 'const { createRequire: cr } = await import("node:module");', 'cr(import.meta.url)("@flowfn/a");', 'import nodeModule from "module";', "const { createRequire } = nodeModule;", 'createRequire(import.meta.url).resolve("@flowfn/b");', 'const { createRequire: viaRequire } = require("node:module");', 'viaRequire(__filename)("@flowfn/c");', 'import * as ns from "node:module";', 'const { createRequire: viaNamespace } = ns.default;', 'viaNamespace(import.meta.url)("@flowfn/d");', 'const { createRequire: notModule } = await import("./local.js");', 'notModule(import.meta.url)("@flowfn/x");', ].join("\n"), "datafn/svelte/src/Commonjs.svelte": [ '", '', ].join("\n"), }, }); const result = run(root); assert.equal(result.status, 1); assert.match(result.stderr, /datafn\/core\/src\/commonjs\.cts:1: \[fn-dependency\] imports "@flowfn\/a"/); assert.deepEqual(await findings(root), [ ...[1, 2, 3, 4, 6, 8, 10, 12].map((line) => `datafn/core/src/commonjs.cts:${line} ${RULES.fnDependency}`), ...[2, 5, 7, 10].map((line) => `datafn/core/src/esm.mts:${line} ${RULES.fnDependency}`), ...[3, 5, 8].map((line) => `datafn/svelte/src/Commonjs.svelte:${line} ${RULES.fnDependency}`), ]); }); test("svelte static on* attributes are read as inline handlers; other static attributes are not", async (t) => { const root = fixture(t, { files: { "datafn/svelte/src/Handlers.svelte": [ "", "", "", "d", ].join("\n"), }, }); assert.deepEqual(await findings(root), [1, 2, 4].map((line) => `datafn/svelte/src/Handlers.svelte:${line} ${RULES.fnDependency}`)); }); test("html scripts of every JavaScript MIME type and legacy language are read; data blocks are not", async (t) => { const types = ["application/ecmascript", "text/jscript", "TEXT/JavaScript; charset=utf-8", "application/x-javascript", "text/livescript", "module", ""]; const scripts = types.map((type) => ``); const root = fixture(t, { files: { "datafn/site/types.html": [ ...scripts, '', '', '', '', '', '', ].join("\n"), }, }); assert.deepEqual( await findings(root), Array.from({ length: types.length + 2 }, (_, index) => `datafn/site/types.html:${index + 1} ${RULES.fnDependency}`), ); }); test("svelte ', ' ', "", "
", " ", "
", ].join("\n"), "datafn/svelte/src/BrokenHead.svelte": "\n \n\n", }, }); const result = run(root); assert.equal(result.status, 1); assert.deepEqual(await findings(root), [ `datafn/svelte/src/BrokenHead.svelte:3 ${RULES.fnDependency}`, `datafn/svelte/src/Head.svelte:2 ${RULES.fnDependency}`, `datafn/svelte/src/Head.svelte:7 ${RULES.fnDependency}`, ]); assert.match(result.stderr, /datafn\/svelte\/src\/BrokenHead\.svelte:3: \[fn-dependency\] cannot be parsed/); }); test("bundler queries, fragments and loader requests name their packages", async (t) => { const root = fixture(t, { files: { "datafn/core/src/bundler.ts": [ 'import a from "@flowfn/core?inline";', 'import b from "flowfn?raw";', 'import c from "raw-loader!@flowfn/x";', 'import d from "@flowfn/core#fragment";', 'import e from "@flowfn/loader?mode=1!./local.txt";', 'import f from "raw-loader!./local.txt?raw";', 'import g from "#internal?raw";', ].join("\n"), }, }); assert.deepEqual( await findings(root), [1, 2, 3, 4, 5].map((line) => `datafn/core/src/bundler.ts:${line} ${RULES.fnDependency}`), ); }); test("a source file that does not parse fails, naming the file, line and rule", async (t) => { const root = fixture(t, { files: { "datafn/core/src/broken.ts": 'export const a = 1;\nimport { from "@flowfn/core";\n', "datafn/svelte/src/Broken.svelte": "\n{#if x}\n", "datafn/docs/broken.mdx": "# Page\n\n{import(\n", }, }); const result = run(root); assert.equal(result.status, 1); assert.match(result.stderr, /datafn\/core\/src\/broken\.ts:2: \[fn-dependency\] cannot be parsed \(.+\); its imports cannot be checked/); assert.match(result.stderr, /datafn\/svelte\/src\/Broken\.svelte(:\d+)?: \[fn-dependency\] cannot be parsed/); assert.match(result.stderr, /datafn\/docs\/broken\.mdx(:\d+)?: \[fn-dependency\] cannot be parsed/); }); test("tracked symlinks and submodules at the top level are checked as top-level paths", async (t) => { const root = fixture(t, { files: { "notes.txt": "x\n" }, links: { "LINKED.md": "notes.txt", privatefn: "datafn" }, gitlinks: ["vendorfn"], owners: { ...manifest(), rootFiles: { ...manifest().rootFiles, public: [...manifest().rootFiles.public, "notes.txt"] } }, }); assert.deepEqual(await findings(root), [`privatefn/ ${RULES.topLevelPath}`, `vendorfn/ ${RULES.topLevelPath}`, `LINKED.md ${RULES.topLevelPath}`]); const result = run(root); assert.equal(result.status, 1); assert.match(result.stderr, /privatefn\/: \[top-level-path\] top-level directory is not listed/); assert.match(result.stderr, /vendorfn\/: \[top-level-path\] top-level directory is not listed/); assert.match(result.stderr, /LINKED\.md: \[top-level-path\] root file is not listed/); }); test("a symlinked source file or package.json is read through its link", async (t) => { const root = fixture(t, { files: { "datafn/core/src/source.txt": 'import { flow } from "@flowfn/core";\n', "datafn/server/manifest.txt": json({ name: "@datafn/server", dependencies: { flowfn: "^1.0.0" } }), }, links: { "datafn/core/src/flow.ts": "source.txt", "datafn/server/package.json": "manifest.txt" }, }); const result = run(root); assert.equal(result.status, 1); assert.match(result.stderr, /datafn\/core\/src\/flow\.ts:1: \[fn-dependency\] imports "@flowfn\/core"/); assert.match(result.stderr, /datafn\/server\/package\.json: \[fn-dependency\] dependencies depends on "flowfn"/); }); test("a symlinked source file or package.json that cannot be read in the tree fails", async (t) => { const outside = mkdtempSync(path.join(tmpdir(), "verify-public-boundary-outside-")); t.after(() => rmSync(outside, { recursive: true, force: true })); writeFileSync(path.join(outside, "secret.ts"), 'import "@flowfn/core";\n'); const root = fixture(t, { links: { "datafn/core/src/outside.ts": path.join(outside, "secret.ts"), "datafn/core/src/dangling.ts": "missing.ts", "datafn/core/src/folder.ts": "../src", "datafn/linked/package.json": "../../gone/package.json", }, }); assert.deepEqual((await findings(root)).sort(), [ `datafn/core/src/dangling.ts ${RULES.fnDependency}`, `datafn/core/src/folder.ts ${RULES.fnDependency}`, `datafn/core/src/outside.ts ${RULES.fnDependency}`, `datafn/linked/package.json ${RULES.fnDependency}`, `datafn/linked/package.json ${RULES.workspacePackage}`, ]); }); test("a symlinked or submodule workspace directory fails; a symlinked directory without a package passes", async (t) => { const root = fixture(t, { files: { "datafn/swift/Package.swift": "// swift\n", "scripts/private/package.json": json({ name: "@private/x" }) }, links: { "datafn/swift-package": "swift", "datafn/private": "../scripts/private" }, gitlinks: ["datafn/vendored"], }); assert.deepEqual((await findings(root)).sort(), [`datafn/private ${RULES.workspacePackage}`, `datafn/vendored ${RULES.workspacePackage}`]); }); test("symlinks and submodules at an ancestor of a workspace match fail, naming the link and rule", async (t) => { const root = fixture(t, { workspaces: ["datafn/core", "datafn/client", "datafn/nested/*", "datafn/deep/*/*", "datafn/gone/*", "*/packages/*"], files: { "scripts/deep/a/b/package.json": json({ name: "@private/deep" }), "scripts/private/x/package.json": json({ name: "@private/x" }), "scripts/private-shallow/package.json": json({ name: "@private/shallow" }), "scripts/docs/readme.md": "# docs\n", }, links: { // Ancestors npm expands workspaces through: each fails. "datafn/deep": "../scripts/deep", "datafn/packages": "../scripts/private", "datafn/gone": "../scripts/missing", // Reached by */packages/*, but no tracked package.json lies at a workspace match through it: passes. "scripts/packages": "docs", // Reached by datafn/deep/*/*, but its package.json is one level too shallow: passes. "datafn/shallow": "../scripts/private-shallow", // No workspace pattern reaches it: passes. "datafn/other": "../scripts/private", }, gitlinks: ["datafn/nested"], }); const result = run(root); assert.equal(result.status, 1); assert.match(result.stderr, /datafn\/nested: \[workspace-package\] is a submodule \(gitlink\) that npm expands workspace pattern "datafn\/nested\/\*" through/); assert.match(result.stderr, /datafn\/packages: \[workspace-package\] is a symlink to "\.\.\/scripts\/private"; npm reads workspace "datafn\/packages\/x" through it from scripts\/private\/x\/package\.json/); assert.deepEqual((await findings(root)).sort(), [ `datafn/deep ${RULES.workspacePackage}`, `datafn/gone ${RULES.workspacePackage}`, `datafn/nested ${RULES.workspacePackage}`, `datafn/packages ${RULES.workspacePackage}`, ]); }); test("a symlinked workspace directory whose target holds any tracked link fails; nothing is followed", async (t) => { const chain = (t, inner) => fixture(t, { workspaces: ["datafn/core", "datafn/linked/*"], files: { "scripts/hidden/package.json": json({ name: "@privatefn/secret" }), "scripts/bridge/notes.md": "# bridge\n" }, links: { "datafn/linked": "../scripts/bridge", "scripts/bridge/leaf": inner }, }); // A chain npm follows to an untracked workspace package. const viaDirectory = chain(t, "../hidden"); const result = run(viaDirectory); assert.equal(result.status, 1); assert.match(result.stderr, /datafn\/linked: \[workspace-package\] is a symlink to "\.\.\/scripts\/bridge", whose target holds the tracked symlink scripts\/bridge\/leaf/); assert.deepEqual(await findings(viaDirectory), [`datafn/linked ${RULES.workspacePackage}`]); // Any nested link fails, even one to a file. assert.deepEqual(await findings(chain(t, "notes.md")), [`datafn/linked ${RULES.workspacePackage}`]); // A nested submodule fails too. const gitlinked = fixture(t, { workspaces: ["datafn/core", "datafn/linked/*"], files: { "scripts/bridge/notes.md": "# bridge\n" }, links: { "datafn/linked": "../scripts/bridge" }, gitlinks: ["scripts/bridge/vendored"], }); assert.deepEqual(await findings(gitlinked), [`datafn/linked ${RULES.workspacePackage}`]); // A single link to a directory with neither a matching package.json nor nested links passes. const plain = fixture(t, { workspaces: ["datafn/core", "datafn/linked/*"], files: { "scripts/bridge/notes.md": "# bridge\n" }, links: { "datafn/linked": "../scripts/bridge" }, }); assert.deepEqual(await findings(plain), []); }); test("python importlib.import_module and __import__ calls with a literal *fn name are checked", async (t) => { const root = fixture(t, { files: { "datafn/python/datafn/dynamic.py": [ "import importlib", "from importlib import import_module", 'importlib.import_module("flowfn")', 'import_module("flowfn.core")', '__import__("flowfn")', 'importlib.import_module(".flowfn", "datafn")', 'importlib.import_module("datafn.client")', '"""importlib.import_module("flowfn") in a docstring"""', 'name = "flowfn"', "", ].join("\n"), "datafn/python/datafn/aliased.py": [ "import importlib as il", "from importlib import import_module as load", 'il.import_module("flowfn")', 'load("flowfn")', 'il.import_module(name="flowfn")', '__import__(name="flowfn")', "", ].join("\n"), "datafn/python/datafn/local.py": [ "def import_module(name):", " return name", 'import_module("flowfn")', 'other.import_module("flowfn")', "", ].join("\n"), }, }); assert.deepEqual((await findings(root)).sort(), [ ...[3, 4, 5, 6].map((line) => `datafn/python/datafn/aliased.py:${line} ${RULES.fnDependency}`), ...[3, 4, 5].map((line) => `datafn/python/datafn/dynamic.py:${line} ${RULES.fnDependency}`), ]); }); test("python __import__ levels, starred arguments, importlib wildcard imports and assignment aliases follow the closed loader set", async (t) => { const root = fixture(t, { files: { "datafn/python/datafn/levels.py": [ '__import__("flowfn", None, None, [], 1)', '__import__("flowfn", level=2)', '__import__("flowfn", None, None, [], 0)', '__import__("flowfn", level=0)', '__import__("flowfn", None, None, [], depth)', '__import__("flowfn", **options)', '__import__("flowfn", globals(), locals())', '__import__("flowfn", level=False)', '__import__("flowfn", None, None, [], -0)', '__import__("flowfn", level=+0)', '__import__("flowfn", level=True)', '__import__("flowfn", None, None, [], +2)', '__import__("flowfn", *rest, 1)', "", ].join("\n"), "datafn/python/datafn/wildcard.py": ["from importlib import *", 'import_module("flowfn")', 'import_module(".flowfn", "datafn")', ""].join("\n"), "datafn/python/datafn/aliases.py": [ "import importlib", "im = importlib.import_module", 'im("flowfn")', "f = __import__", 'f("flowfn")', 'f("flowfn", level=1)', "g = h = im", 'h("flowfn")', "k: object = g", 'k("flowfn")', "lib = importlib", 'lib.import_module("flowfn")', 'late("flowfn")', "late = f", "", ].join("\n"), "datafn/python/datafn/starred.py": [ "import importlib", 'importlib.import_module(*(), name="flowfn")', '__import__(*(), name="flowfn")', "im = importlib.import_module", 'im(*(), name="flowfn")', "f = __import__", 'f(*args, name="flowfn")', 'importlib.import_module(*(), name="datafn")', '__import__(*(), name="datafn")', '__import__(*(), name="flowfn", level=1)', '__import__("flowfn", *rest)', '__import__(*a, "flowfn")', 'f(*(), name="flowfn", level=1)', "", ].join("\n"), "datafn/python/datafn/unrelated.py": [ "def import_module(name, level=0):", " return name", "im = import_module", 'im("flowfn")', 'import_module("flowfn")', "other = object()", "dyn = other.import_module", 'dyn("flowfn")', 'getattr(importlib, "import_module")("flowfn")', "", ].join("\n"), }, }); assert.deepEqual((await findings(root)).sort(), [ ...[3, 5, 8, 10, 12, 13].map((line) => `datafn/python/datafn/aliases.py:${line} ${RULES.fnDependency}`), ...[3, 4, 5, 6, 7, 8, 9, 10, 13].map((line) => `datafn/python/datafn/levels.py:${line} ${RULES.fnDependency}`), ...[2, 3, 5, 7, 11].map((line) => `datafn/python/datafn/starred.py:${line} ${RULES.fnDependency}`), `datafn/python/datafn/wildcard.py:2 ${RULES.fnDependency}`, ].sort()); }); test("python imports of *fn modules must name a public Python project or an allowed package", async (t) => { const root = fixture(t, { allow: { pinnedfn: { reason: "published on PyPI" } }, files: { "datafn/python/datafn/__init__.py": '"""import flowfn is not code here."""\n# import flowfn\nimport datafn.client\nfrom . import flowfn\nimport pinnedfn\n', "datafn/python/datafn/flow.py": "import os\nimport flowfn\nfrom flowfn.core import run\n", "datafn/python/datafn/broken.py": "def broken(:\n", }, }); const result = run(root); assert.equal(result.status, 1); assert.match(result.stderr, /datafn\/python\/datafn\/flow\.py:2: \[fn-dependency\] imports Python module "flowfn": "flowfn" is neither a public Python project nor allowed/); assert.match(result.stderr, /datafn\/python\/datafn\/flow\.py:3: \[fn-dependency\] imports Python module "flowfn\.core"/); assert.match(result.stderr, /datafn\/python\/datafn\/broken\.py:1: \[fn-dependency\] cannot be parsed/); assert.deepEqual((await findings(root)).sort(), [ `datafn/python/datafn/broken.py:1 ${RULES.fnDependency}`, `datafn/python/datafn/flow.py:2 ${RULES.fnDependency}`, `datafn/python/datafn/flow.py:3 ${RULES.fnDependency}`, ]); }); test("every import form is read", () => { const source = [ '/// ', 'import type { A } from "@a-fn/x";', 'export * from "bfn";', 'const c = await import("cfn/sub");', 'const d = require("@dfn/y");', 'import e = require("efn");', 'import "./local";', 'import "node:fs";', 'type G = import("gfn").G;', 'const h = require.resolve("hfn/package.json");', 'export { i } from "ifn";', ].join("\n"); assert.deepEqual( specifiers("x.ts", source).sort(), ["1 ffn", "2 @a-fn/x", "3 bfn", "4 cfn/sub", "5 @dfn/y", "6 efn", "7 ./local", "8 node:fs", "9 gfn", "10 hfn/package.json", "11 ifn"].sort(), ); }); test("*fn package names and specifiers", () => { assert.equal(packageNameOf("@flowfn/core/runtime"), "@flowfn/core"); assert.equal(packageNameOf("flowfn/bin"), "flowfn"); assert.equal(packageNameOf("npm:@flowfn/core@^1.2/runtime"), "@flowfn/core"); assert.equal(packageNameOf("npm:flowfn@1"), "flowfn"); assert.equal(packageNameOf("jsr:@flowfn/core"), "@flowfn/core"); assert.equal(packageNameOf("@flowfn/core/sub?inline"), "@flowfn/core"); assert.equal(packageNameOf("flowfn#hash"), "flowfn"); assert.equal(packageNameOf("raw-loader!@flowfn/x?raw"), "@flowfn/x"); assert.equal(packageNameOf("!!style-loader!./x.css"), null); assert.deepEqual(packageNamesOf("-!@flowfn/loader?x=1!css-loader!@flowfn/x"), ["@flowfn/loader", "css-loader", "@flowfn/x"]); assert.deepEqual(packageNamesOf("./x?raw"), []); for (const specifier of ["./x", "../x", "/abs", "#internal", "node:fs", "https://x/flowfn", "npm:", "npm:./x", "@flowfn"]) { assert.equal(packageNameOf(specifier), null, specifier); } for (const name of ["@flowfn/core", "flowfn", "@a.fn/x", "FlowFn"]) assert.equal(isFnPackage(name), true, name); for (const name of ["@superfunctions/core", "fn", "@fn/x", "fnord", "@flowfn", "zod"]) assert.equal(isFnPackage(name), false, name); }); test("npm aliases count by both their alias and their target", () => { assert.deepEqual( dependencyNames({ dependencies: { local: "npm:@flowfn/core@^1" }, bundleDependencies: ["flowfn"] }).map(({ name }) => name), ["local", "@flowfn/core", "flowfn"], ); }); test("npm aliases in overrides, including nested ones, count as dependencies on their target", () => { assert.deepEqual( dependencyNames({ overrides: { nanoid: "npm:@flowfn/core@1", zod: "3.0.0", react: { ".": "npm:flowfn@2", scheduler: "npm:@flowfn/scheduler" } }, }).map(({ name, field }) => `${field} ${name}`), ["overrides.nanoid (npm alias) @flowfn/core", "overrides.react.. (npm alias) flowfn", "overrides.react.scheduler (npm alias) @flowfn/scheduler"], ); }); test("a malformed allow file or workspace pattern fails closed", () => { const bad = [ [], { version: 2, packages: {} }, { version: 1, packages: {}, extra: true }, { version: 1, packages: { zod: { reason: "not an fn package" } } }, { version: 1, packages: { flowfn: {} } }, { version: 1, packages: { flowfn: { reason: " " } } }, { version: 1, packages: { flowfn: { reason: "x", note: "y" } } }, { version: 1, packages: { flowfn: { reason: "x", paths: [] } } }, { version: 1, packages: { flowfn: { reason: "x", paths: ["../outside"] } } }, { version: 1, packages: { flowfn: { reason: "x", paths: ["datafn/"] } } }, ]; for (const data of bad) assert.throws(() => parseAllowFile(data), BoundaryError, JSON.stringify(data)); for (const pattern of ["datafn/**", "!datafn/x", "datafn/{a,b}", "datafn/@(core|client)", "datafn/+(a)", "datafn/(a)", "./datafn", "/datafn", "datafn/", "datafn/../x"]) { assert.throws(() => workspacePatterns({ workspaces: [pattern] }), BoundaryError, pattern); } assert.deepEqual(workspacePatterns({ workspaces: { packages: [".github/actions/*", "datafn/*"] } }), [".github/actions/*", "datafn/*"]); }); test("a missing allow file fails with an error", (t) => { const result = run(fixture(t, { files: { [ALLOW_FILE]: null } })); assert.equal(result.status, 1); assert.match(result.stderr, /scripts\/public-boundary\.allow\.json not found/); });