io.vertx.up.unity.Ux Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of vertx-up Show documentation
The newest version!
package io.vertx.up.unity;

import io.aeon.experiment.rule.RuleTerm;
import io.horizon.atom.common.Kv;
import io.horizon.eon.VString;
import io.horizon.eon.em.typed.ChangeFlag;
import io.horizon.eon.em.secure.AuthWall;
import io.modello.specification.HRecord;
import io.vertx.core.*;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.eventbus.Message;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;
import io.vertx.core.shareddata.ClusterSerializable;
import io.vertx.ext.auth.User;
import io.vertx.ext.web.FileUpload;
import io.vertx.ext.web.RoutingContext;
import io.vertx.tp.plugin.database.DataPool;
import io.vertx.tp.plugin.jooq.JooqDsl;
import io.vertx.tp.plugin.jooq.JooqInfix;
import io.vertx.up.atom.Refer;
import io.vertx.up.atom.query.Pagination;
import io.vertx.up.atom.record.Apt;
import io.vertx.up.atom.secure.AegisItem;
import io.vertx.up.atom.secure.Vis;
import io.vertx.up.atom.worker.Mission;
import io.vertx.up.commune.Envelop;
import io.vertx.up.commune.config.Integration;
import io.vertx.up.commune.exchange.DConsumer;
import io.vertx.up.commune.exchange.DFabric;
import io.vertx.up.commune.exchange.DSetting;
import io.vertx.up.eon.KName;
import io.horizon.exception.WebException;
import io.vertx.up.fn.Fn;
import io.vertx.up.runtime.ZeroYml;
import io.vertx.up.secure.Lee;
import io.vertx.up.secure.LeeBuiltIn;
import io.vertx.up.uca.jooq.UxJoin;
import io.vertx.up.uca.jooq.UxJooq;
import io.vertx.up.util.Ut;

import java.time.Instant;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * #「Kt」Utility X Component in zero
 * 
 * Here Ux is a util interface of uniform to call different tools.
 * It just like helper for business usage.
 */
@SuppressWarnings("all")
public final class Ux {

    /**
     * Create new log instance for store `Annal` mapping
     * 

     * Debug method for help us to do development
     * 1) debug:
     * -- debugTc:  It will be used in test case
     * 2) otherwise:
     * 3) dataN/dataO -> New / Old Json
     * ( Business Part: Debugging )
     */

    public static void debug(final Object... objects) {
        Debug.monitor(objects);
    }

    public static void debugTc(final ClusterSerializable cluster) {
        Debug.monitorTc(cluster);
    }

    public static  Future debug(final T item) {
        return Debug.debug(item);
    }

    public static  T debug(final Throwable error, final Supplier supplier) {
        return Debug.debug(error, supplier);
    }

    public static Function otherwise() {
        return Debug.otherwise();
    }

    public static  Function otherwise(Supplier supplier) {
        return Debug.otherwise(supplier);
    }

    public static  Function otherwise(T input) {
        return otherwise(() -> input);
    }


    /*
     * Update Data on Record
     * 1. Generic T ( Pojo )
     * 2. List
     * 3. JsonObject
     * 4. JsonArray
     * 5. Record
     * 6. Record[]
     */
    public static  T cloneT(final T input) {
        return Compare.cloneT(input);
    }

    public static  T updateT(final T query, final JsonObject params) {
        return Compare.updateT(query, params);
    }

    public static  List updateT(final List query, final JsonArray params) {
        return Compare.updateT(query, params, KName.KEY);
    }

    public static  List updateT(final List query, final JsonArray params, final String field) {
        return Compare.updateT(query, params, field);
    }

    public static JsonArray updateJ(final JsonArray query, final JsonArray params) {
        return Compare.updateJ(query, params, KName.KEY);
    }

    public static JsonArray updateJ(final JsonArray query, final JsonArray params, final String field) {
        return Compare.updateJ(query, params, field);
    }

    public static HRecord updateR(final HRecord record, final JsonObject params) {
        return Compare.updateR(record, params, () -> UUID.randomUUID().toString());
    }

    public static HRecord[] updateR(final HRecord[] record, final JsonArray array) {
        return updateR(record, array, KName.KEY);
    }

    public static HRecord[] updateR(final HRecord[] record, final JsonArray array, final String field) {
        final List recordList = Arrays.asList(record);
        return Compare.updateR(recordList, array, field).toArray(new HRecord[]{});
    }

    /*
     * Rule Match
     * 1. single checking
     * 2. double checking
     * 3. array checking
     */
    public static JsonObject ruleAll(final Collection rules, final JsonObject input) {
        return Unique.ruleAll(rules, input);
    }

    public static ConcurrentMap ruleAll(final Collection rules, final JsonArray input) {
        return Unique.ruleAll(rules, input);
    }

    public static JsonObject ruleAll(final Collection rules, final JsonObject recordO, final JsonObject recordN) {
        return Unique.ruleAll(rules, recordO, recordN);
    }

    public static JsonObject ruleAll(final Collection rules, final JsonArray source, final JsonObject record) {
        return Unique.ruleAll(rules, source, record);
    }

