lumen-framework 3.0.0

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

@@ -0,0 +1,66 @@
+type JSONAPI$value = string | number | boolean | JSONAPI$BaseObject | Array<JSONAPI$BaseObject> | null | undefined;
+interface JSONAPI$BaseObject {
+    [key: string]: JSONAPI$value;
+    meta?: JSONAPI$BaseObject;
+}
+interface JSONAPI$LinkObject {
+    href: string;
+    meta?: JSONAPI$BaseObject;
+}
+type JSONAPI$Link = string | JSONAPI$LinkObject | null;
+interface JSONAPI$ResourceLinksObject {
+    self?: JSONAPI$Link;
+    related?: JSONAPI$Link;
+}
+export type JSONAPI$versions = '1.0';
+export interface JSONAPI$IdentifierObject {
+    id: string;
+    type: string;
+    meta?: JSONAPI$BaseObject;
+}
+export interface JSONAPI$ResourceObject {
+    id: string;
+    type: string;
+    links?: JSONAPI$ResourceLinksObject;
+    attributes?: JSONAPI$BaseObject;
+    relationships?: {
+        [key: string]: JSONAPI$RelationshipObject | null | undefined;
+    };
+}
+export interface JSONAPI$RelationshipObject {
+    data: JSONAPI$IdentifierObject;
+    meta?: JSONAPI$BaseObject;
+    links?: JSONAPI$ResourceLinksObject;
+}
+export interface JSONAPI$DocumentLinks extends JSONAPI$ResourceLinksObject {
+    first?: JSONAPI$Link;
+    last?: JSONAPI$Link;
+    prev?: JSONAPI$Link | null;
+    next?: JSONAPI$Link | null;
+}
+export interface JSONAPI$ErrorObject {
+    id?: string;
+    code?: string;
+    meta?: JSONAPI$BaseObject;
+    title?: string;
+    status?: string;
+    detail?: string;
+    links?: {
+        about: JSONAPI$Link;
+    };
+    source?: {
+        pointer?: string;
+        parameter?: string;
+    };
+}
+export interface JSONAPI$Document {
+    data?: Array<JSONAPI$ResourceObject> | JSONAPI$ResourceObject;
+    links?: JSONAPI$DocumentLinks;
+    errors?: Array<JSONAPI$ErrorObject>;
+    included?: Array<JSONAPI$ResourceObject>;
+    jsonapi?: {
+        version: JSONAPI$versions;
+        meta?: JSONAPI$BaseObject;
+    };
+}
+export {};

package/dist/types/packages/jsonapi/utils/has-media-type.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function hasMediaType(value: string): boolean;

package/dist/types/packages/jsonapi/utils/is-jsonapi.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function isJSONAPI(value: string): boolean;

package/dist/types/packages/loader/builder/index.d.ts

@@ -0,0 +1,6 @@
+import type { Bundle$Namespace } from '../index';
+import type { Builder$Class, Builder$Construct } from './interfaces';
+/**
+ * @private
+ */
+export declare function build<T>(group: Bundle$Namespace<Builder$Class<T>>, construct: Builder$Construct<T>): Bundle$Namespace<T>;

package/dist/types/packages/loader/builder/interfaces.d.ts

@@ -0,0 +1,10 @@
+import type { Bundle$Namespace, Bundle$NamespaceGroup } from '../index';
+export type Builder$Class<T> = new (...args: Array<any>) => T;
+export type Builder$NamespaceMeta<T> = {
+    key: string;
+    value: Bundle$Namespace<Builder$Class<T>>;
+    parent: T | null;
+};
+export type Builder$ParentBuilder<T> = (target: Bundle$NamespaceGroup<Builder$Class<T>>) => Array<Builder$NamespaceMeta<T>>;
+export type Builder$ChildrenBuilder<T> = (target: Array<Builder$NamespaceMeta<T>>) => Array<Array<[string, T]>>;
+export type Builder$Construct<T> = (key: string, value: Builder$Class<T>, parent?: T | null) => T;

