lumen-framework 3.0.0

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

@@ -0,0 +1,20 @@
+import { FreezeableSet } from '../../freezeable';
+import type Controller from '../../controller';
+import type { Route, Router$Namespace } from '../index';
+import type { Namespace$opts } from './interfaces';
+/**
+ * @private
+ */
+declare class Namespace extends FreezeableSet<Route | Router$Namespace> {
+    name: string;
+    path: string;
+    isRoot: boolean;
+    namespace: Router$Namespace;
+    controller: Controller;
+    controllers: Map<string, Controller>;
+    constructor({ name, path, namespace, controller, controllers }: Namespace$opts);
+}
+export default Namespace;
+export { default as normalizeName } from './utils/normalize-name';
+export { default as normalizePath } from './utils/normalize-path';
+export type { Namespace$opts } from './interfaces';

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

@@ -0,0 +1,9 @@
+import type Controller from '../../controller';
+import type { Router$Namespace } from '../index';
+export type Namespace$opts = {
+    name: string;
+    path: string;
+    namespace?: Router$Namespace;
+    controller: Controller;
+    controllers: Map<string, Controller>;
+};

package/dist/types/packages/router/namespace/utils/normalize-name.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function normalizeName(str: string): string;

package/dist/types/packages/router/namespace/utils/normalize-path.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function normalizePath(str: string): string;

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

@@ -0,0 +1,13 @@
+import Namespace from '../namespace';
+import { FreezeableSet } from '../../freezeable';
+import type { Controller$builtIn } from '../../controller';
+import type { Resource$opts } from './interfaces';
+/**
+ * @private
+ */
+declare class Resource extends Namespace {
+    only: FreezeableSet<Controller$builtIn>;
+    constructor({ only, ...opts }: Resource$opts);
+}
+export default Resource;
+export type { Resource$opts } from './interfaces';

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

@@ -0,0 +1,5 @@
+import type { Controller$builtIn } from '../../controller';
+import type { Namespace$opts } from '../namespace';
+export type Resource$opts = Namespace$opts & {
+    only: Array<Controller$builtIn>;
+};

package/dist/types/packages/router/resource/utils/normalize-only.d.ts

@@ -0,0 +1,5 @@
+import { type Controller$builtIn } from '../../../controller';
+/**
+ * @private
+ */
+export default function normalizeOnly(only: Array<Controller$builtIn>): Array<Controller$builtIn>;

package/dist/types/packages/router/route/action/constants.d.ts

@@ -0,0 +1 @@
+export declare const FINAL_HANDLER = "__FINAL_HANDLER__";

package/dist/types/packages/router/route/action/enhancers/resource.d.ts

@@ -0,0 +1,5 @@
+import type { Action } from '../interfaces';
+/**
+ * @private
+ */
+export default function resource(action: Action<unknown>): Action<unknown>;

package/dist/types/packages/router/route/action/enhancers/track-perf.d.ts

@@ -0,0 +1,5 @@
+import type { Action } from '../interfaces';
+/**
+ * @private
+ */
+export default function trackPerf<T, U extends Action<T>>(action: U): Action<T>;

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

@@ -0,0 +1,9 @@
+import type Controller from '../../../controller';
+import type { Action } from './interfaces';
+/**
+ * @private
+ */
+export declare function createAction(type: string, action: Action<unknown>, controller: Controller): Array<Action<unknown>>;
+export { FINAL_HANDLER } from './constants';
+export { default as createPageLinks } from './utils/create-page-links';
+export type { Action } from './interfaces';

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

@@ -0,0 +1,2 @@
+import type { Request, Response } from '../../../server';
+export type Action<T> = (req: Request, res: Response, data?: unknown) => Promise<T>;

package/dist/types/packages/router/route/action/utils/create-page-links.d.ts

@@ -0,0 +1,12 @@
+import type { Request$params } from '../../../../server';
+import type { JSONAPI$DocumentLinks } from '../../../../jsonapi';
+/**
+ * @private
+ */
+export default function createPageLinks(opts: {
+    total: number;
+    params: Request$params;
+    domain: string;
+    pathname: string;
+    defaultPerPage: number;
+}): JSONAPI$DocumentLinks;

package/dist/types/packages/router/route/action/utils/get-action-name.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from '../../../../server';
+/**
+ * @private
+ */
+export default function getActionName({ route: { action } }: Request): string;

package/dist/types/packages/router/route/action/utils/get-controller-name.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from '../../../../server';
+/**
+ * @private
+ */
+export default function getControllerName({ route: { controller: { constructor: { name } } } }: Request): string;

package/dist/types/packages/router/route/constants.d.ts

@@ -0,0 +1 @@
+export declare const DYNAMIC_PATTERN: RegExp;

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