    public static JsonObject ruleAny(final Collection rules, final JsonObject input) {
        return Unique.ruleAny(rules, input);
    }

    public static JsonObject ruleAny(final Collection rules, final JsonObject record0, final JsonObject recordN) {
        return Unique.ruleAny(rules, record0, recordN);
    }

    public static JsonObject ruleAny(final Collection rules, final JsonArray source, final JsonObject record) {
        return Unique.ruleAny(rules, source, record);
    }

    public static ConcurrentMap ruleAny(final Collection rules, final JsonArray input) {
        return Unique.ruleAny(rules, input);
    }

    public static JsonObject ruleTwins(final JsonObject recordO, final JsonObject recordN) {
        return Unique.ruleTwins(recordO, recordN);
    }

    public static JsonObject ruleNil(final JsonObject twins, final ChangeFlag flag) {
        return Unique.ruleNil(twins, flag);
    }

    public static JsonObject ruleNil(final JsonObject recordN, final JsonObject recordO) {
        return Objects.isNull(recordN) ? recordO : recordN;
    }

    public static Apt ruleApt(final JsonArray twins, final boolean isReplaced) {
        return Unique.ruleApt(twins, isReplaced);
    }

    // ------------------------- Compare Json ------------------------
    /*
     *  1) ruleJOk
     *  2) ruleJReduce
     *  3) ruleJEqual
     *  4) ruleJFind
     */
    public static boolean ruleJOk(final JsonObject record, final Set fields) {
        return CompareJ.ruleJOk(record, fields);
    }

    public static boolean ruleJOk(final JsonObject record, final JsonArray matrix) {
        return CompareJ.ruleJOk(record, matrix);
    }

    public static JsonArray ruleJReduce(final JsonArray records, final Set fields) {
        return CompareJ.ruleJReduce(records, fields);
    }

    public static JsonArray ruleJReduce(final JsonArray records, final JsonArray matrix) {
        return CompareJ.ruleJReduce(records, matrix);
    }

    public static boolean ruleJEqual(final JsonObject record, final JsonObject latest, final Set fields) {
        return CompareJ.ruleJEqual(record, latest, fields);
    }

    public static boolean ruleJEqual(final JsonObject record, final JsonObject latest, final JsonArray matrix) {
        return CompareJ.ruleJEqual(record, latest, matrix);
    }

    public static JsonObject ruleJFind(final JsonArray source, final JsonObject expected, final Set fields) {
        return CompareJ.ruleJFind(source, expected, fields);
    }

    public static JsonObject ruleJFind(final JsonArray source, final JsonObject expected, final JsonArray matrix) {
        return CompareJ.ruleJFind(source, expected, matrix);
    }

    /*
     * Entity ( Pojo ) to JsonObject, support pojo file here
     * 1) toJson / fromJson
     * 2) toZip:  Toggle switch from interface style to worker here, the key should be "0", "1", "2", "3", ....
     * 3) toJArray
     * ( Business Part, support `pojoFile` conversation )
     * 4) toFile
     */

    public static  JsonObject toJson(final T entity) {
        return To.toJObject(entity, "");
    }

    public static  JsonObject toJson(final T entity, final String pojo) {
        return To.toJObject(entity, pojo);
    }

    public static  JsonArray toJson(final List list) {
        return To.toJArray(list, "");
    }

    public static  JsonArray toJson(final List list, final String pojo) {
        return To.toJArray(list, pojo);
    }

    public static JsonObject toZip(final Object... args) {
        return To.toToggle(args);
    }

    /*
     * Analyze the arguments by type
     * 1) used by `io.vertx.up.uca.rs.mime.parse.TypedAtomic`.
     * 2) used by `io.vertx.up.uca.invoker.InvokerUtil`.
     * The arguments are different, but could support more method declare
     */
    // Job
    public static Object toParameter(final Envelop envelop, final Class type, final Mission mission, final Refer underway) {
        return Web.toParameter(envelop, type, mission, underway);
    }

    // Worker
    public static Object toParameter(final Envelop envelop, final Class type) {
        return Web.toParameter(envelop, type);
    }

    // Agent
    public static Object toParameter(final RoutingContext context, final Class type) {
        return Web.toParameter(context, type);
    }

    public static  T fromJson(final JsonObject data, final Class clazz) {
        return From.fromJson(data, clazz, "");
    }

    public static  List fromJson(final JsonArray array, final Class clazz) {
        return From.fromJson(array, clazz, "");
    }

    public static  List fromPage(final JsonObject data, final Class clazz) {
        return fromJson(pageData(data), clazz);
    }

    public static  T fromJson(final JsonObject data, final Class clazz, final String pojo) {
        return From.fromJson(data, clazz, pojo);
    }

    public static  List fromJson(final JsonArray array, final Class clazz, final String pojo) {
        return From.fromJson(array, clazz, pojo);
    }

    /**
     * File upload tool to convert data
     *
     * @param fileUploads Set of file uploads
     * @param expected    The method declared type
     * @param consumer    File consumer to read `filename` to Buffer
     * @param          Returned type for declared
     *
     * @return T reference that converted
     */
    public static  T toFile(final Set fileUploads, final Class expected, final Function consumer) {
        return Upload.toFile(fileUploads, expected, consumer);
    }

