milkio 1.0.0-alpha.98 → 1.0.0-beta.0

package/action/index.d.ts

@@ -0,0 +1,11 @@
+import type { $context, $meta } from "../index.ts";
+export declare function action<ActionInitT extends ActionInit>(init: ActionInitT): Action<ActionInitT>;
+export type ActionInit = {
+    meta?: $meta;
+    handler: (context: $context, params: any) => Promise<unknown>;
+};
+export type Action<ActionInitT extends ActionInit> = {
+    $milkioType: "action";
+    meta: ActionInitT["meta"] extends undefined ? {} : ActionInitT["meta"];
+    handler: ActionInitT["handler"];
+};

package/bootstrap/index.d.ts

@@ -0,0 +1,3 @@
+import type { MilkioWorld } from "../index.ts";
+export declare function bootstrap<BootstrapInitT extends BootstrapInit>(init: BootstrapInitT): BootstrapInitT;
+export type BootstrapInit = (world: MilkioWorld) => Promise<void> | void;

package/command/index.d.ts

@@ -0,0 +1,12 @@
+import type { GeneratedInit } from "../index.ts";
+export declare function command<CommandInitT extends CommandInit>(init: CommandInitT): Command<CommandInitT>;
+export interface CommandInit {
+    handler: (commands: Array<string>, options: Record<string, string>) => Promise<unknown>;
+}
+export interface Command<CommandInitT extends CommandInit> {
+    $milkioType: "command";
+    handler: CommandInitT["handler"];
+}
+export declare function __initCommander(generated: GeneratedInit, runtime: any): (argv: Array<string>, options?: {
+    onNotFound?: () => any;
+}) => Promise<any>;

package/config/index.d.ts

@@ -0,0 +1,8 @@
+export declare function config<ConfigT extends Config>(config: ConfigT): ConfigT;
+export type Config = (mode: string) => Promise<Record<string, unknown>> | Record<string, unknown>;
+export interface ConfigEnvironments<T extends Config> {
+    [key: string]: (env: Record<string, string>) => Partial<Awaited<ReturnType<T>>> | Promise<Partial<Awaited<ReturnType<T>>>>;
+}
+export declare function envToString(value: string | number | undefined, defaultValue: string): string;
+export declare function envToNumber(value: string | undefined, defaultValue: number): number;
+export declare function envToBoolean(value: string | number | undefined, defaultValue: boolean): boolean;

package/context/index.d.ts

@@ -0,0 +1,30 @@
+import type { MilkioHttpRequest, MilkioHttpResponse, $types, Logger, Action, MilkioRuntimeInit, MilkioInit } from "../index.ts";
+export interface $context {
+    _: MilkioRuntimeInit<MilkioInit>;
+    develop: boolean;
+    executeId: string;
+    emit: MilkioRuntimeInit<MilkioInit>["emit"];
+    path: string;
+    logger: Logger;
+    http: ContextHttp<Record<any, any>>;
+    config: Readonly<Awaited<ReturnType<$types["configSchema"]["get"]>>>;
+    call: <Module extends Promise<{
+        default: Action<any>;
+    }>>(module: Module, params: Parameters<Awaited<Module>["default"]["handler"]>[1]) => Promise<ReturnType<Awaited<Module>["default"]["handler"]>>;
+    onFinally: (handler: () => void | Promise<void>) => void;
+}
+export interface ContextHttp<ParamsParsed = any> {
+    url: URL;
+    ip: string;
+    path: {
+        string: keyof $types["generated"]["routeSchema"];
+        array: Array<string>;
+    };
+    params: {
+        string: string;
+        parsed: ParamsParsed;
+    };
+    request: MilkioHttpRequest;
+    response: MilkioHttpResponse;
+}
+export type ContextCreatedHandler = (context: $context) => Promise<void> | void;

package/event/index.d.ts

@@ -0,0 +1,42 @@
+import type { $context, ContextHttp, Results, Logger, $meta } from "../index.ts";
+export interface $events {
+    "milkio:httpRequest": {
+        executeId: string;
+        path: string;
+        logger: Logger;
+        http: ContextHttp<Record<string, any>>;
+    };
+    "milkio:httpResponse": {
+        executeId: string;
+        path: string;
+        logger: Logger;
+        http: ContextHttp<Record<string, any>>;
+        context: $context;
+    };
+    "milkio:httpNotFound": {
+        executeId: string;
+        path: string;
+        logger: Logger;
+        http: ContextHttp<Record<string, any>>;
+    };
+    "milkio:executeBefore": {
+        executeId: string;
+        path: string;
+        logger: Logger;
+        meta: $meta;
+        context: $context;
+    };
+    "milkio:executeAfter": {
+        executeId: string;
+        path: string;
+        logger: Logger;
+        meta: $meta;
+        context: $context;
+        results: Results<any>;
+    };
+}
+export declare function __initEventManager(): {
+    on: <Key extends keyof $events, Handler extends (event: $events[Key]) => void>(key: Key, handler: Handler) => () => void;
+    off: <Key extends keyof $events, Handler extends (event: $events[Key]) => void>(key: Key, handler: Handler) => void;
+    emit: <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value) => Promise<void>;
+};