@@ -0,0 +1,28 @@
+import { FreezeableSet } from '../../freezeable';
+import type Controller from '../../controller';
+import type { Request, Response, Request$method } from '../../server';
+import type { Action } from './action';
+import type { ParameterGroup } from './params';
+import type { Route$opts } from './interfaces';
+/**
+ * @private
+ */
+declare class Route extends FreezeableSet<Action<unknown>> {
+    type: string;
+    path: string;
+    action: string;
+    params: ParameterGroup;
+    method: Request$method;
+    controller: Controller;
+    staticPath: string;
+    defaultParams: Record<string, unknown>;
+    dynamicSegments: Array<string>;
+    constructor({ type, path, action, method, controller }: Route$opts);
+    parseParams(params: Array<string>): Record<string, number>;
+    execHandlers(req: Request, res: Response): Promise<unknown>;
+    visit(req: Request, res: Response): Promise<unknown>;
+}
+export default Route;
+export { DYNAMIC_PATTERN } from './constants';
+export type { Action } from './action';
+export type { Route$opts, Route$type } from './interfaces';

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

@@ -0,0 +1,10 @@
+import type Controller from '../../controller';
+import type { Request$method } from '../../server';
+export type Route$type = 'custom' | 'member' | 'collection';
+export type Route$opts = {
+    type: Route$type;
+    path: string;
+    action: string;
+    method: Request$method;
+    controller: Controller;
+};

package/dist/types/packages/router/route/params/errors/index.d.ts

@@ -0,0 +1,5 @@
+export { default as ParameterTypeError } from './parameter-type-error';
+export { default as ParameterValueError } from './parameter-value-error';
+export { default as InvalidParameterError } from './invalid-parameter-error';
+export { default as ResourceMismatchError } from './resource-mismatch-error';
+export { default as ParameterRequiredError } from './parameter-required-error';

