@halooj/framework 0.3.0

package/api.ts

@@ -0,0 +1,322 @@
+import { Context, Service } from 'cordis';
+import Schema from 'schemastery';
+import { param } from './decorators';
+import { BadRequestError, MethodNotAllowedError, NotFoundError } from './error';
+import { } from './interface';
+import { ConnectionHandler, Handler } from './server';
+import { Types } from './validator';
+
+const BINARY = Symbol.for('hydro.api.response.binary');
+const REDIRECT = Symbol.for('hydro.api.response.redirect');
+
+type MaybePromise<T> = T | Promise<T>;
+export type ApiType = 'Query' | 'Mutation' | 'Subscription';
+export interface ApiCall<Type extends ApiType, Arg, Res, Progress = void> {
+    readonly type: Type;
+    readonly input: Schema<Arg>;
+    readonly func: (Type extends 'Subscription'
+        ? (context: any, args: Arg, emit: (payload: Res) => void) => (() => MaybePromise<void>)
+        : (context: any, args: Arg) => MaybePromise<Res | AsyncGenerator<Progress, Res, never>>);
+    readonly hooks: ApiCall<'Query', Arg, void>[];
+}
+
+export const _get = <Type extends ApiType>(type: Type) => <Arg, Res, Progress = void>(
+    schema: Schema<Arg>,
+    func: ApiCall<Type, Arg, Res, Progress>['func'],
+    hooks: ApiCall<'Query', Arg, void, void>[] = [],
+): ApiCall<Type, Arg, Res, Progress> => ({ input: schema, func, hooks, type } as const);
+
+export const Query = _get('Query');
+export const Mutation = _get('Mutation');
+export const Subscription = _get('Subscription');
+
+export class BinaryResponse {
+    [BINARY] = true;
+    constructor(public readonly data: Buffer, public filename: string) { }
+    static check(value: any): value is BinaryResponse {
+        return value && typeof value === 'object' && BINARY in value && value[BINARY] === true;
+    }
+}
+
+export class RedirectResponse {
+    [REDIRECT] = true;
+    constructor(public readonly url: string) { }
+    static check(value: any): value is RedirectResponse {
+        return value && typeof value === 'object' && REDIRECT in value && value[REDIRECT] === true;
+    }
+}
+
+/** @deprecated TODO */
+export const NOP = Query(Schema.any(), () => { });
+
+export const APIS = {
+    'query.batch': Query(Schema.array(Schema.object({ op: Schema.string(), args: Schema.any() })), () => ({})),
+    'mutation.batch': Mutation(Schema.array(Schema.object({ op: Schema.string(), args: Schema.any() })), () => ({})),
+} as const;
+export interface Apis {
+    builtin: {
+        'query.batch': ApiCall<'Query', { op: string, args: any }[], { [key: string]: any }>;
+        'mutation.batch': ApiCall<'Mutation', { op: string, args: any }[], { [key: string]: any }>;
+    };
+    test: typeof TestApis;
+}
+export type FlattenedApis = Apis[keyof Apis];
+
+// Thanks to @ForkKILLET for the projection function
+type ProjectionSchemaId = 1;
+type MKeyOf<T> = T extends any ? keyof T : never;
+type MId<T> = { [K in MKeyOf<T>]: T[K] } & {};
+type ProjectionSchema<T> = T extends Array<infer U>
+    ? ProjectionSchema<U>
+    : { [K in keyof T]?: ProjectionSchemaId | ProjectionSchema<T[K]> } | Record<keyof any, ProjectionSchemaId | object>;
+type AsKeys<T> = T extends Array<infer U extends string> ? Record<U, 1> : T;
+type Projection<T, S> = S extends ProjectionSchemaId
+    ? T : T extends Array<infer U> ? Array<MId<Projection<U, S>>> : {
+        [K in keyof T & keyof S]: K extends keyof AsKeys<S> ? Projection<T[K], AsKeys<S>[K]> : never
+    };
+
+export const projection = <T, S extends ProjectionSchema<T>>(input: T, schema: S, serializeCtx?: any): Projection<T, S> => {
+    if (typeof input !== 'object' || input === null) throw new Error('Input must be an object.');
+    type R = Projection<T, S>;
+    if ('serialize' in input && typeof (input as any).serialize === 'function') {
+        input = (input as any).serialize(serializeCtx);
+    }
+    if (Array.isArray(schema)) schema = Object.fromEntries(schema.map((s) => [s, 1])) as S;
+    if (Array.isArray(input)) {
+        return input.map((item) => projection(item, schema, serializeCtx)) as R;
+    }
+    const result = {} as R;
+    for (const key of Reflect.ownKeys(input as any)) {
+        const schemaIt = schema[key];
+        if (!schemaIt) continue;
+        if (schemaIt === 1 || !input[key]) result[key] = input[key];
+        else result[key] = projection(input[key], schemaIt, serializeCtx);
+    }
+    return result;
+};
+
+export interface ApiExecutionContext {
+}
+
+function handleArguments(args: any) {
+    try {
+        if (typeof args.args === 'string') {
+            args.args = JSON.parse(args.args);
+        }
+        if (typeof args.projection === 'string') {
+            args.projection = '{['.includes(args.projection[0])
+                ? JSON.parse(args.projection)
+                : args.projection.split(',').map((i) => i.trim()).filter((i) => i);
+        }
+    } catch (e) {
+        throw new BadRequestError('Invalid arguments');
+    }
+}
+
+export class ApiService extends Service {
+    constructor(ctx: Context) {
+        super(ctx, 'api');
+    }
+
+    provide(calls: Partial<FlattenedApis>, atNameSpace = '') {
+        this.ctx.effect(() => {
+            for (const key in calls) {
+                const target = `${atNameSpace ? `${atNameSpace}.` : ''}${key}`;
+                if (APIS[target]) console.warn(`API ${target} already exists, will be overridden`);
+                APIS[target] = calls[key];
+            }
+            return () => {
+                for (const key in calls) {
+                    delete APIS[`${atNameSpace ? `${atNameSpace}.` : ''}${key}`];
+                }
+            };
+        });
+    }
+
+    serialize() {
+        const result = {};
+        for (const key in APIS) {
+            result[key] = {
+                type: APIS[key].type,
+                input: APIS[key].input.toJSON(),
+            };
+        }
+        return result;
+    }
+
+    async execute(
+        context: ApiExecutionContext, callOrName: ApiCall<ApiType, any, any> | string,
+        rawArgs: any, emitHook?: any, project?: any, sendPayload?: (payload: any) => void,
+    ) {
+        const call = typeof callOrName === 'string' ? APIS[callOrName] : callOrName;
+        if (!call) throw new NotFoundError(callOrName);
+        const { input, func, hooks } = call;
+        // eslint-disable-next-line no-await-in-loop
+        for (const hook of hooks) await this.execute(context, hook, rawArgs);
+
+        let args: any;
+        try {
+            args = input ? input(rawArgs as any) : rawArgs;
+        } catch (e) {
+            throw new BadRequestError(e.message);
+        }
+        if (typeof callOrName === 'string') {
+            await emitHook?.('api/before', args);
+            await emitHook?.(`api/before/${callOrName}`, args);
+        }
+        let result = await func(context, args as any, sendPayload);
+        if (result && typeof result === 'object' && 'next' in result) {
+            const it = result as AsyncGenerator<any, any, never>;
+            while (true) {
+                const value = await it.next(); // eslint-disable-line no-await-in-loop
+                if (value.done) {
+                    result = value;
+                    break;
+                } else {
+                    sendPayload?.(value.value);
+                }
+            }
+        }
+        return (project && typeof result === 'object' && result !== null) ? projection(result, project, context) : result;
+    }
+}
+
+declare module 'cordis' {
+    interface Context {
+        api: ApiService;
+    }
+}
+
+export class ApiHandler extends Handler {
+    @param('op', Types.String)
+    async all({ }, op: string) {
+        if (!['get', 'post'].includes(this.request.method.toLowerCase())) {
+            throw new MethodNotAllowedError(this.request.method);
+        }
+        if (!APIS[op]) throw new BadRequestError(`Invalid API operation: ${op}`);
+        if (APIS[op].type === 'Subscription') {
+            throw new BadRequestError('Subscription operation cannot be called in HTTP handler');
+        }
+        if (APIS[op].type === 'Mutation' && this.request.method.toLowerCase() === 'get') {
+            throw new BadRequestError('Mutation operation cannot be called with GET method');
+        }
+        handleArguments(this.args);
+        // @ts-ignore
+        await this.ctx.parallel('handler/api/before', this);
+        // @ts-ignore
+        await this.ctx.parallel(`handler/api/before/${op}`, this);
+        const result = await this.ctx.api.execute(
+            this, op, { domainId: this.args.domainId, ...this.args, ...(this.args.args || {}) },
+            (m, args) => (this.ctx.parallel as any)(m, args), this.args.projection,
+        );
+        if (BinaryResponse.check(result)) {
+            this.binary(result.data, result.filename);
+        } else if (RedirectResponse.check(result)) {
+            this.response.redirect = result.url;
+        } else {
+            this.response.body = result;
+        }
+    }
+}
+
+export class ApiConnectionHandler extends ConnectionHandler {
+    dispose: () => Promise<void> | void;
+    isRpc: boolean;
+
+    @param('op', Types.String)
+    async prepare({ }, op: string) {
+        if (op === 'rpc') {
+            this.isRpc = true;
+            return;
+        }
+        if (!APIS[op]) throw new BadRequestError(`Invalid API operation: ${op}`);
+        if (APIS[op].type !== 'Subscription') {
+            throw new BadRequestError('Only subscription operations are supported');
+        }
+        handleArguments(this.args);
+        // @ts-ignore
+        await this.ctx.parallel('handler/api/before', this);
+        // @ts-ignore
+        await this.ctx.parallel(`handler/api/before/${op}`, this);
+        this.dispose = await this.ctx.api.execute(
+            this, op, { domainId: this.args.domainId, ...this.args, ...(this.args.args || {}) },
+            (m, args) => (this.ctx.parallel as any)(m, args), this.args.projection, (p) => this.send(p),
+        );
+    }
+
+    async message(message) {
+        if (!this.isRpc) throw new BadRequestError('Only RPC operations are supported');
+        if (typeof message === 'string') {
+            try {
+                message = JSON.parse(message);
+            } catch (e) {
+                throw new BadRequestError('Invalid message');
+            }
+        }
+        if (!APIS[message.op]) throw new BadRequestError(`Invalid API operation: ${message.op}`);
+        if (APIS[message.op].type !== 'Subscription') {
+            throw new BadRequestError('Only subscription operations are supported');
+        }
+        handleArguments(message);
+        const result = await this.ctx.api.execute(
+            this, message.op, message.args, (m, args) => (this.ctx.parallel as any)(m, args), message.projection,
+        );
+        this.send(result);
+    }
+
+    async cleanup() {
+        await this.dispose?.();
+    }
+}
+
+export async function applyApiHandler(ctx: Context, name: string, path: string) {
+    ctx.plugin(ApiService);
+    await ctx.inject(['server', 'api'], ({ Route, Connection }) => {
+        Route(name, path, ApiHandler);
+        Connection(`${name}_conn`, `${path}/conn`, ApiConnectionHandler);
+    });
+}
+
+const TestApis = {
+    'test.query': Query(Schema.object({
+        name: Schema.string(),
+    }), (c, { name }) => ({
+        ok: true,
+        name,
+    })),
+    'test.mutation': Mutation(Schema.object({
+        name: Schema.string().required(),
+    }), (c, { name }) => ({
+        ok: true,
+        name,
+    })),
+    'test.mutation_progress': Mutation(Schema.object({
+        count: Schema.number().step(1).min(1).default(10),
+    }), async function* (c, { count }) {
+        for (let i = 1; i <= count; i++) {
+            yield { progress: i };
+        }
+        return {
+            ok: true,
+            count,
+        };
+    }),
+    'test.subscription': Subscription(Schema.object({
+        initial: Schema.number().step(1).min(0).default(0),
+    }), (c, { initial }, send) => {
+        let count = initial;
+        const interval = setInterval(() => {
+            count++;
+            send({ count });
+        }, 1000);
+        return () => {
+            clearInterval(interval);
+        };
+    }),
+} as const;
+
+export function applyTestApis(ctx: Context) {
+    ctx.inject(['api'], ({ api }) => {
+        api.provide(TestApis);
+    });
+}