    /**
     * Single file upload converting
     *
     * @param fileUpload The `FileUpload` reference
     * @param expected   The method declared type
     * @param consumer   File consumer to read `filename` to Buffer
     * @param         Returned type of declared
     *
     * @return T reference that converted
     */
    public static  T toFile(final FileUpload fileUpload, final Class expected, final Function consumer) {
        return Upload.toFile(fileUpload, expected, consumer);
    }

    /**
     * Split `Set` by fieldname
     *
     * @param fileUploads FileUpload Set
     *
     * @return Map of `field = Set`
     */
    public static ConcurrentMap> toFile(final Set fileUploads) {
        return Upload.toFile(fileUploads);
    }

    /*
     * Envelop building here
     * 1) envelop: ( Get different Envelop )
     * 2) future: ( Wrapper Future.successedFuture / Future.failureFuture ) at same time
     * 3) handler: ( Handler> )
     * 4) compare: ( Compare two object )
     * 5) complex:
     *    - JsonObject -> condition -> executor
     *    - JsonArray -> condition -> grouper -> executor
     */
    public static Envelop fromEnvelop(final Class clazz, final Object... args) {
        return To.toEnvelop(clazz, args);
    }

    public static  Envelop fromEnvelop(final T entity) {
        return To.toEnvelop(entity);
    }

    public static  Envelop fromEnvelop(final T entity, final WebException error) {
        return To.toEnvelop(entity, error);
    }

    public static  Future fromAsync(final CompletionStage state) {
        return Async.fromAsync(state);
    }

    public static  Future future(final T entity) {
        return To.future(entity);
    }

    public static  Future future(final T input, final List>> functions) {
        return Async.future(input, functions);
    }

    public static  Future future(final T input, final Set>> functions) {
        return Async.future(input, functions);
    }

    public static  Future future() {
        return To.future(null);
    }

    public static Future complex(final JsonObject input, final Predicate predicate, final Supplier> executor) {
        return Complex.complex(input, predicate, executor);
    }

    public static Future complex(final Pagination first, final Function> total, final Function> page, final Function> result) {
        return Complex.complex(first, total, page, result, JsonArray::addAll);
    }

    public static Function> complex(final Function> total, final Function> page, final Function> result) {
        return Complex.complex(total, page, result);
    }

    public static Function> complex(final Function> page) {
        return complex(data -> To.future(data.getInteger("count")), page, response -> To.future(response.getJsonArray("list")));
    }

    public static  Handler> handler(final Message message) {
        return Web.toHandler(message);
    }

    public static  Future handler(final Consumer>> handler) {
        return Web.toFuture(handler);
    }
    /*
     * 1) compare
     * 2) compareJ
     * 3) compareRun
     */

    public static  ConcurrentMap> compare(final List original, final List current, final Function fnValue, final String pojoFile) {
        return Compare.compare(original, current, fnValue, pojoFile);
    }

    public static  ConcurrentMap> compare(final List original, final List current, final Function fnValue) {
        return Compare.compare(original, current, fnValue, VString.EMPTY);
    }

    public static  ConcurrentMap> compare(final List original, final List current, final Set uniqueSet, final String pojoFile) {
        return Compare.compare(original, current, uniqueSet, pojoFile);
    }

    public static  ConcurrentMap> compare(final List original, final List current, final Set uniqueSet) {
        return Compare.compare(original, current, uniqueSet, VString.EMPTY);
    }

    public static ConcurrentMap compareJ(
        final JsonArray original, final JsonArray current, final Set fields) {
        return CompareJ.compareJ(original, current, fields);
    }

    public static ConcurrentMap compareJ(
        final JsonArray original, final JsonArray current, final String field) {
        return CompareJ.compareJ(original, current, field);
    }

    public static ConcurrentMap compareJ(
        final JsonArray original, final JsonArray current, final JsonArray matrix) {
        return CompareJ.compareJ(original, current, matrix);
    }

    public static Future> compareJAsync(
        final JsonArray original, final JsonArray current, final Set fields) {
        return To.future(CompareJ.compareJ(original, current, fields));
    }

    public static Future> compareJAsync(
        final JsonArray original, final JsonArray current, final String field) {
        return To.future(CompareJ.compareJ(original, current, field));
    }

    public static Future> compareJAsync(
        final JsonArray original, final JsonArray current, final JsonArray matrix) {
        return To.future(CompareJ.compareJ(original, current, matrix));
    }

    public static  Future compareRun(final ConcurrentMap> compared, final Function, Future>> insertAsyncFn, final Function, Future>> updateAsyncFn) {
        return Compare.run(compared, insertAsyncFn, updateAsyncFn);
    }

