vona-core 1.0.0 → 5.0.10

package/dist/lib/module/module.d.ts

@@ -0,0 +1,7 @@
+import type { IModule } from '@cabloy/module-info';
+import { BeanSimple } from '../bean/beanSimple.ts';
+export declare class ModuleTools extends BeanSimple {
+    prepare(): Promise<Record<string, IModule>>;
+    load(): Promise<void>;
+    monkey(monkeyName: any): Promise<void>;
+}

package/dist/lib/module/module.js

@@ -0,0 +1,32 @@
+import { BeanSimple } from "../bean/beanSimple.js";
+export class ModuleTools extends BeanSimple {
+    async prepare() {
+        const app = this.app;
+        const modulesMeta = await app.options.modulesMeta();
+        const modules = modulesMeta.modulesMeta.modules;
+        const modulesArray = modulesMeta.modulesMeta.moduleNames.map(relativeName => modules[relativeName]);
+        app.meta.modules = modules;
+        app.meta.modulesArray = modulesArray;
+        app.meta.modulesMonkey = {};
+        return modules;
+    }
+    async load() {
+        const app = this.app;
+        // main / monkey
+        for (const module of app.meta.modulesArray) {
+            if (module.resource.Main) {
+                module.mainInstance = app.bean._newBean(module.resource.Main, module);
+            }
+            if (module.resource.Monkey) {
+                module.monkeyInstance = app.bean._newBean(module.resource.Monkey, module);
+                app.meta.modulesMonkey[module.info.relativeName] = module;
+            }
+        }
+    }
+    async monkey(monkeyName) {
+        const app = this.app;
+        for (const module of app.meta.modulesArray) {
+            await app.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, monkeyName, module);
+        }
+    }
+}

package/dist/lib/utils/index.d.ts

@@ -0,0 +1,4 @@
+import './zod-openapi.ts';
+export * from './isClass.ts';
+export * from './retry.ts';
+export * from './util.ts';

package/dist/lib/utils/index.js

@@ -0,0 +1,4 @@
+import "./zod-openapi.js";
+export * from "./isClass.js";
+export * from "./retry.js";
+export * from "./util.js";

package/dist/lib/utils/isClass.d.ts

@@ -0,0 +1,2 @@
+export declare function isClass(fn: any): boolean;
+export declare function isClassStrict(fn: any): boolean;

package/dist/lib/utils/isClass.js