package/dist/types/packages/loader/builder/utils/create-children-builder.d.ts

@@ -0,0 +1,2 @@
+import type { Builder$Construct, Builder$ChildrenBuilder } from '../interfaces';
+export default function createChildrenBuilder<T>(construct: Builder$Construct<T>): Builder$ChildrenBuilder<T>;

package/dist/types/packages/loader/builder/utils/create-parent-builder.d.ts

@@ -0,0 +1,2 @@
+import type { Builder$Construct, Builder$ParentBuilder } from '../interfaces';
+export default function createParentBuilder<T>(construct: Builder$Construct<T>): Builder$ParentBuilder<T>;

package/dist/types/packages/loader/builder/utils/sort-by-namespace.d.ts

@@ -0,0 +1,5 @@
+import type { Bundle$Namespace } from '../../index';
+/**
+ * @private
+ */
+export default function sortByNamespace<T>([a]: [string, Bundle$Namespace<T>], [b]: [string, Bundle$Namespace<T>]): number;

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

@@ -0,0 +1,8 @@
+import type { Loader } from './interfaces';
+/**
+ * @private
+ */
+export declare function createLoader(path: string): Loader;
+export { build } from './builder';
+export { closestAncestor, closestChild } from './resolver';
+export type { Loader, Bundle$Namespace, Bundle$NamespaceGroup } from './interfaces';

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

@@ -0,0 +1,4 @@
+import type { FreezeableMap } from '../freezeable';
+export type Loader = (type: string) => any;
+export type Bundle$Namespace<T> = FreezeableMap<string, T>;
+export type Bundle$NamespaceGroup<T> = FreezeableMap<string, Bundle$Namespace<T>>;

package/dist/types/packages/loader/resolver/index.d.ts

@@ -0,0 +1,7 @@
+import type { Bundle$Namespace, Bundle$NamespaceGroup } from '../index';
+/**
+ * @private
+ */
+export declare function resolve<T>(group: Bundle$Namespace<T>): Bundle$NamespaceGroup<T>;
+export { default as closestAncestor } from './utils/closest-ancestor';
+export { default as closestChild } from './utils/closest-child';

package/dist/types/packages/loader/resolver/utils/closest-ancestor.d.ts

@@ -0,0 +1,2 @@
+import type { Bundle$Namespace } from '../../index';
+export default function closestAncestor<T>(source: Bundle$Namespace<T>, key: string): T | undefined;

package/dist/types/packages/loader/resolver/utils/closest-child.d.ts

@@ -0,0 +1,2 @@
+import type { Bundle$Namespace } from '../../index';
+export default function closestChild<T>(source: Bundle$Namespace<T>, key: string): T | undefined;

package/dist/types/packages/loader/utils/bundle-for.d.ts

@@ -0,0 +1,5 @@
+import { FreezeableMap } from '../../freezeable';
+/**
+ * @private
+ */
+export default function bundleFor(path: string): FreezeableMap<string, any>;

package/dist/types/packages/loader/utils/format-key.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function formatKey(key: string, formatter?: (source: string) => string): string;

package/dist/types/packages/logger/constants.d.ts

@@ -0,0 +1,8 @@
+import { FreezeableMap, FreezeableSet } from '../freezeable';
+import type { Logger$level, Logger$format } from './interfaces';
+export declare const DEBUG = "DEBUG";
+export declare const INFO = "INFO";
+export declare const WARN = "WARN";
+export declare const ERROR = "ERROR";
+export declare const FORMATS: FreezeableSet<Logger$format>;
+export declare const LEVELS: FreezeableMap<Logger$level, number>;

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