    /*
     *  future prefix processing here
     *
     * JsonArray
     * 1) futureA
     * -- futureA()
     * -- futureA(List)
     * -- futureA(List, pojo)
     * -- futureA(String)
     * -- futureA(Record[])
     *
     * JsonObject
     * 2) futureJ
     * -- futureJ()
     * -- futureJ(T)
     * -- futureJ(T, pojo)
     * -- futureJ(String)
     * -- futureJ(Record)
     * -- futureJM(T, String)
     *
     * List
     * 3) futureL
     * -- futureL()
     * -- futureL(List)
     * -- futureL(List, pojo)
     * -- futureL(String)
     *
     * Grouped
     * 4) futureG
     * -- futureG(List, String)
     * -- futureG(T, String)
     * -- futureG(List)
     * -- futureG(T)
     *
     * Error Future
     * 5) futureE
     * -- futureE(T)
     * -- futureE(Supplier)
     *
     * New Api for normalized mount
     * 6) futureN
     * -- futureN(JsonObject, JsonObject)
     * -- futureN(JsonArray, JsonArray)
     * -- futureN(JsonArray, JsonArray, String)
     * > N for normalize and add new field:  __data,  __flag instead of original data
     *
     * Combine JsonObject and JsonArray by index
     * 7) futureC
     *
     * Filter JsonObject and JsonArray
     * 8) futureF
     * -- futureF(String...)
     * -- futureF(Set)
     * -- futureF(ClustSerializble, String...)
     * -- futureF(JsonArray, String...)
     * -- futureF(JsonObject, Set)
     * -- futureF(JsonArray, Set)
     */
    // ----------------------- futureF ----------------------

    public static  Function> futureF(final Set removed) {
        return input -> (input instanceof JsonObject) ?
            futureF((JsonObject) input, removed).compose(json -> To.future((T) json)) :
            futureF((JsonArray) input, removed).compose(array -> To.future((T) array));
    }

    public static  Function> futureF(final String... removed) {
        return futureF(Arrays.stream(removed).collect(Collectors.toSet()));
    }

    public static Future futureF(final JsonObject input, final String... removed) {
        return To.future(To.subset(input, Arrays.stream(removed).collect(Collectors.toSet())));
    }

    public static Future futureF(final JsonObject input, final Set removed) {
        return To.future(To.subset(input, removed));
    }

    public static Future futureF(final JsonArray input, final String... removed) {
        return To.future(To.subset(input, Arrays.stream(removed).collect(Collectors.toSet())));
    }

    public static Future futureF(final JsonArray input, final Set removed) {
        return To.future(To.subset(input, removed));
    }

    // ----------------------- futureN ----------------------
    public static Future futureN(final JsonObject input, final JsonObject previous, final JsonObject current) {
        return Norm.effect(input, previous, current);
    }

    public static Future futureN(final JsonArray previous, final JsonArray current) {
        return Norm.effect(previous, current, KName.KEY);
    }

    public static Future futureN(final JsonArray previous, final JsonArray current, final String field) {
        return Norm.effect(previous, current, field);
    }

    public static  Future futureC(final T input, final T processed) {
        return Norm.combine(input, processed);
    }

    public static Future futureT() {
        return To.future(Boolean.TRUE);
    }

    public static  Future futureT(final T input) {
        return To.future(Boolean.TRUE);
    }

    public static Future futureF() {
        return To.future(Boolean.FALSE);
    }

    public static  Future> futureL() {
        return future(new ArrayList<>());
    }

    public static  Future> futureL(final T single) {
        final List list = new ArrayList<>();
        list.add(single);
        return future(list);
    }

    public static  Function> futureE(final T input) {
        return Async.toErrorFuture(() -> input);
    }

    public static  Function> futureE(final Supplier supplier) {
        return Async.toErrorFuture(supplier);
    }

    public static  Future futureA(final List list, final String pojo) {
        return Future.succeededFuture(To.toJArray(list, pojo));
    }

    public static Future futureA() {
        return futureA(new ArrayList<>(), VString.EMPTY);
    }

    public static Future futureA(Throwable ex) {
        return Async.toErrorFuture(JsonArray::new).apply(ex);
    }

    public static  Future futureA(final List list) {
        return futureA(list, VString.EMPTY);
    }

    public static  Function, Future> futureA(final String pojo) {
        return list -> futureA(list, pojo);
    }

    // --------------- T of entity processing -----------------

    public static  Future futureJ(final T entity, final String pojo) {
        return Future.succeededFuture(To.toJObject(entity, pojo));
    }

    public static  Function, Future> futureJM(final T entity, final String field) {
        return list -> Future.succeededFuture(To.toMerge(entity, field, list));
    }

    public static Future futureJ() {
        return futureJ(new JsonObject(), VString.EMPTY);
    }

    public static Future futureJ(Throwable ex) {
        return Async.toErrorFuture(JsonObject::new).apply(ex);
    }

    public static  Future futureJ(final T entity) {
        return futureJ(entity, VString.EMPTY);
    }

    public static  Function> futureJ(final String pojo) {
        return entity -> futureJ(entity, pojo);
    }

    // --------------- List of future processing -----------------
    public static  Future> futureL(final List list, final String pojo) {
        return Future.succeededFuture(To.toJList(list, pojo));
    }

    public static  Future> futureLJ() {
        return futureL(new ArrayList<>(), VString.EMPTY);
    }

