milkio 1.3.3 → 1.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "milkio",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "type": "module",
   "exports": "./index.js",
   "types": "./index.d.ts",

package/action/index.d.ts

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

package/config/index.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,30 +0,0 @@
-import type { MilkioHttpRequest, MilkioHttpResponse, $types, Logger, Action, MilkioRuntimeInit, MilkioInit, CorsConfig } from "../index.ts";
-export interface $context {
-    _: MilkioRuntimeInit<MilkioInit>;
-    develop: boolean;
-    executeId: string;
-    path: string;
-    logger: Logger;
-    http: ContextHttp<Record<any, any>>;
-    headers: Headers;
-    config: Readonly<Awaited<ReturnType<$types["configSchema"]["get"]>>>;
-    typia: Readonly<$types["generated"]["typiaSchema"]>;
-    call: <Module extends Promise<Action<any>>>(module: Module, params: Parameters<Awaited<Module>["handler"]>[1]) => Promise<ReturnType<Awaited<Module>["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;
-    cors: CorsConfig;
-}
-export type ContextCreatedHandler = (context: $context) => Promise<void> | void;

package/event/index.d.ts

@@ -1,51 +0,0 @@
-import type { $context, ContextHttp, Results, Logger, $meta } from "../index.ts";
-export interface $events {
-    "*": {
-        key: keyof $events;
-        value: any;
-    };
-    "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;
-        success: boolean;
-    };
-    "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]) => Promise<void | boolean> | void | boolean>(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>;
-    _hasEmitHandlers: (key: string) => boolean;
-    readonly _version: number;
-    emitAnyApproved: <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value) => Promise<boolean>;
-    emitAllApproved: <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value) => Promise<boolean>;
-};

package/exception/index.d.ts

@@ -1,51 +0,0 @@
-import type { MilkioResponseReject, Logger } from "../index.ts";
-export interface $rejectCode {
-    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;
-        contentType: string | null;
-        params: string;
-    };
-    RESULTS_TYPE_NOT_SUPPORTED: {
-        expected: string;
-    };
-    INTERNAL_SERVER_ERROR: undefined;
-    METHOD_NOT_ALLOWED: undefined;
-    NETWORK_ERROR: undefined;
-}
-export type Reject = {
-    <Code extends keyof $rejectCode>(code: Code, ...data: $rejectCode[Code] extends undefined ? [] | [undefined] : [$rejectCode[Code]]): MilkioRejectError<Code, $rejectCode[Code]>;
-    <T>(obj: T): MilkioRejectError<Extract<keyof T, keyof $rejectCode>, any>;
-};
-export declare const reject: Reject;
-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

@@ -1,3 +0,0 @@
-import { __createId } from "../utils/create-id.ts";
-export type ExecuteIdGenerator = (headers?: Headers) => string | Promise<string>;
-export declare function defineDefaultExecuteIdGenerator(): typeof __createId;

package/execute/index.d.ts

