pipework 0.252.0 → 0.252.1

package/src/request/di/builder.ts

@@ -0,0 +1,535 @@
+import type { Schema, Infer } from '../../data/schema/types.js'
+import type { DB } from '../../data/db/index.js'
+import { DEFAULT_DB } from './types.js'
+import type { Handler, HandlerMeta, HttpMethod, RouteMeta, AuthRequirement, PermissionMeta, JobRetryConfig, JobTransactionMode, Checkpoint, RouteScreen, UploadConfig, BinaryUploadConfig, MultipartUploadConfig, BinaryUpload, MultipartUpload, FileConfig, RouteRefusedHook } from './types.js'
+import type { ResourceOperations, Resource, PaginationConfig } from '../fixture/types.js'
+import type { HttpRequest, HttpResponse, CorsConfig } from '../http/types.js'
+import { buildResource } from '../fixture/builder.js'
+
+interface BuilderState {
+  databases: string[]
+  requiresAuth: boolean
+  authRequirement: AuthRequirement
+  inputSchema: Schema | null
+  outputSchemas: Map<number, Schema>
+  querySchema: Schema | null
+  paramsSchema: Schema | null
+  route: RouteMeta | null
+  cors: CorsConfig | false | null
+  rateLimit: string | false | null
+  isJob: boolean
+  jobType: string | null
+  jobRetry: JobRetryConfig | null
+  jobTimeout: number | null
+  jobTransaction: JobTransactionMode
+  permission: PermissionMeta | null
+  pagination: PaginationConfig | null
+  wantsRequest: boolean
+  wantsResponse: boolean
+  wantsRawBody: boolean
+  ignoresBody: boolean
+  upload: UploadConfig | null
+  file: FileConfig | null
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  onRefused: RouteRefusedHook<any, any, any> | null
+}
+
+/**
+ * Deps shape after `.transaction('manual')`: the databases the handler declared
+ * with `.use()` move out of the top-level deps (a non-transactional handle there
+ * would be a footgun) and into `checkpoint`'s callback, which binds them inside a
+ * fresh tenant-scoped transaction. `checkpoint` is added in their place.
+ */
+type ManualDeps<TDeps, TDb> = Omit<TDeps, keyof TDb> & { checkpoint: Checkpoint<TDb> }
+
+type DepOf<TDeps, K extends string> = TDeps extends Record<K, infer V> ? V : unknown
+
+export class Builder<
+  TDeps extends Record<string, unknown>,
+  TDb extends Record<string, DB> = Record<never, DB>,
+> {
+  private readonly state: BuilderState
+
+  constructor(state?: Partial<BuilderState>) {
+    this.state = {
+      databases: state?.databases ?? [],
+      requiresAuth: state?.requiresAuth ?? false,
+      authRequirement: state?.authRequirement ?? 'none',
+      inputSchema: state?.inputSchema ?? null,
+      outputSchemas: state?.outputSchemas ?? new Map(),
+      querySchema: state?.querySchema ?? null,
+      paramsSchema: state?.paramsSchema ?? null,
+      route: state?.route ?? null,
+      cors: state?.cors ?? null,
+      rateLimit: state?.rateLimit ?? null,
+      isJob: state?.isJob ?? false,
+      jobType: state?.jobType ?? null,
+      jobRetry: state?.jobRetry ?? null,
+      jobTimeout: state?.jobTimeout ?? null,
+      jobTransaction: state?.jobTransaction ?? 'auto',
+      permission: state?.permission ?? null,
+      pagination: state?.pagination ?? null,
+      wantsRequest: state?.wantsRequest ?? false,
+      wantsResponse: state?.wantsResponse ?? false,
+      wantsRawBody: state?.wantsRawBody ?? false,
+      ignoresBody: state?.ignoresBody ?? false,
+      upload: state?.upload ?? null,
+      file: state?.file ?? null,
+      onRefused: state?.onRefused ?? null,
+    }
+  }
+
+  use(): Builder<TDeps & { db: DB }, TDb & { db: DB }>
+  use<N extends string>(name: N): Builder<TDeps & Record<N, DB>, TDb & Record<N, DB>>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  use(name?: string): Builder<any, any> {
+    const sentinel = name ?? DEFAULT_DB
+    return new Builder({
+      ...this.state,
+      databases: [...this.state.databases, sentinel],
+    })
+  }
+
+  auth<TAuth>(): Builder<TDeps & { auth: TAuth }, TDb> {
+    return new Builder<TDeps & { auth: TAuth }, TDb>({
+      ...this.state,
+      requiresAuth: true,
+      authRequirement: 'required',
+    })
+  }
+
+  authOptional<TAuth>(): Builder<TDeps & { auth: TAuth | null }, TDb> {
+    return new Builder<TDeps & { auth: TAuth | null }, TDb>({
+      ...this.state,
+      requiresAuth: false,
+      authRequirement: 'optional',
+    })
+  }
+
+  public(): Builder<TDeps, TDb> {
+    return new Builder<TDeps, TDb>({
+      ...this.state,
+      requiresAuth: false,
+      authRequirement: 'none',
+    })
+  }
+
+  input<T extends Schema>(schema: T): Builder<TDeps & { input: Infer<T> }, TDb> {
+    return new Builder<TDeps & { input: Infer<T> }, TDb>({
+      ...this.state,
+      inputSchema: schema,
+    })
+  }
+
+  query<T extends Schema>(schema: T): Builder<TDeps & { query: Infer<T> }, TDb> {
+    return new Builder<TDeps & { query: Infer<T> }, TDb>({
+      ...this.state,
+      querySchema: schema,
+    })
+  }
+
+  params<T extends Schema>(schema: T): Builder<TDeps & { params: Infer<T> }, TDb> {
+    return new Builder<TDeps & { params: Infer<T> }, TDb>({
+      ...this.state,
+      paramsSchema: schema,
+    })
+  }
+
+  output<T extends Schema>(schema: T): Builder<TDeps, TDb>
+  output<T extends Schema>(status: number, schema: T): Builder<TDeps, TDb>
+  output(statusOrSchema: number | Schema, maybeSchema?: Schema): Builder<TDeps, TDb> {
+    const schemas = new Map(this.state.outputSchemas)
+    const status = typeof statusOrSchema === 'number' ? statusOrSchema : 200
+    if (schemas.has(status)) {
+      const where = this.state.route ? ` on ${this.state.route.method} ${this.state.route.path}` : ''
+      throw new Error(
+        `[pipework] .output() declares status ${status} twice${where}.\n\n` +
+        `  A status keeps one schema; the second would silently replace the first, and a body valid for the first would answer 422.\n` +
+        `  Fix: declare ${status} once, with a schema that is a union of the bodies, e.g. .output(${status}, schema.check.union([a, b])).\n`,
+      )
+    }
+    schemas.set(status, typeof statusOrSchema === 'number' ? maybeSchema! : statusOrSchema)
+    return new Builder<TDeps, TDb>({
+      ...this.state,
+      outputSchemas: schemas,
+    })
+  }
+
+  route(method: HttpMethod, path: string, options?: { bodyLimit?: number; screen?: RouteScreen }): Builder<TDeps, TDb> {
+    return new Builder<TDeps, TDb>({
+      ...this.state,
+      route: {
+        method,
+        path,
+        ...(options?.bodyLimit !== undefined ? { bodyLimit: options.bodyLimit } : {}),
+        ...(options?.screen !== undefined ? { screen: options.screen } : {}),
+      },
+    })
+  }
+
+  /**
+   * This route's own CORS grant. It replaces the server-level `cors` for this route
+   * (no merge); `.cors(false)` closes the route under an open server. Preflight
+   * requests for the route's path and method are answered from the same grant.
+   */
+  cors(grant: CorsConfig | false): Builder<TDeps, TDb> {
+    return new Builder<TDeps, TDb>({ ...this.state, cors: grant })
+  }
+
+  /**
+   * Puts this route in a named class of `rateLimits.classes`; `false` exempts it. Without this, the
+   * class follows the auth requirement: `signedIn` for required, `public` for none, and for optional
+   * `signedIn` when a user is signed in, else `public`. A name the server config lacks is refused
+   * when the server is built.
+   */
+  rateLimit(name: string | false): Builder<TDeps, TDb> {
+    return new Builder<TDeps, TDb>({ ...this.state, rateLimit: name })
+  }
+
+  /**
+   * Marks this handler a job. Its deps gain `signal`: aborted when the job is no longer this
+   * handler's (returned to pending on shutdown, ...); check it before any outside effect.
+   */
+  job(type?: string): Builder<TDeps & { signal: AbortSignal }, TDb> {
+    return new Builder<TDeps & { signal: AbortSignal }, TDb>({
+      ...this.state,
+      isJob: true,
+      jobType: type ?? null,
+    })
+  }
+
+  /**
+   * Selects how this handler's database transaction(s) are managed. Applies to
+   * a job and to a route alike.
+   *
+   * `'auto'` (default) keeps the single framework-owned outer transaction.
+   * `'manual'` opens no outer transaction; the handler instead receives a
+   * `checkpoint(fn)` primitive and owns its own commit boundaries — the
+   * databases declared with `.use()` move from the top-level deps into
+   * `checkpoint`'s callback.
+   *
+   * **What manual mode costs, on either surface.** Each checkpoint commits
+   * independently and durably. An error after one has committed leaves that
+   * state committed: for a job the contract shifts from atomic to
+   * at-least-once / idempotent-on-resume, and for a route the response status
+   * no longer describes what is in the database — a 500 can follow work that
+   * is already durable. The handler owns its own compensation. In exchange it
+   * holds no connection between checkpoints, which is what lets a route commit,
+   * make a network call, and write again under the request's own tenant.
+   *
+   * **Against `pipe.system()`, the row state is the same.** `pipe.system()` also
+   * runs outside the request transaction and also commits mid-request, so a
+   * route already written that way sees no change in what is committed or when.
+   * What changes is which mechanism enforces the tenancy: a hand-written `WHERE`
+   * on a connection that bypasses row-level security, versus the database under
+   * the request's own tenant. That is not observable in the rows, so a test that
+   * only reads them cannot tell the two apart — the difference shows up as a
+   * policy denial when the filter is wrong, which is the point.
+   *
+   * So a test that pins this property reads the handler's declaration next to
+   * the rows: `handler.meta.jobTransaction === 'manual'` and `handler.meta.databases`
+   * holding the databases `.use()` declared. (`jobTransaction` carries the mode
+   * for a route too; the name predates the route surface.) Half the property is
+   * in the rows and half is in the declaration, and only the pair of them
+   * catches a silent move back to `pipe.system()`.
+   */
+  transaction(mode: 'auto'): Builder<TDeps, TDb>
+  transaction(mode: 'manual'): Builder<ManualDeps<TDeps, TDb>, TDb>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  transaction(mode: JobTransactionMode): Builder<any, TDb> {
+    return new Builder({
+      ...this.state,
+      jobTransaction: mode,
+    })
+  }
+
+  retry(config: JobRetryConfig): Builder<TDeps, TDb> {
+    return new Builder<TDeps, TDb>({
+      ...this.state,
+      jobRetry: config,
+    })
+  }
+
+  timeout(ms: number): Builder<TDeps, TDb> {
+    return new Builder<TDeps, TDb>({
+      ...this.state,
+      jobTimeout: ms,
+    })
+  }
+
+  permission(resource: string, action: string, scope?: string): Builder<TDeps, TDb> {
+    const perm: PermissionMeta = scope !== undefined
+      ? { resource, action, scope }
+      : { resource, action }
+    return new Builder<TDeps, TDb>({
+      ...this.state,
+      permission: perm,
+    })
+  }
+
+  paginate(config: { defaultLimit?: number; maxLimit?: number } = {}): Builder<TDeps, TDb> {
+    return new Builder<TDeps, TDb>({
+      ...this.state,
+      pagination: {
+        defaultLimit: config.defaultLimit ?? 20,
+        maxLimit: config.maxLimit ?? 100,
+      },
+    })
+  }
+
+  request(): Builder<TDeps & { request: HttpRequest }, TDb> {
+    return new Builder<TDeps & { request: HttpRequest }, TDb>({
+      ...this.state,
+      wantsRequest: true,
+    })
+  }
+
+  response(): Builder<TDeps & { response: HttpResponse }, TDb> {
+    return new Builder<TDeps & { response: HttpResponse }, TDb>({
+      ...this.state,
+      wantsResponse: true,
+    })
+  }
+
+  rawBody(): Builder<TDeps & { rawBody: Buffer }, TDb> {
+    return new Builder<TDeps & { rawBody: Buffer }, TDb>({
+      ...this.state,
+      wantsRawBody: true,
+    })
+  }
+
+  /**
+   * Makes this route accept a body of any content type and never read it: the body is drained
+   * unparsed (a declared length over 64 KiB is refused with 413) and `input` is undefined.
+   * For a POST whose body carries nothing the handler needs, such as an RFC 8058 one-click
+   * unsubscribe (`List-Unsubscribe=One-Click` as form-urlencoded or multipart). This route only:
+   * no other route's parsing changes. Cannot be combined with `.input()`, `.rawBody()` or `.upload()`.
+   */
+  ignoreBody(): Builder<TDeps, TDb> {
+    return new Builder<TDeps, TDb>({ ...this.state, ignoresBody: true })
+  }
+
+  /**
+   * Makes this route accept a file upload and hands the handler the file as a
+   * stream in the `upload` dep. The body is never buffered whole.
+   *
+   * `{ kind: 'binary', mediaTypes, maxBytes }` takes the request body itself as
+   * the file: `upload` is `{ stream, length, mediaType, detectedType,
+   * declaredType, extension }` (`length` is the declared Content-Length, null
+   * when chunked). `{ kind: 'multipart', file, mediaTypes, maxBytes, fields? }`
+   * takes the part named `file` of a `multipart/form-data` body: `upload` is
+   * `{ stream, filename, fields, mediaType, detectedType, declaredType,
+   * extension }`.
+   *
+   * `mediaTypes` is matched against `mediaType`, the type found in the file's
+   * first 1024 bytes (`detectedType`; null when no signature matches). A zip or
+   * compound-file container takes the declared type or filename extension when
+   * that names an Office, OpenDocument, epub, jar or apk file. With no
+   * signature the declared type stands, except a type a signature would show
+   * (pdf, png, ...), which the bytes then contradict and is refused. Entries
+   * may be `type/*` wildcards, or a star on each side of the slash to take any
+   * type and refuse in the handler.
+   *
+   * A body (binary) or file (multipart) over `maxBytes` gets 413: refused before
+   * reading when the declared Content-Length is over, and while streaming
+   * otherwise (the handler's read of `upload.stream` rejects with
+   * `errors.PayloadTooLarge`). A media type outside `mediaTypes` gets 415. The
+   * route's `screen`, when set, still runs first, and auth runs before any body
+   * is read.
+   *
+   * `onRefuse(refusal)` runs once for each such 413 or 415, in the request's
+   * context, with the detected and declared types, extension, filename, sizes,
+   * accepted list, auth, and the route's `params` and `query` as the handler gets
+   * them (typed when `.params()` / `.query()` come before `.upload()`; the raw
+   * values on a route with no schema; null when they fail it). A non-empty string it returns becomes the error
+   * message; if it throws, the default message is sent. Nothing of the file is
+   * kept: only its first 1024 bytes are held, to detect the type.
+   *
+   * Multipart: text fields must come before the file part, only names listed in
+   * `fields` are accepted (another name gets 422), each at most 64 KiB; fields
+   * after the file part are not read, and only the first file part is handed
+   * over. A missing file part gets 422.
+   *
+   * The handler must consume or destroy `upload.stream`. If it returns with the
+   * stream unfinished the framework destroys it and closes the connection after
+   * the response. Errors from the stream reach the handler as rejected reads and
+   * become the response when the handler lets them propagate.
+   *
+   * In `'auto'` transaction mode the request transaction, and its pool
+   * connection, is held for the whole upload: for large files use
+   * `.transaction('manual')` and write to the database in a `checkpoint` after
+   * the bytes are stored.
+   *
+   * Cannot be combined with `.input()`, `.rawBody()` or `.job()`; each throws.
+   */
+  upload(config: BinaryUploadConfig<DepOf<TDeps, 'params'>, DepOf<TDeps, 'query'>>): Builder<TDeps & { upload: BinaryUpload }, TDb>
+  upload(config: MultipartUploadConfig<DepOf<TDeps, 'params'>, DepOf<TDeps, 'query'>>): Builder<TDeps & { upload: MultipartUpload }, TDb>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  upload(config: BinaryUploadConfig<any, any> | MultipartUploadConfig<any, any>): Builder<any, TDb> {
+    if (config.mediaTypes.length === 0) {
+      throw new Error('[pipework] .upload() needs at least one entry in mediaTypes (e.g. ["application/pdf"] or ["image/*"]).')
+    }
+    if (!Number.isInteger(config.maxBytes) || config.maxBytes <= 0) {
+      throw new Error(`[pipework] .upload() maxBytes must be a positive integer number of bytes, got ${String(config.maxBytes)}.`)
+    }
+    if (config.kind === 'multipart' && config.file === '') {
+      throw new Error('[pipework] .upload({ kind: "multipart" }) needs the form field name of the file in `file`.')
+    }
+    return new Builder({
+      ...this.state,
+      upload: config,
+    })
+  }
+
+  /**
+   * Declares that this route answers with a file, returned from the handler as
+   * `http.file({ body, mediaType, filename? ... })`. `mediaTypes` lists what the
+   * route may send (`type/*` wildcards allowed) and `status` (default 200) is the
+   * status of the file response. OpenAPI gets `responses.<status>.content.<type>`
+   * as `{ type: 'string', format: 'binary' }` for each media type.
+   *
+   * At the file's status the route must return `http.file(...)`: anything else,
+   * or a file whose `mediaType` is outside `mediaTypes`, is a 500 with the reason
+   * in the body. At any other status it answers as on any route: return
+   * `{ status, body? }` (declare the body with `.output(status, schema)`); a
+   * redirect is `{ status: 302 }` after `response.header('location', url)` on
+   * a `.response()` route. A Buffer is sent whole with Content-Length; a Readable is
+   * streamed (add `length` for Content-Length, else it is chunked). Content-
+   * Disposition carries an ASCII `filename=` fallback and the exact name in
+   * `filename*`, and the response sets `X-Content-Type-Options: nosniff`.
+   *
+   * The request transaction (auto mode) has committed before the body streams,
+   * so the stream must not need it. A stream that fails after the first byte
+   * destroys the connection and logs the error. Range requests are not supported.
+   *
+   * Cannot be combined with `.output()` for the same status, or with `.job()`;
+   * `fit()` throws.
+   */
+  file(config: { mediaTypes: readonly string[]; status?: number }): Builder<TDeps, TDb> {
+    if (config.mediaTypes.length === 0) {
+      throw new Error('[pipework] .file() needs at least one entry in mediaTypes (e.g. ["application/pdf"] or ["image/*"]).')
+    }
+    const status = config.status ?? 200
+    if (!Number.isInteger(status) || status < 200 || status > 599) {
+      throw new Error(`[pipework] .file() status must be an HTTP status code, got ${String(config.status)}.`)
+    }
+    return new Builder<TDeps, TDb>({
+      ...this.state,
+      file: { mediaTypes: [...config.mediaTypes], status },
+    })
+  }
+
+  /**
+   * Runs `hook` once for every 4xx this route answers, including those made before
+   * the handler: the input/params/query 422, auth 401, permission 403, 429, upload
+   * 413/415 and the handler's own thrown 4xx. Never for a 5xx, nor the route's `screen`.
+   * It gets `{ status, code, message, fields, auth, params, query, request,
+   * requestId }`; `auth` is null where auth itself refused, `params`/`query` are null
+   * when they fail their schema. A plain object it returns is merged into the
+   * response's `error`; `code`, `message`, `fields` and `details` keep pipework's
+   * values (a hook that sets one is warned and dropped). A throw is logged and the
+   * refusal is sent as without the hook. Runs in the request's Flow as a trace step
+   * after the upload `onRefuse`, once the request transaction has rolled back: it has none.
+   */
+  onRefused(hook: RouteRefusedHook<DepOf<TDeps, 'auth'>, DepOf<TDeps, 'params'>, DepOf<TDeps, 'query'>>): Builder<TDeps, TDb> {
+    return new Builder<TDeps, TDb>({ ...this.state, onRefused: hook })
+  }
+
+  fixture<TAuth>(name: string, operations: ResourceOperations<TAuth>): Resource<TAuth> {
+    const dbName = this.state.databases[0]
+    if (dbName === undefined) {
+      throw new Error(
+        `[pipework] .fixture("${name}") requires a database. Call .use("dbName") before .fixture().`,
+      )
+    }
+    return buildResource(name, operations, {
+      database: dbName,
+      authRequirement: this.state.authRequirement,
+      permission: this.state.permission,
+      pagination: this.state.pagination,
+    })
+  }
+
+  fit<TReturn>(fn: (deps: TDeps) => Promise<TReturn>): Handler<TDeps, TReturn> {
+    if (this.state.jobTransaction === 'manual' && this.state.databases.length === 0) {
+      throw new Error(
+        '[pipework] .transaction("manual") requires at least one database.\n\n' +
+        '  A checkpointed handler commits database work incrementally, so it must\n' +
+        '  declare which database(s) participate. Call .use("dbName") before\n' +
+        '  .transaction("manual").\n'
+      )
+    }
+
+    if (this.state.upload !== null) {
+      const what = this.state.isJob ? '.job()' : this.state.inputSchema !== null ? '.input()' : this.state.wantsRawBody ? '.rawBody()' : null
+      if (what !== null) {
+        throw new Error(
+          `[pipework] .upload() cannot be combined with ${what}.\n\n` +
+          '  An upload route\'s body is the file, delivered as a stream in the `upload` dep.\n' +
+          '  Remove ' + what + (what === '.job()' ? ': a job has no request body to stream.' : ', or take the text fields from a multipart form (`fields`).') + '\n',
+        )
+      }
+    }
+
+    if (this.state.ignoresBody) {
+      const what = this.state.upload !== null ? '.upload()' : this.state.inputSchema !== null ? '.input()' : this.state.wantsRawBody ? '.rawBody()' : null
+      if (what !== null) {
+        throw new Error(`[pipework] .ignoreBody() cannot be combined with ${what}: the body is drained unread, so ${what} would have nothing to read. Remove one.`)
+      }
+    }
+
+    if (this.state.file !== null) {
+      if (this.state.isJob) {
+        throw new Error(
+          '[pipework] .file() cannot be combined with .job().\n\n' +
+          '  A file response is sent to an HTTP client; a job has no response to send.\n' +
+          '  Remove .file(), or remove .job().\n',
+        )
+      }
+      if (this.state.outputSchemas.has(this.state.file.status)) {
+        throw new Error(
+          `[pipework] .file() and .output(${this.state.file.status}, ...) both declare the ${this.state.file.status} response.\n\n` +
+          '  A route answers each status with one body: a file or a JSON schema.\n' +
+          '  Remove .output() for that status, or give .file({ status }) another one.\n',
+        )
+      }
+    }
+
+    const meta: HandlerMeta = {
+      databases: this.state.databases,
+      requiresAuth: this.state.requiresAuth,
+      authRequirement: this.state.authRequirement,
+      inputSchema: this.state.inputSchema,
+      outputSchemas: this.state.outputSchemas,
+      querySchema: this.state.querySchema,
+      paramsSchema: this.state.paramsSchema,
+      route: this.state.route,
+      cors: this.state.cors,
+      rateLimit: this.state.rateLimit,
+      isJob: this.state.isJob,
+      jobType: this.state.jobType,
+      jobRetry: this.state.jobRetry,
+      jobTimeout: this.state.jobTimeout,
+      jobTransaction: this.state.jobTransaction,
+      permission: this.state.permission,
+      wantsRequest: this.state.wantsRequest,
+      wantsResponse: this.state.wantsResponse,
+      wantsRawBody: this.state.wantsRawBody,
+      ignoresBody: this.state.ignoresBody,
+      upload: this.state.upload,
+      file: this.state.file,
+      onRefused: this.state.onRefused,
+    }
+
+    return {
+      async execute(deps: TDeps): Promise<TReturn> {
+        return fn(deps)
+      },
+      meta,
+    }
+  }
+}
+
+export function createBuilder(): Builder<Record<never, never>> {
+  return new Builder()
+}

package/src/request/di/index.ts

@@ -0,0 +1,8 @@
+import { createBuilder } from './builder.js'
+
+export const fitting = createBuilder()
+
+export { createBuilder, Builder } from './builder.js'
+export { resolveAndExecute, type ResolveOptions } from './resolve.js'
+export { DEFAULT_DB } from './types.js'
+export type { Handler, HandlerMeta, RouteMeta, HttpMethod, InferDeps, InferReturn, DatabaseDeps, JobTransactionMode, Checkpoint, UploadConfig, BinaryUploadConfig, MultipartUploadConfig, BinaryUpload, MultipartUpload, FileConfig } from './types.js'