@prestack/thread 0.1.20 → 0.1.22

package/dist/operations/generators/permits.ts

@@ -1,224 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
-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 { PUBLIC_ROLE as PUBLIC } from '../../core/actor.ts'
-import { ROOT, descend } from '../../core/descend.ts'
-import { forbids, runChecker, type Finding } from '../../core/finding.ts'
-import type { Condition, Operand } from '../../core/condition.ts'
-import { findTree, inTree } from '../../core/tree.ts'
-
-import { PERMITS_AT, grantedTwice, opensToEverybody, unanswerable, type Grant } from '../access.ts'
-import { operations as woven, runtime, types } from './seed.ts'
-
-function stop(why: string): never {
-  stderr.write(`permits: ${why}\n`)
-  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<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`)
-  let held: Record<string, unknown>
-  try {
-    held = valuesIn(readFileSync(at)) as Record<string, unknown>
-  } catch (thrown) {
-    stop(
-      `${at} could not be read: ${thrown instanceof Error ? thrown.message : String(thrown)}. A tree whose access ` +
-        'cannot be read reports exactly like a tree that granted nothing, and a gate written from that would refuse ' +
-        'every caller rather than say so',
-    )
-  }
-  const list = held[name]
-  if (!Array.isArray(list)) stop(`${at} exports no \`${name}\` list, so nothing there states ${what}`)
-  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[]>()
-
-function reads(one: Operand, grant: Grant): string {
-  if ('value' in one) return said(one.value)
-  if ('now' in one) return 'Date.now()'
-  if ('ago' in one) {
-    const size = Number(one.ago.slice(0, -1))
-    const unit = one.ago.slice(-1)
-    const seconds = size * (unit === 's' ? 1 : unit === 'm' ? 60 : unit === 'h' ? 3_600 : 86_400)
-    return `(Date.now() - ${String(seconds * 1000)})`
-  }
-  if ('actor' in one) return `actor.${one.actor}`
-  if ('field' in one) {
-    if (grant.on === undefined) {
-      stop(
-        `\`${grant.id}\` reads the field "${one.field}" and names no entity in \`on\`, so there is nothing saying what ` +
-          'the row in front of the gate is. Name the entity the resource is, or state the rule without reading a field',
-      )
-    }
-    if (one.field.includes('.')) {
-      stop(
-        `\`${grant.id}\` reads "${one.field}", which reaches through a link. The gate is handed one row and has ` +
-          'nothing to follow a link with — name a value of "' +
-          grant.on +
-          '" itself, or state the rule as an invariant where the rows are',
-      )
-    }
-    used.add(READS)
-    return `at(resource, ${said(one.field)})`
-  }
-  stop(`\`${grant.id}\` states an operand this gate cannot read`)
-}
-
-function predicate(condition: Condition, grant: Grant): string {
-  if ('all' in condition) {
-    return condition.all.length === 0 ? 'true' : `(${condition.all.map((one) => predicate(one, grant)).join(' && ')})`
-  }
-  if ('any' in condition) {
-    return condition.any.length === 0 ? 'false' : `(${condition.any.map((one) => predicate(one, grant)).join(' || ')})`
-  }
-  if ('not' in condition) return `(!${predicate(condition.not, grant)})`
-  used.add(COMPARES)
-  return `held(${said(condition.op)}, ${reads(condition.is, grant)}, ${reads(condition.than, grant)})`
-}
-
-function wears(grant: Grant): readonly string[] {
-  const held: string[] = []
-  const roles = grant.to?.roles
-  if (roles !== undefined && !roles.includes(PUBLIC)) held.push(`some(actor.roles, ${said(roles)})`)
-  if (grant.to?.entitlements !== undefined) held.push(`some(actor.entitlements, ${said(grant.to.entitlements)})`)
-  if (held.length > 0) used.add(WEARS)
-  return held
-}
-
-const READS = ['const at = (row: Row | null, name: string): unknown => (row === null ? undefined : row[name])']
-
-const WEARS = [
-  'const some = (worn: readonly string[], named: readonly string[]): boolean => named.some((one) => worn.includes(one))',
-]
-
-const COMPARES = [
-  'const held = (op: string, left: unknown, right: unknown): boolean => {',
-  '  if (op === \'in\') return Array.isArray(right) && right.includes(left)',
-  '  if (op === \'has\') return Array.isArray(left) && left.includes(right)',
-  '  if (op === \'eq\') return left === right',
-  '  if (op === \'neq\') return left !== right',
-  '  if (typeof left !== typeof right) return false',
-  '  if (typeof left !== \'number\' && typeof left !== \'string\') return false',
-  '  const other = right as number | string',
-  '  if (op === \'lt\') return left < other',
-  '  if (op === \'lte\') return left <= other',
-  '  if (op === \'gt\') return left > other',
-  '  return left >= other',
-  '}',
-]
-
-function permitting(): string {
-  const arms = grants.flatMap((one) => {
-    const parts = [...wears(one), ...(one.when === undefined ? [] : [predicate(one.when, one)])]
-    return [
-      `  if (${said(one.may)}.includes(action)) {`,
-      `    if (${parts.length === 0 ? 'true' : parts.join(' && ')}) return { allow: true, because: ${said(one.describes)} }`,
-      `    denied.push(${said(one.describes)})`,
-      '  }',
-    ]
-  })
-
-  const body =
-    grants.length === 0
-      ? [
-          '  return {',
-          '    allow: false,',
-          "    because: 'this app declares no grants, so nothing permits any operation. Declare one with `thread grant`',",
-          '  }',
-        ]
-      : [
-          '  const denied: string[] = []',
-          ...arms,
-          '  return { allow: false, because: denied[0] ?? `nothing granted permits ${action}` }',
-        ]
-
-  return [
-    `import type { Actor } from '${runtime(PERMITS_AT, '../../core/actor.ts')}'`,
-    "import type { Row } from '" + runtime(PERMITS_AT, '../../integrations/target.ts') + "'",
-    '',
-    ...[READS, WEARS, COMPARES].filter((one) => used.has(one)).flatMap((one) => [...one, '']),
-
-    'export function permits(actor: Actor, action: string, resource: Row | null): { allow: boolean; because?: string } {',
-    ...(grants.length === 0 ? ['  void actor', '  void resource'] : []),
-    ...body,
-    '}',
-    '',
-  ].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: 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',
-)