package/base.ts

@@ -0,0 +1,144 @@
+import { PassThrough } from 'stream';
+import type { Next } from 'koa';
+import {
+    HydroRequest, HydroResponse, KoaContext, serializer,
+} from '@halooj/framework';
+import { errorMessage } from '@halooj/utils/lib/utils';
+import { SystemError, UserFacingError } from './error';
+
+const pick = <T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> => {
+    const result: Partial<Pick<T, K>> = {};
+    for (const key of keys) result[key] = obj[key];
+    return result as Pick<T, K>;
+};
+
+export default (logger, xff, xhost) => async (ctx: KoaContext, next: Next) => {
+    // Base Layer
+    const request: HydroRequest = {
+        method: ctx.request.method.toLowerCase(),
+        host: ctx.request.headers[xhost?.toLowerCase() || ''] as string || ctx.request.host,
+        ip: (ctx.request.headers[xff?.toLowerCase() || ''] as string || ctx.request.ip).split(',')[0].trim(),
+        ...pick(ctx, ['cookies', 'query', 'path', 'originalPath', 'querystring']),
+        ...pick(ctx.request, ['headers', 'body', 'hostname']),
+        files: ctx.request.files as any,
+        referer: ctx.request.headers.referer || '',
+        json: (ctx.request.headers.accept || '').includes('application/json'),
+        websocket: ctx.request.headers.upgrade === 'websocket',
+        get params() {
+            return ctx.params;
+        },
+    };
+    const response: HydroResponse = {
+        body: {},
+        type: '',
+        status: null,
+        template: null,
+        redirect: null,
+        attachment: (name, streamOrBuffer) => {
+            if (name) ctx.attachment(name);
+            if (streamOrBuffer instanceof Buffer || streamOrBuffer instanceof PassThrough) {
+                response.body = null;
+                ctx.body = streamOrBuffer;
+            } else {
+                response.body = null;
+                ctx.body = streamOrBuffer.pipe(new PassThrough());
+            }
+        },
+        addHeader: (name: string, value: string) => ctx.set(name, value),
+        disposition: null,
+    };
+    const args = {
+        ...ctx.params, ...ctx.query, ...ctx.request.body, __start: Date.now(),
+    };
+    ctx.HydroContext = { request, response, args } as any;
+    try {
+        await next();
+        if (request.websocket) return;
+        const handler = ctx.handler;
+        if (!handler) {
+            logger.error('No handler found on request', request);
+            ctx.response.status = 500;
+            return;
+        }
+        const { UiContext, user } = ctx.HydroContext;
+        if (response.redirect) {
+            response.body ||= {};
+            response.body.url = response.redirect;
+        }
+        if (!response.type) {
+            if (response.pjax && args.pjax) {
+                const pjax = typeof response.pjax === 'string' ? [[response.pjax, {}]] : response.pjax;
+                response.body = {
+                    fragments: (await Promise.all(
+                        pjax.map(async ([template, extra]) => handler.renderHTML(template, { ...response.body, ...extra })),
+                    )).map((i) => ({ html: i })),
+                };
+                response.type = 'application/json';
+            } else if (
+                request.json || response.redirect
+                || request.query.noTemplate || !response.template // no template, send raw data
+            ) {
+                // Send raw data
+                try {
+                    if (request.headers['x-hydro-inject']) {
+                        const inject = request.headers['x-hydro-inject'].toString().toLowerCase().split(',').map((i) => i.trim());
+                        if (inject.includes('pagename')) {
+                            ctx.set('x-hydro-page', ctx._matchedRouteName || '');
+                            ctx.set('x-hydro-template', response.template || '');
+                        }
+                        if (response.body !== null && typeof response.body === 'object') {
+                            if (inject.includes('uicontext')) response.body.UiContext = UiContext;
+                            if (inject.includes('usercontext')) response.body.UserContext = user;
+                            if (inject.includes('routemap')) response.body.routeMap = handler.ctx.server.routeMap;
+                        }
+                    }
+                    response.body = JSON.stringify(response.body, serializer(false, handler));
+                } catch (e) {
+                    response.body = new SystemError('Serialize failure', e.message);
+                }
+                response.type = 'application/json';
+            } else if (response.template) {
+                response.body = await handler.renderHTML(response.template, response.body || {});
+                response.type = 'text/html';
+            }
+        }
+        if (response.disposition) ctx.set('Content-Disposition', response.disposition);
+        if (response.etag) {
+            ctx.set('ETag', response.etag);
+            ctx.set('Cache-Control', 'public');
+        }
+    } catch (err) {
+        const error = errorMessage(err);
+        response.status = error instanceof UserFacingError ? error.code : 500;
+        if (request.json) response.body = { error };
+        else {
+            try {
+                response.body = await ctx.handler.renderHTML(
+                    error instanceof UserFacingError ? 'error.html' : 'bsod.html',
+                    { UserFacingError, error },
+                );
+                response.type = 'text/html';
+            } catch (e) {
+                logger.error(e);
+                // this.response.body.error = {};
+            }
+        }
+    } finally {
+        if (!request.websocket) {
+            if (response.etag && request.headers['if-none-match'] === response.etag) {
+                ctx.response.status = 304;
+            } else if (response.redirect && !request.json) {
+                ctx.response.type = 'application/octet-stream';
+                ctx.response.status = 302;
+                ctx.redirect(response.redirect);
+            } else if (response.body) {
+                ctx.body = response.body instanceof Blob ? Buffer.from(await response.body.arrayBuffer()) : response.body;
+                ctx.response.status = response.status || 200;
+                ctx.response.type = response.type
+                    || (request.json
+                        ? 'application/json'
+                        : ctx.response.type);
+            }
+        }
+    }
+};