    public static  Future> futureL(final List list) {
        return futureL(list, VString.EMPTY);
    }

    public static  Function, Future>> futureL(final String pojo) {
        return list -> futureL(list, pojo);
    }

    // --------------- Record processing -----------------

    public static Future futureJ(final HRecord record) {
        return Fn.runOr(futureJ(), () -> To.future(record.toJson()), record);
    }

    public static Future futureA(final HRecord[] records) {
        return Fn.runOr(futureA(), () -> To.future(Ut.toJArray(records)), records);
    }

    // --------------- Future of Map -----------------
    public static  Future> futureG(final List item, final String field) {
        return futureG(To.toJArray(item, ""), field);
    }

    public static Future> futureG(final JsonArray item, final String field) {
        return Future.succeededFuture(Ut.elementGroup(item, field));
    }

    public static  Future> futureG(final List item) {
        return futureG(To.toJArray(item, ""), "type");
    }

    public static Future> futureG(final JsonArray item) {
        return futureG(item, "type");
    }

    /*
     * Channel Execution
     *
     * 1. channel
     * 2. channelS
     * 3. channelA
     */
    public static  Future channel(final Class clazz, final Supplier supplier,
                                           final Function> executor) {
        return Async.channel(clazz, supplier, executor);
    }


    public static  O channelS(final Class clazz, final Supplier supplier,
                                    final Function executor) {
        return Async.channelSync(clazz, supplier, executor);
    }

    public static  O channelS(final Class clazz, final Function executor) {
        return Async.channelSync(clazz, () -> null, executor);
    }

    public static  Future channelA(final Class clazz, final Supplier> supplier,
                                            final Function> executor) {
        return Async.channelAsync(clazz, supplier, executor);
    }

    /*
     * Normalize pageData in framework
     * {
     *      "list": [],
     *      "count": xx
     * }
     * Normalize old/new data in framework
     */

    public static JsonObject pageData() {
        return Web.pageData(new JsonArray(), 0L);
    }

    public static JsonObject pageData(final JsonArray data, final long size) {
        return Web.pageData(data, size);
    }

    public static JsonArray pageData(final JsonObject data) {
        return Ut.valueJArray(data.getJsonArray(KName.LIST));
    }

    public static JsonObject pageData(final JsonObject pageData, final Function function) {
        return Web.pageData(pageData, function);
    }

    /*
     * JqTool Engine method
     * 1) whereDay
     * 2) whereAnd
     * 3) whereOr
     * 4) whereKeys
     */
    public static JsonObject whereDay(final JsonObject filters, final String field, final Instant instant) {
        return Where.whereDay(filters, field, instant);
    }

    public static JsonObject whereDay(final JsonObject filters, final String field, final LocalDateTime instant) {
        return Where.whereDay(filters, field, Ut.parse(instant).toInstant());
    }

    public static JsonObject whereKeys(final Set keys) {
        return Where.whereKeys(Ut.toJArray(keys));
    }

    public static JsonObject whereKeys(final JsonArray keys) {
        return Where.whereKeys(keys);
    }

    public static JsonObject whereAnd() {
        return Where.whereAnd();
    }

    public static JsonObject whereAnd(final String field, final Object value) {
        return Where.whereAnd().put(field, value);
    }

    public static JsonObject whereOr() {
        return Where.whereOr();
    }

    public static JsonObject whereOr(final String field, final Object value) {
        return Where.whereOr().put(field, value);
    }

    // Where current condition is null
    /*
     * Query Engine API
     *
     * QH -> Query with Criteria   （全格式）
     * H  -> Criteria              （查询条件）
     * V  -> Projection            （列过滤）
     *
     * 1) irNil / irAnd / irOne
     *    - irNil:          判断查询条件是否为空，"": true | false 单节点也为空
     *    - irOp:           判断查询条件是 AND 还是 OR，AND返回true，OR返回false
     *    - irOne:          判断查询条件是否单条件（只有一个条件）
     * 2) irAndQH / irAndH
     *    - irAndQH:        参数本身为全格式:
     *      {
     *           "criteria": {}
     *      }
     *    - irAndH:         参数本身为全格式中的 criteria 纯格式
     * 3) irQV / irV
     *    - irQV:           参数本身为全格式:
     *      {
     *           "projection": []
     *      }
     *    - irV:            参数本身为全格式中的 projection 纯格式
     *
     * 全格式返回全格式，纯格式返回纯格式
     */
    public static boolean irNil(final JsonObject condition) {
        return Query.irNil(condition);
    }

    public static boolean irOp(final JsonObject condition) {
        return Query.irAnd(condition);
    }

    public static boolean irOne(final JsonObject condition) {
        return Query.irOne(condition);
    }

    // ---------------------- Qr Modification --------------------------
    public static JsonObject irAndQH(final JsonObject qr, final Kv kv) {
        Objects.requireNonNull(kv);
        return Query.irQH(qr, kv.key(), kv.value());
    }

    public static JsonObject irAndQH(final JsonObject qr, final String field, final Object value) {
        return Query.irQH(qr, field, value);
    }

