@openstax/ts-utils 1.0.0

package/dist/fetch.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateHasError = exports.stateHasData = exports.fetchSuccess = exports.fetchError = exports.fetchLoading = exports.FetchStateType = void 0;
+/*
+ * these are just helpers for formatting responses, they don't actually do any loading. especially in UI development they
+ * help with continuity over loading, reloading, saving, and errors. this is pretty nice in typescript because you have to deal
+ * with the possibility that the result state is in a loading or error state. if you avoid dealing with those states you need
+ * to write very clear code to ignore them, which easily presents missing functionality like errors that are not being messaged
+ * to the user.
+ * */
+var FetchStateType;
+(function (FetchStateType) {
+    FetchStateType["SUCCESS"] = "success";
+    FetchStateType["ERROR"] = "error";
+    FetchStateType["LOADING"] = "loading";
+})(FetchStateType = exports.FetchStateType || (exports.FetchStateType = {}));
+/*
+ * keeps existing data but sets the new status
+ *
+ * const state = fetchLoading(previousState)
+ * */
+const fetchLoading = (previous) => ({ type: FetchStateType.LOADING, ...(previous && 'data' in previous ? { data: previous.data } : {}) });
+exports.fetchLoading = fetchLoading;
+/*
+ * keeps existing data but sets the new status and error value
+ *
+ * const state = fetchError(error, previousState)
+ * */
+const fetchError = (error, previous) => ({ ...previous, type: FetchStateType.ERROR, error });
+exports.fetchError = fetchError;
+/*
+ * formats data with success type
+ *
+ * const state = fetchSuccess(newData)
+ * */
+const fetchSuccess = (data) => ({ type: FetchStateType.SUCCESS, data });
+exports.fetchSuccess = fetchSuccess;
+/*
+ * guard for checking if the state has result data, it might be true for any state type.
+ * */
+const stateHasData = (state) => 'data' in state;
+exports.stateHasData = stateHasData;
+/*
+ * guard for checking if the state has an error, it might be true for error or loading states.
+ * */
+const stateHasError = (state) => 'error' in state;
+exports.stateHasError = stateHasError;

package/dist/guards.d.ts

@@ -0,0 +1,5 @@
+export declare const isDefined: <X>(x: X) => x is Exclude<X, undefined>;
+export declare const isPlainObject: (thing: any) => thing is {
+    [key: string]: any;
+};
+export declare const ifDefined: <X, D>(x: X, d: D) => D | Exclude<X, undefined>;

package/dist/guards.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ifDefined = exports.isPlainObject = exports.isDefined = void 0;
+/*
+ * checks if a thing is defined. this is often easy to do with a simple if statement, but in certain
+ * situations the guard is required and its nice to have one pre-defined.
+ *
+ * eg this filters the array but doesn't fix the array type:
+ *   const result = (array as Array<string | undefined>).filter(thing => !!thing);
+ *
+ * eg this does the right thing:
+ *   const result = (array as Array<string | undefined>).filter(isDefined);
+ *
+ * eg because writing this is annoying:
+ *   const result = (array as Array<string | undefined>).filter(<X>(x: X): x is Exclude<X, undefined> => x !== undefined);
+ */
+const isDefined = (x) => x !== undefined;
+exports.isDefined = isDefined;
+/*
+ * a guard for plain old javascript objects that are not based on some other prototype,
+ * for example making them safe to JSON stringify and stuff
+ * */
+const isPlainObject = (thing) => thing instanceof Object && thing.__proto__.constructor.name === 'Object';
+exports.isPlainObject = isPlainObject;
+/*
+ * this isn't really a guard its just a way to provide a default value without creating a coverage branch.
+ *
+ * if the first thing is defined it uses it, otherwise it returns the second thing.
+ *
+ * eg:
+ *   const valueWithDefault = ifDefined(thing, 'default value')
+ */
+const ifDefined = (x, d) => (0, exports.isDefined)(x) ? x : d;
+exports.ifDefined = ifDefined;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { UnionToIntersection } from './types';
+export declare const getKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O) => O[K];
+export declare const getKeyValueOr: <K extends string, V>(key: K, defaultValue: V) => <O extends { [key in K]?: any; }>(obj: O) => V | NonNullable<O[K]>;
+export declare const putKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O, value: O[K]) => O;
+export declare const fnIf: <T1, T2>(condition: boolean, trueValue: T1, falseValue: T2) => T1 | T2;
+export declare const mapFind: <I, R>(array: I[], mapper: (item: I) => R, predicate?: (result: R) => boolean) => R | undefined;
+declare type HashValue = string | number | boolean | null | HashCompoundValue;
+declare type HashCompoundValue = Array<HashValue> | {
+    [key: string]: HashValue;
+};
+export declare const hashValue: (value: HashValue) => string;
+export declare const once: <F extends (...args: any[]) => any>(fn: F) => F;
+export declare const getCommonProperties: <T1 extends {}, T2 extends {}>(thing1: T1, thing2: T2) => (keyof T1 & keyof T2)[];
+export declare const merge: <T extends {}[]>(...[thing1, ...tail]: T) => UnionToIntersection<T[number]>;
+export declare const tuple: <A extends any[]>(...args: A) => A;
+export {};