@@ -0,0 +1,18 @@
+export function isClass(fn) {
+    // just check if is function
+    return typeof fn === 'function';
+}
+export function isClassStrict(fn) {
+    return typeof fn === 'function' && /^class(?:\s|\{)/.test(fn.toString());
+}
+// function fnBody(fn) {
+//   return fn
+//     .toString()
+//     .replace(/^[^{]*{\s*/, '')
+//     .replace(/\s*}[^}]*$/, '');
+// }
+// export function isClassStrict(fn) {
+//   return (
+//     typeof fn === 'function' && (/^class(?:\s|{)/.test(fn.toString()) || /^.*classCallCheck\(/.test(fnBody(fn))) // babel.js
+//   );
+// }

package/dist/lib/utils/retry.d.ts

@@ -0,0 +1,4 @@
+import * as Retry from 'retry';
+export * as Retry from 'retry';
+export type RetryFunction<DATA> = (currentAttempt: number) => Promise<DATA>;
+export declare function retry<DATA = void>(options: Retry.OperationOptions, fn: RetryFunction<DATA>): Promise<unknown>;

package/dist/lib/utils/retry.js

@@ -0,0 +1,16 @@
+import * as Retry from 'retry';
+export * as Retry from 'retry';
+export async function retry(options, fn) {
+    return new Promise((resolve, reject) => {
+        const operation = Retry.operation(options);
+        operation.attempt(currentAttempt => {
+            fn(currentAttempt)
+                .then(data => resolve(data))
+                .catch(err => {
+                if (operation.retry(err))
+                    return;
+                reject(err);
+            });
+        });
+    });
+}

package/dist/lib/utils/util.d.ts

@@ -0,0 +1,59 @@
+import type * as ModuleInfo from '@cabloy/module-info';
+import type { IModule } from '@cabloy/module-info';
+import type { BinaryToTextEncoding, HashOptions } from 'node:crypto';
+import type { TypeMonkeyName, VonaConfigEnv, VonaContext } from '../../types/index.ts';
+import type { IBeanSceneRecord } from '../decorator/interface/beanOptions.ts';
+import { BeanSimple } from '../bean/beanSimple.ts';
+export interface IExecuteBeanCallbackParams {
+    ctx: VonaContext;
+    bean: any;
+    context: any;
+}
+export interface IExecuteBeanCallback {
+    (params: IExecuteBeanCallbackParams): Promise<any>;
+}
+export interface IModuleAssetSceneRecord {
+    cli: never;
+    static: never;
+    templates: never;
+    site: never;
+}
+declare const SymbolProdRootPath: unique symbol;
+export declare class AppUtil extends BeanSimple {
+    private [SymbolProdRootPath];
+    instanceStarted(instanceName: string): boolean;
+    get protocol(): string;
+    get host(): string;
+    getAbsoluteUrl(path?: string): string;
+    getAbsoluteUrlByApiPath(path: string): string;
+    combineApiPathControllerAndActionRaw(moduleName: ModuleInfo.IModuleInfo | string, controllerPath: string | undefined, actionPath: RegExp | string | undefined, simplify?: boolean): string;
+    combineApiPathControllerAndAction(moduleName: ModuleInfo.IModuleInfo | string, controllerPath: string | undefined, actionPath: RegExp | string | undefined, prefix?: string | boolean, simplify?: boolean): string;
+    combineApiPath(path: string | undefined, moduleName?: ModuleInfo.IModuleInfo | string, prefix?: string | boolean, simplify?: boolean): string;
+    combineStaticPath(path: string | undefined, moduleName?: ModuleInfo.IModuleInfo | string): string;
+    combineResourceName(resourceName: string | undefined, moduleName: ModuleInfo.IModuleInfo | string, simplify?: boolean, simplifyProviderId?: boolean): string;
+    getPublicPathPhysical(subdir?: string, ensure?: boolean): Promise<string>;
+    get prodRootPath(): string;
+    getAssetPathPhysical(moduleName: ModuleInfo.IModuleInfo | string, scene: keyof IModuleAssetSceneRecord, assetPath?: string): string | undefined;
+    createError(data: any, returnObject?: boolean): any;
+    monkeyModule(ebAppMonkey: any, ebModulesMonkey: any, monkeyName: TypeMonkeyName, moduleTarget?: IModule, ...monkeyData: any[]): Promise<void>;
+    monkeyModuleSync(ebAppMonkey: any, ebModulesMonkey: any, monkeyName: TypeMonkeyName, moduleTarget?: IModule, ...monkeyData: any[]): void;
+    detectErrorMessage(err: Error): string;
+    detectStatus(err: Error): number;
+    accepts(): "json" | "html";
+}
+export declare function compose(chains: any, adapter?: any): (context: any, next?: any) => any;
+export declare function instanceDesp(instanceName: string | null | undefined): string;
+export declare function requireDynamic(file: string): any;
+export declare function deepExtend<T extends []>(target: T, ...args: any[]): [];
+export declare function deepExtend<T = any>(target: {}, ...args: any[]): T;
+export declare function uuidv4(): string;
+export declare function createHash(str: string, encoding?: BinaryToTextEncoding, algorithm?: string, options?: HashOptions): string;
+export declare function disposeInstance(instance: any): Promise<void>;
+export declare function polyfillDispose(instance: any): void;
+export declare function pathToHref(fileName: string): string;
+export declare function prepareEnv(env: Partial<NodeJS.ProcessEnv>): VonaConfigEnv;
+export declare function beanFullNameFromOnionName(onionName: string, sceneName: keyof IBeanSceneRecord): string;
+export declare function onionNameFromBeanFullName(beanFullName: string, sceneName: keyof IBeanSceneRecord): string;
+export declare function filterHeaders(headers: object | undefined, whitelist: string[]): {} | undefined;
+export declare function combineFilePathSafe(dir: string, file: string): string | undefined;
+export {};

package/dist/lib/utils/util.js

@@ -0,0 +1,298 @@
+import crypto from 'node:crypto';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { compose as _compose } from '@cabloy/compose';
+import { extend } from '@cabloy/extend';
+import { combineApiPath, combineApiPathControllerAndAction, combineApiPathControllerAndActionRaw, combineResourceName } from '@cabloy/utils';
+import fse from 'fs-extra';
+import * as uuid from 'uuid';
+import { cast } from "../../types/index.js";
+import { BeanSimple } from "../bean/beanSimple.js";
+const SymbolProdRootPath = Symbol('SymbolProdRootPath');
+export class AppUtil extends BeanSimple {
+    [SymbolProdRootPath];
+    instanceStarted(instanceName) {
+        return this.app.meta.appReadyInstances && this.app.meta.appReadyInstances[instanceName];
+    }
+    get protocol() {
+        const config = this.app.config;
+        return config.server.serve.protocol || this.ctx?.protocol;
+    }
+    get host() {
+        const config = this.app.config;
+        return config.server.serve.host || this.ctx?.host;
+    }
+    getAbsoluteUrl(path) {
+        const prefix = this.host ? `${this.protocol}://${this.host}` : '';
+        return `${prefix}${path || ''}`;
+    }
+    getAbsoluteUrlByApiPath(path) {
+        return this.getAbsoluteUrl(this.combineApiPath(path, '', true, true));
+    }
+    combineApiPathControllerAndActionRaw(moduleName, controllerPath, actionPath, simplify) {
+        return combineApiPathControllerAndActionRaw(moduleName, controllerPath, actionPath, simplify);
+    }
+    combineApiPathControllerAndAction(moduleName, controllerPath, actionPath, prefix, simplify) {
+        return combineApiPathControllerAndAction(moduleName, controllerPath, actionPath, prefix, simplify, this.app.config.server.globalPrefix);
+    }
+    combineApiPath(path, moduleName, prefix, simplify) {
+        return combineApiPath(path, moduleName, prefix, simplify, this.app.config.server.globalPrefix);
+    }
+    combineStaticPath(path, moduleName) {
+        const globalPrefix = '/api/static';
+        if (!path)
+            path = '';
+        // ignore globalPrefix
+        if (path.startsWith('//'))
+            return path.substring(1);
+        // ignore module path
+        if (path.startsWith('/'))
+            return `${globalPrefix}${path}`;
+        // globalPrefix + module path + arg
+        if (!moduleName)
+            throw new Error('should specify the moduleName');
+        if (typeof moduleName !== 'string')
+            moduleName = moduleName.relativeName;
+        const parts = moduleName.split('-');
+        // path
+        return `${globalPrefix}/${parts[0]}/${parts[1]}/${path}`;
+    }
+    combineResourceName(resourceName, moduleName, simplify, simplifyProviderId) {
+        return combineResourceName(resourceName, moduleName, simplify, simplifyProviderId);
+    }
+    async getPublicPathPhysical(subdir, ensure) {
+        const rootPath = this.app.config.server.publicDir;
+        // use instance.id, not instanceName
+        const dir = combineFilePathSafe(path.join(rootPath, cast(this.ctx).instance.id.toString()), subdir || '');
+        if (!dir)
+            throw new Error('not valid path');
+        if (ensure) {
+            await fse.ensureDir(dir);
+        }
+        return dir;
+    }
+    get prodRootPath() {
+        if (!this.app.meta.isProd)
+            throw new Error('only invoked in prod');
+        if (!this[SymbolProdRootPath]) {
+            this[SymbolProdRootPath] = import.meta.dirname;
+        }
+        return this[SymbolProdRootPath];
+    }
+    getAssetPathPhysical(moduleName, scene, assetPath) {
+        if (typeof moduleName !== 'string')
+            moduleName = moduleName.relativeName;
+        if (this.app.meta.isProd) {
+            return combineFilePathSafe(path.join(this.prodRootPath, 'assets', scene, moduleName), assetPath || '');
+        }
+        else {
+            const module = this.app.meta.modules[moduleName];
+            if (!module)
+                throw new Error('module not found');
+            return combineFilePathSafe(path.join(module.root, scene), assetPath || '');
+        }
+    }
+    createError(data, returnObject) {
+        const error = returnObject ? {} : new Error();
+        error.code = data.code !== undefined ? data.code : 500;
+        if (data.message && typeof data.message === 'object') {
+            error.message = JSON.stringify(data.message, null, 2);
+        }
+        else {
+            error.message = data.message;
+        }
+        if (!this.app.meta.isProd) {
+            if (data.stack)
+                error.stack = data.stack;
+            if (data.name)
+                error.name = data.name;
+            if (data.errno)
+                error.errno = data.errno;
+            if (data.sqlMessage)
+                error.sqlMessage = data.sqlMessage;
+            if (data.sqlState)
+                error.sqlState = data.sqlState;
+            if (data.index)
+                error.index = data.index;
+            if (data.sql)
+                error.sql = data.sql;
+        }
+        return error;
+    }
+    async monkeyModule(ebAppMonkey, ebModulesMonkey, monkeyName, moduleTarget, ...monkeyData) {
+        // self: main
+        if (moduleTarget && moduleTarget.mainInstance && moduleTarget.mainInstance[monkeyName]) {
+            // @ts-ignore ignore
+            await moduleTarget.mainInstance[monkeyName](...monkeyData);
+        }
+        // module monkey
+        for (const key in ebModulesMonkey) {
+            const moduleMonkey = ebModulesMonkey[key];
+            if (moduleMonkey.monkeyInstance && moduleMonkey.monkeyInstance[monkeyName]) {
+                if (moduleTarget === undefined) {
+                    // @ts-ignore ignore
+                    await moduleMonkey.monkeyInstance[monkeyName](...monkeyData);
+                }
+                else {
+                    // @ts-ignore ignore
+                    await moduleMonkey.monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
+                }
+            }
+        }
+        // app monkey
+        if (ebAppMonkey && ebAppMonkey[monkeyName]) {
+            if (moduleTarget === undefined) {
+                await ebAppMonkey[monkeyName](...monkeyData);
+            }
+            else {
+                await ebAppMonkey[monkeyName](moduleTarget, ...monkeyData);
+            }
+        }
+    }
+    monkeyModuleSync(ebAppMonkey, ebModulesMonkey, monkeyName, moduleTarget, ...monkeyData) {
+        // self: main
+        if (moduleTarget && moduleTarget.mainInstance && moduleTarget.mainInstance[monkeyName]) {
+            // @ts-ignore ignore
+            moduleTarget.mainInstance[monkeyName](...monkeyData);
+        }
+        // module monkey
+        for (const key in ebModulesMonkey) {
+            const moduleMonkey = ebModulesMonkey[key];
+            if (moduleMonkey.monkeyInstance && moduleMonkey.monkeyInstance[monkeyName]) {
+                if (moduleTarget === undefined) {
+                    // @ts-ignore ignore
+                    moduleMonkey.monkeyInstance[monkeyName](...monkeyData);
+                }
+                else {
+                    // @ts-ignore ignore
+                    moduleMonkey.monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
+                }
+            }
+        }
+        // app monkey
+        if (ebAppMonkey && ebAppMonkey[monkeyName]) {
+            if (moduleTarget === undefined) {
+                ebAppMonkey[monkeyName](...monkeyData);
+            }
+            else {
+                ebAppMonkey[monkeyName](moduleTarget, ...monkeyData);
+            }
+        }
+    }
+    detectErrorMessage(err) {
+        // detect json parse error
+        if (err.status === 400 &&
+            err.name === 'SyntaxError' &&
+            this.ctx.request.is('application/json', 'application/vnd.api+json', 'application/csp-report')) {
+            return 'Problems parsing JSON';
+        }
+        return err.message;
+    }
+    detectStatus(err) {
+        // detect status
+        let status = err.status || 500;
+        if (typeof status !== 'number')
+            status = Number(status);
+        if (status < 200) {
+            // invalid status consider as 500, like urllib will return -1 status
+            status = 500;
+        }
+        return status;
+    }
+    accepts() {
+        if (this.ctx.acceptJSON)
+            return 'json';
+        return 'html';
+    }
+}
+export function compose(chains, adapter) {
+    return _compose(chains, adapter);
+}
+export function instanceDesp(instanceName) {
+    if (instanceName === undefined || instanceName === null)
+        return '~';
+    return instanceName || '-';
+}
+export function requireDynamic(file) {
+    if (!file)
+        throw new Error('file should not empty');
+    const require = createRequire(import.meta.url);
+    let instance = require(file);
+    const mtime = _requireDynamic_getFileTime(file);
+    if (instance.__requireDynamic_mtime === undefined) {
+        instance.__requireDynamic_mtime = mtime;
+    }
+    else if (instance.__requireDynamic_mtime !== mtime) {
+        delete require.cache[require.resolve(file)];
+        instance = require(file);
+        instance.__requireDynamic_mtime = mtime;
+    }
+    return instance;
+}
+function _requireDynamic_getFileTime(file) {
+    if (!path.isAbsolute(file))
+        return null;
+    const exists = fse.pathExistsSync(file);
+    if (!exists)
+        return null;
+    // stat
+    const stat = fse.statSync(file);
+    return stat.mtime.valueOf();
+}
+export function deepExtend(target, ...args) {
+    return extend(true, target, ...args);
+}
+export function uuidv4() {
+    return uuid.v4();
+}
+export function createHash(str, encoding, algorithm, options) {
+    const hash = crypto.createHash(algorithm ?? 'sha256', options);
+    hash.update(str);
+    return hash.digest(encoding ?? 'hex');
+}
+export async function disposeInstance(instance) {
+    await instance?.__dispose__?.();
+}
+export function polyfillDispose(instance) {
+    if (!instance || instance.__dispose__)
+        return;
+    Object.getPrototypeOf(instance).__dispose__ = () => { };
+}
+export function pathToHref(fileName) {
+    return pathToFileURL(fileName).href;
+    // return Path.sep === '\\' ? pathToFileURL(fileName).href : fileName;
+}
+export function prepareEnv(env) {
+    const env2 = { ...env };
+    for (const key of Object.keys(env2)) {
+        if (process.env[key] !== undefined) {
+            env2[key] = process.env[key];
+        }
+    }
+    return env2;
+}
+export function beanFullNameFromOnionName(onionName, sceneName) {
+    return onionName.replace(':', `.${sceneName}.`);
+}
+export function onionNameFromBeanFullName(beanFullName, sceneName) {
+    return beanFullName.replace(`.${sceneName}.`, ':');
+}
+export function filterHeaders(headers, whitelist) {
+    if (!headers)
+        return;
+    const res = {};
+    for (const key in headers) {
+        if (whitelist.includes(key)) {
+            res[key] = headers[key];
+        }
+    }
+    return res;
+}
+export function combineFilePathSafe(dir, file) {
+    const fullPath = path.normalize(path.join(dir, file));
+    // files that can be accessd should be under options.dir
+    if (fullPath.indexOf(dir) !== 0)
+        return;
+    return fullPath;
+}

package/dist/lib/utils/zod-openapi.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/utils/zod-openapi.js

@@ -0,0 +1,3 @@
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import { z } from 'zod';
+extendZodWithOpenApi(z);

package/dist/types/application/app.d.ts

@@ -0,0 +1,36 @@
+import type { IModule, VonaConfigMeta } from '@cabloy/module-info';
+import type { VonaConfig, VonaConfigOptional } from '../config/config.ts';
+import type { VonaLocaleOptionalMap } from '../config/locale.ts';
+import type { AppMonkeyConstructable } from '../interface/monkey.ts';
+import type { VonaConfigEnv } from '../utils/env.ts';
+export interface VonaModulesMeta {
+    modules: Record<string, IModule>;
+    moduleNames: string[];
+}
+export type TypeOptionsModulesMeta = () => Promise<{
+    modulesMeta: VonaModulesMeta;
+}>;
+export interface KoaApplicationOptions {
+    env?: string | undefined;
+    keys?: string[] | undefined;
+    proxy?: boolean | undefined;
+    subdomainOffset?: number | undefined;
+    proxyIpHeader?: string | undefined;
+    maxIpsCount?: number | undefined;
+    asyncLocalStorage?: boolean | undefined;
+}
+export interface VonaAppInfo {
+    name: string;
+    projectPath: string;
+    configMeta: VonaConfigMeta;
+}
+export interface VonaApplicationOptions {
+    name: string;
+    projectPath: string;
+    modulesMeta: TypeOptionsModulesMeta;
+    locales: VonaLocaleOptionalMap;
+    config: VonaConfig;
+    env: VonaConfigEnv;
+    AppMonkey?: AppMonkeyConstructable;
+}
+export type TypeAppInfoConfig = (appInfo: VonaAppInfo, env: VonaConfigEnv) => VonaConfigOptional;

package/dist/types/application/app.js

@@ -0,0 +1 @@
+export {};

package/dist/types/application/index.d.ts

@@ -0,0 +1 @@
+export * from './app.ts';

package/dist/types/application/index.js

@@ -0,0 +1 @@
+export * from "./app.js";

package/dist/types/config/config.d.ts

@@ -0,0 +1,36 @@
+import type { VonaConfigMeta } from '@cabloy/module-info';
+import type { ConfigLogger, IBeanScopeConfig } from '../../index.ts';
+import type { PowerPartial } from '../utils/powerPartial.ts';
+import type { ConfigInstanceBase } from './instance.ts';
+export interface VonaConfig {
+    meta: VonaConfigMeta;
+    server: {
+        keys: string[];
+        globalPrefix: string;
+        publicDir: string;
+        loggerDir: string;
+        subdomainOffset: number;
+        workers: number;
+        listen: {
+            hostname: string;
+            port: number;
+            disable: boolean;
+        };
+        serve: {
+            protocol: string;
+            host: string;
+        };
+    };
+    proxy: {
+        enabled: boolean;
+        ipHeaders: string;
+        hostHeaders: string;
+        protocolHeaders: string;
+        maxProxyCount: number;
+        maxIpsCount: number;
+    };
+    logger: ConfigLogger;
+    modules: IBeanScopeConfig;
+    instances: ConfigInstanceBase[];
+}
+export type VonaConfigOptional = PowerPartial<VonaConfig>;

package/dist/types/config/config.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config.ts';
+export * from './instance.ts';
+export * from './locale.ts';

package/dist/types/config/index.js

@@ -0,0 +1,3 @@
+export * from "./config.js";
+export * from "./instance.js";
+export * from "./locale.js";

package/dist/types/config/instance.d.ts

@@ -0,0 +1,7 @@
+import type { VonaConfigOptional } from './config.ts';
+export interface ConfigInstanceBase {
+    instanceName: string;
+    password?: string;
+    title?: string;
+    config?: VonaConfigOptional;
+}

package/dist/types/config/instance.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/locale.d.ts

@@ -0,0 +1,10 @@
+import type { IBeanScopeLocale } from '../../lib/bean/type.ts';
+import type { PowerPartial } from '../utils/powerPartial.ts';
+export declare const localeDefault: {
+    modules: {};
+};
+export type VonaLocale = {
+    modules: IBeanScopeLocale;
+} & typeof localeDefault;
+export type VonaLocaleOptional = PowerPartial<VonaLocale>;
+export type VonaLocaleOptionalMap = Record<string, VonaLocaleOptional>;

package/dist/types/config/locale.js

@@ -0,0 +1,3 @@
+export const localeDefault = {
+    modules: {},
+};

package/dist/types/context/contextBase.d.ts

@@ -0,0 +1,24 @@
+import type { BeanContainer, Constructable, ILocaleInfos, MetadataKey } from '../../lib/index.ts';
+import type { VonaConfig } from '../config/config.ts';
+import type { VonaContext } from './index.ts';
+export interface ContextBase {
+    get bean(): BeanContainer;
+    get locale(): keyof ILocaleInfos;
+    set locale(value: keyof ILocaleInfos);
+    get instanceName(): string | undefined | null;
+    set instanceName(value: string | undefined | null);
+    get config(): VonaConfig;
+    get innerAccess(): boolean;
+    set innerAccess(value: boolean);
+    get ctxCaller(): VonaContext;
+    set ctxCaller(value: VonaContext);
+    getController: () => Constructable | undefined;
+    getControllerPrototype: () => object | undefined;
+    getControllerBeanFullName: () => string | undefined;
+    getHandler: () => Function | undefined;
+    getHandlerName: () => MetadataKey | undefined;
+    get onionsDynamic(): any | undefined;
+    set onionsDynamic(value: any | undefined);
+    get acceptJSON(): boolean;
+    redirect(url: string, status?: 301 | 302): void;
+}

package/dist/types/context/contextBase.js

@@ -0,0 +1 @@
+export {};

package/dist/types/context/contextConfig.d.ts

@@ -0,0 +1,3 @@
+export interface ContextConfig {
+    module: (moduleName: string) => any;
+}

package/dist/types/context/contextConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/types/context/contextOthers.d.ts

@@ -0,0 +1,4 @@
+export interface ContextOthers {
+    subdomains: string[];
+    realStatus?: number;
+}

package/dist/types/context/contextOthers.js

@@ -0,0 +1 @@
+export {};

package/dist/types/context/contextState.d.ts

@@ -0,0 +1,7 @@
+export interface JwtPayload {
+    exp: number;
+    token: string;
+}
+export interface ContextState {
+    jwt?: JwtPayload;
+}

package/dist/types/context/contextState.js

@@ -0,0 +1 @@
+export {};

package/dist/types/context/index.d.ts

@@ -0,0 +1,10 @@
+import type KoaApplication from 'koa';
+import type { VonaApplication } from '../../lib/core/application.ts';
+import type { ContextBase } from './contextBase.ts';
+import type { ContextOthers } from './contextOthers.ts';
+import type { ContextState } from './contextState.ts';
+export * from './contextState.ts';
+export interface VonaContext extends Omit<KoaApplication.ParameterizedContext<ContextState, {}>, 'redirect'>, ContextBase, ContextOthers {
+    app: VonaApplication;
+    state: ContextState;
+}

package/dist/types/context/index.js

@@ -0,0 +1 @@
+export * from "./contextState.js";