package/exception/index.d.ts

@@ -0,0 +1,44 @@
+import type { MilkioResponseReject, Logger } from "../index.ts";
+export interface $rejectCode {
+    FAIL: string;
+    REQUEST_FAIL: any;
+    NOT_DEVELOP_MODE: string;
+    REQUEST_TIMEOUT: {
+        timeout: number;
+        message: string;
+    };
+    NOT_FOUND: {
+        path: string;
+    };
+    PARAMS_TYPE_INCORRECT: {
+        path: string;
+        expected: string;
+        value: any;
+        message: string;
+    } | null;
+    RESULTS_TYPE_INCORRECT: {
+        path: string;
+        expected: string;
+        value: any;
+        message: string;
+    } | null;
+    UNACCEPTABLE: {
+        expected: string;
+        message: string;
+    };
+    PARAMS_TYPE_NOT_SUPPORTED: {
+        expected: string;
+    };
+    RESULTS_TYPE_NOT_SUPPORTED: {
+        expected: string;
+    };
+    INTERNAL_SERVER_ERROR: undefined;
+}
+export declare function reject<Code extends keyof $rejectCode, RejectData extends $rejectCode[Code]>(code: Code, data: RejectData): MilkioRejectError<Code, RejectData>;
+export type MilkioRejectError<Code extends keyof $rejectCode = keyof $rejectCode, RejectData extends $rejectCode[Code] = $rejectCode[Code]> = {
+    code: Code;
+    data: RejectData;
+    stack: string;
+    $milkioReject: true;
+};
+export declare function exceptionHandler(executeId: string, logger: Logger, error: MilkioRejectError<any, any> | any): MilkioResponseReject;

package/execute/execute-id-generator.d.ts

@@ -0,0 +1,2 @@
+export type ExecuteIdGenerator = (request?: Request) => string | Promise<string>;
+export declare function defineDefaultExecuteIdGenerator(): () => string;

package/execute/index.d.ts

@@ -0,0 +1,30 @@
+import type { $context, $meta, Logger, Results, GeneratedInit } from "../index.ts";
+export declare function __initExecuter(generated: GeneratedInit, runtime: any): {
+    __call: (context: $context, module: {
+        default: any;
+    }, params?: any) => Promise<any>;
+    __execute: (routeSchema: any, options: {
+        createdExecuteId: string;
+        createdLogger: Logger;
+        path: string;
+        headers: Record<string, string> | Headers;
+        mixinContext: Record<any, any> | undefined;
+    } & ({
+        params: Record<any, any>;
+        paramsType: "raw";
+    } | {
+        params: string;
+        paramsType: "string";
+    })) => Promise<{
+        executeId: string;
+        headers: Headers;
+        params: Record<any, unknown>;
+        results: Results<any>;
+        context: $context;
+        meta: Readonly<$meta>;
+        type: "action" | "stream";
+        emptyResult: boolean;
+        resultsTypeSafety: boolean;
+        finales: Array<() => void | Promise<void>>;
+    }>;
+};

package/flow/index.d.ts

@@ -0,0 +1,8 @@
+export type MilkioFlow<T, TReturn = any, TNext = any> = {
+    emit: (flow: T) => void;
+    [Symbol.asyncIterator]: () => MilkioFlow<T>;
+    next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
+    return(): Promise<IteratorResult<T, TReturn>>;
+    throw(error: any): Promise<IteratorResult<T, TReturn>>;
+};
+export declare function createFlow<T>(): MilkioFlow<T>;

package/handler/index.d.ts

@@ -0,0 +1,3 @@
+import type { MilkioWorld } from "../index.ts";
+export declare function handler<HandlerInitT extends HandlerInit>(init: HandlerInitT): HandlerInitT;
+export type HandlerInit = (world: MilkioWorld) => Promise<void> | void;

package/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./type-safety/index.ts";
+export * from "@southern-aurora/tson";
+export * from "./types/index.ts";
+export * from "./config/index.ts";
+export * from "./execute/index.ts";
+export * from "./bootstrap/index.ts";
+export * from "./event/index.ts";
+export * from "./flow/index.ts";
+export * from "./handler/index.ts";
+export * from "./world/index.ts";
+export * from "./command/index.ts";
+export * from "./action/index.ts";
+export * from "./stream/index.ts";
+export * from "./logger/index.ts";
+export * from "./context/index.ts";
+export * from "./meta/index.ts";
+export * from "./step/index.ts";
+export * from "./listener/index.ts";
+export * from "./exception/index.ts";