@prestack/thread 0.1.20 → 0.1.22

package/dist/operations/dispatch.ts

@@ -1,294 +0,0 @@
-import { ANONYMOUS, ENVIRONMENT } from '../core/actor.ts'
-import { HOLDS, type Holds, type Reach } from '../integrations/target.ts'
-import { PERMITS_AT } from './access.ts'
-import { DbConflict } from '../core/errors/catalogue.ts'
-import { beside, quoted, runtime } from './generators/seed.ts'
-import type { ResultCode } from './result.ts'
-
-const reaching = (holds: (one: Holds) => boolean): readonly Reach[] =>
-  (Object.keys(HOLDS) as Reach[]).filter((one) => holds(HOLDS[one]))
-
-const KEEPS = reaching((one) => one.takes === 'entities')
-
-const ANSWERS = reaching((one) => one.takes === null)
-
-const RUNS = reaching((one) => one.takes === 'calls' && one.addressed === 'nothing')
-
-const asked = (reaches: readonly Reach[]): string => reaches.map((one) => "reach === '" + one + "'").join(' || ')
-
-export const DISPATCH_AT = 'operations/_dispatch.ts'
-
-const REFUSAL: Readonly<Record<ResultCode, string>> = {
-  denied: 'not allowed',
-  invalid: 'invalid input',
-  rate_limited: 'rate limited',
-  feature_denied: 'not in plan',
-  quota_exceeded: 'quota exceeded',
-  error: 'failed',
-}
-
-const printed = (value: unknown): string => JSON.stringify(value, null, 2)
-
-export const dispatched = (
-  reached: Readonly<
-    Record<
-      string,
-      {
-        readonly reach: string
-        readonly address?: string
-        readonly headers: Readonly<Record<string, string>>
-          readonly sends: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]
-          readonly signs: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]
-        readonly calls: Readonly<Record<string, { readonly method: string | null; readonly path: string }>>
-      }
-    >
-  >,
-): string => [
-  "import { createHmac } from 'node:crypto'",
-  '',
-  `import type { Actor } from ${quoted(runtime(DISPATCH_AT, '../../core/actor.ts'))}`,
-  `import type { Allowance, Counting, Operation } from ${quoted(runtime(DISPATCH_AT, '../operations.ts'))}`,
-  `import type { FailureIdentity, Result, ResultCode } from ${quoted(runtime(DISPATCH_AT, '../result.ts'))}`,
-  'import type { Opened } from ' + quoted(runtime(DISPATCH_AT, '../operations.ts')),
-  'import type { Vault } from ' + quoted(runtime(DISPATCH_AT, '../../integrations/secret.ts')),
-  `import { permits } from ${quoted(beside(DISPATCH_AT, PERMITS_AT))}`,
-  '',
-  `const ANONYMOUS: Actor = ${printed(ANONYMOUS)}`,
-  '',
-  `const ENVIRONMENT: readonly string[] = ${printed(ENVIRONMENT.map(([fact]) => fact))}`,
-  '',
-  `const REFUSAL: Readonly<Record<ResultCode, string>> = ${printed(REFUSAL)}`,
-  '',
-  `const CONFLICT = ${printed({ code: DbConflict.def.code, class: DbConflict.def.class })} as FailureIdentity`,
-  '',
-  'type Reached = Readonly<Record<string, {',
-  '  readonly reach: string',
-  '  readonly address?: string',
-  '  readonly headers: Readonly<Record<string, string>>',
-  '  readonly sends: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]',
-  '  readonly signs: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]',
-  '  readonly calls: Readonly<Record<string, { readonly method: string | null; readonly path: string }>>',
-  '}>>',
-  '',
-  'type Reaches = Readonly<Record<string, unknown>>',
-  '',
-  `const REACHED: Reached = ${printed(reached)}`,
-  '',
-  "const STOPPED = Symbol.for('thread.operation.stopped')",
-  '',
-  'const ok = <O>(value: O): Result<O> => ({ ok: true, value })',
-  '',
-  'const fail = (code: ResultCode, error: string, because?: string, identity?: FailureIdentity): Result<never> => ({',
-  '  ok: false,',
-  '  code,',
-  '  error,',
-  '  because,',
-  '  ...(identity === undefined ? {} : { errorCode: identity.code, errorClass: identity.class }),',
-  '}) as Result<never>',
-  '',
-  'const allowance = async (',
-  '  id: string,',
-  '  actor: Actor,',
-  '  counting: Counting | undefined,',
-  '  held: Allowance | undefined,',
-  '  code: ResultCode,',
-  '): Promise<Result<never> | undefined> => {',
-  '  if (held === undefined) return undefined',
-  '  if (counting === undefined) {',
-  "    return fail('error', REFUSAL['error'], id + ' allows ' + String(held.runs) + ' run(s) per ' + held.per + ' and this dispatch was handed nothing to count with. An operation that states an allowance is handed a counter or it does not run')",
-  '  }',
-  "  const seen = await counting['seen'](id + '/' + String(actor.id ?? 'anonymous') + '/' + code, held.per)",
-  '  if (seen <= held.runs) return undefined',
-  "  return fail(code, REFUSAL[code], String(seen) + ' of ' + String(held.runs) + ' allowed per ' + held.per)",
-  '}',
-  '',
-  "const strings = (value: unknown): value is string[] => Array.isArray(value) && value.every((one) => typeof one === 'string')",
-  '',
-  'const person = (value: unknown): Actor | undefined => {',
-  "  if (typeof value !== 'object' || value === null) return undefined",
-  '  const one = value as Record<string, unknown>',
-  "  const id = one['id']",
-  "  if (!(id === null || typeof id === 'string')) return undefined",
-  "  const roles = one['roles']",
-  "  const entitlements = one['entitlements']",
-  '  if (!strings(roles) || !strings(entitlements)) return undefined',
-  '  const carried: Record<string, string> = {}',
-  '  for (const fact of ENVIRONMENT) {',
-  '    const held = one[fact]',
-  '    if (held === undefined) continue',
-  "    if (typeof held !== 'string') return undefined",
-  '    carried[fact] = held',
-  '  }',
-  '  return { ...carried, id, roles, entitlements }',
-  '}',
-  '',
-  'const named = (thrown: unknown, what: string): boolean => {',
-  "  if (typeof thrown !== 'object' || thrown === null) return false",
-  '  const one = thrown as { readonly name?: unknown; readonly constructor?: { readonly name?: unknown } }',
-  '  return one.name === what || one.constructor?.name === what',
-  '}',
-  '',
-  'const stopped = (thrown: unknown): { readonly value: unknown } | undefined => {',
-  "  if (typeof thrown !== 'object' || thrown === null) return undefined",
-  '  const one = thrown as Record<PropertyKey, unknown>',
-  "  return one[STOPPED] === true ? { value: one['value'] } : undefined",
-  '}',
-  '',
-  'const platform = (thrown: unknown): string | undefined => {',
-  "  if (typeof thrown !== 'object' || thrown === null) return undefined",
-  '  const said = (thrown as { readonly because?: unknown }).because',
-  "  return typeof said === 'string' ? said : undefined",
-  '}',
-  '',
-  'const filled = (path: string, fills: Readonly<Record<string, string | number>> | undefined): string => {',
-  '  let held = path',
-  '  for (const [name, value] of Object.entries(fills ?? {})) held = held.split(`{${name}}`).join(encodeURIComponent(String(value)))',
-  '  const left = /\\{([a-z][a-z0-9_]*)\\}/.exec(held)',
-  '  if (left !== null) throw new Error(`the path ${path} leaves ${left[0]} to be filled and nothing filled it`)',
-  '  return held',
-  '}',
-  '',
-  'const bound = (word: string, wired: Reached[string], opened: Reaches, opening: Vault | undefined, within: number): Record<string, unknown> | string => {',
-  '  const reached = opened[word]',
-  '  const { reach } = wired',
-  '  if (' + asked(ANSWERS) + ') {',
-  '    const held = reached',
-  '    if (held === undefined) {',
-  "      return word + ' is a disk this operation requires, and this dispatch was handed none under that name. The disk under this process is written in by thread capabilities; one at the other end of a connection is handed in by whoever opened it'",
-  '    }',
-  '    return held as unknown as Record<string, unknown>',
-  '  }',
-  '  if (' + asked(KEEPS) + ') {',
-  '    if (reached === undefined) {',
-  "      return word + ' keeps rows for this app, and this dispatch was handed no store. A store is written in by thread capabilities, out of the target that keeps the entity'",
-  '    }',
-  '    return reached as unknown as Record<string, unknown>',
-  '  }',
-  '',
-  '  const names = Object.keys(wired.calls)',
-  '  if (names.length === 0) {',
-  '    return `\\`${word}\\` is required and takes no call, so there is nothing to hand a node. Declare one with \\`thread create target call\\``',
-  '  }',
-  '  if (' + asked(RUNS) + ') {',
-  '    const held = reached',
-  '    if (held === undefined) {',
-  "      return word + ' is a program this operation requires, and this dispatch was handed none under that name. A program is written in by thread capabilities, out of the calls declared beside the target'",
-  '    }',
-  '    const out: Record<string, unknown> = {}',
-  '    for (const name of names) {',
-  '      const doing = (held as unknown as Record<string, unknown>)[name]',
-  "      if (typeof doing !== 'function') {",
-  "        return word + ' takes ' + name + ' and the program handed in under that name does not answer to it, so a node would be handed a word that does nothing'",
-  '      }',
-    '      out[name] = (args: readonly string[], shows?: boolean, sooner?: number, how?: unknown) => (doing as (a: readonly string[], s?: boolean, w?: number, h?: unknown) => unknown)(args, shows, sooner === undefined ? within : Math.min(sooner, within), how)',
-  '    }',
-  '    return out',
-  '  }',
-  '  if (reached === undefined) {',
-  "    return word + ' is reached over ' + wired.reach + ', and this dispatch was handed nothing to send an outward call through. thread capabilities writes that in; or take that word off the row that requires it'",
-  '  }',
-  '  const wanted = [...wired.sends.map((one) => one.secret), ...wired.signs.map((one) => one.secret)]',
-  '  if (wanted.length > 0 && opening === undefined) {',
-  "    return word + ' needs ' + wanted.join(', ') + ' and this dispatch was handed no vault to open them. A target is reached with what opens it or not at all'",
-  '  }',
-  '  const out: Record<string, unknown> = {}',
-  '  for (const name of names) {',
-  '    const call = wired.calls[name]',
-  '    if (call === undefined) continue',
-  '    out[name] = async (given?: { fills?: Readonly<Record<string, string | number>>; json?: unknown; body?: Uint8Array; contentType?: string; told?: (said: unknown) => void }) => {',
-  "      const values = wanted.length === 0 ? {} : await opening!['resolve'](wanted)",
-  '      const headers: Record<string, string> = {}',
-  '      for (const [name, value] of Object.entries(wired.headers)) headers[name] = value',
-  '      for (const one of wired.sends) headers[one.header] = `${one.prefix}${values[one.secret] ?? \'\'}`',
-  '      const body = given?.json === undefined ? given?.body : new TextEncoder().encode(JSON.stringify(given.json))',
-  '      for (const one of wired.signs) {',
-  "        const mac = createHmac('sha256', values[one.secret] ?? '').update(body ?? new Uint8Array()).digest('hex')",
-  '        headers[one.header] = one.prefix + mac',
-  '      }',
-  "      const send = reached as { call: (request: unknown, within?: number) => Promise<unknown> }",
-  "      return await send['call']({",
-  '        target: word,',
-  '        address: wired.address ?? \'\',',
-  "        method: call.method as 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',",
-  '        path: filled(call.path, given?.fills),',
-  '        headers,',
-  '        ...(body === undefined ? {} : { body, contentType: given?.contentType ?? \'application/json\' }),',
-    '        ...(given?.told === undefined ? {} : { told: given.told }),',
-  '      }, within)',
-  '    }',
-  '  }',
-  '  return out',
-  '}',
-  '',
-  'const given = (operation: Operation<unknown, string>, actor: Actor, opened: Reaches, opening: Vault | undefined, telling: (said: unknown) => void): Record<string, unknown> | string => {',
-  '  const held: Record<string, unknown> = { actor, tell: telling }',
-  '  for (const word of operation.requires) {',
-  '    const wired = REACHED[word]',
-  '    if (wired === undefined) {',
-  '      return `\\`${operation[\'id\']}\\` requires \\`${word}\\`, and this app declares no target by that name. An operation requires targets: declare one with \\`thread create target\\`, or take that word off its row`',
-  '    }',
-  '    const reached = bound(word, wired, opened, opening, operation.timeout)',
-  "    if (typeof reached === 'string') return reached",
-  '    held[word] = reached',
-  '  }',
-  '  return held',
-  '}',
-  '',
-  'export async function dispatch<I, R extends string = string>(',
-  '  operation: Operation<I, R>,',
-  '  rawInput: unknown,',
-  '  asking: Actor,',
-  '  opened: Reaches,',
-  '  opening: Vault | undefined,',
-  '  counting?: Counting,',
-  '  telling?: (said: unknown) => void,',
-  '): Promise<Result<unknown>> {',
-  '  const id = operation.id',
-  '  const who = person(asking)',
-  '  const actor: Actor = who ?? ANONYMOUS',
-  '  try {',
-  "    if (who === undefined) return fail('denied', REFUSAL['denied'], 'identity_invalid')",
-  '    const parsed = operation.input.safeParse(rawInput)',
-  '    if (!parsed.success) {',
-  "      return fail('invalid', REFUSAL['invalid'], String(parsed['error']))",
-  '    }',
-  '    const { resource } = operation',
-  '    const ruled = permits(actor, id, resource(parsed[\'data\']))',
-  '    const { allow, because: why } = ruled',
-  "    if (!allow) return fail('denied', REFUSAL['denied'], why)",
-  '',
-  '    const { entitled } = operation',
-  '    if (entitled !== undefined && !actor.entitlements.includes(entitled)) {',
-  "      return fail('feature_denied', REFUSAL['feature_denied'], id + ' is offered on ' + entitled + ', which this caller does not hold')",
-  '    }',
-  '',
-  "    const limited = await allowance(id, actor, counting, operation.rate, 'rate_limited')",
-  '    if (limited !== undefined) return limited',
-  "    const over = await allowance(id, actor, counting, operation.quota, 'quota_exceeded')",
-  '    if (over !== undefined) return over',
-  '',
-  '    const handed = given(operation as Operation<unknown, string>, actor, opened, opening, telling ?? (() => undefined))',
-  "    if (typeof handed === 'string') return fail('error', REFUSAL['error'], handed)",
-  '',
-  '    const held: { readonly input: I } & Record<string, unknown> = { input: parsed.data }',
-  '    const value = await operation.run(handed as Opened<R>, held)',
-  '    return ok(value)',
-  '  } catch (thrown) {',
-  '    const early = stopped(thrown)',
-  '    if (early !== undefined) {',
-  '      return ok(early[\'value\'])',
-  '    }',
-  '',
-  '    const message = thrown instanceof Error ? thrown.message : String(thrown)',
-  '',
-  "    if (named(thrown, 'VersionConflictError')) {",
-  "      return fail('invalid', message, 'version_conflict', CONFLICT)",
-  '    }',
-  '',
-  "    const code: ResultCode = named(thrown, 'ValidationError') ? 'invalid' : 'error'",
-  '    const because = platform(thrown) ?? message',
-  '    return fail(code, message, because)',
-  '  }',
-  '}',
-  '',
-].join('\n')