@@ -0,0 +1,182 @@
+import type { Logger$RequestLogger } from './request-logger/interfaces';
+import type { Logger$config, Logger$format, Logger$level, Logger$logFn, Logger$filter } from './interfaces';
+/**
+ * @class Logger
+ * @public
+ */
+declare class Logger {
+    /**
+     * The level your application should log (DEBUG, INFO, WARN, or ERROR).
+     *
+     * @property level
+     * @type {String}
+     * @public
+     */
+    level: Logger$level;
+    /**
+     * The output format of log data (text or json).
+     *
+     * @property format
+     * @type {String}
+     * @public
+     */
+    format: Logger$format;
+    /**
+     * Hackers love logs. It's easy to get sensitive user information from log
+     * data if your server has been breached. To prevent leaking sensitive
+     * information in a potential attack, blacklist certain keys that should be
+     * filtered out of the logs.
+     *
+     * ```javascript
+     * // config/environments/development.js
+     * export default {
+     *   logging: {
+     *     level: 'DEBUG',
+     *     format: 'text',
+     *     enabled: true,
+     *     filter: {
+     *       params: ['password']
+     *     }
+     *   }
+     * };
+     * ```
+     *
+     * Now that we've added password to the array of parameters we want to filter
+     * out of the logs, let's try to create a new user.
+     *
+     * ```http
+     * POST /users HTTP/1.1
+     * Content-Type: application/vnd.api+json
+     * Host: 127.0.0.1:4000
+     * Connection: close
+     * User-Agent: Paw/3.0.14 (Macintosh; OS X/10.12.1) GCDHTTPRequest
+     * Content-Length: 188
+     *
+     * {
+     *   "data": {
+     *   "type": "users",
+     *     "attributes": {
+     *       "name": "Zachary Golba",
+     *       "email": "zachary.golba@postlight.com",
+     *       "password": "vcZxniFYyfnFDcLn%nhe8Vrt"
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * The request above will yield the following log message.
+     *
+     * ```text
+     * [2016-12-10T18:28:04.610Z] Processed POST "/users" from ::ffff:127.0.0.1
+     * with 201 Created by UsersController#create
+     *
+     * Params
+     *
+     * {
+     *   "data": {
+     *     "type": "users",
+     *     "attributes": {
+     *       "name": "Zachary Golba",
+     *       "email": "zachary.golba@postlight.com",
+     *       "password": "[FILTERED]"
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * It worked! The password value did not leak into the log message.
+     *
+     * @property filter
+     * @type {Object}
+     * @public
+     */
+    filter: Logger$filter;
+    /**
+     * A boolean flag that determines whether or not the logger is enabled.
+     *
+     * @property enabled
+     * @type {Boolean}
+     * @public
+     */
+    enabled: boolean;
+    /**
+     * Log a message at the DEBUG level.
+     *
+     * ```javascript
+     * logger.debug('Hello World!');
+     * // => [6/4/16 5:46:53 PM] Hello World!
+     * ```
+     *
+     * @method debug
+     * @param {any} data - The data you wish to log.
+     * @return {void}
+     * @public
+     */
+    debug: Logger$logFn;
+    /**
+     * Log a message at the INFO level.
+     *
+     * ```javascript
+     * logger.info('Hello World!');
+     * // => [6/4/16 5:46:53 PM] Hello World!
+     * ```
+     *
+     * @method info
+     * @param {any} data - The data you wish to log.
+     * @return {void}
+     * @public
+     */
+    info: Logger$logFn;
+    /**
+     * Log a message at the WARN level.
+     *
+     * ```javascript
+     * logger.warn('Good Bye World!');
+     * // => [6/4/16 5:46:53 PM] Good Bye World!
+     * ```
+     *
+     * @method warn
+     * @param {any} data - The data you wish to log.
+     * @return {void}
+     * @public
+     */
+    warn: Logger$logFn;
+    /**
+     * Log a message at the ERROR level.
+     *
+     * ```javascript
+     * logger.warn('HELP!');
+     * // => [6/4/16 5:46:53 PM] HELP!
+     * ```
+     *
+     * @method error
+     * @param {any} data - The data you wish to log.
+     * @return {void}
+     * @public
+     */
+    error: Logger$logFn;
+    /**
+     * Internal method used for logging requests.
+     *
+     * @method request
+     * @param {Request} request
+     * @param {Response} response
+     * @param {Object} opts - An options object.
+     * @param {Number} opts.startTime - The timestamp from when the request was
+     * received.
+     * @return {void}
+     * @private
+     */
+    request: Logger$RequestLogger;
+    constructor({ level, format, filter, enabled }: Logger$config);
+    /**
+     * @method getTimestamp
+     * @return {String} The current time as an ISO8601 string.
+     * @private
+     */
+    getTimestamp(): string;
+}
+export default Logger;
+export { default as line } from './utils/line';
+export { default as sql } from './utils/sql';
+export type { Logger$config } from './interfaces';

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