package/dist/index.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tuple = exports.merge = exports.getCommonProperties = exports.once = exports.hashValue = exports.mapFind = exports.fnIf = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
+const crypto_1 = require("crypto");
+const guards_1 = require("./guards");
+/*
+ * there was a reason i made these instead of using lodash/fp but i forget what it was. i think maybe
+ * these do more validation that the second function gets a compatible object.
+ *
+ * const getAuthor = getKeyValue('author');
+ * const author = getAuthor(book);
+ *
+ * const getAuthorOrNope = getKeyValueOr('author', 'nope');
+ * const authorOrNope = getAuthorOrNope(book);
+ *
+ * const putAuthor = putKeyValue('author');
+ * const newBook = putAuthor(book, 'tom');
+ * */
+const getKeyValue = (key) => (obj) => obj[key];
+exports.getKeyValue = getKeyValue;
+const getKeyValueOr = (key, defaultValue) => (obj) => obj[key] || defaultValue;
+exports.getKeyValueOr = getKeyValueOr;
+const putKeyValue = (key) => (obj, value) => ({ ...obj, [key]: value });
+exports.putKeyValue = putKeyValue;
+/*
+ * a shameful helper to avoid needing to test code coverage of branches
+ */
+const fnIf = (condition, trueValue, falseValue) => condition ? trueValue : falseValue;
+exports.fnIf = fnIf;
+/*
+ * maps the array and returns the first result that matches the predicate
+ * avoids processing extra elements that would happen with .map().find() or .reduce
+ *
+ * eg the third element of the array is never processed:
+ *   const result = mapFind([1,2,3], x => 'hello'.charAt(x), x => x === 'l');
+ */
+const mapFind = (array, mapper, predicate = (r) => !!r) => {
+    for (const item of array) {
+        const mapped = mapper(item);
+        if (predicate(mapped)) {
+            return mapped;
+        }
+    }
+};
+exports.mapFind = mapFind;
+/*
+ * creates a string hash of lots of different kinds of things.
+ *
+ * eg:
+ *   hashValue({someKey: 'someValue'})
+ * */
+const hashValue = (value) => {
+    const strValue = JSON.stringify(value);
+    return (0, crypto_1.createHash)('sha1').update(strValue).digest('hex');
+};
+exports.hashValue = hashValue;
+/*
+ * returns a function that will only ever call the given function once, returning the first result for every subsequent call
+ *
+ * eg:
+ *   const heavyFunction = () => 'hello';
+ *   const butOnlyOnce = once(() => 'hello');
+ *
+ *   heavyFunction() // returns `hello`;
+ *   butOnlyOnce() // returns `hello`;
+ */
+const once = (fn) => {
+    let result;
+    return ((...args) => result || (result = fn(...args)));
+};
+exports.once = once;
+const getCommonProperties = (thing1, thing2) => Object.keys(thing1).filter((key) => Object.keys(thing2).includes(key));
+exports.getCommonProperties = getCommonProperties;
+/*
+ * recursive merge properties of inputs. values are merged if they are
+ * plain objects or arrays, otherwise if the same property exists in both
+ * objects the value from the second argument will win.
+ *
+ * unlike lodash merge, this will not change object references for values that
+ * exist only in one parameter.
+ *
+ * eg:
+ *   merge({thing: 'one'}, {thing: 'two', otherKey: 'one'}, {coolKey: 'coolValue'});
+ */
+const merge = (...[thing1, ...tail]) => {
+    const mergedTail = tail.length > 0
+        ? (0, exports.merge)(...tail)
+        : null;
+    if (!mergedTail) {
+        return thing1;
+    }
+    return {
+        ...thing1,
+        ...mergedTail,
+        ...(0, exports.getCommonProperties)(thing1, mergedTail).reduce((result, property) => ({
+            ...result,
+            ...((0, guards_1.isPlainObject)(thing1[property]) && (0, guards_1.isPlainObject)(mergedTail[property])
+                ? { [property]: (0, exports.merge)(thing1[property], mergedTail[property]) }
+                : (Array.isArray(thing1[property]) && Array.isArray(mergedTail[property]))
+                    ? { [property]: [...thing1[property], ...mergedTail[property]] }
+                    : {}),
+        }), {}),
+    };
+};
+exports.merge = merge;
+/*
+ * a silly utility to help typescript realize an array is a tuple
+ *
+ * eg:
+ *  const a = [5, 'string'] // type is `Array<string | number>`
+ *  const t = tuple(5, 'string') type is `[5, 'string']`
+ *
+ * both have the same javascript value, but one is forced to be a tuple, which
+ * is nice if its structure is important. examples are like the React.useState
+ * pattern where there are two return values in a tuple, or if you're feeding
+ * Object.fromEntries
+ *
+ */
+const tuple = (...args) => args;
+exports.tuple = tuple;