package/dist/operations/generators/seed.ts

@@ -1,359 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
-import { dirname, relative, resolve } from 'node:path'
-import { argv, stdout } from 'node:process'
-import { fileURLToPath } from 'node:url'
-
-import ts from 'typescript'
-
-import { ROOT, descend, under, type Pass, type Row } from '../../core/descend.ts'
-import { runChecker, type Finding } from '../../core/finding.ts'
-import { BESIDE, exit, invoked } from '../../core/invoked.ts'
-import { PREFIXES } from '../../core/thread.ts'
-
-const COMPILES = 'thread compile'
-
-const OPERATIONS_ID = 'operations'
-
-const NODES_ID = 'nodes'
-
-const NAMED = /\btype:\s*'((?:[^'\\]|\\.)*)'/
-
-import { quoted } from '../../core/rows.ts'
-
-export { quoted }
-
-const slash = (one: string): string => one.split('\\').join('/')
-
-export const beside = (from: string, to: string): string => {
-  const said = slash(relative(dirname(from), to))
-  return said.startsWith('.') ? said : `./${said}`
-}
-
-export const runtime = (at: string, file: string): string =>
-  beside(resolve(ROOT, at), fileURLToPath(new URL(BESIDE(file.replace(/\.ts$/, '')), import.meta.url)))
-
-const FRESH: Readonly<Record<string, (throws: string) => string>> = {
-  nd_read: (throws) => `async () => {\n  ${throws}\n}`,
-  nd_action: (throws) => `async () => {\n  ${throws}\n}`,
-  nd_stop: (throws) => `async () => {\n  ${throws}\n}`,
-  nd_each: (throws) => `() => [], async () => {\n  ${throws}\n}`,
-  nd_repeat: (throws) => `1, async (pass, carried) => {\n  ${throws}\n}`,
-  nd_parallel: (throws) => `[\n  async () => {\n    ${throws}\n  },\n]`,
-  nd_branch: (throws) => `async () => 'one', {\n  one: async () => {\n    ${throws}\n  },\n}`,
-}
-
-const SHIPPED = new Set(Object.keys(FRESH))
-
-const isType = (pass: Pass, id: string): boolean => under(pass, id, NODES_ID)
-
-const isOurs = (pass: Pass, id: string): boolean => under(pass, id, OPERATIONS_ID)
-
-const isOperation = (pass: Pass, id: string): boolean =>
-  Object.values(PREFIXES).some((one) => id.startsWith(one)) && isOurs(pass, id)
-
-export function types(pass: Pass): ReadonlySet<string> {
-  const found = new Set<string>(SHIPPED)
-  const named = new Set<string>()
-  for (const threadings of pass.threaded.values()) {
-    for (const one of threadings) if (one.row.id !== undefined) named.add(one.row.id)
-  }
-
-  for (const one of pass.coined.keys()) {
-    if (one !== NODES_ID && !named.has(one) && under(pass, one, NODES_ID)) found.add(one)
-  }
-  return found
-}
-
-export function builtFrom(row: Row, known: ReadonlySet<string>): string | undefined {
-  const found = (row.requires ?? []).filter((one) => known.has(one))
-  return found.length === 1 ? found[0] : undefined
-}
-
-interface Woven {
-  readonly nodes: readonly Row[]
-  readonly takes: readonly Row[]
-  readonly body?: string
-
-  readonly requires: readonly string[]
-  readonly stray: readonly string[]
-
-  readonly timeout?: number
-}
-
-const reaches = (pass: Pass, one: string): boolean => pass.stated.has(one) && !under(pass, one, NODES_ID)
-
-const waiting = (held: ts.Expression | undefined): number | undefined =>
-  held !== undefined && ts.isNumericLiteral(held) ? Number(held.text.replace(/_/g, '')) : undefined
-
-export function operations(pass: Pass, known: ReadonlySet<string>): ReadonlyMap<string, Woven> {
-  const found = new Map<string, Woven & { nodes: Row[]; takes: Row[]; body?: string; wants: ReadonlySet<string> }>()
-  const held = (id: string): { nodes: Row[]; takes: Row[]; body?: string; wants: ReadonlySet<string> } => {
-    const one = found.get(id)
-    if (one !== undefined) return one
-    const stated = pass.stated.get(id)
-    const asked = stated?.requires ?? []
-    const made = {
-      nodes: [] as Row[],
-      takes: [] as Row[],
-      body: undefined as string | undefined,
-      wants: new Set(stated?.takes ?? []),
-      requires: asked.filter((one) => reaches(pass, one)),
-      stray: asked.filter((one) => !reaches(pass, one)),
-      timeout: waiting(stated?.fields.get('timeout')),
-    }
-    found.set(id, made)
-    return made
-  }
-
-  for (const [at, threadings] of pass.threaded) {
-    for (const one of threadings) {
-      if (!isOperation(pass, one.by)) continue
-
-      if (one.list === 'derives' && one.row.by === COMPILES) held(one.by).body = at
-      else if (one.list === 'seeds') {
-        const mine = held(one.by)
-        if (mine.wants.has(one.row.id ?? '')) mine.takes.push(one.row)
-        else mine.nodes.push(one.row)
-      }
-    }
-  }
-  return found
-}
-
-export const problem = (id: string, one: Woven): string | undefined => {
-  if (one.nodes.length === 0) return `\`${id}\` is an operation that seeds no nodes, and an operation is its nodes`
-  if (one.takes.length === 0) {
-    return (
-      `\`${id}\` names nothing it takes, and an operation takes one thing — its input and the row it touches. ` +
-      `Write \`takes: ['${id}_takes']\` on its row beside the file that row seeds`
-    )
-  }
-  if (one.takes.length > 1) return `\`${id}\` takes ${String(one.takes.length)} things, and it takes one`
-  if (one.stray.length > 0) {
-    return (
-      `\`${id}\` requires ${one.stray.join(', ')}, and dispatch can supply neither a capability nor a target by that ` +
-      `name. What an operation may require is a target this app declares — ` +
-      'declare one with `thread create target`'
-    )
-  }
-  return undefined
-}
-
-const takesFile = (at: string): string =>
-  [
-    "import { z } from 'zod'",
-    '',
-    'import type { Row } from ' + quoted(runtime(at, '../../integrations/target.ts')),
-    '',
-    'export const input = z.unknown()',
-    '',
-    'export const resource = (): Row | null => null',
-    '',
-    'export type In = z.infer<typeof input>',
-    '',
-  ].join('\n')
-
-const OPENS = 'export const node = '
-
-export function blockIn(text: string): string | undefined {
-  const at = text.indexOf(OPENS)
-  if (at === -1) return undefined
-  const open = text.indexOf('(', at)
-  const shut = text.lastIndexOf(')')
-  if (open === -1 || shut <= open) return undefined
-  return text.slice(open + 1, shut)
-}
-
-export function scaffold(from: string, name: string): string {
-  const throws = `throw new Error(${quoted(`the node ${name} was scaffolded and never written`)})`
-  return (FRESH[from] ?? ((one: string) => `async () => {\n  ${one}\n}`))(throws)
-}
-
-export function nodeText(
-  at: string,
-  name: string,
-  takes: string,
-  from: string,
-  requires: readonly string[],
-  body?: string,
-): string {
-  const held = SHIPPED.has(from)
-    ? `import { ${from} } from ${quoted(runtime(at, '../nodes.ts'))}`
-    : `import { node as ${from} } from ${quoted(beside(at, `nodes/${from}.ts`))}`
-
-  const only = requires.length === 0 ? 'never' : requires.map((one) => quoted(one)).join(' | ')
-
-  return [
-    held,
-    '',
-    `import type { In } from ${quoted(beside(at, takes))}`,
-    '',
-    `${OPENS}${from}<In, ${only}>(${body ?? scaffold(from, name)})`,
-    '',
-  ].join('\n')
-}
-
-const nodeFile = (at: string, row: Row, takes: string, from: string, requires: readonly string[], body?: string): string =>
-  nodeText(at, row.id ?? '', takes, from, requires, body)
-
-const ownType = (at: string, id: string): string =>
-  [
-    `import type { Held } from ${quoted(runtime(at, '../nodes.ts'))}`,
-    'import type { Opened } from ' + quoted(runtime(at, '../operations.ts')),
-    '',
-    'export const node = <I, R extends string = never>(block: (opened: Opened<R>, held: Held<I>) => Promise<unknown>) => ({',
-    `  type: ${quoted(id)} as const,`,
-    '})',
-    '',
-  ].join('\n')
-
-interface Wanted {
-  readonly at: string
-  readonly derived: boolean
-  readonly wraps?: string
-  readonly text?: string
-  readonly because?: string
-  readonly type?: string
-}
-
-function planned(bodies: ReadonlyMap<string, string>): readonly Wanted[] {
-  const pass = descend()
-  const known = types(pass)
-  const mine = operations(pass, known)
-  const found: Wanted[] = []
-
-  for (const [id, one] of mine) {
-    void id
-    for (const row of one.takes) if (row.at !== undefined) found.push({ at: row.at, derived: false, text: takesFile(row.at) })
-    for (const row of one.nodes) {
-      const from = builtFrom(row, known)
-      const takes = one.takes[0]?.at
-      if (row.at === undefined || from === undefined || takes === undefined) continue
-      const path = resolve(ROOT, row.at)
-      const held = existsSync(path) ? readFileSync(path, 'utf8') : undefined
-      const block = bodies.get(row.at) ?? (held === undefined ? undefined : blockIn(held))
-      if (held !== undefined && block === undefined) {
-        found.push({
-          at: row.at,
-          derived: true,
-          because:
-            `\`${String(row.id)}\` states no \`${OPENS}\` this can read, so the block it holds cannot be told from the ` +
-            'wrapper its rows own. Delete the file and run `thread seed` to scaffold it again, then write the block back into it',
-        })
-        continue
-      }
-      found.push({ at: row.at, derived: true, wraps: String(row.id), text: nodeFile(row.at, row, takes, from, one.requires, block) })
-    }
-  }
-
-  for (const [at, threadings] of pass.threaded) {
-    for (const one of threadings) {
-      if (one.list !== 'seeds' || !isType(pass, one.by) || SHIPPED.has(one.by)) continue
-      found.push({ at, derived: false, text: ownType(at, one.by), type: one.by })
-    }
-  }
-
-  return found
-}
-
-function checked(plan: readonly Wanted[]): void {
-  if (plan.length === 0) {
-    stdout.write('seed: this app declares no operation and no node type of its own, so there is no file to write or check.\n')
-    exit(0)
-  }
-
-  const findings: Finding[] = plan.flatMap((one): Finding[] => {
-    const path = resolve(ROOT, one.at)
-
-    if (one.because !== undefined) {
-      return [
-        {
-          file: one.at,
-          detail: one.because,
-          instead: 'declare it properly — this file is written from those rows and cannot be written without them',
-        },
-      ]
-    }
-
-    if (!existsSync(path)) {
-      return [
-        {
-          file: one.at,
-          detail: 'a row declares this file and nothing is there',
-          instead: 'run `thread seed` and write what it leaves — a row that seeded nothing is half a declaration',
-        },
-      ]
-    }
-
-    if (one.type !== undefined) {
-      const said = NAMED.exec(readFileSync(path, 'utf8'))?.[1]
-      if (said === one.type) return []
-      return [
-        {
-          file: one.at,
-          detail:
-            said === undefined
-              ? `\`${one.type}\` seeds this type and the file states no name of its own`
-              : `\`${one.type}\` seeds this type and the file calls itself \`${said}\``,
-          instead:
-            "state the row's own id as the type's name. A node declares which type it is built from, and the compiler holds the two together by that name",
-        },
-      ]
-    }
-
-    if (!one.derived) return []
-
-    if (readFileSync(path, 'utf8') === one.text) return []
-
-    if (one.wraps !== undefined) {
-      return [
-        {
-          file: one.at,
-          detail: `the line that opens \`${one.wraps}\` is written from its rows, and this is no longer the bytes they write`,
-          instead:
-            'run `thread seed`. Which type builds this node and what its operation lets it touch are the rows to say, not this line — the block inside the call is yours and is put back exactly as you left it',
-        },
-      ]
-    }
-
-    return [
-      {
-        file: one.at,
-        detail: 'this operation derives its body, and this is no longer the bytes that derive it',
-        instead:
-          'run `thread seed`, or put back what it writes. A derived body has no author: to change what an operation does, change the rows that declare its nodes, and to change what a node does, write it in the file that node seeds',
-      },
-    ]
-  })
-
-  runChecker('seed', findings, `${String(plan.length)} file(s) declared`)
-  exit(findings.length === 0 ? 0 : 1)
-}
-
-export function seed(bodies: ReadonlyMap<string, string> = new Map(), say: boolean = true): number {
-  const plan = planned(bodies)
-  let written = 0
-  for (const one of plan) {
-    const path = resolve(ROOT, one.at)
-    const held = existsSync(path) ? readFileSync(path, 'utf8') : undefined
-
-    if (held !== undefined && !one.derived && !bodies.has(one.at)) continue
-
-    if (one.text === undefined) {
-      if (say) stdout.write(`seed: ${one.at} was not written — ${one.because ?? 'the rows behind it are incomplete'}\n`)
-      continue
-    }
-    if (held === one.text) continue
-
-    writeFileSync(path, one.text, 'utf8')
-    written += 1
-    if (say) stdout.write(`seed: wrote ${one.at}\n`)
-  }
-  if (say) stdout.write(`seed: ${String(written)} of ${String(plan.length)} file(s) written, ${String(plan.length - written)} already as declared.\n`)
-  return written
-}
-
-if (invoked(import.meta.url)) {
-  if (argv.includes('--check')) checked(planned(new Map()))
-  else seed()
-}