lumen-framework 3.0.3 → 3.1.1

package/dist/types/packages/serializer/utils/include-tree.d.ts

@@ -0,0 +1,29 @@
+import type { Model, ModelClass } from '../../database';
+import type Serializer from '../index';
+/**
+ * A parsed `include` parameter: each relationship name maps to the tree of
+ * relationships to include from the records it points to.
+ *
+ * @private
+ */
+export type IncludeTree = Map<string, IncludeTree>;
+/**
+ * Parse relationship paths (`['comments', 'comments.user', 'user']`) into an
+ * include tree. Every prefix of a path is part of the tree, because JSON:API
+ * requires the intermediate resources of a multi-part path to be included
+ * along with its leaves (`comments.user` includes the comments too).
+ *
+ * @private
+ */
+export declare function createIncludeTree(paths?: Array<string>): IncludeTree;
+/**
+ * Enumerate every include path available from `names` (relationships of
+ * `model`), down to `depth` levels. Each level continues with the relationships
+ * declared by the related model's serializer as `serializerFor` resolves it —
+ * the same one its included resources are serialized with (namespaced, with a
+ * fallback to the root). Used to build the allowed values of the `include`
+ * parameter.
+ *
+ * @private
+ */
+export declare function enumerateIncludePaths(model: ModelClass, names: Array<string>, depth: number, serializerFor?: (model: ModelClass) => Serializer<Model> | undefined): Array<string>;

package/dist/types/packages/serializer/utils/load-linkage.d.ts

@@ -0,0 +1,22 @@
+import type { Model, ModelClass } from '../../database';
+/**
+ * The resource linkage of one record: the primary key(s) of the records each
+ * named relationship points to — an array for has-many, otherwise a single id
+ * or `null`.
+ *
+ * @private
+ */
+export type Linkage = Record<string, Array<string> | string | null>;
+/**
+ * Batch-load the resource linkage of the relationships `names` for every one of
+ * `records` (all instances of `model`), keyed by each record's primary key.
+ *
+ * This is what lets included resources carry `relationships` without an N+1:
+ * it issues at most one query per relationship — and a single query for all
+ * belongs-to relationships, whose foreign keys live on `model` itself — however
+ * many records there are. The queries mirror the lazy relationship getters in
+ * `database/relationship/utils/getters.ts`, which remain the source of truth.
+ *
+ * @private
+ */
+export default function loadLinkage(model: ModelClass, records: Array<Model>, names: Array<string>): Promise<Map<string, Linkage>>;

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

@@ -22,6 +22,7 @@ declare class Server {
 export default Server;
 export { REQUEST_METHODS, getDomain } from './request';
 export { default as createServerError } from './utils/create-server-error';
-export type { Server$config } from './interfaces';
+export { default as sourceFor } from './utils/source-for';
+export type { Server$config, Server$ErrorSource } from './interfaces';
 export type { Request, Request$params, Request$method } from './request/interfaces';
 export type { Response } from './response/interfaces';

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

@@ -13,6 +13,11 @@ export type Server$opts = Server$config & {
     logger: Logger;
     router: Router;
 };
+export type Server$ErrorSource = {
+    pointer?: string;
+    parameter?: string;
+};
 export interface Server$Error extends Error {
     statusCode: number;
+    source?: Server$ErrorSource;
 }

package/dist/types/packages/server/utils/source-for.d.ts

@@ -0,0 +1,10 @@
+import type { Server$ErrorSource } from '../interfaces';
+/**
+ * Map an internal parameter path to a JSON:API error `source`. Paths under
+ * `data` are request document members and become a JSON Pointer
+ * (`data.attributes.isPublic` -> `/data/attributes/is-public`); anything else
+ * is a query parameter (`page.size` -> `page[size]`).
+ *
+ * @private
+ */
+export default function sourceFor(path: string): Server$ErrorSource;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lumen-framework",
-  "version": "3.0.3",
+  "version": "3.1.1",
   "description": "Build scalable, Node.js-powered REST APIs with almost no code.",
   "keywords": [
     "mvc",