package/dist/middleware.d.ts

@@ -0,0 +1,9 @@
+import { TupleExtends } from './types';
+export declare type MiddlewareProvider<Sa, M, A extends any[], R> = (app: Sa) => (middleware: M, ...args: A) => R;
+export declare type MiddlewareTransformProvider<Sa, M, A extends any[], R> = (app: Sa) => (middleware: M, ...args: A) => Omit<M, keyof R> & R;
+export declare type MiddlewareInput<S> = S extends MiddlewareProvider<any, infer M, any, any> ? M : never;
+export declare type ServiceMiddlewareProviderResult<M, S> = [M] extends [never] ? never : [M] extends [MiddlewareInput<S>] ? S extends MiddlewareTransformProvider<any, M, any, infer R> ? R extends M ? R : Omit<M, keyof R> & R : S extends MiddlewareProvider<any, M, any, infer R> ? R : never : never;
+export declare type ServiceMiddlewareProviderArgs<S> = S extends MiddlewareProvider<any, any, infer A, any> ? A : never;
+export declare type ServiceMiddlewareProviderChainResult<C, M> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderResult<M, S1> : ServiceMiddlewareProviderChainResult<S, ServiceMiddlewareProviderResult<M, S1>> : C extends unknown ? M : never;
+export declare type ServiceMiddlewareProviderChainArgs<C> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderArgs<S1> : TupleExtends<ServiceMiddlewareProviderChainArgs<S>, ServiceMiddlewareProviderArgs<S1>> extends 'yes' ? ServiceMiddlewareProviderChainArgs<S> : TupleExtends<ServiceMiddlewareProviderArgs<S1>, ServiceMiddlewareProviderChainArgs<S>> extends 'yes' ? ServiceMiddlewareProviderArgs<S1> : never : C extends unknown ? [] : never;
+export declare const makeComposeMiddleware: <Sa, M>() => <C extends any[]>(...chain: C) => MiddlewareProvider<Sa, M, ServiceMiddlewareProviderChainArgs<C>, ServiceMiddlewareProviderChainResult<C, M>>;

