lumen-framework 3.1.0 → 4.0.0

package/dist/testing.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/packages/testing/utils/identifiers-in.ts", "../src/packages/testing/audit-visibility.ts", "../src/packages/testing/start-app.ts"],
+  "sourcesContent": ["/** A resource's `type` and `id`. */\nexport type Identifier = { type: string; id: string };\n\ntype Linkage = Identifier | Array<Identifier> | null | undefined;\n\ntype Resource = Identifier & {\n  relationships?: Record<string, { data?: Linkage }>;\n};\n\nconst isIdentifier = (value: unknown): value is Identifier =>\n  typeof value === 'object' &&\n  value !== null &&\n  'type' in value &&\n  'id' in value;\n\n/**\n * Every resource a JSON:API document names: its primary data, its `included`\n * resources, and the linkage of each one's relationships. A relationship\n * endpoint's primary data is linkage itself, so it is covered the same way.\n * Ids are strings, as JSON:API sends them.\n *\n * @internal\n */\nexport default function identifiersIn(document: unknown): Array<Identifier> {\n  const found: Array<Identifier> = [];\n\n  const add = (value: unknown) => {\n    if (isIdentifier(value)) {\n      found.push({ type: value.type, id: String(value.id) });\n    }\n  };\n\n  const addLinkage = (linkage: Linkage) => {\n    (Array.isArray(linkage) ? linkage : [linkage]).forEach(add);\n  };\n\n  const addResource = (resource: unknown) => {\n    add(resource);\n\n    if (isIdentifier(resource)) {\n      Object.values((resource as Resource).relationships ?? {}).forEach(\n        relationship => addLinkage(relationship?.data)\n      );\n    }\n  };\n\n  if (typeof document !== 'object' || document === null) {\n    return found;\n  }\n\n  const { data, included } = document as {\n    data?: unknown;\n    included?: Array<unknown>;\n  };\n\n  (Array.isArray(data) ? data : [data]).forEach(addResource);\n  (included ?? []).forEach(addResource);\n\n  return found;\n}\n", "import type { AddressInfo } from 'net';\n\nimport type Application from '../application';\nimport type { Model } from '../database';\nimport type Route from '../router/route';\n\nimport identifiersIn from './utils/identifiers-in';\nimport type { Identifier } from './utils/identifiers-in';\n\n/**\n * Which records of one type a request may see, for {@link auditVisibility}:\n * every one (`true`), the ids listed, or the ids a function accepts.\n */\nexport type VisibleRecords =\n  true | ReadonlyArray<string | number> | ((id: string) => boolean);\n\n/** The options of {@link auditVisibility}. */\nexport type AuditVisibilityOptions = {\n  /**\n   * The namespace to audit: `''` (the default) for the root, `'admin'` for\n   * `/admin`. Nested namespaces are audited on their own.\n   */\n  namespace?: string;\n\n  /**\n   * What the request may see, keyed by type. Written by hand, independently\n   * of the app's visibility rules: it is what they are checked against. A\n   * type left out may not appear at all.\n   */\n  visible: Record<string, VisibleRecords>;\n\n  /**\n   * Headers sent with every request, such as the `Authorization` of the user\n   * the audit is for.\n   */\n  headers?: Record<string, string>;\n\n  /**\n   * The ids to request each type's routes with (`GET /posts/:id`,\n   * `/posts/:id/comments`, \u2026), keyed by type: visible and hidden ones\n   * alike. A type left out is requested with every id in the database, so\n   * keep the database small or list the ids.\n   */\n  ids?: Record<string, ReadonlyArray<string | number>>;\n\n  /**\n   * Query parameters a read requires, keyed by the type it serves: they are\n   * sent with that type's list, its records by id, and every related\n   * endpoint that serves it (`/posts/:id/comments` serves `comments`, and\n   * takes the parameters of the comments' controller). Relationship\n   * endpoints take none.\n   *\n   * ```javascript\n   * query: { comments: { fromDate: '2026-01-01' } }\n   * ```\n   */\n  query?: Record<string, Record<string, string>>;\n\n  /**\n   * Where the application is served, when not by `app` itself: a server\n   * started as a separate process (`lumen serve`), such as\n   * `'http://localhost:4000'`. `app` still provides the routes, the\n   * include paths and the ids, so it must be booted in the test, but need\n   * not listen.\n   */\n  origin?: string;\n\n  /**\n   * Called with each document a read answers with, for checks beyond which\n   * records appear, such as the fields a request may see of each. Return a\n   * message, or several, for each problem found: each is reported as a\n   * violation of that request. May be async.\n   *\n   * ```javascript\n   * onDocument({ document }) {\n   *   return document.included\n   *     ?.filter(({ type, attributes }) => type === 'users' && attributes.email)\n   *     .map(({ id }) => `users ${id} shows its email`);\n   * }\n   * ```\n   */\n  onDocument?: (\n    response: AuditedDocument\n  ) => DocumentCheckResult | Promise<DocumentCheckResult>;\n};\n\n/**\n * The read a request was made to, as the route defines it: so a check need\n * not parse the URL to know which record it is about.\n */\nexport type AuditedRoute = {\n  /** The action, as hooks see it. */\n  action: 'index' | 'show' | 'showRelationship' | 'showRelated';\n  /**\n   * The route's resource type: for a relationship or related endpoint, the\n   * owner's (`posts` for `/posts/3/comments`).\n   */\n  type: string;\n  /**\n   * The id in the URL: the record of a `show`, the owner of a relationship\n   * or related endpoint. None for a list.\n   */\n  id?: string;\n  /** The relationship of a relationship or related endpoint (`comments`). */\n  relationship?: string;\n};\n\n/** A document a read answered with, for `onDocument`. */\nexport type AuditedDocument = {\n  /** The request, as a path and query string. */\n  url: string;\n  /** Its status. */\n  status: number;\n  /** The read the request was made to. */\n  route: AuditedRoute;\n  /** The parsed JSON:API document. */\n  document: Record<string, unknown>;\n};\n\n/**\n * What `onDocument` returns: a message for each problem found, or nothing\n * when there is none.\n */\nexport type DocumentCheckResult =\n  string | ReadonlyArray<string> | null | undefined | void;\n\n/**\n * A record a response contained that the audit's `visible` does not allow; a\n * relationship or related endpoint that answered for an owner `visible` does\n * not allow; a request that failed with an error other than `401`, `403` or\n * `404`, so that what it serves could not be checked; or a problem\n * `onDocument` found.\n */\nexport type VisibilityViolation = {\n  /** The request, as a path and query string. */\n  url: string;\n  /** Its status. */\n  status: number;\n  /**\n   * The record's type, if the violation is a record: one the response named,\n   * or the hidden owner an endpoint answered for.\n   */\n  type?: string;\n  /** The record's id, if the violation is a record. */\n  id?: string;\n  /**\n   * What is wrong, for a hidden owner an endpoint answered for and for what\n   * `onDocument` found.\n   */\n  message?: string;\n};\n\n/** What {@link auditVisibility} found. */\nexport type VisibilityAudit = {\n  /** Every request made, as a path and query string. */\n  requests: Array<string>;\n  /** What should not have been in a response, in request order. */\n  violations: Array<VisibilityViolation>;\n  /**\n   * Every record the responses named, keyed by type: as primary data,\n   * included or as linkage, allowed or not, each id once. Compare it with\n   * what the request should see to check that the audit reached it all.\n   */\n  seen: Record<string, Array<string>>;\n};\n\n// The built-in reads; custom routes take parameters the audit cannot know.\nconst READS = new Set(['index', 'show', 'showRelationship', 'showRelated']);\n\n// Statuses that reveal nothing: the request may not read, or there is nothing\n// it may see. Any other error means the read went unchecked.\nconst DENIED = new Set([401, 403, 404]);\n\n// Bounds the `links.next` chain of a single list, should one never end.\nconst MAX_PAGES = 1000;\n\n/** Where `app` itself is listening, if it is. */\nfunction originOf(app: Application): string {\n  const address = app.server.instance.address() as AddressInfo | null;\n\n  if (!address) {\n    throw new Error(\n      'auditVisibility: the application is not listening. Start it ' +\n        '(`startApp()`), or pass the `origin` of the server to audit.'\n    );\n  }\n\n  return `http://localhost:${address.port}`;\n}\n\nfunction allows(visible: VisibleRecords | undefined, id: string): boolean {\n  if (visible === true) {\n    return true;\n  }\n\n  if (typeof visible === 'function') {\n    return visible(id);\n  }\n\n  return Boolean(visible?.some(allowed => String(allowed) === id));\n}\n\n/**\n * The `include` values to request a route with: none, and every path it\n * accepts at once. A compound document holds what each path reaches, so one\n * request covers them all; a path that leads on to a longer one\n * (`comments` to `comments.user`) adds nothing and is left out. A\n * relationship endpoint (linkage only) accepts none.\n */\nfunction includesOf(route: Route): Array<string | undefined> {\n  const include = route.params.get('include') as Set<string> | undefined;\n  const paths = include ? Array.from(include) : [];\n  const longest = paths.filter(\n    path => !paths.some(other => other.startsWith(`${path}.`))\n  );\n\n  return longest.length ? [undefined, longest.join(',')] : [undefined];\n}\n\n/**\n * Request every read a namespace serves \u2014 each list, each record by id, each\n * relationship and related endpoint, without `include` and with every path\n * it accepts, following every page \u2014 and report each record in a response that\n * `visible` does not allow: in `data`, in `included`, or in any\n * relationship's linkage. A relationship or related endpoint that answers\n * for an owner `visible` does not allow is reported too, whatever it\n * answers with: that it answers reveals the owner. A `401`, `403` or `404`\n * (for a hidden record) reveals nothing and passes; any other error is\n * reported, since the read it answers went unchecked.\n *\n * Visibility rules apply to every one of these paths, but scoping in an\n * `index` or `show` override, or in a hook keyed on the action, does not.\n * This checks the result rather than the mechanism, against a list written\n * by hand:\n *\n * ```javascript\n * import { auditVisibility } from 'lumen-framework/testing';\n *\n * it('shows a member only public posts and their comments', async () => {\n *   const { violations } = await auditVisibility(app, {\n *     namespace: 'members',\n *     headers: { Authorization: `Bearer ${memberToken}` },\n *     visible: {\n *       posts: [publicPost.id],\n *       comments: [commentOnPublicPost.id],\n *       users: true\n *     }\n *   });\n *\n *   expect(violations).toEqual([]);\n * });\n * ```\n *\n * Requests are made one at a time, to `app` itself (which must then be\n * listening, as {@link startApp} leaves it) or to `origin`. Custom routes are\n * not requested. Each route is requested once per\n * id (and per page), so run it against a small fixture database, or narrow\n * the ids with `ids`.\n *\n * @param app - The application, listening.\n * @param options - What to audit, and what the request may see.\n * @returns Every request made, every violation found, and every record\n * seen.\n * @throws When the namespace serves no reads, so a mistyped namespace cannot\n * pass by checking nothing.\n */\nexport default async function auditVisibility(\n  app: Application,\n  {\n    namespace = '',\n    visible,\n    headers = {},\n    ids = {},\n    query: required = {},\n    origin = originOf(app),\n    onDocument\n  }: AuditVisibilityOptions\n): Promise<VisibilityAudit> {\n  const audit: VisibilityAudit = { requests: [], violations: [], seen: {} };\n  const seen = new Map<string, Set<string>>();\n\n  const routes = Array.from(app.router.values()).filter(\n    route =>\n      route.method === 'GET' &&\n      READS.has(route.action) &&\n      route.controller.namespace === namespace\n  );\n\n  if (!routes.length) {\n    throw new Error(\n      `auditVisibility: namespace '/${namespace}' serves no index, show, ` +\n        'relationship or related routes.'\n    );\n  }\n\n  // A link as a path and query string, which the audit reports.\n  const relative = (link: string) => {\n    const { pathname, search } = new URL(link, origin);\n\n    return pathname + search;\n  };\n\n  const idsCache = new Map<string, Array<string>>();\n\n  const idsOf = async (route: Route): Promise<Array<string>> => {\n    const { model } = route.controller;\n    const type = model.resourceName;\n    let list = idsCache.get(type);\n\n    if (!list) {\n      const given = ids[type];\n\n      list = given\n        ? given.map(String)\n        : (\n            (await model.select(model.primaryKey)) as unknown as Array<Model>\n          ).map(record => String(record.getPrimaryKey()));\n\n      idsCache.set(type, list);\n    }\n\n    return list;\n  };\n\n  const check = (url: string, status: number, found: Array<Identifier>) => {\n    found.forEach(({ type, id }) => {\n      if (!seen.has(type)) {\n        seen.set(type, new Set());\n      }\n\n      seen.get(type)?.add(id);\n\n      if (!allows(visible[type], id)) {\n        audit.violations.push({ url, status, type, id });\n      }\n    });\n  };\n\n  // One request, and the pages after it.\n  const read = async (first: string, route: AuditedRoute) => {\n    let url: string | undefined = first;\n\n    // A relationship or related endpoint whose owner the request may not\n    // see. Answering at all, whatever it answers with, tells the client the\n    // owner exists, and what it is linked to: the owner is in the URL, not\n    // in the response, so `check()` cannot catch it.\n    const hiddenOwner =\n      route.action.startsWith('showRel') &&\n      route.id !== undefined &&\n      !allows(visible[route.type], route.id);\n\n    for (let page = 0; url && page < MAX_PAGES; page += 1) {\n      audit.requests.push(url);\n\n      const res: globalThis.Response = await fetch(origin + url, {\n        headers: { Accept: 'application/vnd.api+json', ...headers }\n      });\n\n      if (!res.ok && !DENIED.has(res.status)) {\n        audit.violations.push({ url, status: res.status });\n        await res.body?.cancel();\n        return;\n      }\n\n      if (res.ok && hiddenOwner && page === 0) {\n        audit.violations.push({\n          url,\n          status: res.status,\n          type: route.type,\n          id: route.id,\n          message:\n            `answered for ${route.type} ${route.id}, which the request ` +\n            'may not see'\n        });\n      }\n\n      // An override may answer with something other than a document (a\n      // string is `text/plain`); only a JSON body can name records.\n      if (!res.ok || !res.headers.get('content-type')?.includes('json')) {\n        await res.body?.cancel();\n        return;\n      }\n\n      const document = (await res.json()) as {\n        links?: { next?: unknown };\n      } | null;\n\n      check(url, res.status, identifiersIn(document));\n\n      if (onDocument && document) {\n        const found = await onDocument({\n          url,\n          status: res.status,\n          route,\n          document: document as Record<string, unknown>\n        });\n        const messages =\n          typeof found === 'string' ? [found] : Array.from(found ?? []);\n\n        const at = { url, status: res.status };\n\n        messages.forEach(message => {\n          audit.violations.push({ ...at, message });\n        });\n      }\n\n      const next: unknown = document?.links?.next;\n\n      url = typeof next === 'string' ? relative(next) : undefined;\n    }\n  };\n\n  for (const route of routes) {\n    const paged = route.params.get('page')\n      ? (route.related ?? route.controller).maxPerPage\n      : undefined;\n\n    // The type the route's records are of: none for a relationship\n    // endpoint, which answers with linkage and takes no parameters.\n    const served =\n      route.type === 'relationship'\n        ? undefined\n        : (route.related ?? route.controller).model.resourceName;\n\n    const query = (include: string | undefined) => {\n      const params = new URLSearchParams(served ? required[served] : {});\n\n      if (include) {\n        params.set('include', include);\n      }\n\n      if (paged) {\n        params.set('page[size]', String(paged));\n      }\n\n      const search = params.toString();\n\n      return search ? `?${search}` : '';\n    };\n\n    const about = {\n      action: route.action as AuditedRoute['action'],\n      type: route.controller.model.resourceName,\n      ...(route.relationship ? { relationship: route.relationship } : {})\n    };\n\n    const targets: Array<[string, AuditedRoute]> = route.dynamicSegments.length\n      ? (await idsOf(route)).map(id => [\n          route.path.replace(':id', encodeURIComponent(id)),\n          { ...about, id }\n        ])\n      : [[route.path, about]];\n\n    for (const [path, target] of targets) {\n      for (const include of includesOf(route)) {\n        await read(path + query(include), target);\n      }\n    }\n  }\n\n  seen.forEach((list, type) => {\n    audit.seen[type] = Array.from(list);\n  });\n\n  return audit;\n}\n", "import { once } from 'events';\nimport { createRequire } from 'module';\nimport { resolve as resolvePath, join as joinPath } from 'path';\nimport type { AddressInfo } from 'net';\n\nimport type Application from '../application';\n\n/** The options of {@link startApp}. */\nexport type StartAppOptions = {\n  /**\n   * The environment to boot in: which `config/environments/*.js` and which\n   * entry of `config/database.js` apply. Sets `NODE_ENV` when given, and\n   * defaults it to `'test'` when unset, until `close()` restores it.\n   */\n  env?: string;\n\n  /** The port to listen on. `0`, the default, takes a free one. */\n  port?: number;\n};\n\n/** An application {@link startApp} booted. */\nexport type StartedApp = {\n  /** The application, for {@link auditVisibility} and the models. */\n  app: Application;\n  /** Where it listens, such as `'http://localhost:53017'`. */\n  origin: string;\n  /**\n   * Stops the server, closes the database connections, and restores\n   * `NODE_ENV` to what it was before `startApp()`.\n   */\n  close: () => Promise<void>;\n};\n\ntype Bundle = {\n  Application: new (options: Record<string, unknown>) => Promise<Application>;\n  config: Record<string, unknown>;\n  database: Record<string, unknown>;\n};\n\n// The bundles booting or booted in this process. Booting sets up an app's\n// model classes, which happens once per process: a second boot of the same\n// bundle fails. A failed boot is removed again, so a retry reports its own\n// error rather than \"already started\".\nconst started = new Set<string>();\n\n// The first error each bundle failed to boot with: a failed boot can leave the\n// app half set up, so a retry may fail on that rather than on the cause.\nconst failed = new Map<string, unknown>();\n\nconst messageOf = (error: unknown) =>\n  error instanceof Error ? error.message : String(error);\n\n/**\n * Boot the app at `path` in the test's own process, from its compiled\n * bundle (`dist/bundle.js`), and listen on a free port.\n *\n * ```javascript\n * import { startApp } from 'lumen-framework/testing';\n *\n * let app, origin, close;\n *\n * beforeAll(async () => {\n *   ({ app, origin, close } = await startApp(process.cwd()));\n * });\n *\n * afterAll(() => close());\n * ```\n *\n * The bundle must be compiled for the environment first, as `lumen build`\n * and the `lumen db:*` commands do. Its model classes are set up once per\n * process, so start an app once and share it between test files; starting\n * the same one again throws. `NODE_ENV` holds the app's environment until\n * `close()`.\n *\n * @param path - The app's root directory.\n * @param options - The environment and port.\n * @returns The application, where it listens, and how to stop it.\n * @throws When the app at `path` was already started in this process.\n */\nexport default async function startApp(\n  path: string,\n  { env, port = 0 }: StartAppOptions = {}\n): Promise<StartedApp> {\n  const root = resolvePath(path);\n  const bundlePath = joinPath(root, 'dist', 'bundle.js');\n\n  if (started.has(bundlePath)) {\n    throw new Error(\n      `startApp: ${root} was already started in this process. Its models ` +\n        'are set up once per process: start it once and share it.'\n    );\n  }\n\n  // Read when the bundle loads, which is why it is set first. It stays set\n  // while the app runs: the app reads it again per request (whether a 500\n  // shows its message).\n  const previous = process.env.NODE_ENV;\n  const restoreEnv = () => {\n    if (previous === undefined) {\n      delete process.env.NODE_ENV;\n    } else {\n      process.env.NODE_ENV = previous;\n    }\n  };\n\n  process.env.NODE_ENV = env ?? previous ?? 'test';\n  started.add(bundlePath);\n\n  let app: Application;\n\n  try {\n    // The app's bundle, resolved at runtime: not a module of the framework.\n    const {\n      Application: App,\n      config,\n      database\n    } = createRequire(bundlePath)(bundlePath) as Bundle;\n\n    app = await new App({ ...config, database, path: root, port });\n\n    if (!app.server.instance.listening) {\n      await once(app.server.instance, 'listening');\n    }\n  } catch (error) {\n    started.delete(bundlePath);\n    restoreEnv();\n\n    const earlier = failed.get(bundlePath);\n\n    if (failed.has(bundlePath)) {\n      throw new Error(\n        `startApp: booting ${root} failed: ${messageOf(error)}. An earlier ` +\n          `attempt in this process failed first, with: ${messageOf(earlier)}. ` +\n          'A failed boot can leave the app half set up: fix that one first.',\n        { cause: error }\n      );\n    }\n\n    failed.set(bundlePath, error);\n    throw error;\n  }\n\n  const { port: listening } = app.server.instance.address() as AddressInfo;\n\n  return {\n    app,\n    origin: `http://localhost:${listening}`,\n    close: async () => {\n      try {\n        await app.close();\n      } finally {\n        restoreEnv();\n      }\n    }\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/types/errors/links-only-error.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Thrown at boot when a Serializer's `linksOnly` names a relationship it
+ * cannot serialize as links only.
+ *
+ * @private
+ */
+declare class LinksOnlyError extends TypeError {
+    /**
+     * @param problems - One line per relationship, saying what is wrong.
+     */
+    constructor(problems: Array<string>);
+}
+export default LinksOnlyError;

package/dist/types/errors/reserved-field-name-error.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Thrown at boot when a serializer lists a field named `type` or `id`, which
+ * JSON:API forbids, without `allowReservedNames`.
+ *
+ * @internal
+ */
+declare class ReservedFieldNameError extends TypeError {
+    /**
+     * @param problems - One line per name, saying where it is listed.
+     */
+    constructor(problems: Array<string>);
+}
+export default ReservedFieldNameError;

package/dist/types/errors/unknown-attribute-error.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Thrown at boot when a serializer's `attributes`, or a controller's `sort`
+ * or `filter`, names something that is not a column of the model's table.
+ *
+ * @internal
+ */
+declare class UnknownAttributeError extends TypeError {
+    /**
+     * @param problems - One line per name, saying where it is listed.
+     */
+    constructor(problems: Array<string>);
+}
+export default UnknownAttributeError;

package/dist/types/index.d.ts

@@ -1,6 +1,20 @@
+/**
+ * The framework: what an app's models, controllers, serializers and
+ * application extend. Test helpers live in `lumen-framework/testing`.
+ *
+ * @module lumen-framework
+ */
 export { Model } from './packages/database';
 export { default as Logger } from './packages/logger';
 export { default as Controller } from './packages/controller';
 export { default as Serializer } from './packages/serializer';
 export { default as Application } from './packages/application';
 export { default as lumenify } from './packages/lumenify';
+export type { ApplicationOptions } from './packages/application';
+export type { Config } from './packages/config';
+export type { AfterAction, BeforeAction, ControllerOptions, Visibility } from './packages/controller';
+export type { DatabaseConfig, DatabaseEnvironmentConfig, DatabasePoolConfig, ModelClass, ModelHook, ModelHooks, Query, RelationshipOptions, TransactionResult } from './packages/database';
+export type { LogFilter, LogFormat, LogFunction, LoggerConfig, LogLevel } from './packages/logger';
+export type { Action } from './packages/router';
+export type { SerializerOptions } from './packages/serializer';
+export type { CorsConfig, Request, RequestMethod, RequestParams, Response, ServerConfig } from './packages/server';

package/dist/types/interfaces.d.ts

@@ -1,4 +1,4 @@
-export interface Lumen$Collection<T> {
+export interface LumenCollection<T> {
     size: number;
     has(key: T): boolean;
     clear(): void;

package/dist/types/packages/application/index.d.ts

@@ -6,92 +6,85 @@ import type Serializer from '../serializer';
 import type Database from '../database';
 import type { Model, ModelClass } from '../database';
 import type { FreezeableMap } from '../freezeable';
-import type { Application$opts } from './interfaces';
+import type { ApplicationOptions } from './interfaces';
 /**
- * @class Application
- * @public
+ * A running Lumen app: its models, controllers, serializers, routes and HTTP
+ * server. `app/index.js` exports a subclass, usually empty:
+ *
+ * ```javascript
+ * import { Application } from 'lumen-framework';
+ *
+ * class Blog extends Application {}
+ *
+ * export default Blog;
+ * ```
+ *
+ * `lumen serve` builds the app and constructs it; constructing one resolves
+ * once the database is connected, every module is loaded and the server is
+ * listening.
  */
 declare class Application {
-    /**
-     * The path of `Application` instance.
-     *
-     * @property path
-     * @type {String}
-     * @public
-     */
+    /** The app's root directory. */
     path: string;
-    /**
-     * The port that an `Application` instance is listening for incomming HTTP
-     * requests.
-     *
-     * @property port
-     * @type {Number}
-     * @public
-     */
+    /** The port the app listens on. */
     port: number;
     /**
      * A reference to the `Database` instance.
      *
-     * @property store
-     * @type {Database}
-     * @private
+     * @internal
      */
     store: Database;
     /**
      * A reference to the `Logger` instance.
      *
-     * @property logger
-     * @type {Logger}
-     * @private
+     * @internal
      */
     logger: Logger;
     /**
      * A reference to the `Router` instance.
      *
-     * @property router
-     * @type {Router}
-     * @private
+     * @internal
      */
     router: Router;
     /**
      * A reference to the `Server` instance.
      *
-     * @property server
-     * @type {Server}
-     * @private
+     * @internal
      */
     server: Server;
     /**
      * A map containing each `Model` class.
      *
-     * @property models
-     * @type {Map}
-     * @private
+     * @internal
      */
     models: FreezeableMap<string, ModelClass>;
     /**
      * A map containing each `Controller` instance.
      *
-     * @property controllers
-     * @type {Map}
-     * @private
+     * @internal
      */
     controllers: FreezeableMap<string, Controller>;
     /**
      * A map containing each `Serializer` instance.
      *
-     * @property serializers
-     * @type {Map}
-     * @private
+     * @internal
      */
     serializers: FreezeableMap<string, Serializer<Model>>;
     /**
-     * @method constructor
-     * @param {Object} config
-     * @return {Promise}
-     * @public
+     * Boot the app. Resolves with the ready instance, though TypeScript types
+     * it as the instance itself; `await` it.
+     */
+    constructor(opts: ApplicationOptions);
+    /**
+     * Stop the application gracefully: the server stops accepting connections
+     * and closes idle ones, the requests in flight finish, and then the
+     * database connections close. Resolves once all of that is done.
+     *
+     * `lumen serve` calls it in each worker when the process is asked to stop
+     * (`SIGTERM`, `SIGINT`); call it yourself when you construct an
+     * application in a script or a test.
      */
-    constructor(opts: Application$opts);
+    close(): Promise<void>;
 }
 export default Application;
-export type { Application$opts, Application$Class, Application$factoryOpts } from './interfaces';
+export type { ApplicationOptions, ApplicationClass, ApplicationFactoryOptions } from './interfaces';

package/dist/types/packages/application/initialize.d.ts

@@ -1,6 +1,4 @@
 import type Application from './index';
-import type { Application$opts } from './index';
-/**
- * @private
- */
-export default function initialize<T extends Application>(app: T, { path, port, logging, database, server: serverConfig }: Application$opts): Promise<T>;
+import type { ApplicationOptions } from './index';
+/** @internal */
+export default function initialize<T extends Application>(app: T, { path, port, logging, database, server: serverConfig }: ApplicationOptions): Promise<T>;

package/dist/types/packages/application/interfaces.d.ts

@@ -1,15 +1,23 @@
 import type { Config } from '../config';
 import type Database from '../database';
-import type { Database$config, Model } from '../database';
+import type { DatabaseConfig, Model } from '../database';
 import type Controller from '../controller';
 import type Serializer from '../serializer';
-export type Application$opts = Config & {
+/**
+ * What an {@link Application} is constructed with: the environment's
+ * {@link Config}, plus where the app is and how to reach its database. The
+ * app's generated boot code passes these; apps don't build them by hand.
+ */
+export type ApplicationOptions = Config & {
+    /** The app's root directory. */
     path: string;
+    /** The port to listen on. */
     port: string | number;
-    database: Database$config;
+    /** The contents of `config/database.js`. */
+    database: DatabaseConfig;
 };
-export type Application$Class<T> = new (...args: Array<any>) => T;
-export type Application$factoryOpts<T extends Controller | Serializer<Model>> = {
+export type ApplicationClass<T> = new (...args: Array<any>) => T;
+export type ApplicationFactoryOptions<T extends Controller | Serializer<Model>> = {
     key: string;
     store: Database;
     parent?: T | null;

package/dist/types/packages/application/utils/create-controller.d.ts

@@ -1,12 +1,22 @@
 import type Database from '../../database';
 import type { Model } from '../../database';
+import { NAMESPACE_SETTINGS } from '../../controller';
 import type Controller from '../../controller';
 import type Serializer from '../../serializer';
-import type { Bundle$Namespace } from '../../loader';
-import type { Application$Class } from '../index';
-export default function createController<T extends Controller>(constructor: Application$Class<T>, opts: {
+import type { BundleNamespace } from '../../loader';
+import type { ApplicationClass } from '../index';
+type NamespaceSetting = (typeof NAMESPACE_SETTINGS)[number];
+/**
+ * Whether `controller`, or the `ApplicationController` of a namespace it is
+ * in, sets `setting` itself rather than leaving it at the default.
+ *
+ * @internal
+ */
+export declare function setsItself(controller: Controller, setting: NamespaceSetting): boolean;
+export default function createController<T extends Controller>(constructor: ApplicationClass<T>, opts: {
     key: string;
     store: Database;
     parent?: Controller | null;
-    serializers: Bundle$Namespace<Serializer<Model>>;
+    serializers: BundleNamespace<Serializer<Model>>;
 }): T;
+export {};

package/dist/types/packages/application/utils/create-serializer.d.ts

@@ -1,4 +1,4 @@
 import type Serializer from '../../serializer';
 import type { Model } from '../../database';
-import type { Application$Class, Application$factoryOpts } from '../index';
-export default function createSerializer<T extends Serializer<Model>>(constructor: Application$Class<T>, opts: Application$factoryOpts<T>): T;
+import type { ApplicationClass, ApplicationFactoryOptions } from '../index';
+export default function createSerializer<T extends Serializer<Model>>(constructor: ApplicationClass<T>, opts: ApplicationFactoryOptions<T>): T;

package/dist/types/packages/application/utils/normalize-port.d.ts

@@ -1,4 +1,2 @@
-/**
- * @private
- */
+/** @internal */
 export default function normalizePort(port?: string | number): number;

package/dist/types/packages/application/utils/resolve-visibility.d.ts

@@ -0,0 +1,15 @@
+import Controller from '../../controller';
+import type { ModelClass } from '../../database';
+import type { BundleNamespace } from '../../loader';
+/**
+ * Give every controller the visibility rules of its namespace — the
+ * `static visibility` of the namespace's `ApplicationController`, or, when it
+ * has none or declares none, the closest ancestor namespace's — and whether
+ * any were declared (`hasVisibilityRules`), and refuse to boot on rules that
+ * cannot be applied: rules declared on any other controller (a rule must hold for the
+ * whole namespace, since types are included across controllers), rules for a
+ * type that has no model, and rules that are not functions.
+ *
+ * @internal
+ */
+export default function resolveVisibility(controllers: BundleNamespace<Controller> | Map<string, Controller>, models: Iterable<ModelClass>): void;

package/dist/types/packages/application/utils/restrict-open-namespaces.d.ts

@@ -0,0 +1,19 @@
+import type Logger from '../../logger';
+import type Controller from '../../controller';
+/**
+ * Give the controllers of a namespace without visibility rules — neither its
+ * own nor an ancestor's, run after `resolveVisibility()` — conservative
+ * defaults, and warn once per such namespace that serves records.
+ *
+ * Without rules, nothing scopes what a request reaches beyond its primary
+ * data: an `index` or `show` override, or a hook checking `request.action`,
+ * does not apply to included resources or to the relationship and related
+ * endpoints. So unless a controller (or its namespace) sets
+ * `maxIncludeDepth`, `?include=` is turned off (`0`); the router serves
+ * relationship endpoints only where a resource's `relationships` option asks
+ * for them. Declaring rules — `static visibility = {}` for a namespace that
+ * may see everything — lifts both.
+ *
+ * @internal
+ */
+export default function restrictOpenNamespaces(controllers: Map<string, Controller>, logger: Logger): void;

package/dist/types/packages/application/utils/validate-attributes.d.ts

@@ -0,0 +1,17 @@
+import type Controller from '../../controller';
+import type Serializer from '../../serializer';
+import type { Model } from '../../database';
+import type { BundleNamespace } from '../../loader';
+/**
+ * Check that every serializer's `attributes`, and every controller's `sort`
+ * and `filter`, name columns of their model. Anything else used to be
+ * accepted and then silently ignored: missing from responses, and a `sort`
+ * or `filter` that did nothing. Throws listing every problem.
+ *
+ * A controller's `sort` and `filter` default to its serializer's
+ * `attributes`, so only names its serializer does not list are reported for
+ * the controller.
+ *
+ * @internal
+ */
+export default function validateAttributes(controllers: BundleNamespace<Controller> | Map<string, Controller>, serializers: BundleNamespace<Serializer<Model>> | Map<string, Serializer<Model>>): void;

package/dist/types/packages/application/utils/validate-links-only.d.ts

@@ -0,0 +1,19 @@
+import type Router from '../../router';
+import type Serializer from '../../serializer';
+import type { Model } from '../../database';
+import type { BundleNamespace } from '../../loader';
+/**
+ * Check every Serializer's `linksOnly` against the built `router`: each
+ * relationship must be one of its `hasMany`, and have a related endpoint
+ * (`/posts/:id/comments`) in at least one namespace where the Serializer
+ * formats its type — else it could never be left without its linkage.
+ * Throws listing every problem.
+ *
+ * Whatever removes a related endpoint counts: no controller for the related
+ * type in the namespace, a related resource without `index`, an owning
+ * resource without `show` (or without the relationship in its
+ * `relationships`), or a custom route at that path.
+ *
+ * @internal
+ */
+export default function validateLinksOnly(router: Router, serializers: BundleNamespace<Serializer<Model>> | Map<string, Serializer<Model>>): void;

package/dist/types/packages/application/utils/validate-namespaced-serializers.d.ts

@@ -1,7 +1,7 @@
 import type Controller from '../../controller';
 import type Serializer from '../../serializer';
 import type { Model } from '../../database';
-import type { Bundle$Namespace } from '../../loader';
+import type { BundleNamespace } from '../../loader';
 /**
  * Enforce `serializerFallback = false`: for every namespace whose
  * ApplicationController sets it, each type its controllers can serialize — the
@@ -10,6 +10,6 @@ import type { Bundle$Namespace } from '../../loader';
  * Serializer in exactly that namespace. Throws listing every gap, so a missing
  * serializer fails the boot instead of silently falling back to the root one.
  *
- * @private
+ * @internal
  */
-export default function validateNamespacedSerializers(controllers: Bundle$Namespace<Controller> | Map<string, Controller>, serializers: Bundle$Namespace<Serializer<Model>> | Map<string, Serializer<Model>>): void;
+export default function validateNamespacedSerializers(controllers: BundleNamespace<Controller> | Map<string, Controller>, serializers: BundleNamespace<Serializer<Model>> | Map<string, Serializer<Model>>): void;

package/dist/types/packages/application/utils/validate-reserved-names.d.ts

@@ -0,0 +1,12 @@
+import type Logger from '../../logger';
+import type Serializer from '../../serializer';
+import type { Model } from '../../database';
+import type { BundleNamespace } from '../../loader';
+/**
+ * Refuse to boot when a serializer's `attributes`, `hasOne` or `hasMany`
+ * names `type` or `id`, listing every one; warn instead for a serializer that
+ * sets `allowReservedNames`.
+ *
+ * @internal
+ */
+export default function validateReservedNames(serializers: BundleNamespace<Serializer<Model>> | Map<string, Serializer<Model>>, logger: Logger): void;

package/dist/types/packages/application/utils/warn-query-param-names.d.ts

@@ -0,0 +1,10 @@
+import type Logger from '../../logger';
+import type Controller from '../../controller';
+/**
+ * Warn at boot about custom `query` parameters whose names the spec reserves
+ * for itself (all lowercase a-z, e.g. `search`). They keep working; a
+ * spec-aware client or a future version of the spec may not agree.
+ *
+ * @internal
+ */
+export default function warnQueryParamNames(controllers: Map<string, Controller>, logger: Logger): void;

package/dist/types/packages/cli/commands/dbcreate.d.ts

@@ -1,4 +1,4 @@
 /**
  * @private
  */
-export declare function dbcreate(): Promise<unknown>;
+export declare function dbcreate(): Promise<void>;

package/dist/types/packages/cli/commands/dbdrop.d.ts

@@ -1,4 +1,4 @@
 /**
  * @private
  */
-export declare function dbdrop(): Promise<unknown>;
+export declare function dbdrop(): Promise<void> | Promise<boolean>;

package/dist/types/packages/cli/commands/destroy.d.ts

@@ -1,11 +1,12 @@
 /**
  * @private
  */
-export declare function destroyType(type: string, name: string): Promise<void>;
+export declare function destroyType(type: string, name: string, cwd?: string): Promise<void>;
 /**
  * @private
  */
-export declare function destroy({ type, name }: {
+export declare function destroy({ type, name, cwd }: {
     type: string;
     name: string;
+    cwd?: string;
 }): Promise<void>;

package/dist/types/packages/cli/commands/generate.d.ts

@@ -1,10 +1,10 @@
-import type { Generator$opts } from '../generator';
+import type { GeneratorOptions } from '../generator';
 /**
  * @private
  */
 export declare function generate({ cwd, name, type, attrs }: {
-    cwd?: Generator$opts['cwd'];
-    name: Generator$opts['name'];
-    type: Generator$opts['type'];
-    attrs?: Generator$opts['attrs'];
+    cwd?: GeneratorOptions['cwd'];
+    name: GeneratorOptions['name'];
+    type: GeneratorOptions['type'];
+    attrs?: GeneratorOptions['attrs'];
 }): Promise<void>;

package/dist/types/packages/cli/commands/index.d.ts

@@ -9,4 +9,3 @@ export { destroy } from './destroy';
 export { generate } from './generate';
 export { repl } from './repl';
 export { serve } from './serve';
-export { test } from './test';

package/dist/types/packages/cli/generator/index.d.ts

@@ -1,11 +1,11 @@
-import type { Generator$opts } from './interfaces';
+import type { GeneratorOptions } from './interfaces';
 /**
  * @private
  */
 export declare function runGenerator({ cwd, type, name, attrs }: {
-    cwd: Generator$opts['cwd'];
-    type: Generator$opts['type'];
-    name: Generator$opts['name'];
-    attrs: Generator$opts['attrs'];
+    cwd: GeneratorOptions['cwd'];
+    type: GeneratorOptions['type'];
+    name: GeneratorOptions['name'];
+    attrs: GeneratorOptions['attrs'];
 }): Promise<void>;
-export type { Generator, Generator$opts, Generator$template } from './interfaces';
+export type { Generator, GeneratorOptions, GeneratorTemplate } from './interfaces';

package/dist/types/packages/cli/generator/interfaces.d.ts

@@ -1,9 +1,9 @@
-export type Generator$opts = {
+export type GeneratorOptions = {
     cwd: string;
     type: string;
     name: string;
     attrs: Array<string>;
     onConflict(text: string): Promise<string | boolean>;
 };
-export type Generator = (opts: Generator$opts) => Promise<void>;
-export type Generator$template = (name: string, attrs: Array<string>) => string;
+export type Generator = (opts: GeneratorOptions) => Promise<void>;
+export type GeneratorTemplate = (name: string, attrs: Array<string>) => string;

package/dist/types/packages/cli/generator/utils/create-generator.d.ts

@@ -1,9 +1,9 @@
-import type { Generator, Generator$template } from '../index';
+import type { Generator, GeneratorTemplate } from '../index';
 /**
  * @private
  */
 export default function createGenerator({ dir, template, hasConflict }: {
     dir: string;
-    template: Generator$template;
+    template: GeneratorTemplate;
     hasConflict?: (path: string) => Promise<boolean>;
 }): Generator;

package/dist/types/packages/cli/generator/utils/generate-type.d.ts

@@ -1,33 +1,33 @@
-import type { Generator$opts } from '../index';
+import type { GeneratorOptions } from '../index';
 /**
  * @private
  */
-export declare function controller(opts: Generator$opts): Promise<void>;
+export declare function controller(opts: GeneratorOptions): Promise<void>;
 /**
  * @private
  */
-export declare function serializer(opts: Generator$opts): Promise<void>;
+export declare function serializer(opts: GeneratorOptions): Promise<void>;
 /**
  * @private
  */
-export declare function migration(opts: Generator$opts): Promise<void>;
+export declare function migration(opts: GeneratorOptions): Promise<void>;
 /**
  * @private
  */
-export declare function modelMigration(opts: Generator$opts): Promise<void>;
+export declare function modelMigration(opts: GeneratorOptions): Promise<void>;
 /**
  * @private
  */
-export declare function model(opts: Generator$opts): Promise<void>;
+export declare function model(opts: GeneratorOptions): Promise<void>;
 /**
  * @private
  */
-export declare function middleware(opts: Generator$opts): Promise<void>;
+export declare function middleware(opts: GeneratorOptions): Promise<void>;
 /**
  * @private
  */
-export declare function util(opts: Generator$opts): Promise<void>;
+export declare function util(opts: GeneratorOptions): Promise<void>;
 /**
  * @private
  */
-export declare function resource(opts: Generator$opts): Promise<void>;
+export declare function resource(opts: GeneratorOptions): Promise<void>;