@@ -0,0 +1,17 @@
+export type Logger$level = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+export type Logger$logFn = (data: string | Record<string, unknown>) => void;
+export type Logger$format = 'text' | 'json';
+export type Logger$data = {
+    level: Logger$level;
+    message?: unknown;
+    timestamp: string;
+};
+export type Logger$filter = {
+    params: string[];
+};
+export type Logger$config = {
+    level: Logger$level;
+    format: Logger$format;
+    filter: Logger$filter;
+    enabled: boolean;
+};

package/dist/types/packages/logger/request-logger/index.d.ts

@@ -0,0 +1,6 @@
+import type Logger from '../index';
+import type { Logger$RequestLogger } from './interfaces';
+/**
+ * @private
+ */
+export declare function createRequestLogger(logger: Logger): Logger$RequestLogger;

package/dist/types/packages/logger/request-logger/interfaces.d.ts

@@ -0,0 +1,25 @@
+import type { Route } from '../../router';
+import type { Request, Response } from '../../server';
+export type Logger$RequestLogger = (req: Request, res: Response, opts: {
+    startTime: number;
+}) => void;
+type RequestLogger$stat = {
+    type: string;
+    name: string;
+    duration: number;
+    controller: string;
+};
+export type RequestLogger$templateData = {
+    path: string;
+    stats: Array<RequestLogger$stat>;
+    route?: Route;
+    method: string;
+    params: Record<string, unknown>;
+    startTime: number;
+    endTime: number;
+    statusCode: string;
+    statusMessage: string;
+    remoteAddress: string;
+    colorStr(source: string): string;
+};
+export {};

package/dist/types/packages/logger/request-logger/templates.d.ts

@@ -0,0 +1,9 @@
+import type { RequestLogger$templateData } from './interfaces';
+/**
+ * @private
+ */
+export declare const debugTemplate: ({ path, stats, route, method, params, colorStr, startTime, endTime, statusCode, statusMessage, remoteAddress }: RequestLogger$templateData) => string;
+/**
+ * @private
+ */
+export declare const infoTemplate: ({ path, route, method, params, colorStr, startTime, endTime, statusCode, statusMessage, remoteAddress }: RequestLogger$templateData) => string;

package/dist/types/packages/logger/request-logger/utils/filter-params.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function filterParams(params: Record<string, unknown>, ...filtered: string[]): Record<string, unknown>;

package/dist/types/packages/logger/request-logger/utils/log-json.d.ts

@@ -0,0 +1,10 @@
+import type Logger from '../../index';
+import type { Request, Response } from '../../../server';
+/**
+ * @private
+ */
+export default function logJSON(logger: Logger, { request: req, response: res }: {
+    startTime: number;
+    request: Request;
+    response: Response;
+}): void;

package/dist/types/packages/logger/request-logger/utils/log-text.d.ts

@@ -0,0 +1,10 @@
+import type Logger from '../../index';
+import type { Request, Response } from '../../../server';
+/**
+ * @private
+ */
+export default function logText(logger: Logger, { startTime, request: req, response: res }: {
+    request: Request;
+    response: Response;
+    startTime: number;
+}): void;