package/dist/operations/error-results.ts

@@ -1,31 +0,0 @@
-import { PlatformError, catalog, type ErrorDef } from '../core/errors/error.ts'
-import { AuthDenied, FeatureNotInPlan, InternalInvalidArgument, InternalUnexpected, QuotaExceeded, RateLimitExceeded } from '../core/errors/catalogue.ts'
-
-import type { Result, ResultCode } from './result.ts'
-
-const RESULT_ERROR_DEFS: Readonly<Record<ResultCode, ErrorDef>> = {
-  invalid: InternalInvalidArgument.def,
-  denied: AuthDenied.def,
-  rate_limited: RateLimitExceeded.def,
-  quota_exceeded: QuotaExceeded.def,
-  feature_denied: FeatureNotInPlan.def,
-  error: InternalUnexpected.def,
-}
-
-export function errorDefForResult(code: ResultCode): ErrorDef {
-  return RESULT_ERROR_DEFS[code]
-}
-
-export function platformErrorForResult(result: Result<unknown>, run: string): PlatformError {
-  if (result.ok) throw new TypeError('cannot render a successful Result as a problem')
-
-  const def = result.errorCode === undefined ? errorDefForResult(result.code) : catalog.get(result.errorCode)
-  const resolved = def ?? InternalUnexpected.def
-  const detail = result.errorCode === undefined && resolved.code === InternalUnexpected.def.code ? undefined : result.error
-
-  return new PlatformError(resolved, {
-    ...(detail === undefined ? {} : { detail }),
-    ...(result.because === undefined ? {} : { because: result.because }),
-    traceId: run,
-  })
-}