@@ -1,32 +0,0 @@
-import type { $context, $meta, Logger, Results, GeneratedInit } from "../index.ts";
-export declare function __initExecuter(generated: GeneratedInit, runtime: any): {
-    __call: (context: $context, module: {
-        meta: any;
-        handler: any;
-    }, params?: any) => Promise<any>;
-    __execute: (routeSchema: any, options: {
-        createdExecuteId: string;
-        createdLogger: Logger;
-        path: string;
-        headers: Record<string, string> | Headers;
-        context: any | undefined;
-        paramsContentType?: string;
-    } & ({
-        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

@@ -1,8 +0,0 @@
-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/index.d.ts

@@ -1,17 +0,0 @@
-export * from "./utils/part.ts";
-export * from "./type-safety/index.ts";
-export * from "./types/index.ts";
-export * from "./config/index.ts";
-export * from "./execute/index.ts";
-export * from "./event/index.ts";
-export * from "./flow/index.ts";
-export * from "./world/index.ts";
-export * from "./action/index.ts";
-export * from "./stream/index.ts";
-export * from "./typia/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";

package/listener/index.d.ts

@@ -1,26 +0,0 @@
-import type { Mixin, GeneratedInit } from "../index.ts";
-import type { __initExecuter } from "../execute/index.ts";
-export type MilkioHttpRequest = Request;
-export type MilkioHttpResponse = Mixin<ResponseInit, {
-    body: string | ReadableStream<Uint8Array> | Uint8Array | ArrayBuffer | Blob | null;
-    status: number;
-    headers: Record<string, string>;
-}>;
-export declare function __initListener(generated: GeneratedInit, runtime: any, executer: ReturnType<typeof __initExecuter>): {
-    port: any;
-    fetch: (options: {
-        request: MilkioHttpRequest;
-        envMode?: string;
-        env?: Record<any, any>;
-        routeSchema?: any;
-        rawResponse?: boolean;
-    }) => Promise<Response>;
-    handleMessage: (port: {
-        postMessage(message: any): void;
-    }, options: {
-        executeId: string;
-        path: string;
-        params?: Record<any, any>;
-        headers?: Record<string, string>;
-    } | string) => Promise<void>;
-};

package/logger/index.d.ts

@@ -1,20 +0,0 @@
-import type { $context, MilkioInit, MilkioRuntimeInit } from "../index.ts";
-export type Log = ["(debug)" | "(info)" | "(warn)" | "(error)" | "(request)" | "(response)", string, string, string, string, ...Array<unknown>];
-export interface Logger {
-    _: {
-        logs: Array<Log>;
-        tags: Map<string, unknown>;
-        submit: (context: $context) => Promise<void> | void;
-    };
-    setTag: (key: string, value: unknown) => void;
-    setLog: (...log: Log) => void;
-    debug: (description: string, ...params: Array<unknown>) => Log;
-    info: (description: string, ...params: Array<unknown>) => Log;
-    warn: (description: string, ...params: Array<unknown>) => Log;
-    error: (description: string, ...params: Array<unknown>) => Log;
-    request: (description: string, ...params: Array<unknown>) => Log;
-    response: (description: string, ...params: Array<unknown>) => Log;
-}
-export type LoggerInsertingHandler = (log: Log) => boolean;
-export type LoggerSubmittingHandler = (context: $context, logs: Array<Log>, tags: Map<string, unknown>) => Promise<void> | void;
-export declare function createLogger<MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(runtime: MilkioRuntime, path: string, executeId: string): Logger;

package/meta/index.d.ts

@@ -1,12 +0,0 @@
-export interface $meta {
-    /**
-     * type safety
-     * @default ["params"]
-     */
-    typeSafety?: boolean | Array<"params">;
-    /**
-     * methods
-     * @default ["POST"]
-     */
-    methods?: Array<"GET" | "POST" | "PUT" | "DELETE" | "PATCH" | string>;
-}

package/step/index.d.ts

@@ -1,11 +0,0 @@
-export interface Steps<StageT extends Record<any, any>> {
-    step: StepFunction<StageT>;
-    run: () => Promise<Remove_<StageT>>;
-}
-type Remove_<T> = {
-    [K in keyof T as K extends `_${string}` ? never : K]: T[K];
-};
-type ToEmptyObject<T> = T extends undefined | null | never ? {} : T extends object ? T : {};
-export type StepFunction<StageT extends Record<any, any>> = <HandlerT extends (stage: Readonly<StageT>) => Record<any, any> | Promise<Record<any, any>>>(handler: HandlerT) => Steps<Awaited<StageT> & ToEmptyObject<Awaited<ReturnType<HandlerT>>>>;
-export declare function createStep(): Steps<{}>;
-export {};

package/stream/index.d.ts

@@ -1,9 +0,0 @@
-import type { $context, $meta } from "../index.ts";
-export type StreamInit = {
-    meta?: $meta;
-    handler: (context: $context, params: any) => AsyncGenerator<unknown>;
-};
-export type Stream<StreamInitT extends StreamInit> = {
-    meta?: $meta;
-    handler: StreamInitT["handler"];
-};

package/type-safety/index.d.ts

@@ -1,9 +0,0 @@
-export type TypeSafety<Value extends Record<any, any>> = (value: Value) => TypeSafetyValue;
-export interface TypeSafetyValue {
-    type: <Type extends Record<any, any>>() => Type;
-}
-export interface TypeSafetyType<Type extends Record<any, any>> {
-    $milkioType: "type-safety";
-    value: Type;
-}
-export declare function typeSafety<Value extends Record<any, any>>(value: Value): TypeSafetyValue;

package/types/index.d.ts

@@ -1,76 +0,0 @@
-import type { $rejectCode } from "../index.ts";
-export interface $types {
-    [key: string]: Record<any, any>;
-}
-export type Override<P, S> = Omit<P, keyof S> & S;
-export type Mixin<T, U> = U & Omit<T, keyof U>;
-export type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
-export type DBSelect<T extends Record<any, any>, K extends keyof T> = Omit<T, K>;
-export type DBCreate<T, KO extends keyof T | never = never, TO extends Omit<T, KO> = Omit<T, KO>> = {
-    [K in keyof TO]?: TO[K] extends null ? undefined : Exclude<TO[K], null>;
-};
-export type DBUpdate<T, KO extends keyof T | never = never, TO extends Partial<Omit<T, KO>> = Partial<Omit<T, KO>>> = {
-    [K in keyof TO]?: TO[K] extends null ? undefined : Exclude<TO[K], null>;
-};
-export type ExecuteId = string | "global";
-export interface GeneratedInit {
-    routeSchema: any;
-    handlerSchema: any;
-    typiaSchema: any;
-    events: any;
-}
-export interface Results<T> {
-    value: T;
-}
-export interface ExecuteOptions {
-    params?: Record<any, any>;
-    headers?: Record<string, string>;
-}
-export type Ping = [
-    {
-        connect: false;
-        delay: number;
-        error: any;
-    },
-    null
-] | [
-    null,
-    {
-        connect: true;
-        delay: number;
-        serverTimestamp: number;
-    }
-];
-export interface ExecuteResultsOption {
-    executeId: string;
-}
-export type ExecuteActionResults<Path extends keyof Generated["routeSchema"], Generated extends $types["generated"] = $types["generated"]> = Generated["routeSchema"][Path]["result"];
-export type ExecuteStreamResults<Path extends keyof Generated["routeSchema"], Generated extends $types["generated"] = $types["generated"]> = GeneratorGeneric<Generated["routeSchema"][Path]["result"]>;
-export interface MilkioResponseReject<Code extends keyof $rejectCode = keyof $rejectCode> {
-    success: false;
-    code: Code;
-    reject: $rejectCode[Code];
-    executeId: string;
-}
-export interface MilkioResponseSuccess<Path extends keyof Generated["routeSchema"], Generated extends $types["generated"] = $types["generated"]> {
-    success: true;
-    data: Generated["routeSchema"][Path]["result"];
-    executeId: string;
-}
-export type BreadBrowse<T, U extends Record<any, any> = {}> = Omit<{
-    data: Array<T>;
-}, keyof U> & U;
-export type BreadRead<T, U extends Record<any, any> = {}> = Omit<{
-    data: T;
-}, keyof U> & U;
-export type BreadEdit<U extends Record<any, any> = {}> = U;
-export type BreadAdd<U extends Record<any, any> = {}> = U;
-export type BreadDelete<U extends Record<any, any> = {}> = U;
-export interface CorsConfig {
-    corsAllowMethods?: string[];
-    corsAllowHeaders?: string[];
-    corsExposeHeaders?: string[];
-    corsAllowOrigin?: string[];
-    corsAllowCredentials?: boolean;
-    corsMaxAge?: number;
-}

package/typia/index.d.ts

@@ -1,3 +0,0 @@
-export declare function typia<TypiaInitT extends TypiaInit>(init: TypiaInitT): Typia<TypiaInitT>;
-export type TypiaInit = () => Record<PropertyKey, unknown> | Promise<Record<PropertyKey, unknown>>;
-export type Typia<TypiaInitT extends TypiaInit> = TypiaInitT;

package/utils/build-cors-headers.d.ts

@@ -1,2 +0,0 @@
-import type { CorsConfig } from "../index.ts";
-export declare function buildCorsHeaders(cors: CorsConfig | undefined, origin?: string | null): Record<string, string>;

package/utils/create-id.d.ts

@@ -1 +0,0 @@
-export declare function __createId(): string;

package/utils/headers-to-json.d.ts

@@ -1 +0,0 @@
-export declare function headersToJSON(headers: Headers): Record<string, string>;

package/utils/merge-deep.d.ts

@@ -1 +0,0 @@
-export declare function mergeDeep<T extends Record<string, any>, U extends Record<string, any>>(target: T, source: U): T;

package/utils/part.d.ts

@@ -1 +0,0 @@
-export declare function part<T extends () => unknown>(handler: T): ReturnType<T>;

package/utils/revive-json-parse.d.ts

@@ -1 +0,0 @@
-export declare function reviveJSONParse<T>(json: T): T;

package/utils/send-cookbook-event.d.ts

@@ -1,7 +0,0 @@
-import type { Log, MilkioInit, MilkioRuntimeInit } from "../index.ts";
-interface CookbookEvent {
-    type: "milkio@logger";
-    log: Log;
-}
-export declare function sendCookbookEvent(runtime: MilkioRuntimeInit<MilkioInit>, event: CookbookEvent): Promise<void>;
-export {};

package/utils/trie.d.ts

@@ -1,9 +0,0 @@
-export declare class Trie<T> {
-    private root;
-    private cache;
-    constructor();
-    add(path: string, value: T): void;
-    get(path: string): T | null;
-    getByParts(parts: string[]): T | null;
-    has(path: string): boolean;
-}

package/world/index.d.ts

@@ -1,49 +0,0 @@
-import { type $types, __initListener, __initEventManager, type ExecuteId, type Logger, type Mixin, type GeneratedInit, type Ping, type LoggerSubmittingHandler, type LoggerInsertingHandler, type CorsConfig } from "../index.ts";
-export interface MilkioInit {
-    port: number;
-    develop: boolean;
-    fetchEnv?: (key: string) => string | undefined;
-    accessKey?: string;
-    http?: {
-        cors?: CorsConfig;
-    };
-    ignorePathLevel?: number;
-    realIp?: (headers: Headers) => string;
-    executeId?: (headers: Headers) => string | Promise<string>;
-    onLoggerSubmitting?: LoggerSubmittingHandler;
-    onLoggerInserting?: LoggerInsertingHandler;
-    bootstraps?: Array<(world: any) => Promise<void> | void>;
-}
-export type MilkioRuntimeInit<T extends MilkioInit> = Mixin<T, {
-    executeId: (headers: Headers) => string | Promise<string>;
-    runtime: {
-        request: Map<ExecuteId, {
-            logger: Logger;
-        }>;
-        config: Awaited<ReturnType<$types["generated"]["configSchema"]>>;
-        app: any;
-    };
-    on: Awaited<ReturnType<typeof __initEventManager>>["on"];
-    off: Awaited<ReturnType<typeof __initEventManager>>["off"];
-    emit: Awaited<ReturnType<typeof __initEventManager>>["emit"];
-    emitAnyApproved: Awaited<ReturnType<typeof __initEventManager>>["emitAnyApproved"];
-    emitAllApproved: Awaited<ReturnType<typeof __initEventManager>>["emitAllApproved"];
-    _hasEmitHandlers: Awaited<ReturnType<typeof __initEventManager>>["_hasEmitHandlers"];
-    _emitHandlersVersion: number;
-}>;
-export declare function createWorld<MilkioOptions extends MilkioInit>(generated: GeneratedInit, configSchema: {
-    get: () => Promise<Record<any, any>>;
-}, options: MilkioOptions): Promise<unknown>;
-export interface MilkioWorld<Generated extends GeneratedInit, MilkioOptions extends MilkioInit = MilkioInit> {
-    _: MilkioRuntimeInit<MilkioOptions>;
-    on: <Key extends keyof Generated["events"], Handler extends (event: Generated["events"][Key]) => void>(key: Key, handler: Handler) => (() => void);
-    off: <Key extends keyof Generated["events"], Handler extends (event: Generated["events"][Key]) => void>(key: Key, handler: Handler) => void;
-    emit: <Key extends keyof Generated["events"], Value extends Generated["events"][Key]>(key: Key, value: Value) => Promise<void>;
-    emitAnyApproved: <Key extends keyof Generated["events"], Value extends Generated["events"][Key]>(key: Key, value: Value) => Promise<boolean>;
-    emitAllApproved: <Key extends keyof Generated["events"], Value extends Generated["events"][Key]>(key: Key, value: Value) => Promise<boolean>;
-    ping: (options?: {
-        timeout?: number;
-    }) => Promise<Ping>;
-    listener: Awaited<ReturnType<typeof __initListener>>;
-    config: Readonly<Awaited<ReturnType<$types["configSchema"]["get"]>>>;
-}