package/dist/middleware.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeComposeMiddleware = void 0;
+/*
+ * this function creates a middleware composer for the given AppServices and starting value. the ending
+ * value will depend on the composed values. after composing the values, the composer returns a function that
+ * expects the given input value and returns the result of the last element of the middleware chain.
+ *
+ * eg:
+ *   export const composeServiceMiddleware = makeComposeMiddleware<AppServices, {request: ApiRouteRequest}>();
+ *   export const composeResponseMiddleware = makeComposeMiddleware<AppServices, Promise<ApiRouteResponse> | undefined>();
+ *
+ * eg:
+ *   // `requestServiceProvider` is a function that expects `{request: ApiRouteResponse}` (specified in the call to `makeComposeMiddleware`)
+ *   // for requestServiceProviders as part of routes in particular, the request responder calls this when it resolves the routes.
+ *   const requestServiceProvider = composeServiceMiddleware(
+ *     cookieAuthMiddleware, // this one just depends on `request`, which is in the input, and returns that plus the authProvider
+ *     myDocumentStoreMiddleware, // this one expects the authProvider, and adds the document store
+ *     myDocumentSearchMiddleware, // this one expects the document store, and adds the search provider
+ *   ); // if you try to specify them in the wrong order it'll yell at you
+ *
+ * WARNING: depending on how you use it, typescript _sometimes_ explodes on these recursive types. if you have problems in your build
+ * with memory, you will have to specify the expected result type when calling the middleware reducer. this is a little annoying,
+ * but it will still correctly error if the type you specify is wrong, so you've still got the type safety.
+ *
+ * // this might work, or it might make your compiler run out of memory
+ * eg: const myThing = makeComposeMiddleware()(...);
+ *
+ * // this helps typescript figure out what is going on
+ * eg: const myThing: myType = makeComposeMiddleware()(...);
+ * */
+const makeComposeMiddleware = () => (...chain) => (app) => {
+    const boundChain = chain.map(provider => provider(app));
+    return (middleware, ...args) => {
+        return boundChain.reduce((result, provider) => provider(result, ...args), middleware);
+    };
+};
+exports.makeComposeMiddleware = makeComposeMiddleware;

package/dist/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@openstax/ts-utils",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./": "./dist/"
+  },
+  "files": [
+    "dist"
+  ],
+  "typesVersions": {
+    "*": {
+      "*": [
+        "dist/*",
+        "dist/*.d.ts",
+        "dist/*/index.d.ts"
+      ]
+    }
+  },
+  "license": "MIT",
+  "scripts": {
+    "coverage-report": "open coverage/index.html",
+    "test": "yarn jest",
+    "ci:test": "yarn jest --coverage",
+    "ci:typecheck": "tsc --noEmit",
+    "ci:spelling": "git ls-files | yarn cspell -c ../../cspell.json --file-list stdin",
+    "ci:lint": "eslint --max-warnings=0 .",
+    "ci": "CI=true npm-run-all ci:*"
+  },
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.171.0",
+    "@aws-sdk/client-ssm": "^3.171.0",
+    "@aws-sdk/client-sts": "^3.171.0",
+    "aws-sdk": "^2.1145.0",
+    "cookie": "^0.5.0",
+    "date-fns": "^2.29.2",
+    "jose": "^4.9.3",
+    "path-to-regexp": "^6.2.0",
+    "query-string": "^7.1.1",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/cookie": "^0.5.0",
+    "@types/jest": "^27.4.1",
+    "@types/node": "^17.0.35",
+    "@types/node-fetch": "2.6.1",
+    "@types/uuid": "^8.3.4",
+    "@typescript-eslint/eslint-plugin": "^5.13.0",
+    "@typescript-eslint/parser": "^5.13.0",
+    "cspell": "^5.18.5",
+    "eslint": "^8.10.0",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-jest": "^26.1.1",
+    "jest": "^29.1.1",
+    "node-fetch": "2.6.7",
+    "npm-run-all": "^4.1.5",
+    "rollup-plugin-commonjs": "^10.1.0",
+    "rollup-plugin-typescript2": "^0.31.2",
+    "ts-jest": "^29.0.3",
+    "typescript": "v4.6",
+    "yargs": "^17.5.1"
+  }
+}

package/dist/pagination.d.ts

