@adonisjs/http-server 8.0.0-next.0 → 8.0.0-next.10

package/build/src/types/route.d.ts

@@ -1,67 +1,93 @@
 import type Middleware from '@poppinss/middleware';
 import type { ContainerResolver } from '@adonisjs/fold';
 import type { Constructor, LazyImport } from '@poppinss/utils/types';
-import type { ServerErrorHandler } from './server.js';
-import type { HttpContext } from '../http_context/main.js';
-import { type RouteMatcher, type MatchItRouteToken } from '../client/types.ts';
-import type { MiddlewareFn, ParsedGlobalMiddleware } from './middleware.js';
+import type { ServerErrorHandler } from './server.ts';
+import type { HttpContext } from '../http_context/main.ts';
+import type { MiddlewareFn, ParsedGlobalMiddleware } from './middleware.ts';
+import { type ClientRouteJSON, type ClientRouteMatchItTokens } from '../client/types.ts';
 /**
- * Returns a union of methods from a controller that accepts
- * the context as the first argument.
+ * Configuration for matching and casting route parameters
+ */
+export type RouteMatcher = {
+    /** Regular expression to match parameter values */
+    match?: RegExp;
+    /** Function to cast string parameter values to specific types */
+    cast?: (value: string) => any;
+};
+/**
+ * Route token structure used internally by the matchit routing library
+ */
+export type MatchItRouteToken = RouteMatcher & ClientRouteMatchItTokens;
+/**
+ * Extracts method names from a controller class that accept HttpContext as first parameter
  */
 export type GetControllerHandlers<Controller extends Constructor<any>> = {
     [K in keyof InstanceType<Controller>]: InstanceType<Controller>[K] extends (ctx: HttpContext, ...args: any[]) => any ? K : never;
 }[keyof InstanceType<Controller>];
 /**
- * Route handler defined as a function
+ * Route handler implemented as a function that accepts HTTP context
  */
 export type RouteFn = (ctx: HttpContext) => any;
 /**
- * Route handler persisted with the route store
+ * Route handler representation stored in the route registry
  */
 export type StoreRouteHandler = RouteFn | {
+    /** Optional name for the handler */
+    name?: string;
+    /** Method name on the controller */
+    method: string;
+    /** Dynamic import expression for lazy loading */
+    importExpression: string | null;
+    /** Reference to controller class or method */
     reference: string | [LazyImport<Constructor<any>> | Constructor<any>, any?];
+    /** Handler execution function */
     handle: (resolver: ContainerResolver<any>, ...args: [ctx: HttpContext, ...injections: any[]]) => any;
 };
 /**
- * The middleware persisted with the route store
+ * Middleware representation stored with route information
  */
 export type StoreRouteMiddleware = MiddlewareFn | ({
     name?: string;
     args?: any[];
 } & ParsedGlobalMiddleware);
 /**
- * An object of routes for a given HTTP method
+ * Route storage structure for a specific HTTP method containing tokens and route mappings
  */
 export type StoreMethodNode = {
+    /** Array of route tokens for pattern matching */
     tokens: MatchItRouteToken[][];
+    /** Mapping from route patterns to unique route keys */
     routeKeys: {
         [pattern: string]: string;
     };
+    /** Mapping from route patterns to route definitions */
     routes: {
         [pattern: string]: RouteJSON;
     };
 };
 /**
- * Each domain node container an object of methods. Each method
- * object has nested routes.
+ * Domain-specific route storage containing method-based route organization
  */
 export type StoreDomainNode = {
+    /** HTTP method to method node mapping */
     [method: string]: StoreMethodNode;
 };
 /**
- * Routes tree stored within the routes store
+ * Complete route tree structure organizing routes by domains and methods
  */
 export type StoreRoutesTree = {
+    /** Global route tokens for pattern matching */
     tokens: MatchItRouteToken[][];
+    /** Domain-based route organization */
     domains: {
         [domain: string]: StoreDomainNode;
     };
 };
 /**
- * Shape of the matched route for a pattern, method and domain.
+ * Result of successful route matching containing route details and extracted parameters
  */
 export type MatchedRoute = {
+    /** The matched route definition */
     route: RouteJSON;
     /**
      * A unique key for the looked up route
@@ -77,28 +103,21 @@ export type MatchedRoute = {
     subdomains: Record<string, any>;
 };
 /**
- * A collection of route matchers
+ * Collection of parameter matchers indexed by parameter name
  */
 export type RouteMatchers = {
+    /** Parameter name to matcher mapping */
     [param: string]: RouteMatcher;
 };
 /**
- * Representation of a route as JSON
+ * Complete route definition with all metadata, handlers, and execution context
  */
-export type RouteJSON = {
+export type RouteJSON = Pick<ClientRouteJSON, 'name' | 'methods' | 'domain' | 'pattern'> & {
     /**
      * The execute function to execute the route middleware
      * and the handler
      */
     execute: (route: RouteJSON, resolver: ContainerResolver<any>, ctx: HttpContext, errorResponder: ServerErrorHandler['handle']) => any;
-    /**
-     * A unique name for the route
-     */
-    name?: string;
-    /**
-     * Route URI pattern
-     */
-    pattern: string;
     /**
      * Route handler
      */
@@ -115,51 +134,34 @@ export type RouteJSON = {
      * Tokens to be used to construct the route URL
      */
     tokens: MatchItRouteToken[];
-    /**
-     * HTTP methods, the route responds to.
-     */
-    methods: string[];
-    /**
-     * The domain for which the route is registered.
-     */
-    domain: string;
     /**
      * Matchers for route params.
      */
     matchers: RouteMatchers;
 };
 /**
- * Resource action names
+ * Standard RESTful resource action names for CRUD operations
  */
 export type ResourceActionNames = 'create' | 'index' | 'store' | 'show' | 'edit' | 'update' | 'destroy';
 /**
- * Options accepted by makeUrl method
- * @deprecated
+ * @deprecated Options for URL generation (use URLBuilder instead)
  */
 export type MakeUrlOptions = {
+    /** Query string parameters to append */
     qs?: Record<string, any>;
+    /** Domain name to use for the URL */
     domain?: string;
+    /** Prefix to prepend to the generated URL */
     prefixUrl?: string;
+    /** Whether to disable route lookup optimization */
     disableRouteLookup?: boolean;
 };
 /**
- * Options accepted by makeSignedUrl method
- * @deprecated
+ * @deprecated Options for signed URL generation (use URLBuilder instead)
  */
 export type MakeSignedUrlOptions = MakeUrlOptions & {
+    /** Expiration time for the signed URL */
     expiresIn?: string | number;
+    /** Purpose identifier for the signed URL */
     purpose?: string;
 };
-/**
- * To be generated by the router and used by the URL builder
- * and the LookupStore
- */
-export interface RoutesList {
-}
-/**
- * Helper to get routes for a given method from the RoutesList. The
- * RoutesList is extended in the userland code.
- */
-export type GetRoutesForMethod<Method> = {
-    [K in keyof RoutesList]: Method extends K ? RoutesList[Method] : never;
-};

package/build/src/types/server.d.ts

@@ -1,67 +1,82 @@
 import type { Constructor } from '@poppinss/utils/types';
 import type { ErrorHandler, FinalHandler } from '@poppinss/middleware/types';
-import type { QSParserConfig } from './qs.js';
-import type { RequestConfig } from './request.js';
-import type { ResponseConfig } from './response.js';
-import type { HttpContext } from '../http_context/main.js';
+import type { QSParserConfig } from './qs.ts';
+import type { RequestConfig } from './request.ts';
+import type { ResponseConfig } from './response.ts';
+import type { HttpContext } from '../http_context/main.ts';
 /**
- * Normalized HTTP error used by the exception
- * handler.
+ * Normalized HTTP error structure used by exception handlers
  */
 export type HttpError = {
+    /** Error message describing the issue */
     message: string;
+    /** HTTP status code */
     status: number;
+    /** Optional error code identifier */
     code?: string;
+    /** Optional stack trace */
     stack?: string;
+    /** Optional underlying cause of the error */
     cause?: any;
+    /** Optional additional error messages */
     messages?: any;
+    /** Optional validation or field errors */
     errors?: any;
+    /** Optional custom error handler method */
     handle?: (...args: any[]) => any;
+    /** Optional error reporting method */
     report?: (...args: any[]) => any;
 };
 /**
- * The pipeline for executing middleware during tests
+ * Pipeline interface for executing middleware chains during testing
  */
 export interface TestingMiddlewarePipeline {
+    /** Set the final handler for the pipeline */
     finalHandler(handler: FinalHandler): this;
+    /** Set the error handler for the pipeline */
     errorHandler(handler: ErrorHandler): this;
+    /** Execute the middleware pipeline with the given context */
     run(ctx: HttpContext): Promise<any>;
 }
 /**
- * The expression to define a status page range
+ * Expression format for defining HTTP status code ranges for error pages
  */
 export type StatusPageRange = `${number}..${number}` | `${number}` | number;
 /**
- * The callback function to render status page for a given
- * error.
+ * Callback function to render custom status pages for HTTP errors
  */
 export type StatusPageRenderer = (error: HttpError, ctx: HttpContext) => any | Promise<any>;
 /**
- * Data type for the "http:request_completed" event
+ * Payload structure for the http:request_completed event
  */
 export type HttpRequestFinishedPayload = {
+    /** HTTP context for the completed request */
     ctx: HttpContext;
+    /** Request duration as a high-resolution time tuple */
     duration: [number, number];
 };
 /**
- * Events emitted by the HttpServer
+ * Event types and payloads emitted by the HTTP server
  */
 export type HttpServerEvents = {
+    /** Event fired when an HTTP request is completed */
     'http:request_completed': HttpRequestFinishedPayload;
 };
 /**
- * Error handler to handle HTTP errors
+ * Interface for handling and reporting HTTP errors in the server
  */
 export type ServerErrorHandler = {
+    /** Method to report errors for logging or monitoring */
     report: (error: any, ctx: HttpContext) => any;
+    /** Method to handle errors and send appropriate responses */
     handle: (error: any, ctx: HttpContext) => any;
 };
 /**
- * Error handler represented as a class
+ * Constructor type for error handler classes that implement ServerErrorHandler
  */
 export type ErrorHandlerAsAClass = Constructor<ServerErrorHandler>;
 /**
- * Config accepted by the HTTP server
+ * Complete configuration options for the HTTP server extending request and response configs
  */
 export type ServerConfig = RequestConfig & ResponseConfig & {
     /**

package/build/src/types/tracing_channels.d.ts

@@ -1,6 +1,24 @@
-import type { RouteJSON } from './route.js';
-import type { HttpContext } from '../http_context/main.js';
-import type { MiddlewareFn, ParsedGlobalMiddleware, ParsedNamedMiddleware } from './middleware.js';
-export type HTTPRequestTracingData = HttpContext;
-export type MiddlewareTracingData = ParsedGlobalMiddleware | ParsedNamedMiddleware | MiddlewareFn;
-export type RouteHandlerTracingData = RouteJSON;
+import type { RouteJSON } from './route.ts';
+import type { HttpContext } from '../http_context/main.ts';
+import type { MiddlewareFn, ParsedGlobalMiddleware, ParsedNamedMiddleware } from './middleware.ts';
+/**
+ * Tracing data structure for HTTP request events
+ */
+export type HTTPRequestTracingData = {
+    /** HTTP context for the traced request */
+    ctx: HttpContext;
+};
+/**
+ * Tracing data structure for middleware execution events
+ */
+export type MiddlewareTracingData = {
+    /** The middleware being traced */
+    middleware: ParsedGlobalMiddleware | ParsedNamedMiddleware | MiddlewareFn;
+};
+/**
+ * Tracing data structure for route handler execution events
+ */
+export type RouteHandlerTracingData = {
+    /** The route being traced */
+    route: RouteJSON;
+};

package/build/src/types/url_builder.d.ts

@@ -0,0 +1,22 @@
+import { type UrlFor, type LookupList, type URLOptions, type LookupListRoute, type RouteBuilderArguments } from '../client/types.ts';
+export { URLOptions, LookupListRoute, RouteBuilderArguments, LookupList, UrlFor };
+/**
+ * Configuration options for signed URL generation helpers
+ */
+export type SignedURLOptions = URLOptions & {
+    /** Expiration time for the signed URL */
+    expiresIn?: string | number;
+    /** Purpose identifier for the signed URL */
+    purpose?: string;
+};
+/**
+ * Utility type to extract routes for a specific HTTP method from the routes collection
+ */
+export type GetRoutesForMethod<Routes, Method> = {
+    [K in keyof Routes]: Method extends K ? Routes[Method] : never;
+}[keyof Routes];
+/**
+ * Interface to be augmented by the router containing all registered routes for type-safe URL generation
+ */
+export interface RoutesList {
+}

package/build/src/utils.d.ts

@@ -1,26 +1,91 @@
-import { type Route } from './router/route.js';
-import { RouteGroup } from './router/group.js';
-import { BriskRoute } from './router/brisk.js';
-import type { RouteJSON } from './types/route.js';
-import { RouteResource } from './router/resource.js';
+import { type Route } from './router/route.ts';
+import { RouteGroup } from './router/group.ts';
+import { BriskRoute } from './router/brisk.ts';
+import type { RouteJSON } from './types/route.ts';
+import { RouteResource } from './router/resource.ts';
 /**
- * Makes input string consistent by having only the starting
- * slash
+ * Makes input string consistent by having only the starting slash.
+ *
+ * Removes trailing slashes and ensures the path starts with a forward slash,
+ * except for the root path '/' which remains unchanged.
+ *
+ * @param input - The input path string to normalize
+ *
+ * @example
+ * ```ts
+ * dropSlash('/users/') // '/users'
+ * dropSlash('users') // '/users'
+ * dropSlash('/') // '/'
+ * ```
  */
 export declare function dropSlash(input: string): string;
 /**
- * Returns a flat list of routes from the route groups and resources
+ * Returns a flat list of routes from route groups, resources, and brisk routes.
+ *
+ * This function recursively processes route collections, extracting individual routes
+ * from groups and resources while filtering out any deleted routes.
+ *
+ * @param routes - Array containing route groups, individual routes, resources, and brisk routes
+ *
+ * @example
+ * ```ts
+ * const flatRoutes = toRoutesJSON([
+ *   routeGroup,
+ *   singleRoute,
+ *   resourceRoutes
+ * ])
+ * ```
  */
 export declare function toRoutesJSON(routes: (RouteGroup | Route | RouteResource | BriskRoute)[]): RouteJSON[];
 /**
- * Helper to know if the remote address should
- * be trusted.
+ * Helper to determine if a remote address should be trusted.
+ *
+ * Uses caching to avoid repeated expensive proxy function calls for the same
+ * remote address. The cache improves performance when the same addresses are
+ * checked multiple times.
+ *
+ * @param remoteAddress - The remote IP address to check
+ * @param proxyFn - Function that determines if an address should be trusted
+ *
+ * @example
+ * ```ts
+ * const isTrusted = trustProxy('192.168.1.1', proxyAddr.compile('loopback'))
+ * ```
  */
 export declare function trustProxy(remoteAddress: string, proxyFn: (addr: string, distance: number) => boolean): boolean;
 /**
- * Parses a range expression to an object filled with the range
+ * Parses a range expression (e.g., '200..299') into an object with numeric keys.
+ *
+ * Supports both single values and ranges. For ranges, all numbers between
+ * the start and end (inclusive) are mapped to the provided value.
+ *
+ * @param range - Range expression as a string (e.g., '200', '200..299')
+ * @param value - Value to assign to each number in the range
+ *
+ * @example
+ * ```ts
+ * parseRange('200', 'success') // { 200: 'success' }
+ * parseRange('200..202', 'success') // { 200: 'success', 201: 'success', 202: 'success' }
+ * ```
  */
 export declare function parseRange<T>(range: string, value: T): Record<number, T>;
+/**
+ * Safely decodes a URI path while handling special characters and query strings.
+ *
+ * This function carefully parses and decodes URI components, handling edge cases
+ * like double-encoded characters and non-standard query string delimiters.
+ * It separates the pathname from query parameters and determines whether
+ * route parameters should be decoded.
+ *
+ * @param path - The URI path to decode
+ * @param useSemicolonDelimiter - Whether to treat semicolons as query string delimiters
+ *
+ * @example
+ * ```ts
+ * const result = safeDecodeURI('/users/123?name=john', false)
+ * // Returns: { pathname: '/users/123', query: 'name=john', shouldDecodeParam: false }
+ * ```
+ */
 export declare function safeDecodeURI(path: string, useSemicolonDelimiter: boolean): {
     pathname: string;
     query: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/http-server",
-  "version": "8.0.0-next.0",
+  "version": "8.0.0-next.10",
   "description": "AdonisJS HTTP server with support packed with Routing and Cookies",
   "main": "build/index.js",
   "type": "module",
@@ -13,10 +13,7 @@
     ".": "./build/index.js",
     "./helpers": "./build/src/helpers.js",
     "./types": "./build/src/types/main.js",
-    "./client": {
-      "import": "./build/client.js",
-      "require": "./build/client.cjs"
-    },
+    "./client/url_builder": "./build/src/client/url_builder.js",
     "./factories": "./build/factories/main.js"
   },
   "engines": {
@@ -28,8 +25,7 @@
     "typecheck": "tsc --noEmit",
     "precompile": "npm run lint",
     "compile": "tsup-node && tsc --emitDeclarationOnly --declaration",
-    "compile:client": "tsup-node --config=bin/build_client.ts",
-    "build": "npm run compile && npm run compile:client",
+    "build": "npm run compile",
     "prebenchmark": "npm run build",
     "benchmark": "node benchmarks/index.js",
     "release": "release-it",
@@ -37,7 +33,8 @@
     "format": "prettier --write .",
     "prepublishOnly": "npm run build",
     "lint": "eslint",
-    "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts"
+    "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts",
+    "docs": "typedoc"
   },
   "keywords": [
     "http",
@@ -46,21 +43,21 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^9.0.0-next.2",
-    "@adonisjs/encryption": "^7.0.0-next.0",
-    "@adonisjs/eslint-config": "^3.0.0-next.0",
-    "@adonisjs/events": "^10.1.0-next.1",
-    "@adonisjs/fold": "^11.0.0-next.0",
-    "@adonisjs/logger": "^7.0.0-next.1",
+    "@adonisjs/application": "^9.0.0-next.4",
+    "@adonisjs/encryption": "^7.0.0-next.1",
+    "@adonisjs/eslint-config": "^3.0.0-next.1",
+    "@adonisjs/events": "^10.1.0-next.2",
+    "@adonisjs/fold": "^11.0.0-next.2",
+    "@adonisjs/logger": "^7.1.0-next.0",
     "@adonisjs/prettier-config": "^1.4.5",
     "@adonisjs/tsconfig": "^2.0.0-next.0",
     "@fastify/middie": "^9.0.3",
     "@japa/assert": "^4.1.1",
     "@japa/expect-type": "^2.0.3",
     "@japa/file-system": "^2.3.2",
-    "@japa/runner": "^4.3.0",
+    "@japa/runner": "^4.4.0",
     "@japa/snapshot": "^2.0.9",
-    "@poppinss/ts-exec": "^1.4.0",
+    "@poppinss/ts-exec": "^1.4.1",
     "@release-it/conventional-changelog": "^10.0.1",
     "@types/accepts": "^1.3.7",
     "@types/content-disposition": "^0.5.9",
@@ -70,7 +67,7 @@
     "@types/fresh": "^0.5.3",
     "@types/fs-extra": "^11.0.4",
     "@types/mime-types": "^3.0.1",
-    "@types/node": "^24.1.0",
+    "@types/node": "^24.7.0",
     "@types/on-finished": "^2.3.5",
     "@types/pem": "^1.14.4",
     "@types/proxy-addr": "^2.0.3",
@@ -81,27 +78,28 @@
     "@vinejs/vine": "^3.0.1",
     "autocannon": "^8.0.0",
     "c8": "^10.1.3",
-    "cross-env": "^10.0.0",
-    "eslint": "^9.32.0",
-    "fastify": "^5.4.0",
-    "fs-extra": "^11.3.0",
+    "cross-env": "^10.1.0",
+    "eslint": "^9.37.0",
+    "fastify": "^5.6.1",
+    "fs-extra": "^11.3.2",
     "get-port": "^7.1.0",
     "http-status-codes": "^2.3.0",
     "pem": "^1.14.8",
     "prettier": "^3.6.2",
     "reflect-metadata": "^0.2.2",
-    "release-it": "^19.0.4",
+    "release-it": "^19.0.5",
     "supertest": "^7.1.4",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.3",
+    "typedoc": "^0.28.13",
+    "typescript": "^5.9.3",
     "youch": "^4.1.0-beta.11"
   },
   "dependencies": {
-    "@poppinss/macroable": "^1.0.5",
+    "@poppinss/macroable": "^1.1.0",
     "@poppinss/matchit": "^3.2.0",
     "@poppinss/middleware": "^3.2.6",
     "@poppinss/utils": "^7.0.0-next.3",
-    "@sindresorhus/is": "^7.0.2",
+    "@sindresorhus/is": "^7.1.0",
     "accepts": "^1.3.8",
     "content-disposition": "^0.5.4",
     "cookie": "^1.0.2",
@@ -118,11 +116,11 @@
     "vary": "^1.1.2"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^9.0.0-next.2",
-    "@adonisjs/encryption": "^7.0.0-next.0",
-    "@adonisjs/events": "^10.1.0-next.1",
-    "@adonisjs/fold": "^11.0.0-next.0",
-    "@adonisjs/logger": "^7.0.0-next.1",
+    "@adonisjs/application": "^9.0.0-next.4",
+    "@adonisjs/encryption": "^7.0.0-next.1",
+    "@adonisjs/events": "^10.1.0-next.2",
+    "@adonisjs/fold": "^11.0.0-next.2",
+    "@adonisjs/logger": "^7.1.0-next.0",
     "youch": "^4.1.0-beta.11"
   },
   "peerDependenciesMeta": {
@@ -184,6 +182,7 @@
       "./index.ts",
       "./src/helpers.ts",
       "./src/types/main.ts",
+      "./src/client/url_builder.ts",
       "./factories/main.ts"
     ],
     "outDir": "./build",

package/build/chunk-ASX56VAK.js

@@ -1,76 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/helpers.ts
-import cookie from "cookie";
-import matchit from "@poppinss/matchit";
-import string from "@poppinss/utils/string";
-import { parseBindingReference } from "@adonisjs/fold";
-import { default as default2 } from "encodeurl";
-import { default as default3 } from "mime-types";
-function parseRoute(pattern, matchers) {
-  const tokens = matchit.parse(pattern, matchers);
-  return tokens;
-}
-function matchRoute(url, patterns) {
-  const tokensBucket = patterns.map((pattern) => parseRoute(pattern));
-  const match = matchit.match(url, tokensBucket);
-  if (!match.length) {
-    return null;
-  }
-  return matchit.exec(url, match);
-}
-function serializeCookie(key, value, options) {
-  let expires;
-  let maxAge;
-  if (options) {
-    expires = typeof options.expires === "function" ? options.expires() : options.expires;
-    maxAge = options.maxAge ? string.seconds.parse(options.maxAge) : void 0;
-  }
-  return cookie.serialize(key, value, { ...options, maxAge, expires });
-}
-async function middlewareInfo(middleware) {
-  if (typeof middleware === "function") {
-    return {
-      type: "closure",
-      name: middleware.name || "closure"
-    };
-  }
-  if ("args" in middleware) {
-    return {
-      type: "named",
-      name: middleware.name,
-      args: middleware.args,
-      ...await parseBindingReference([middleware.reference])
-    };
-  }
-  return {
-    type: "global",
-    name: middleware.name,
-    ...await parseBindingReference([middleware.reference])
-  };
-}
-async function routeInfo(route) {
-  return "reference" in route.handler ? {
-    type: "controller",
-    ...await parseBindingReference(route.handler.reference)
-  } : {
-    type: "closure",
-    name: route.handler.name || "closure",
-    args: "listArgs" in route.handler ? String(route.handler.listArgs) : void 0
-  };
-}
-
-export {
-  __export,
-  parseRoute,
-  matchRoute,
-  serializeCookie,
-  middlewareInfo,
-  routeInfo,
-  default2 as default,
-  default3 as default2
-};