    public static JsonObject irAndQH(final JsonObject query, final JsonObject criteria, final boolean clear) {
        return Query.irQH(query, criteria, clear);
    }

    public static JsonObject irAndH(final JsonObject original, final JsonObject criteria) {
        return Query.irH(original, criteria);
    }

    public static JsonObject irAndH(final JsonObject original, final String field, final Object value) {
        return Query.irH(original, field, value);
    }

    public static JsonObject irAndH(final JsonObject original, final Kv kv) {
        Objects.requireNonNull(kv);
        return Query.irH(original, kv.key(), kv.value());
    }

    // Qr Combine ( projection + projection )
    public static JsonObject irQV(final JsonObject query, final JsonArray projection, final boolean clear) {
        return Query.irQV(query, projection, clear);
    }

    public static JsonArray irV(final JsonArray original, final JsonArray projection) {
        return Query.irV(original, projection);
    }

    // ---------------------- Request Data Extract --------------------------
    // -> Message -> T ( Interface mode )

    public static JsonArray getArray(final Envelop envelop, final int index) {
        return In.request(envelop, index, JsonArray.class);
    }

    // -> Message -> T ( Interface mode )
    public static JsonArray getArray(final Envelop envelop) {
        return In.request(envelop, 0, JsonArray.class);
    }

    // -> Message -> T ( Interface mode )

    public static JsonArray getArray1(final Envelop envelop) {
        return In.request(envelop, 1, JsonArray.class);
    }

    // -> Message -> T ( Interface mode )

    public static JsonArray getArray2(final Envelop envelop) {
        return In.request(envelop, 2, JsonArray.class);
    }

    // -> Message -> String ( Interface mode )

    public static String getString(final Envelop envelop, final int index) {
        return In.request(envelop, index, String.class);
    }

    // -> Message -> String ( Interface mode )
    public static String getString(final Envelop envelop) {
        return In.request(envelop, 0, String.class);
    }

    // -> Message -> String ( Interface mode )
    public static String getString1(final Envelop envelop) {
        return In.request(envelop, 1, String.class);
    }

    // -> Message -> String ( Interface mode )
    public static String getString2(final Envelop envelop) {
        return In.request(envelop, 2, String.class);
    }

    // -> Message -> String ( Interface mode )

    public static Vis getVis(final Envelop envelop, final int index) {
        return In.request(envelop, index, Vis.class);
    }

    // -> Message -> String ( Interface mode )
    public static Vis getVis(final Envelop envelop) {
        return In.request(envelop, 0, Vis.class);
    }

    // -> Message -> String ( Interface mode )
    public static Vis getVis1(final Envelop envelop) {
        return In.request(envelop, 1, Vis.class);
    }

    // -> Message -> String ( Interface mode )
    public static Vis getVis2(final Envelop envelop) {
        return In.request(envelop, 2, Vis.class);
    }

    // -> Message -> JsonObject ( Interface mode )
    public static JsonObject getJson(final Envelop envelop, final int index) {
        return In.request(envelop, index, JsonObject.class);
    }
    // -> Message -> JsonObject ( Interface mode )

    public static  T fromEnvelop(final Envelop envelop, final Class clazz, final String pojo) {
        return From.fromJson(getJson(envelop), clazz, pojo);
    }

    public static JsonObject fromEnvelop(final Envelop envelop, final String pojo) {
        return From.fromJson(Ux.getJson(envelop), pojo);
    }

    public static JsonObject getJson(final Envelop envelop) {
        return In.request(envelop, 0, JsonObject.class);
    }

    // -> Message -> JsonObject ( Interface mode )

    public static  T fromEnvelop1(final Envelop envelop, final Class clazz, final String pojo) {
        return From.fromJson(getJson1(envelop), clazz, pojo);
    }

    public static JsonObject fromEnvelop1(final Envelop envelop, final String pojo) {
        return From.fromJson(Ux.getJson1(envelop), pojo);
    }

    public static JsonObject getJson1(final Envelop envelop) {
        return In.request(envelop, 1, JsonObject.class);
    }

    // -> Message -> JsonObject ( Interface mode )

    public static JsonObject getJson2(final Envelop envelop) {
        return In.request(envelop, 2, JsonObject.class);
    }

    public static JsonObject fromEnvelop2(final Envelop envelop, final String pojo) {
        return From.fromJson(Ux.getJson2(envelop), pojo);
    }

    public static  T fromEnvelop2(final Envelop envelop, final Class clazz, final String pojo) {
        return From.fromJson(getJson2(envelop), clazz, pojo);
    }

    // -> Message -> Integer ( Interface mode )

    public static Integer getInteger(final Envelop envelop, final int index) {
        return In.request(envelop, index, Integer.class);
    }

    public static Integer getInteger(final Envelop envelop) {
        return In.request(envelop, 0, Integer.class);
    }

    // -> Message -> Integer ( Interface mode )
    public static Integer getInteger1(final Envelop envelop) {
        return In.request(envelop, 1, Integer.class);
    }

    // -> Message -> Integer ( Interface mode )
    public static Integer getInteger2(final Envelop envelop) {
        return In.request(envelop, 2, Integer.class);
    }