package/decorators.ts

@@ -0,0 +1,123 @@
+import Schema from 'schemastery';
+import { ValidationError } from './error';
+import type { Handler } from './server';
+import { Converter, Type, Validator } from './validator';
+
+type MethodDecorator = (target: any, funcName: string, obj: any) => any;
+type ClassDecorator = <T extends new (...args: any[]) => any>(Class: T) => T extends new (...args: infer R) => infer S
+    ? new (...args: R) => S : never;
+export interface ParamOption<T> {
+    name: string;
+    source: 'all' | 'get' | 'post' | 'route';
+    isOptional?: boolean | 'convert';
+    convert?: Converter<T>;
+    validate?: Validator;
+}
+
+const kSchema = Symbol.for('schemastery');
+const mergeValidator = (L: Validator, R: Validator) => (v: any) => L(v) && R(v);
+
+function isSchema(v: any): v is Schema {
+    return v && typeof v === 'function' && kSchema in v;
+}
+
+function _buildParam(name: string, source: 'get' | 'post' | 'all' | 'route', ...args: Array<Type<any> | boolean | Validator | Converter<any>>) {
+    let cursor = 0;
+    const v: ParamOption<any> = { name, source };
+    let isValidate = true;
+    while (cursor < args.length) {
+        const current = args[cursor];
+        if (isSchema(current)) {
+            v.validate = (val) => {
+                try {
+                    current(val);
+                    return true;
+                } catch (e) {
+                    return false;
+                }
+            };
+            v.convert = (val) => current(val);
+            cursor++;
+            continue;
+        }
+        if (current instanceof Array) {
+            const type = current;
+            if (type[0]) v.convert = type[0];
+            if (type[1]) v.validate = type[1];
+            if (type[2]) v.isOptional = type[2];
+        } else if (typeof current === 'boolean') v.isOptional = current;
+        else if (isValidate) {
+            if (current !== null) v.validate = v.validate ? mergeValidator(v.validate, current) : current;
+            isValidate = false;
+        } else v.convert = current;
+        cursor++;
+    }
+    return v;
+}
+
+function _descriptor(v: ParamOption<any>) {
+    return function desc(this: Handler, target: any, funcName: string, obj: any) {
+        target.__param ||= {};
+        target.__param[target.constructor.name] ||= {};
+        if (!target.__param[target.constructor.name][funcName]) {
+            const originalMethod = obj.value;
+            const val = originalMethod.toString();
+            const firstArg = val.split(')')[0]?.split(',')[0]?.split('(')[1]?.trim() || '';
+            const domainIdStyle = firstArg.toLowerCase().startsWith('domainid');
+            target.__param[target.constructor.name][funcName] = [];
+            obj.value = function validate(this: Handler, rawArgs: any, ...extra: any[]) {
+                if (typeof rawArgs !== 'object' || extra.length) return originalMethod.call(this, rawArgs, ...extra);
+                const c = [];
+                const arglist: ParamOption<any>[] = target.__param[target.constructor.name][funcName];
+                if (typeof rawArgs.domainId !== 'string' || !rawArgs.domainId) throw new ValidationError('domainId');
+                for (const item of arglist) {
+                    const src = item.source === 'all'
+                        ? rawArgs
+                        : item.source === 'get'
+                            ? this.request.query
+                            : item.source === 'route'
+                                ? { ...this.request.params, domainId: this.args.domainId }
+                                : this.request.body;
+                    const value = src[item.name];
+                    if (!item.isOptional || value) {
+                        if (value === undefined || value === null || value === '') throw new ValidationError(item.name);
+                        if (item.validate && !item.validate(value)) throw new ValidationError(item.name);
+                        if (item.convert) c.push(item.convert(value));
+                        else c.push(value);
+                    } else if (item.isOptional === 'convert') {
+                        c.push(item.convert ? item.convert(value) : value);
+                    } else c.push(undefined);
+                }
+                return domainIdStyle ? originalMethod.call(this, rawArgs.domainId, ...c) : originalMethod.call(this, rawArgs, ...c);
+            };
+        }
+        target.__param[target.constructor.name][funcName].unshift(v);
+        return obj;
+    };
+}
+
+type DescriptorBuilder =
+    ((name: string, type: Type<any>) => MethodDecorator)
+    & ((name: string, type: Type<any>, validate: null, convert: Converter<any>) => MethodDecorator)
+    & ((name: string, type: Type<any>, validate?: Validator, convert?: Converter<any>) => MethodDecorator)
+    & ((name: string, type?: Type<any>, isOptional?: boolean, validate?: Validator, convert?: Converter<any>) => MethodDecorator)
+    & ((name: string, ...args: Array<Type<any> | boolean | Validator | Converter<any>>) => MethodDecorator);
+
+export const get: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'get', ...args));
+export const query: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'get', ...args));
+export const post: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'post', ...args));
+export const route: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'route', ...args));
+export const param: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'all', ...args));
+
+export const subscribe: (name: string) => MethodDecorator & ClassDecorator = (name) => (target, funcName?, obj?) => {
+    if (funcName) {
+        target.__subscribe ||= [];
+        target.__subscribe.push({ name, target: obj.value });
+        return obj;
+    }
+    return (...args) => {
+        const c = new target(...args); // eslint-disable-line new-cap
+        c.__subscribe = [{ name, target: c.send }];
+        return c;
+    };
+};

