@prestack/thread 0.1.20 → 0.1.22

package/dist/core/errors/catalogue.ts

@@ -1,314 +0,0 @@
-
-
-import { defineError } from './error.ts'
-
-export const AuthUnauthenticated = defineError({
-  code: 'auth.unauthenticated',
-  class: 'UNAUTHENTICATED',
-})
-
-export const AuthInvalidCredentials = defineError({
-  code: 'auth.invalid_credentials',
-  class: 'UNAUTHENTICATED',
-})
-
-export const AuthTokenExpired = defineError({
-  code: 'auth.token_expired',
-  class: 'UNAUTHENTICATED',
-})
-
-export const AuthTokenReused = defineError({
-  code: 'auth.token_reused',
-  class: 'UNAUTHENTICATED',
-})
-
-export const AuthSessionRevoked = defineError({
-  code: 'auth.session_revoked',
-  class: 'UNAUTHENTICATED',
-})
-
-export const AuthDenied = defineError({
-  code: 'auth.denied',
-  class: 'PERMISSION_DENIED',
-})
-
-export const QuotaExceeded = defineError({
-  code: 'quota.exceeded',
-  class: 'RESOURCE_EXHAUSTED',
-
-  status: 402,
-})
-
-export const QuotaReservationExpired = defineError({
-  code: 'quota.reservation_expired',
-  class: 'ABORTED',
-})
-
-export const RateLimitExceeded = defineError({
-  code: 'rate_limit.exceeded',
-  class: 'RESOURCE_EXHAUSTED',
-})
-
-export const FeatureNotInPlan = defineError({
-  code: 'feature.not_in_plan',
-  class: 'PERMISSION_DENIED',
-})
-
-export const DbNotFound = defineError({
-  code: 'db.not_found',
-  class: 'NOT_FOUND',
-})
-
-export const DbConstraintViolation = defineError({
-  code: 'db.constraint_violation',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const DbAlreadyExists = defineError({
-  code: 'db.already_exists',
-  class: 'ALREADY_EXISTS',
-})
-
-export const DbConflict = defineError({
-  code: 'db.conflict',
-  class: 'ABORTED',
-
-  status: 412,
-})
-
-export const DbMigrationChecksumMismatch = defineError({
-  code: 'db.migration_checksum_mismatch',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const DbDestructiveWithoutDryRun = defineError({
-  code: 'db.destructive_without_dry_run',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const DbRoundTripBudgetExceeded = defineError({
-  code: 'db.round_trip_budget_exceeded',
-  class: 'INTERNAL',
-})
-
-export const DbCursorInvalid = defineError({
-  code: 'db.cursor_invalid',
-  class: 'INVALID_ARGUMENT',
-})
-
-export const DbCursorExpired = defineError({
-  code: 'db.cursor_expired',
-  class: 'INVALID_ARGUMENT',
-})
-
-export const WorkflowNodeFailed = defineError({
-  code: 'workflow.node_failed',
-  class: 'INTERNAL',
-})
-
-export const WorkflowInvalidTransition = defineError({
-  code: 'workflow.invalid_transition',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const WorkflowCompensationFailed = defineError({
-  code: 'workflow.compensation_failed',
-  class: 'INTERNAL',
-})
-
-export const WorkflowAlreadyRunning = defineError({
-  code: 'workflow.already_running',
-  class: 'ALREADY_EXISTS',
-})
-
-export const QueueJobFailed = defineError({
-  code: 'queue.job_failed',
-  class: 'INTERNAL',
-})
-
-export const QueueDlqExhausted = defineError({
-  code: 'queue.dlq_exhausted',
-  class: 'INTERNAL',
-})
-
-export const AiProviderUnavailable = defineError({
-  code: 'ai.provider_unavailable',
-  class: 'UNAVAILABLE',
-})
-
-export const AiSchemaValidationFailed = defineError({
-  code: 'ai.schema_validation_failed',
-  class: 'INTERNAL',
-})
-
-export const AiToolNotInMask = defineError({
-  code: 'ai.tool_not_in_mask',
-  class: 'PERMISSION_DENIED',
-})
-
-export const AiNodeCapExceeded = defineError({
-  code: 'ai.node_cap_exceeded',
-  class: 'RESOURCE_EXHAUSTED',
-})
-
-export const SearchIndexFailed = defineError({
-  code: 'search.index_failed',
-  class: 'INTERNAL',
-})
-
-export const SearchQueryInvalid = defineError({
-  code: 'search.query_invalid',
-  class: 'INVALID_ARGUMENT',
-})
-
-export const CommsChannelKindUndeclared = defineError({
-  code: 'comms.channel_kind_undeclared',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const CommsChannelKindUndescribed = defineError({
-  code: 'comms.channel_kind_undescribed',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const CommsChannelKindUnlabelled = defineError({
-  code: 'comms.channel_kind_unlabelled',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const CommsChannelKindUndocumented = defineError({
-  code: 'comms.channel_kind_undocumented',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const CommsChannelKindDuplicate = defineError({
-  code: 'comms.channel_kind_duplicate',
-  class: 'ALREADY_EXISTS',
-})
-
-export const ConfigInvalid = defineError({
-  code: 'config.invalid',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const ConfigMissingEnv = defineError({
-  code: 'config.missing_env',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const ConfigSecretInPublicVar = defineError({
-  code: 'config.secret_in_public_var',
-  class: 'FAILED_PRECONDITION',
-})
-
-export const ConfigCredentialInvalid = defineError({
-  code: 'config.credential_invalid',
-  class: 'UNAUTHENTICATED',
-})
-
-export const ConfigScopeMissing = defineError({
-  code: 'config.scope_missing',
-  class: 'PERMISSION_DENIED',
-})
-
-export const ConfigResourceNotFound = defineError({
-  code: 'config.resource_not_found',
-  class: 'NOT_FOUND',
-})
-
-export const ConfigDestinationIncompatible = defineError({
-  code: 'config.destination_incompatible',
-  class: 'FAILED_PRECONDITION',
-  status: 406,
-})
-
-export const ConfigBlocksExit = defineError({
-  code: 'config.blocks_exit',
-  class: 'FAILED_PRECONDITION',
-  status: 422,
-})
-
-export const NetTimeout = defineError({
-  code: 'net.timeout',
-  class: 'DEADLINE_EXCEEDED',
-})
-
-export const NetUpstreamUnavailable = defineError({
-  code: 'net.upstream_unavailable',
-  class: 'UNAVAILABLE',
-})
-
-export const NetDestinationRefused = defineError({
-  code: 'net.destination_refused',
-  class: 'INVALID_ARGUMENT',
-})
-
-export const InternalUnexpected = defineError({
-  code: 'internal.unexpected',
-  class: 'INTERNAL',
-})
-
-export const InternalNotImplemented = defineError({
-  code: 'internal.not_implemented',
-  class: 'UNIMPLEMENTED',
-})
-
-export const InternalInvalidArgument = defineError({
-  code: 'internal.invalid_argument',
-  class: 'INVALID_ARGUMENT',
-})
-
-export const PLATFORM_ERRORS = [
-  AuthUnauthenticated,
-  AuthInvalidCredentials,
-  AuthTokenExpired,
-  AuthTokenReused,
-  AuthSessionRevoked,
-  AuthDenied,
-  QuotaExceeded,
-  QuotaReservationExpired,
-  RateLimitExceeded,
-  FeatureNotInPlan,
-  DbNotFound,
-  DbConstraintViolation,
-  DbAlreadyExists,
-  DbConflict,
-  DbMigrationChecksumMismatch,
-  DbDestructiveWithoutDryRun,
-  DbRoundTripBudgetExceeded,
-  DbCursorInvalid,
-  DbCursorExpired,
-  WorkflowNodeFailed,
-  WorkflowInvalidTransition,
-  WorkflowCompensationFailed,
-  WorkflowAlreadyRunning,
-  QueueJobFailed,
-  QueueDlqExhausted,
-  AiProviderUnavailable,
-  AiSchemaValidationFailed,
-  AiToolNotInMask,
-  AiNodeCapExceeded,
-  SearchIndexFailed,
-  SearchQueryInvalid,
-  CommsChannelKindUndeclared,
-  CommsChannelKindUndescribed,
-  CommsChannelKindUnlabelled,
-  CommsChannelKindUndocumented,
-  CommsChannelKindDuplicate,
-  ConfigInvalid,
-  ConfigMissingEnv,
-  ConfigSecretInPublicVar,
-  ConfigCredentialInvalid,
-  ConfigScopeMissing,
-  ConfigResourceNotFound,
-  ConfigDestinationIncompatible,
-  ConfigBlocksExit,
-  NetTimeout,
-  NetUpstreamUnavailable,
-  NetDestinationRefused,
-  InternalUnexpected,
-  InternalNotImplemented,
-  InternalInvalidArgument,
-] as const
-
-export type PlatformErrorCode = (typeof PLATFORM_ERRORS)[number]['def']['code']

package/dist/core/errors/classes.ts

@@ -1,51 +0,0 @@
-
-
-export interface ErrorClassDef {
-
-  readonly status: number
-
-  readonly retryable: boolean
-}
-
-export const ERROR_CLASSES = {
-
-  OK: { status: 200, retryable: false },
-
-  CANCELLED: { status: 499, retryable: false },
-
-  UNKNOWN: { status: 500, retryable: false },
-
-  INVALID_ARGUMENT: { status: 400, retryable: false },
-
-  DEADLINE_EXCEEDED: { status: 504, retryable: true },
-
-  NOT_FOUND: { status: 404, retryable: false },
-
-  ALREADY_EXISTS: { status: 409, retryable: false },
-
-  PERMISSION_DENIED: { status: 403, retryable: false },
-
-  RESOURCE_EXHAUSTED: { status: 429, retryable: true },
-
-  FAILED_PRECONDITION: { status: 400, retryable: false },
-
-  ABORTED: { status: 409, retryable: true },
-
-  OUT_OF_RANGE: { status: 400, retryable: false },
-
-  UNIMPLEMENTED: { status: 501, retryable: false },
-
-  INTERNAL: { status: 500, retryable: false },
-
-  UNAVAILABLE: { status: 503, retryable: true },
-
-  UNAUTHENTICATED: { status: 401, retryable: false },
-} as const satisfies Record<string, ErrorClassDef>
-
-export type ErrorClass = keyof typeof ERROR_CLASSES
-
-export const ERROR_CLASS_NAMES = Object.keys(ERROR_CLASSES) as readonly ErrorClass[]
-
-export function classDef(cls: ErrorClass): ErrorClassDef {
-  return ERROR_CLASSES[cls]
-}

package/dist/core/errors/error.ts

@@ -1,152 +0,0 @@
-
-
-import { classDef, type ErrorClass } from './classes.ts'
-
-import type { ErrorCode } from './namespaces.ts'
-
-export type { ErrorCode } from './namespaces.ts'
-
-export interface ErrorDef<C extends ErrorCode = ErrorCode> {
-  readonly code: C
-  readonly class: ErrorClass
-  readonly status: number
-
-  readonly titleKey: string
-  readonly retryable: boolean
-}
-
-export interface DefineErrorInput<C extends ErrorCode = ErrorCode> {
-  readonly code: C
-  readonly class: ErrorClass
-
-  readonly status?: number
-
-  readonly retryable?: boolean
-
-  readonly titleKey?: string
-}
-
-export interface PlatformErrorInit {
-
-  readonly detail?: string
-
-  readonly instance?: string
-
-  readonly because?: string
-  readonly traceId?: string
-
-  readonly retryAfter?: number
-  readonly cause?: unknown
-
-  readonly extensions?: Readonly<Record<string, unknown>>
-}
-
-export class PlatformError<C extends ErrorCode = ErrorCode> extends Error {
-  readonly def: ErrorDef<C>
-  readonly detail?: string
-  readonly instance?: string
-  readonly because?: string
-  readonly traceId?: string
-  readonly retryAfter?: number
-  readonly extensions: Readonly<Record<string, unknown>>
-
-  constructor(def: ErrorDef<C>, init: PlatformErrorInit = {}) {
-
-    super(def.code, init.cause === undefined ? undefined : { cause: init.cause })
-    this.name = 'PlatformError'
-    this.def = def
-    this.detail = init.detail
-    this.instance = init.instance
-    this.because = init.because
-    this.traceId = init.traceId
-    this.retryAfter = init.retryAfter
-    this.extensions = init.extensions ?? {}
-  }
-
-  get code(): C {
-    return this.def.code
-  }
-
-  get status(): number {
-    return this.def.status
-  }
-
-  get retryable(): boolean {
-    return this.def.retryable
-  }
-}
-
-export function isPlatformError(value: unknown): value is PlatformError {
-  return value instanceof PlatformError
-}
-
-export type ErrorFactory<C extends ErrorCode = ErrorCode> = ((
-  init?: PlatformErrorInit,
-) => PlatformError<C>) & {
-  readonly def: ErrorDef<C>
-
-  readonly is: (value: unknown) => value is PlatformError<C>
-}
-
-export class DuplicateErrorCodeError extends Error {
-  constructor(code: string) {
-    super(`duplicate error code: ${code}`)
-    this.name = 'DuplicateErrorCodeError'
-  }
-}
-
-export class ErrorCatalog {
-  readonly #byCode = new Map<ErrorCode, ErrorDef>()
-
-  define<const C extends ErrorCode>(input: DefineErrorInput<C>): ErrorFactory<C> {
-    if (this.#byCode.has(input.code)) {
-
-      throw new DuplicateErrorCodeError(input.code)
-    }
-
-    const cls = classDef(input.class)
-    const def: ErrorDef<C> = {
-      code: input.code,
-      class: input.class,
-      status: input.status ?? cls.status,
-      retryable: input.retryable ?? cls.retryable,
-      titleKey: input.titleKey ?? `errors.${input.code}.title`,
-    }
-    this.#byCode.set(def.code, def)
-
-    const factory = ((init?: PlatformErrorInit) => new PlatformError(def, init)) as {
-      (init?: PlatformErrorInit): PlatformError<C>
-      def: ErrorDef<C>
-      is: (value: unknown) => value is PlatformError<C>
-    }
-    factory.def = def
-    factory.is = (value: unknown): value is PlatformError<C> =>
-      isPlatformError(value) && value.def.code === def.code
-
-    return factory as ErrorFactory<C>
-  }
-
-  get(code: string): ErrorDef | undefined {
-    return this.#byCode.get(code as ErrorCode)
-  }
-
-  has(code: string): boolean {
-    return this.#byCode.has(code as ErrorCode)
-  }
-
-  all(): readonly ErrorDef[] {
-    return [...this.#byCode.values()].sort((a, b) => a.code.localeCompare(b.code))
-  }
-
-  get size(): number {
-    return this.#byCode.size
-  }
-}
-
-export const catalog = new ErrorCatalog()
-
-export function defineError<const C extends ErrorCode>(
-  input: DefineErrorInput<C>,
-): ErrorFactory<C> {
-  return catalog.define(input)
-}

package/dist/core/errors/namespaces.ts

@@ -1,19 +0,0 @@
-export const NAMESPACES = [
-  'auth',
-  'quota',
-  'rate_limit',
-  'feature',
-  'db',
-  'workflow',
-  'queue',
-  'ai',
-  'search',
-  'comms',
-  'config',
-  'net',
-  'internal',
-] as const
-
-export type Namespace = (typeof NAMESPACES)[number]
-
-export type ErrorCode = `${Namespace}.${string}`

package/dist/core/finding.ts

@@ -1,37 +0,0 @@
-import { stdout } from 'node:process'
-
-export interface Finding {
-  readonly detail: string
-  readonly instead: string
-  readonly file?: string
-  readonly at?: { readonly line?: number; readonly column?: number }
-  readonly severity?: 'forbidden' | 'warning'
-}
-
-export const forbids = (finding: Finding): boolean => finding.severity !== 'warning'
-
-function locate(finding: Finding): string {
-  if (finding.file === undefined) return ''
-  const line = finding.at?.line
-  const column = finding.at?.column
-  const position = line === undefined ? '' : `:${String(line)}${column === undefined ? '' : `:${String(column)}`}`
-  return ` (${finding.file}${position})`
-}
-
-export function runChecker(name: string, findings: readonly Finding[], measured: string): void {
-  if (findings.length === 0) {
-    stdout.write(`${name}: ${measured} — no findings.\n`)
-    return
-  }
-
-  const lines = findings.map(
-    (finding) => `  ${forbids(finding) ? '' : 'warning: '}${finding.detail}${locate(finding)}\n    Instead: ${finding.instead}`,
-  )
-  const forbidding = findings.filter(forbids).length
-  stdout.write(
-    `${name}: ${String(findings.length)} finding${findings.length === 1 ? '' : 's'}` +
-      `${forbidding === findings.length ? '' : `, ${String(findings.length - forbidding)} of them warnings`} — ${measured}\n\n` +
-      `${lines.join('\n')}\n`,
-  )
-  if (forbidding > 0) process.exitCode = 1
-}