    // -> Message -> Long ( Interface mode )

    public static Long getLong(final Envelop envelop, final int index) {
        return In.request(envelop, index, Long.class);
    }

    // -> Message -> Long ( Interface mode )
    public static Long getLong(final Envelop envelop) {
        return In.request(envelop, 0, Long.class);
    }

    // -> Message -> Long ( Interface mode )
    public static Long getLong1(final Envelop envelop) {
        return In.request(envelop, 1, Long.class);
    }

    // -> Message -> Long ( Interface mode )
    public static Long getLong2(final Envelop envelop) {
        return In.request(envelop, 2, Long.class);
    }

    // -> Message -> T ( Interface mode )

    public static  T getT(final Envelop envelop, final int index, final Class clazz) {
        return In.request(envelop, index, clazz);
    }

    // -> Message -> T ( Interface mode )

    public static  T getT(final Envelop envelop, final Class clazz) {
        return In.request(envelop, 0, clazz);
    }

    // -> Message -> T ( Interface mode )

    public static  T getT1(final Envelop envelop, final Class clazz) {
        return In.request(envelop, 1, clazz);
    }

    // -> Message -> T ( Interface mode )

    public static  T getT2(final Envelop envelop, final Class clazz) {
        return In.request(envelop, 2, clazz);
    }

    // ---------------------- Agent mode usage --------------------------
    // -> Message -> JsonObject ( Agent mode )
    // -> Envelop -> JsonObject ( Agent mode )
    public static JsonObject getBody(final Envelop envelop) {
        return In.request(envelop, JsonObject.class);
    }

    // -> Envelop -> T ( Agent mode )
    public static  T getBodyT(final Envelop envelop, final Class clazz) {
        return In.request(envelop, clazz);
    }

    // ---------------------- Agent mode usage --------------------------

    /**
     * This method will be configured in `vertx-extension.yml` file in common situation,
     * The file content should be as following:
     * 

     * ```yml
     * // 

     * init:
     *   - component: "[ComponentName1]"
     *   - component: "[ComponentName2]"
     * // 
     * ```
     * 
     * new mode as
     * 
     * ```yml
     * // 

     * init:
     *    extension:
     *     - component: "[ComponentName1]"
     *     - component: "[ComponentName2]"
     *    bridge:
     *     - component: "xxxx"
     *     - order: 1
     * // 
     * ```
     * 
     * All components here will be called when container starting, the component must declare the init method as
     * 
     * ```java
     * // 

     * public static void init(){
     *     // Here are initialize code logical
     *     Ke.banner("「Εκδήλωση」- Crud ( Ix )");
     *
     *     Ix.infoInit(LOGGER, "IxConfiguration...");
     * }
     * // 
     * ```
     * 
     * This method should be used when you want to develop zero extension module for business requirement.
     *
     * @param init The configuration data came from `init` node in file
     */
    public static Future nativeInit(final JsonObject initConfig, final Vertx vertx) {
        return Atomic.nativeInit(initConfig, vertx);
    }

    public static Vertx nativeVertx() {
        return Atomic.nativeVertx();
    }

    public static WorkerExecutor nativeWorker(final String name) {
        return Atomic.nativeWorker(name, 10);
    }

    public static WorkerExecutor nativeWorker(final String name, final Integer mins) {
        return Atomic.nativeWorker(name, mins);
    }

    public static  Future nativeWorker(final String name, final Handler> handler) {
        return Atomic.nativeWorker(name, handler);
    }

    // -> Dict for caculation
    /*
     * Keep following dict method
     */
    public static ConcurrentMap dictEpsilon(final JsonObject epsilon) {
        return DConsumer.mapEpsilon(epsilon);
    }

    public static Future> dictCalc(final DSetting dict, final MultiMap paramsMap) {
        return Dict.dictCalc(dict, paramsMap);
    }

    public static  Future dictTo(final T record, final DFabric fabric) {
        return Dict.dictTo(record, fabric);
    }

    /*
     * key part for extract data from environment
     */
    public static String keyUser(final User user) {
        Objects.requireNonNull(user);
        final JsonObject principle = user.principal();
        if (principle.containsKey(KName.USER)) {
            return principle.getString(KName.USER);
        } else {
            /*
             * To avoid fetch user information from JWT token
             */
            final String accessToken = principle.getString(KName.ACCESS_TOKEN);
            final JsonObject credential = Jwt.extract(accessToken);
            return credential.getString(KName.USER);
        }
    }

    // ---------------------------------- Children Utility

    /**
     * Inner class of `Jooq` tool of Jooq Engine operations based on pojo here.
     * When developers want to access database and select zero default implementation.
     *
     * @author lang
     * 
     *
     *     public Future fetchAsync(final User user){
     *         return Ux.Jooq.on(UserDao.class)
     *                    .insertAsync(user)
     *                    .compose(Ux::fnJObject);
     *     }
     *
     * 
     * 
     * Here you can do database access smartly and do nothing then.
     */
    public static class Jooq {