package/error.ts

@@ -0,0 +1,68 @@
+interface IHydroError {
+    new(...args: any[]): HydroError;
+}
+
+export class HydroError extends Error {
+    params: any[];
+    code: number;
+
+    constructor(...params: any[]) {
+        super();
+        this.params = params;
+    }
+
+    msg() {
+        return 'HydroError';
+    }
+
+    get message() {
+        return this.msg();
+    }
+}
+
+const Err = (name: string, Class: IHydroError, ...info: Array<(() => string) | string | number>) => {
+    let msg: () => string;
+    let code: number;
+    for (const item of info) {
+        if (typeof item === 'number') {
+            code = item;
+        } else if (typeof item === 'string') {
+            msg = function () { return item; };
+        } else if (typeof item === 'function') {
+            msg = item;
+        }
+    }
+    // eslint-disable-next-line ts/no-shadow
+    return class HydroError extends Class {
+        name = name;
+        constructor(...args: any[]) {
+            super(...args);
+            if (msg) this.msg = msg;
+            if (code) this.code = code;
+        }
+    };
+};
+
+export const UserFacingError = Err('UserFacingError', HydroError, 'UserFacingError', 400);
+export const SystemError = Err('SystemError', HydroError, 'SystemError', 500);
+
+export const BadRequestError = Err('BadRequestError', UserFacingError, 'BadRequestError', 400);
+export const ForbiddenError = Err('ForbiddenError', UserFacingError, 'ForbiddenError', 403);
+export const NotFoundError = Err('NotFoundError', UserFacingError, 'NotFoundError', 404);
+export const MethodNotAllowedError = Err('MethodNotAllowedError', UserFacingError, 'MethodNotAllowedError', 405);
+
+export const ValidationError = Err('ValidationError', ForbiddenError, function (this: HydroError) {
+    if (this.params.length === 3) {
+        return this.params[1]
+            ? 'Field {0} or {1} validation failed. ({2})'
+            : 'Field {0} validation failed. ({2})';
+    }
+    return this.params[1]
+        ? 'Field {0} or {1} validation failed.'
+        : 'Field {0} validation failed.';
+});
+export const CsrfTokenError = Err('CsrfTokenError', ForbiddenError, 'CsrfTokenError');
+export const InvalidOperationError = Err('InvalidOperationError', MethodNotAllowedError);
+export const FileTooLargeError = Err('FileTooLargeError', ValidationError, 'The uploaded file is too long.');
+
+export const CreateError = Err;

package/index.ts

@@ -0,0 +1,8 @@
+export * from './api';
+export * from './decorators';
+export * from './error';
+export * from './interface';
+export * from './router';
+export { default as serializer } from './serializer';
+export * from './server';
+export * from './validator';