package/dist/types/packages/router/route/params/errors/invalid-parameter-error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @private
+ */
+declare class InvalidParameterError extends TypeError {
+    constructor(path: string);
+}
+declare const _default: new (...args: Array<any>) => InvalidParameterError & import("../../../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/router/route/params/errors/parameter-not-nullable-error.d.ts

@@ -0,0 +1,9 @@
+import type { ParameterLike } from '../index';
+/**
+ * @private
+ */
+declare class ParameterNotNullableError extends TypeError {
+    constructor({ path }: ParameterLike);
+}
+declare const _default: new (...args: Array<any>) => ParameterNotNullableError & import("../../../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/router/route/params/errors/parameter-required-error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @private
+ */
+declare class ParameterRequiredError extends TypeError {
+    constructor(path: string);
+}
+declare const _default: new (...args: Array<any>) => ParameterRequiredError & import("../../../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/router/route/params/errors/parameter-type-error.d.ts

@@ -0,0 +1,9 @@
+import type { ParameterLike } from '../index';
+/**
+ * @private
+ */
+declare class ParameterTypeError extends TypeError {
+    constructor(param: ParameterLike, actual: string);
+}
+declare const _default: new (...args: Array<any>) => ParameterTypeError & import("../../../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/router/route/params/errors/parameter-value-error.d.ts

@@ -0,0 +1,9 @@
+import type { ParameterLike } from '../index';
+/**
+ * @private
+ */
+declare class ParameterValueError extends TypeError {
+    constructor(param: ParameterLike, actual: unknown);
+}
+declare const _default: new (...args: Array<any>) => ParameterValueError & import("../../../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/router/route/params/errors/resource-mismatch-error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @private
+ */
+declare class ResourceMismatchError extends TypeError {
+    constructor(path: string, expected: unknown, actual: unknown);
+}
+declare const _default: new (...args: Array<any>) => ResourceMismatchError & import("../../../../server/interfaces").Server$Error;
+export default _default;

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

@@ -0,0 +1,18 @@
+import type Controller from '../../../controller';
+import ParameterGroup from './parameter-group';
+import type { Params$opts } from './interfaces';
+/**
+ * @private
+ */
+export declare function paramsFor({ type, method, controller, dynamicSegments }: Params$opts): ParameterGroup;
+/**
+ * @private
+ */
+export declare function defaultParamsFor({ type, controller }: {
+    type: string;
+    controller: Controller;
+}): Record<string, unknown>;
+export { default as validateResourceId } from './utils/validate-resource-id';
+export type { ParameterLike, ParameterLike$opts } from './interfaces';
+export type { default as Parameter } from './parameter';
+export type { default as ParameterGroup } from './parameter-group';

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

@@ -0,0 +1,25 @@
+import type Controller from '../../../controller';
+import type { Route$type } from '../index';
+import type { Request$method } from '../../../server';
+import type { Lumen$Collection } from '../../../../interfaces';
+export type Params$opts = {
+    type: Route$type;
+    method: Request$method;
+    controller: Controller;
+    dynamicSegments: Array<string>;
+};
+export type ParameterLike$opts = {
+    path: string;
+    type?: string;
+    values?: Array<unknown>;
+    required?: boolean;
+    sanitize?: boolean;
+};
+export interface ParameterLike extends Lumen$Collection<unknown> {
+    path: string;
+    type: string;
+    required: boolean;
+    sanitize: boolean;
+    values(): IterableIterator<unknown>;
+    validate<V>(value: V): V;
+}

package/dist/types/packages/router/route/params/parameter/index.d.ts

@@ -0,0 +1,14 @@
+import { FreezeableSet } from '../../../../freezeable';
+import type { Parameter$opts } from './interfaces';
+/**
+ * @private
+ */
+declare class Parameter extends FreezeableSet<unknown> {
+    path: string;
+    type: string;
+    required: boolean;
+    sanitize: boolean;
+    constructor({ path, type, values, required, sanitize }: Parameter$opts);
+    validate<V>(value: V): V;
+}
+export default Parameter;

package/dist/types/packages/router/route/params/parameter/interfaces.d.ts

@@ -0,0 +1,4 @@
+import type { ParameterLike$opts } from '../index';
+export type Parameter$opts = ParameterLike$opts & {
+    values?: Array<unknown>;
+};

package/dist/types/packages/router/route/params/parameter/utils/validate-value.d.ts

@@ -0,0 +1,5 @@
+import type Parameter from '../index';
+/**
+ * @private
+ */
+export default function validateValue<V>(param: Parameter, value: V): V;

package/dist/types/packages/router/route/params/parameter-group/index.d.ts

@@ -0,0 +1,14 @@
+import { FreezeableMap } from '../../../../freezeable';
+import type { ParameterLike, ParameterLike$opts } from '../index';
+/**
+ * @private
+ */
+declare class ParameterGroup extends FreezeableMap<string, ParameterLike> {
+    type: string;
+    path: string;
+    required: boolean;
+    sanitize: boolean;
+    constructor(contents: Array<[string, ParameterLike]>, { path, required, sanitize }: ParameterLike$opts);
+    validate<V>(params: V): V;
+}
+export default ParameterGroup;

package/dist/types/packages/router/route/params/parameter-group/utils/has-required-params.d.ts

@@ -0,0 +1,5 @@
+import type ParameterGroup from '../index';
+/**
+ * @private
+ */
+export default function hasRequiredParams(group: ParameterGroup, params: Record<string, unknown>): boolean;

package/dist/types/packages/router/route/params/utils/get-data-params.d.ts

@@ -0,0 +1,6 @@
+import type Controller from '../../../../controller';
+import type { ParameterLike } from '../interfaces';
+/**
+ * @private
+ */
+export default function getDataParams(controller: Controller, method: 'PATCH' | 'POST', includeID: boolean): [string, ParameterLike];

package/dist/types/packages/router/route/params/utils/get-default-collection-params.d.ts

@@ -0,0 +1,6 @@
+import type Controller from '../../../../controller';
+/**
+ * @private
+ */
+declare function getDefaultCollectionParams(controller: Controller): Record<string, unknown>;
+export default getDefaultCollectionParams;

package/dist/types/packages/router/route/params/utils/get-default-member-params.d.ts

@@ -0,0 +1,5 @@
+import type Controller from '../../../../controller';
+/**
+ * @private
+ */
+export default function getDefaultMemberParams({ model, serializer: { hasOne, hasMany, attributes } }: Controller): Record<string, unknown>;

package/dist/types/packages/router/route/params/utils/get-query-params.d.ts

@@ -0,0 +1,14 @@
+import type Controller from '../../../../controller';
+import type { ParameterLike } from '../interfaces';
+/**
+ * @private
+ */
+export declare function getCustomParams({ query }: Controller): Array<[string, ParameterLike]>;
+/**
+ * @private
+ */
+export declare function getMemberQueryParams(controller: Controller): Array<[string, ParameterLike]>;
+/**
+ * @private
+ */
+export declare function getCollectionQueryParams(controller: Controller): Array<[string, ParameterLike]>;

package/dist/types/packages/router/route/params/utils/get-url-params.d.ts

@@ -0,0 +1,5 @@
+import type { ParameterLike } from '../interfaces';
+/**
+ * @private
+ */
+export default function getURLParams(dynamicSegments: Array<string>): Array<[string, ParameterLike]>;

package/dist/types/packages/router/route/params/utils/validate-resource-id.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from '../../../../server';
+/**
+ * @private
+ */
+export default function validateResourceId({ params: { id, data: { id: resourceId } } }: Request): true;

package/dist/types/packages/router/route/params/utils/validate-type.d.ts

@@ -0,0 +1,5 @@
+import type { Parameter, ParameterGroup } from '../index';
+/**
+ * @private
+ */
+export default function validateType(param: Parameter | ParameterGroup, value: unknown): true;

package/dist/types/packages/router/route/utils/get-dynamic-segments.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function getDynamicSegments(path: string): Array<string>;

package/dist/types/packages/router/route/utils/get-static-path.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function getStaticPath(path: string, dynamicSegments: Array<string>): string;

package/dist/types/packages/router/utils/create-replacer.d.ts

@@ -0,0 +1,5 @@
+import type Controller from '../../controller';
+/**
+ * @private
+ */
+export default function createReplacer(controllers: Map<string, Controller>): RegExp;