@@ -0,0 +1,65 @@
+import { QueryParams, RouteMatchRecord } from './routing';
+export declare type PaginationHandler<Pa> = <R>(queryParams: QueryParams, match: RouteMatchRecord<R>) => Pa & {
+    getUnusedQueryParams: () => QueryParams;
+};
+export declare const createPaginationMiddleware: <Ri, R = any>() => <Pa>({ getQueryParams, setUnusedQueryParams, paginator }: {
+    getQueryParams: (request: Ri) => QueryParams;
+    setUnusedQueryParams: (request: Ri, query: QueryParams) => Ri;
+    paginator: PaginationHandler<Pa>;
+}) => <M extends {
+    request: Ri;
+}>() => (middleware: M, match: RouteMatchRecord<R>) => M & {
+    pagination: Pa & {
+        getUnusedQueryParams: () => QueryParams;
+    };
+};
+export declare const loadMorePagination: <R>(queryParams: Record<string, string | undefined>, { route, params }: RouteMatchRecord<R>) => {
+    getUnusedQueryParams: () => {
+        [x: string]: string | undefined;
+    };
+    getPageTokenString: () => string | undefined;
+    getPageTokenNumber: () => number | undefined;
+    getPaginationResponse: <T>({ items, ...meta }: LoadMorePaginationResultInput<T>) => {
+        items: T[];
+        meta: {
+            nextPageToken: string | number | undefined;
+        };
+        links: {
+            nextPage: string | undefined;
+        };
+    };
+};
+export interface LoadMorePaginationResultInput<T> {
+    items: T[];
+    nextPageToken: string | number | undefined;
+}
+export declare const pageNumberPagination: <R>(queryParams: Record<string, string | undefined>, { route, params }: RouteMatchRecord<R>) => {
+    getUnusedQueryParams: () => {
+        [x: string]: string | undefined;
+    };
+    getPaginationParams: () => {
+        page: number | undefined;
+    };
+    getPaginationResponse: <T>({ items, ...meta }: PageNumberPaginationResultInput<T>) => {
+        items: T[];
+        meta: {
+            pageSize: number;
+            currentPage: number;
+            totalItems: number;
+            totalPages: number;
+        };
+        links: {
+            firstPage: string;
+            lastPage: string;
+            nextPage: string | undefined;
+            prevPage: string | undefined;
+        };
+    };
+};
+export interface PageNumberPaginationResultInput<T> {
+    items: T[];
+    pageSize: number;
+    currentPage: number;
+    totalItems: number;
+    totalPages: number;
+}

package/dist/pagination.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pageNumberPagination = exports.loadMorePagination = exports.createPaginationMiddleware = void 0;
+const assertions_1 = require("./assertions");
+const errors_1 = require("./errors");
+const routing_1 = require("./routing");
+/*
+ * helper to create middleware with the given paginator. aside from taking care of annoying to write pagination logic, these helpers also make
+ * sure that all item list responses have the same formatting.
+ *
+ * eg:
+ *   const getQueryParams = getKeyValueOr('queryStringParameters', {} as QueryParams);
+ *   const setUnusedQueryParams = putKeyValue('queryStringParameters');
+ *
+ *   export const loadMorePaginationMiddleware = createPaginationMiddleware<ApiRouteRequest>()({getQueryParams, setUnusedQueryParams, paginator: loadMorePagination});
+ *   export const pageNumberPaginationMiddleware = createPaginationMiddleware<ApiRouteRequest>()({getQueryParams, setUnusedQueryParams, paginator: pageNumberPagination});
+ *
+ * eg the pagination middleware then provides your necessary inputs (getPageToken... in this case) and formats the response:
+ *  const result = await services.myDocumentStore.getVersions(key, services.pagination.getPageTokenNumber());
+ *
+ *  if (!result) {
+ *    throw new NotFoundError('requested item not found');
+ *  }
+ *
+ *  return apiJsonResponse(200, services.pagination.getPaginationResponse(result));
+ */
+const createPaginationMiddleware = () => ({ getQueryParams, setUnusedQueryParams, paginator }) => () => (middleware, match) => {
+    const queryParams = getQueryParams(middleware.request);
+    const pagination = paginator(queryParams, match);
+    // remove pagination params from downstream logic
+    middleware.request = setUnusedQueryParams(middleware.request, pagination.getUnusedQueryParams());
+    return { ...middleware, pagination };
+};
+exports.createPaginationMiddleware = createPaginationMiddleware;
+const loadMorePagination = (queryParams, { route, params }) => {
+    const { pageToken, ...otherParams } = queryParams;
+    return {
+        getUnusedQueryParams: () => otherParams,
+        getPageTokenString: () => pageToken,
+        getPageTokenNumber: () => pageToken
+            ? (0, assertions_1.notNaN)(parseInt(pageToken, 10), () => { throw new errors_1.InvalidRequestError(); })
+            : undefined,
+        getPaginationResponse: ({ items, ...meta }) => {
+            return {
+                items,
+                meta,
+                links: {
+                    nextPage: meta.nextPageToken
+                        ? (0, routing_1.renderAnyRouteUrl)(route, params, { ...queryParams, pageToken: meta.nextPageToken.toString() })
+                        : undefined,
+                }
+            };
+        },
+    };
+};
+exports.loadMorePagination = loadMorePagination;
+const pageNumberPagination = (queryParams, { route, params }) => {
+    const { page, ...otherParams } = queryParams;
+    const numberPage = page
+        ? (0, assertions_1.notNaN)(parseInt(page, 10), () => { throw new errors_1.InvalidRequestError(); })
+        : undefined;
+    return {
+        getUnusedQueryParams: () => otherParams,
+        getPaginationParams: () => ({ page: numberPage }),
+        getPaginationResponse: ({ items, ...meta }) => {
+            return {
+                items,
+                meta,
+                links: {
+                    firstPage: (0, routing_1.renderAnyRouteUrl)(route, params, { ...queryParams, page: '1' }),
+                    lastPage: (0, routing_1.renderAnyRouteUrl)(route, params, { ...queryParams, page: meta.totalPages.toString() }),
+                    nextPage: meta.currentPage < meta.totalPages
+                        ? (0, routing_1.renderAnyRouteUrl)(route, params, { ...queryParams, page: (meta.currentPage + 1).toString() })
+                        : undefined,
+                    prevPage: meta.currentPage > 1
+                        ? (0, routing_1.renderAnyRouteUrl)(route, params, { ...queryParams, page: (meta.currentPage - 1).toString() })
+                        : undefined
+                }
+            };
+        },
+    };
+};
+exports.pageNumberPagination = pageNumberPagination;

