@prestack/thread 0.1.19 → 0.1.21

package/dist/operations/generators/permits.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk
 import { valuesIn } from '../../core/rows.js';
 import { resolve } from 'node:path';
 import { argv, stderr, stdout } from 'node:process';
-import { exit } from '../../core/invoked.js';
+import { exit, invoked } from '../../core/invoked.js';
 import { PUBLIC_ROLE as PUBLIC } from '../../core/actor.js';
 import { ROOT, descend } from '../../core/descend.js';
 import { forbids, runChecker } from '../../core/finding.js';
@@ -14,12 +14,6 @@ function stop(why) {
     exit(1);
 }
 const CHECKING = argv.includes('--check');
-const pass = await descend();
-const stopped = [...pass.broken, ...pass.findings].filter(forbids)[0];
-if (stopped !== undefined) {
-    stop('the descent is broken, so who may ask for what is only partly known, and a gate written from half of it ' +
-        `would permit callers nobody granted — ${stopped.detail} (${stopped.file ?? ''})`);
-}
 async function taken(file, name, what) {
     const at = inTree(findTree(), file);
     if (!existsSync(at))
@@ -38,28 +32,6 @@ async function taken(file, name, what) {
         stop(`${at} exports no \`${name}\` list, so nothing there states ${what}`);
     return list;
 }
-const grants = await taken('access.ts', 'GRANTS', 'who may ask for what');
-const operations = [...woven(pass, types(pass))].map(([id]) => ({
-    id,
-    describes: pass.stated.get(id)?.describes ?? '',
-}));
-for (const found of [unanswerable(grants)]) {
-    if (found.length > 0)
-        stop(found.join('; '));
-}
-const twice = grantedTwice(grants);
-if (twice.length > 0) {
-    stop(`${twice.map((one) => `\`${one}\``).join(', ')} ${twice.length === 1 ? 'is granted' : 'are granted'} more than once, ` +
-        'so two arms answer to one id and either may permit. One id, one policy — rename one of them, or delete the ' +
-        'arm that is not meant to stand');
-}
-const open = opensToEverybody(grants);
-if (open.length > 0) {
-    stop(`${open.map((one) => `\`${one.id}\``).join(', ')} names no roles or entitlements and states no condition that ` +
-        'reads the caller, so who may run this is left unsaid rather than decided. If it is meant to be open, say so: ' +
-        `\`to: { roles: ['${PUBLIC}'] }\` is the role an unauthenticated caller already wears, and naming it puts ` +
-        'that decision in the sheet. Otherwise name the roles that may, or state a `when` saying whose row it is');
-}
 const said = (held) => JSON.stringify(held);
 const used = new Set();
 function reads(one, grant) {
@@ -133,7 +105,8 @@ const COMPARES = [
     '  return left >= other',
     '}',
 ];
-function permitting() {
+export function permitting(grants) {
+    used.clear();
     const arms = grants.flatMap((one) => {
         const parts = [...wears(one), ...(one.when === undefined ? [] : [predicate(one.when, one)])];
         return [
@@ -168,22 +141,54 @@ function permitting() {
     ].join('\n');
 }
 const RUNS = 'thread permits';
-const permitted = resolve(ROOT, PERMITS_AT);
-const content = permitting();
-const count = `${String(grants.length)} grant(s) over ${String(operations.length)} operation(s)`;
-if (CHECKING) {
-    const findings = [];
-    const current = existsSync(permitted) ? readFileSync(permitted, 'utf8') : '';
-    if (current !== content) {
-        findings.push({
-            file: PERMITS_AT,
-            detail: 'is not what this app grants',
-            instead: `run \`${RUNS}\` and commit what it writes. Never edit this file — a branch here exists because a grant was declared, and an edit widens or narrows access nobody agreed to`,
-        });
+async function run() {
+    const pass = await descend();
+    const stopped = [...pass.broken, ...pass.findings].filter(forbids)[0];
+    if (stopped !== undefined) {
+        stop('the descent is broken, so who may ask for what is only partly known, and a gate written from half of it ' +
+            `would permit callers nobody granted — ${stopped.detail} (${stopped.file ?? ''})`);
+    }
+    const grants = await taken('access.ts', 'GRANTS', 'who may ask for what');
+    const operations = [...woven(pass, types(pass))].map(([id]) => ({
+        id,
+        describes: pass.stated.get(id)?.describes ?? '',
+    }));
+    for (const found of [unanswerable(grants)]) {
+        if (found.length > 0)
+            stop(found.join('; '));
+    }
+    const twice = grantedTwice(grants);
+    if (twice.length > 0) {
+        stop(`${twice.map((one) => `\`${one}\``).join(', ')} ${twice.length === 1 ? 'is granted' : 'are granted'} more than once, ` +
+            'so two arms answer to one id and either may permit. One id, one policy — rename one of them, or delete the ' +
+            'arm that is not meant to stand');
+    }
+    const open = opensToEverybody(grants);
+    if (open.length > 0) {
+        stop(`${open.map((one) => `\`${one.id}\``).join(', ')} names no roles or entitlements and states no condition that ` +
+            'reads the caller, so who may run this is left unsaid rather than decided. If it is meant to be open, say so: ' +
+            `\`to: { roles: ['${PUBLIC}'] }\` is the role an unauthenticated caller already wears, and naming it puts ` +
+            'that decision in the sheet. Otherwise name the roles that may, or state a `when` saying whose row it is');
+    }
+    const permitted = resolve(ROOT, PERMITS_AT);
+    const content = permitting(grants);
+    const count = `${String(grants.length)} grant(s) over ${String(operations.length)} operation(s)`;
+    if (CHECKING) {
+        const findings = [];
+        const current = existsSync(permitted) ? readFileSync(permitted, 'utf8') : '';
+        if (current !== content) {
+            findings.push({
+                file: PERMITS_AT,
+                detail: 'is not what this app grants',
+                instead: `run \`${RUNS}\` and commit what it writes. Never edit this file — a branch here exists because a grant was declared, and an edit widens or narrows access nobody agreed to`,
+            });
+        }
+        runChecker('permits', findings, count);
+        exit(findings.length === 0 ? 0 : 1);
     }
-    runChecker('permits', findings, count);
-    exit(findings.length === 0 ? 0 : 1);
+    writeFileSync(permitted, content);
+    stdout.write(`permits: wrote ${PERMITS_AT} — ${count}. Dispatch imports this check itself, so every operation passes it; ` +
+        '`thread grant` adds a grant, and a refusal no grant can say is an invariant on the entity, or a rule from `thread create rule`.\n');
 }
-writeFileSync(permitted, content);
-stdout.write(`permits: wrote ${PERMITS_AT} — ${count}. Dispatch imports this check itself, so every operation passes it; ` +
-    '`thread grant` adds a grant, and a refusal no grant can say is an invariant on the entity, or a rule from `thread create rule`.\n');
+if (invoked(import.meta.url))
+    await run();

package/dist/operations/generators/permits.ts

@@ -3,7 +3,7 @@ import { valuesIn } from '../../core/rows.ts'
 import { resolve } from 'node:path'
 import { argv, stderr, stdout } from 'node:process'
 
-import { exit } from '../../core/invoked.ts'
+import { exit, invoked } from '../../core/invoked.ts'
 import { PUBLIC_ROLE as PUBLIC } from '../../core/actor.ts'
 import { ROOT, descend } from '../../core/descend.ts'
 import { forbids, runChecker, type Finding } from '../../core/finding.ts'
@@ -20,16 +20,6 @@ function stop(why: string): never {
 
 const CHECKING = argv.includes('--check')
 
-const pass = await descend()
-
-const stopped = [...pass.broken, ...pass.findings].filter(forbids)[0]
-if (stopped !== undefined) {
-  stop(
-    'the descent is broken, so who may ask for what is only partly known, and a gate written from half of it ' +
-      `would permit callers nobody granted — ${stopped.detail} (${stopped.file ?? ''})`,
-  )
-}
-
 async function taken<T>(file: string, name: string, what: string): Promise<readonly T[]> {
   const at = inTree(findTree(), file)
   if (!existsSync(at)) stop(`${at} is where this app states ${what}, and it is not there`)
@@ -48,36 +38,6 @@ async function taken<T>(file: string, name: string, what: string): Promise<reado
   return list as readonly T[]
 }
 
-const grants = await taken<Grant>('access.ts', 'GRANTS', 'who may ask for what')
-
-const operations = [...woven(pass, types(pass))].map(([id]) => ({
-  id,
-  describes: pass.stated.get(id)?.describes ?? '',
-}))
-
-for (const found of [unanswerable(grants)]) {
-  if (found.length > 0) stop(found.join('; '))
-}
-
-const twice = grantedTwice(grants)
-if (twice.length > 0) {
-  stop(
-    `${twice.map((one) => `\`${one}\``).join(', ')} ${twice.length === 1 ? 'is granted' : 'are granted'} more than once, ` +
-      'so two arms answer to one id and either may permit. One id, one policy — rename one of them, or delete the ' +
-      'arm that is not meant to stand',
-  )
-}
-
-const open = opensToEverybody(grants)
-if (open.length > 0) {
-  stop(
-    `${open.map((one) => `\`${one.id}\``).join(', ')} names no roles or entitlements and states no condition that ` +
-      'reads the caller, so who may run this is left unsaid rather than decided. If it is meant to be open, say so: ' +
-      `\`to: { roles: ['${PUBLIC}'] }\` is the role an unauthenticated caller already wears, and naming it puts ` +
-      'that decision in the sheet. Otherwise name the roles that may, or state a `when` saying whose row it is',
-  )
-}
-
 const said = (held: unknown): string => JSON.stringify(held)
 
 const used = new Set<readonly string[]>()
@@ -156,7 +116,8 @@ const COMPARES = [
   '}',
 ]
 
-function permitting(): string {
+export function permitting(grants: readonly Grant[]): string {
+  used.clear()
   const arms = grants.flatMap((one) => {
     const parts = [...wears(one), ...(one.when === undefined ? [] : [predicate(one.when, one)])]
     return [
@@ -197,28 +158,72 @@ function permitting(): string {
 
 const RUNS = 'thread permits'
 
-const permitted = resolve(ROOT, PERMITS_AT)
+async function run(): Promise<void> {
+  const pass = await descend()
+
+  const stopped = [...pass.broken, ...pass.findings].filter(forbids)[0]
+  if (stopped !== undefined) {
+    stop(
+      'the descent is broken, so who may ask for what is only partly known, and a gate written from half of it ' +
+        `would permit callers nobody granted — ${stopped.detail} (${stopped.file ?? ''})`,
+    )
+  }
+
+  const grants = await taken<Grant>('access.ts', 'GRANTS', 'who may ask for what')
 
-const content = permitting()
+  const operations = [...woven(pass, types(pass))].map(([id]) => ({
+    id,
+    describes: pass.stated.get(id)?.describes ?? '',
+  }))
 
-const count = `${String(grants.length)} grant(s) over ${String(operations.length)} operation(s)`
+  for (const found of [unanswerable(grants)]) {
+    if (found.length > 0) stop(found.join('; '))
+  }
 
-if (CHECKING) {
-  const findings: Finding[] = []
-  const current = existsSync(permitted) ? readFileSync(permitted, 'utf8') : ''
-  if (current !== content) {
-    findings.push({
-      file: PERMITS_AT,
-      detail: 'is not what this app grants',
-      instead: `run \`${RUNS}\` and commit what it writes. Never edit this file — a branch here exists because a grant was declared, and an edit widens or narrows access nobody agreed to`,
-    })
+  const twice = grantedTwice(grants)
+  if (twice.length > 0) {
+    stop(
+      `${twice.map((one) => `\`${one}\``).join(', ')} ${twice.length === 1 ? 'is granted' : 'are granted'} more than once, ` +
+        'so two arms answer to one id and either may permit. One id, one policy — rename one of them, or delete the ' +
+        'arm that is not meant to stand',
+    )
+  }
+
+  const open = opensToEverybody(grants)
+  if (open.length > 0) {
+    stop(
+      `${open.map((one) => `\`${one.id}\``).join(', ')} names no roles or entitlements and states no condition that ` +
+        'reads the caller, so who may run this is left unsaid rather than decided. If it is meant to be open, say so: ' +
+        `\`to: { roles: ['${PUBLIC}'] }\` is the role an unauthenticated caller already wears, and naming it puts ` +
+        'that decision in the sheet. Otherwise name the roles that may, or state a `when` saying whose row it is',
+    )
   }
-  runChecker('permits', findings, count)
-  exit(findings.length === 0 ? 0 : 1)
+
+  const permitted = resolve(ROOT, PERMITS_AT)
+
+  const content = permitting(grants)
+
+  const count = `${String(grants.length)} grant(s) over ${String(operations.length)} operation(s)`
+
+  if (CHECKING) {
+    const findings: Finding[] = []
+    const current = existsSync(permitted) ? readFileSync(permitted, 'utf8') : ''
+    if (current !== content) {
+      findings.push({
+        file: PERMITS_AT,
+        detail: 'is not what this app grants',
+        instead: `run \`${RUNS}\` and commit what it writes. Never edit this file — a branch here exists because a grant was declared, and an edit widens or narrows access nobody agreed to`,
+      })
+    }
+    runChecker('permits', findings, count)
+    exit(findings.length === 0 ? 0 : 1)
+  }
+
+  writeFileSync(permitted, content)
+  stdout.write(
+    `permits: wrote ${PERMITS_AT} — ${count}. Dispatch imports this check itself, so every operation passes it; ` +
+      '`thread grant` adds a grant, and a refusal no grant can say is an invariant on the entity, or a rule from `thread create rule`.\n',
+  )
 }
 
-writeFileSync(permitted, content)
-stdout.write(
-  `permits: wrote ${PERMITS_AT} — ${count}. Dispatch imports this check itself, so every operation passes it; ` +
-    '`thread grant` adds a grant, and a refusal no grant can say is an invariant on the entity, or a rule from `thread create rule`.\n',
-)
+if (invoked(import.meta.url)) await run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prestack/thread",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "type": "module",
   "files": [
     "dist",