package/dist/types/packages/logger/utils/line.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function line(strings: readonly string[], ...values: unknown[]): string;

package/dist/types/packages/logger/utils/sql.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function sql(strings: readonly string[], ...values: unknown[]): string;

package/dist/types/packages/logger/writer/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ANSI: RegExp;
+export declare const STDOUT: RegExp;
+export declare const STDERR: RegExp;

package/dist/types/packages/logger/writer/index.d.ts

@@ -0,0 +1,6 @@
+import type { Logger$format } from '../interfaces';
+import type { Logger$Writer } from './interfaces';
+/**
+ * @private
+ */
+export declare function createWriter(format: Logger$format): Logger$Writer;

package/dist/types/packages/logger/writer/interfaces.d.ts

@@ -0,0 +1,2 @@
+import type { Logger$data } from '../interfaces';
+export type Logger$Writer = (data: Logger$data) => void;

package/dist/types/packages/logger/writer/utils/format-message.d.ts

@@ -0,0 +1,9 @@
+import type { Logger$format } from '../../interfaces';
+/**
+ * Returns `string | undefined` because `Error#stack` is optional — the Flow
+ * original had the same behaviour, it just did not say so.
+ *
+ * `data` is required here; Flow allowed it to be declared optional ahead of a
+ * required parameter, which TypeScript does not (and every caller passes both).
+ */
+export default function formatMessage(data: unknown, format: Logger$format): string | undefined;

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

@@ -0,0 +1,11 @@
+import type { Action } from '../router';
+import type { Request, Response } from '../server';
+/**
+ * Convert traditional node HTTP server middleware into a lumen compatible
+ * function for use in Controller#beforeAction.
+ *
+ * @module lumen-framework
+ * @namespace Lumen
+ * @function lumenify
+ */
+export default function lumenify(middleware: (req: Request, res: Response, next: (err?: Error) => void) => void): Action<unknown>;

package/dist/types/packages/lumenify/utils/create-response-proxy.d.ts

@@ -0,0 +1,8 @@
+import type { Response } from '../../server';
+/**
+ * Create a Proxy that will trap typical node middleware callback invocations
+ * and route them to the appropriate Promise callback (resolve or reject).
+ *
+ * @private
+ */
+export default function createResponseProxy(res: Response, resolve: (result: unknown) => void): Response;

package/dist/types/packages/pm/cluster/index.d.ts

@@ -0,0 +1,21 @@
+import EventEmitter from 'events';
+import { type Worker } from 'cluster';
+import type Logger from '../../logger';
+import type { Cluster$opts } from './interfaces';
+/**
+ * @private
+ */
+declare class Cluster extends EventEmitter {
+    path: string;
+    port: number;
+    logger: Logger;
+    workers: Set<Worker>;
+    maxWorkers: number;
+    constructor({ path, port, logger, maxWorkers }: Cluster$opts);
+    fork(retry?: boolean): Promise<Worker>;
+    shutdown<T extends Worker>(worker: T): Promise<T>;
+    reload(): any;
+    forkAll(): Promise<Worker>;
+}
+export default Cluster;
+export type { Cluster$opts } from './interfaces';

package/dist/types/packages/pm/cluster/interfaces.d.ts

@@ -0,0 +1,7 @@
+import type Logger from '../../logger';
+export type Cluster$opts = {
+    path: string;
+    port: number;
+    logger: Logger;
+    maxWorkers?: number;
+};

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

@@ -0,0 +1,6 @@
+import Cluster from './cluster';
+import type { Cluster$opts } from './cluster';
+/**
+ * @private
+ */
+export declare function createCluster({ path, port, logger, maxWorkers }: Cluster$opts): Cluster;

package/dist/types/packages/router/definitions/context/index.d.ts