package/dist/routing.d.ts

@@ -0,0 +1,100 @@
+export declare type QueryParams = Record<string, string | undefined>;
+export declare type RouteParams = {
+    [key: string]: string;
+};
+export declare type AnyRoute<R> = R extends Route<infer N, infer P, infer Sa, infer Sr, infer Ri, infer Ro> ? Route<N, P, Sa, Sr, Ri, Ro> : never;
+export declare type AnySpecificRoute<R, Sa, Ri, Ro> = R extends Route<infer N, infer P, Sa, infer Sr, Ri, Ro> & infer E ? Route<N, P, Sa, Sr, Ri, Ro> & E : never;
+export declare type OutputForRoute<R> = R extends Route<any, any, any, any, any, infer Ro> ? Ro : never;
+export declare type ParamsForRoute<R> = R extends Route<any, infer P, any, any, any, any> ? P : never;
+export declare type RequestServicesForRoute<R> = R extends Route<any, any, any, infer Sr, any, any> ? Sr : never;
+export declare type ParamsForRouteOrEmpty<R> = ParamsForRoute<R> extends undefined ? {} : Exclude<ParamsForRoute<R>, undefined>;
+export declare type RouteMatchRecord<R> = R extends AnyRoute<R> ? {
+    route: R;
+    params: ParamsForRoute<R>;
+} : never;
+export declare type PayloadForRoute<R> = RequestServicesForRoute<R> extends {
+    payload: any;
+} ? RequestServicesForRoute<R>['payload'] : undefined;
+declare type RequestServiceProvider<Sa, Sr, Ri> = (app: Sa) => <R>(middleware: {
+    request: Ri;
+}, match: RouteMatchRecord<R>) => Sr;
+declare type RouteHandler<P, Sr, Ro> = (params: P, request: Sr) => Ro;
+declare type Route<N extends string, P extends RouteParams | undefined, Sa, Sr, Ri, Ro> = (Sr extends undefined ? {
+    requestServiceProvider?: RequestServiceProvider<Sa, Sr, Ri> | undefined;
+} : {
+    requestServiceProvider: RequestServiceProvider<Sa, Sr, Ri>;
+}) & {
+    name: N;
+    path: string;
+    handler: (params: P, request: Sr) => Ro;
+};
+declare type CreateRouteConfig<Sa, Sr, Ri, N extends string, Ex> = (Sr extends undefined ? {
+    requestServiceProvider?: RequestServiceProvider<Sa, Sr, Ri> | undefined;
+} : {
+    requestServiceProvider: RequestServiceProvider<Sa, Sr, Ri>;
+}) & {
+    name: N;
+    path: string;
+} & Ex;
+export interface CreateRoute<Sa, Ri, Ex> {
+    <N extends string, Ro, Sr extends unknown | undefined = undefined, P extends RouteParams | undefined = undefined>(config: CreateRouteConfig<Sa, Sr, Ri, N, Ex> & {
+        handler: RouteHandler<P, Sr, Ro>;
+    }): Route<N, P, Sa, Sr, Ri, Ro> & Ex;
+    <N extends string, Ro, Sr extends unknown | undefined, P extends RouteParams | undefined = undefined>(config: CreateRouteConfig<Sa, Sr, Ri, N, Ex>, handler: RouteHandler<P, Sr, Ro>): Route<N, P, Sa, Sr, Ri, Ro> & Ex;
+}
+export declare const makeCreateRoute: <Sa, Ri, Ex = {}>() => CreateRoute<Sa, Ri, Ex>;
+export declare const makeRenderRouteUrl: <Ru extends {
+    path: string;
+}>() => <R extends Ru>(route: R, params: ParamsForRoute<R>, query?: QueryParams) => string;
+export declare const renderAnyRouteUrl: <R extends any>(route: R, params: ParamsForRoute<R>, query?: QueryParams) => string;
+declare type RequestPathExtractor<Ri> = (request: Ri) => string;
+declare type RequestRouteMatcher<Ri, R> = (request: Ri, route: R) => boolean;
+declare type RequestResponder<Sa, Ri, Ro> = {
+    (services: Sa): (request: Ri) => Ro | undefined;
+    <RoF>(services: Sa, responseMiddleware: (app: Sa) => (response: Ro | undefined, request: Ri) => RoF): (request: Ri) => RoF;
+};
+export declare const makeGetRequestResponder: <Sa, Ru, Ri, Ro>() => ({ routes, pathExtractor, routeMatcher, errorHandler }: {
+    routes: () => AnySpecificRoute<Ru, Sa, Ri, Ro>[];
+    pathExtractor: RequestPathExtractor<Ri>;
+    routeMatcher?: RequestRouteMatcher<Ri, AnySpecificRoute<Ru, Sa, Ri, Ro>> | undefined;
+    errorHandler?: ((e: Error) => Ro) | undefined;
+}) => RequestResponder<Sa, Ri, Ro>;
+export declare type HttpHeaders = {
+    [key: string]: string | undefined;
+};
+export declare type JsonCompatibleValue = string | number | null | undefined | boolean;
+export declare type JsonCompatibleArray = Array<JsonCompatibleValue | JsonCompatibleStruct | JsonCompatibleStruct>;
+export declare type JsonCompatibleStruct = {
+    [key: string]: JsonCompatibleStruct | JsonCompatibleValue | JsonCompatibleArray;
+};
+export declare type ApiResponse<S extends number, T> = {
+    statusCode: S;
+    data: T;
+    body: string;
+    headers?: {
+        [key: string]: string;
+    };
+};
+export declare const apiJsonResponse: <S extends number, T extends JsonCompatibleStruct>(statusCode: S, data: T, headers?: HttpHeaders | undefined) => ApiResponse<S, T>;
+export declare const apiTextResponse: <S extends number>(statusCode: S, data: string, headers?: HttpHeaders | undefined) => ApiResponse<S, string>;
+export declare enum METHOD {
+    GET = "GET",
+    HEAD = "HEAD",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    OPTIONS = "OPTIONS"
+}
+export declare const getHeader: (headers: HttpHeaders, name: string) => string | undefined;
+export declare const getRequestBody: (request: {
+    headers: HttpHeaders;
+    body?: string | undefined;
+}) => any;
+export declare const unsafePayloadValidator: <T>() => (input: any) => input is T;
+export declare const requestPayloadProvider: <T>(validator: (input: any) => input is T) => () => <M extends {
+    request: Parameters<typeof getRequestBody>[0];
+}>(requestServices: M) => M & {
+    payload: T;
+};
+export {};