        /**
         * Get reference of UxJooq that bind to Dao class, this method won't access standard database,
         * instead it will access history database that has been configured in `vertx-jooq.yml` file.
         * 

         * key = orbit
         *
         * 

         *
         * jooq:
         *   orbit:
         *     driverClassName: "com.mysql.cj.jdbc.Driver"
         *     ......
         *
         * 
         *
         * @param clazz The class of `VertxDao` that has been generated by jooq tool
         *
         * @return UxJooq reference that has been initialized
         */
        public static UxJooq ons(final Class clazz) {
            final JooqDsl dsl = JooqInfix.getDao(clazz, ZeroYml.lime.jooq.orbit);
            return Cache.CC_JOOQ.pick(() -> new UxJooq(clazz, dsl), "HIS-" + dsl.poolKey());
            // return Fn.po?lThread(Cache.JOOQ_POOL_HIS, () -> new UxJooq(clazz, dsl), dsl.poolKey());
        }

        /**
         * Get reference of UxJooq that bind to Dao class, this method access standard database,
         * the configured position is `vertx-jooq.yml`
         * 
         * key = provider
         *
         * 

         * jooq:
         *   provider:
         *     driverClassName: "com.mysql.cj.jdbc.Driver"
         * 
         *
         * @param clazz The class of `VertxDao` that has been generated by jooq tool
         *
         * @return UxJooq reference that has been initialized
         */
        public static UxJooq on(final Class clazz) {
            final JooqDsl dsl = JooqInfix.getDao(clazz);
            return Cache.CC_JOOQ.pick(() -> new UxJooq(clazz, dsl), dsl.poolKey());
            // return Fn.po?lThread(Cache.JOOQ_POOL, () -> new UxJooq(clazz, dsl), dsl.poolKey());
        }

        /**
         * The overloading method of above `on(Class)` method here.
         *
         * @param clazz The class of `VertxDao` that has been generated by jooq tool
         * @param pool  Input data pool reference, it provide developers to access other database in one application.
         *
         * @return UxJooq reference that has been initialized
         */
        public static UxJooq on(final Class clazz, final DataPool pool) {
            final JooqDsl dsl = JooqInfix.getDao(clazz, pool);
            return Cache.CC_JOOQ.pick(() -> new UxJooq(clazz, dsl), dsl.poolKey());
            // return Fn.po?lThread(Cache.JOOQ_POOL, () -> new UxJooq(clazz, dsl), dsl.poolKey());
        }

        /**
         * The overloading method of above `on(Class)` method here.
         *
         * @param clazz The class of `VertxDao` that has been generated by jooq tool
         * @param key   the key configuration in vertx-jooq.yml such as above "orbit", "provider"
         *
         * @return UxJooq reference that has been initialized
         */
        public static UxJooq on(final Class clazz, final String key) {
            final JooqDsl dsl = JooqInfix.getDao(clazz, key);
            return Cache.CC_JOOQ.pick(() -> new UxJooq(clazz, dsl), dsl.poolKey());
            // return Fn.po?lThread(Cache.JOOQ_POOL, () -> new UxJooq(clazz, dsl), dsl.poolKey());
        }
    }

    // -> Jooq -> Multi
    public static class Join {

        public static UxJoin on(final String configFile) {
            return new UxJoin(configFile);
        }

        public static UxJoin on() {
            return new UxJoin(null);
        }

        public static UxJoin on(final Class daoCls) {
            return new UxJoin(null).add(daoCls);
        }
    }

    public static class Pool {

        public static UxPool on(final String name) {
            return Cache.CC_UX_POOL.pick(() -> new UxPool(name), name);
            // return Fn.po?l(Cache.MAP_POOL, name, () -> new UxPool(name));
        }

        public static UxPool on() {
            return new UxPool();
        }
    }

    public static class Job {
        public static UxJob on() {
            return new UxJob();
        }
    }

    public static class Ldap {
        public static UxLdap on(final Integration integration) {
            return Cache.CC_LDAP.pick(() -> new UxLdap(integration), String.valueOf(integration.hashCode()));
        }
    }

    public static class Timer {
        public static UxTimer on() {
            return new UxTimer();
        }
    }

    /*
     * Here the Jwt class is for lagency system because all following method will be called and existed
     * But the new structure is just like following:
     *
     * 1. Lee -> ( Impl ) by Service Loader
     * 2. The `AuthWall.JWT` will be selected and called API of Lee interface
     * 3. The final result is token ( encoding / decoding ) part
     * 4. The implementation class is defined in `zero-ifx-auth` instead of standard framework
     *
     * If you want to use security module, you should set-up `zero-ifx-auth` infix instead, or
     * you can run zero framework in non-secure mode
     */
    public static class Jwt {

        public static String token(final JsonObject data) {
            final Lee lee = Ut.service(LeeBuiltIn.class);
            return lee.encode(data, AegisItem.configMap(AuthWall.JWT));
        }

        public static JsonObject extract(final String token) {
            final Lee lee = Ut.service(LeeBuiltIn.class);
            return lee.decode(token, AegisItem.configMap(AuthWall.JWT));
        }

        public static JsonObject extract(final JsonObject jwtToken) {
            return extract(jwtToken.getString(KName.ACCESS_TOKEN));
        }
    }

}