@@ -0,0 +1,11 @@
+import type { Router$Namespace } from '../../index';
+import type { Router$DefinitionBuilder } from '../interfaces';
+export type DefinitionContext = {
+    [key: string]: (...args: Array<any>) => unknown;
+};
+/**
+ * @private
+ */
+export declare function contextFor(build: Router$DefinitionBuilder<Router$Namespace>): {
+    create(namespace: Router$Namespace): DefinitionContext;
+};

package/dist/types/packages/router/definitions/context/utils/create-definition-group.d.ts

@@ -0,0 +1,7 @@
+import type { Route$type, Router$Namespace } from '../../../index';
+type DefinitionFn = (name: string, action?: string) => void;
+/**
+ * @private
+ */
+export default function createDefinitionGroup<T extends Router$Namespace>(type: Route$type, namespace: T): Record<string, DefinitionFn>;
+export {};

package/dist/types/packages/router/definitions/context/utils/create-definition.d.ts

@@ -0,0 +1,10 @@
+import type { Request$method } from '../../../../server';
+import type { Router$Namespace, Route$type } from '../../../index';
+/**
+ * @private
+ */
+export default function createDefinition({ type, method, namespace }: {
+    type: Route$type;
+    method: Request$method;
+    namespace: Router$Namespace;
+}): (name: string, action?: string) => void;

package/dist/types/packages/router/definitions/context/utils/normalize-resource-args.d.ts

@@ -0,0 +1,12 @@
+import { type Controller$builtIn } from '../../../../controller';
+/**
+ * @private
+ */
+export default function normalizeResourceArgs(args: Array<any>): [
+    {
+        name: string;
+        path: string;
+        only: Array<Controller$builtIn>;
+    },
+    () => void
+];

package/dist/types/packages/router/definitions/index.d.ts

@@ -0,0 +1,10 @@
+import type Router from '../index';
+import type { Router$Namespace } from '../index';
+/**
+ * @private
+ */
+export declare function build<T extends Router$Namespace>(builder: (() => void) | undefined, namespace: T): T;
+/**
+ * @private
+ */
+export declare function define<T extends Router$Namespace>(router: Router, parent: T): void;

package/dist/types/packages/router/definitions/interfaces.d.ts

@@ -0,0 +1,7 @@
+import type { Router$Namespace, Resource$opts } from '../index';
+export type Router$DefinitionBuilder<T extends Router$Namespace> = (builder: (() => void) | undefined, namespace: T) => T;
+export type Router$resourceArgs = [
+    string,
+    (Resource$opts | null | undefined)?,
+    ((() => void) | null | undefined)?
+];

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

@@ -0,0 +1,18 @@
+import { FreezeableMap } from '../freezeable';
+import type { Request } from '../server';
+import Route, { DYNAMIC_PATTERN } from './route';
+import type { Router$opts } from './interfaces';
+/**
+ * @private
+ */
+declare class Router extends FreezeableMap<string, Route> {
+    replacer: RegExp;
+    constructor({ routes, controller, controllers }: Router$opts);
+    match({ method, url }: Request): void | Route;
+}
+export default Router;
+export { Route, DYNAMIC_PATTERN };
+export type { Router$Namespace } from './interfaces';
+export type { Resource$opts } from './resource';
+export type { Namespace$opts } from './namespace';
+export type { Action, Route$opts, Route$type } from './route';

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

@@ -0,0 +1,18 @@
+import type Route from './route';
+import type Controller from '../controller';
+import type { FreezeableSet } from '../freezeable';
+export type Router$opts = {
+    controller: Controller;
+    controllers: Map<string, Controller>;
+    routes(): void;
+};
+type Router$NS$content = Route | Router$Namespace;
+export interface Router$Namespace extends FreezeableSet<Router$NS$content> {
+    name: string;
+    path: string;
+    isRoot: boolean;
+    namespace: Router$Namespace;
+    controller: Controller;
+    controllers: Map<string, Controller>;
+}
+export {};